alias_method(p1, p2)
public
Makes new_name a new copy of the method old_name. This can be used to retain access to methods that are overridden.
module Mod alias_method :orig_exit, :exit def exit(code=0) puts "Exiting with code #{code}" orig_exit(code) end end include Mod exit(99)
produces:
Exiting with code 99
Very bad documentation
This is terrible documentation. It makes it very hard to understand what the arguments mean.
The signature is
alias_method(p1, p2)
So what do p1 and p2 mean? The description doesn’t refer to them at all, but to new_name and old_name. How are we supposed to know which is which?
And then it gets even worse in the code sample:
alias_method :orig_exit, :exit
From the naming it sounds like the first argument is the original method name.
Documentation is supposed to resolve this kind of confusion, not create it.
Bad example
Note that it would be better to avoid the alias_method line in the example and just call super.
Perfectly applicable
@rkh You would be correct if this code had occurred in a subclass who’s parent method was being overridden.
However, defining the method in this manner is completely removing the old method - as if you had written code like this:
class MyClass def do_something puts "We're doing some stuff here" end def do_something puts "The old do_something method no longer exists!" end end MyClass.new.do_something # => "The old do_something method no longer exists!"
Of course this is non-sensical. But the idea is that you have either included a module, or monkey-patched an already existent class, and completely replaced the old method. super(*args) will not work
Bad Example
@nZifnab it is a bad example because an included module is basically a class.
module Mod def exit(code = 0) puts "Exiting with code #{code}" super end end include Mod exit 99
produces
Exiting with code 99
@drewyoung1
Including module in a class does not automatically over-write methods defined with the same name.
Ex:
module Mod
def exit(code = 0) puts "Exiting with code #{code}" super end
end
class OriginalClass
include Mod def exit puts "Original message" end
end
OriginalClass.new.exit 99
Produces:
exit': wrong number of arguments (1 for 0) (ArgumentError)
if you use this construct, the alias_method will work similar to super:
module Mod
alias_method :super_exit, :exit def self.included base base.instance_eval do def exit(code = 0) puts "Exiting with code #{code}" super_exit end end end
end
Examples corrected
I have documented this method clearly with corrections to the examples shown in this page on my blog: http://www.rubyplus.net/2016/11/aliasmethod-in-ruby.html
Rails caching with dalli gem
Dalli is a high performance pure Ruby client for accessing memcached servers. It works with memcached 1.4+ only, as it uses the newer binary protocol.
Memcache Memcached is a quick in-memory protest reserving framework that can make Rails run much quicker with not very many changes. Memcached is an in-memory key-value store for little pieces of discretionary information (strings, objects) from consequences of database calls, API calls, or page rendering.
Run the command below to install memcached On Ubuntu
sudo apt-get install memcached
On Mac
brew install memcached
Please refer the URL below to know more about installing memcahed
https://github.com/petergoldstein/dalli#installation-and-usage Install dalli gem gem 'dalli'
Add the gem above to your gemfile and run bundle install.
Configuration Here, we have to configure our rails app to serve caching mechanisam. Add below line to the production.rb(config/environments/production.rb)
config.cache_store = :dalli_store Dalli::Client accepts the following options. All times are in seconds.
expires_in: Global default for key TTL. Default is 0, which means no expiry. namespace: By default, it is nil. It’s prepend to each key if you specify namespace. failover: Default is true. Boolean, if true, Dalli will failover to another working server if the main server for a key is down. threadsafe: Boolean. If true, Dalli ensures that only one thread is using a socket at a specified given time. Default is true. serializer: The serializer to use for objects being stored (ex. JSON). Default is Marshal. compress: Boolean, if true Dalli will gzip-compress values larger than 1K. Default is false. compression_min_size: Minimum value byte size for which to attempt compression. Default is 1K. compression_max_size: Maximum value byte size for which to attempt compression. Default is unlimited. Please check more configations at
https://github.com/petergoldstein/dalli#configuration
After this, we have to tell ActionController to perform caching. Add the line below to the same file and restart Rails server if you are already running it.
config.action_controller.perform_caching = true
Please add the code below to your index method
@posts = Rails.cache.fetch('posts', expires_in: 5.minutes){ Post.all }
Here, Rails.catche.fetch reads the data from ‘posts’ key. If the specified key has any data, it will return data otherwise it will write to that key and it will be available for successive calls within the expiry time.
Rails provides helpers such as Rails.cache.read to read the cache, Rails.cache.write to write in the cache and Rails.cache.fetch to return the results if present in the cache or else, write in the cache to return the results.
You can read more about Rails cache at
http://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html Rails.cache.clear() – Flushing all the keys from memcached. Rails.cache.delete(‘posts’) – If you wish to flush any specific key from memcached server.
http://www.railscarma.com/blog/technical-articles/rails-caching-dalli-gem/
Code Refactoring Gem – Flay
Flay examines code for structural likenesses. Differences in literal values, variable, class, method names, whitespace, programming style, braces vs do/end, props versus do/end, and so forth are all overlooked,making this absolutely rad. It’s fit for recognizing both correct and close matches, and does in certainty discover a few spots in Active Record where patterns repeat. In its current state, Flay’s output is very primitive: a list of repeated code nodes, together with a weight to rank them by and line numbers and file names where the repeated code appears. Code that flay reports as comparative is a decent possibility tool for refactoring.
Command to install
sudo gem install flay
Command to see output
Cd “Path to your project folder” flay “path of the folder” Eg : flay ./app/controllers - Identifies the code duplication in all the controllers. flay ./app - Identifies the code duplication in entire project flay ./app/controllers/example_controler.rb - Identifies the code duplication in specified controller.
Example of Output An output is generated of the code duplicated areas like this:
sridevi@carmatec-MS-7788$ flay ./app/models/*.rb Total score (lower is better) = 1666 1) Similar code found in :call (mass = 170) ./app/models/example.rb:8 ./app/models/example.rb:9 ./app/models/example.rb:10 ./app/models/example.rb:11 ./app/models/example.rb:15 ./app/models/example.rb:17 ./app/models/example.rb:19 ./app/models/example.rb:20 ./app/models/example.rb:22 ./app/models/example.rb:23 2) Similar code found in :defs (mass = 154) ./app/models/example.rb:260 ./app/models/result.rb:195 3) Similar code found in :defs (mass = 138) ./app/models/feedback.rb:62 ./app/models/example.rb:54 ./app/models/result.rb:51 4) Similar code found in :call (mass = 136) ./app/models/example.rb:12 ./app/models/example.rb:13 ./app/models/example.rb:14 ./app/models/example.rb:16 ./app/models/example.rb:18 ./app/models/example.rb:21 ./app/models/example.rb:24 ./app/models/example.rb:25 5) IDENTICAL code found in :defn (mass*2 = 128) ./app/models/result.rb:7 ./app/models/summary_report.rb:7 6) IDENTICAL code found in :defn (mass*2 = 120) ./app/models/example.rb:17 ./app/models/example.rb:23
The total app score of 1666 (‘lower is better’ advice holds true) can be viewed in its individual components showing areas that provide the most bang for the buck. For experienced developers operating on their own or in a small team Flay may be unnecessary. However, on larger projects (as the one I ran it on) or those with beginner or intermediate programmers it can help increase the maintainability of your codebase. http://www.railscarma.com/blog/technical-articles/code-refactoring-gem-flay/
Ruby Developers
How to create a Ruby Gem Ruby Gems or “gem” is a package manager for the Ruby programming language that provides a standard format for distributing Ruby programs and libraries. It is easy to manage and install to your system and it can be used by various rails applications development.
Every RoR developer might have customised a gem at least once in his career, but not each one of them has actually, created a gem. Here, I am going to give a basic idea about how to create a new gem and how to publish it.
Kick off Before starting please make sure that you are using the latest ruby version. RVM is really useful in this case;
How to name your Gem Don’t blindly give a random name to your gem. Please take care of the following; Every dash represents a structure (folder, module) immersion Every underscore represents a joining in the class name
Some examples:
gem new_test_gem require ‘new_test_gem’ module/class NewTestGem
gem gem-structure-new_test_gem require ‘gem/structure/new_test_gem module/class Gem::Structure::NewTestGem
How to create your Gem To create a gem; $ bundle gem new_test_gem It will create some basic files and directories.
Where to add your code or job Your beautiful code goes here
# lib/new_test_gem.rb
Once you have added your code into the lib file then you will have to update the gemspec file;
# new_test_gem.gemspec
For Complete details go through this link => http://www.railscarma.com/blog/technical-articles/how-to-create-a-ruby-gem/
Volt Framework for Ruby
Volt – a new Framework for Ruby where both the server and client sides are written in Ruby via OPAL (a ruby to JavaScript compiler) so developer can write dynamic applications without writing a single JavaScript code. Volt is similar to Meteor but it doesn’t have all the portions of Meteor.
The Basic Setup for Volt Framework
Let us install Volt and create an empty app. Make sure that you have ruby (>2.1.0) and ruby gems installed.
gem install volt
We can create a new project using the volt gem:
volt new sample_project
Fire up the web server:
bundle exec volt server
We can access the Volt console with:
bundle exec volt console
The Opal Compiler
Volt applications run Ruby on both frontend and backend. So the puts statement in a controller action appears in browser window and not in terminal console. And also writing Ruby code for the front end with Volt is very easy. The opal compiler translates Ruby to JavaScript. Amazing thing about it is that there is no compilation process to follow and no build tools to install. When you run volt server, everything takes place in the background. No refresh or restart is needed when you do changes to code and data.
Calling a JavaScript alert with Ruby
# Calling JavaScript functions in Ruby module Main class MainController < Volt::ModelController # Called from front end when “todos” route loads. def todos alert ‘totes amaze’ end end end
Easy Syncing via Reactive Models
Concentrate more on this part when learning volt. Volt::Model acts as hash-like Ruby objects that sync between the front end and back end simultaneously. Usually, updates to the model happens automatically. The concept of “stores” in Volt is used to sync application data in persistent and non-persistent forms. And also a uniform means of syncing data between local storage, MangoDB, cookies, sessions and URL params.
Let’s check how to create real-time chat app of Ruby and HTML:
# Create a persistent data model. This gets stored in MongoDB. class ChatMessage < Volt::Model end
View Code:
<:Body> <form e-submit=”say”> <input class=”form-control” type=”text” value=”{{ page._input }}” /> </form> <ul> {{ _chat_messages.each do |msg| }} <ul> <button e-click=”msg.destroy”>X</button> {{ msg._text }} </ul> {{ end }} </ul>
Full HTTP Endpoint Support
Volt is not only for real-time framework. It also provides workflows for traditional HTTP application development. Checkout an example from GitHub :
# Routes for HTTP endpoint get ‘/simple_http’, controller: ‘simple_http’, action: ‘index’ get ‘/simple_http/store’, controller: ‘simple_http’, action: ‘show’ post ‘/simple_http/upload’, controller: ‘simple_http’, action: ‘upload’ # Example controller class SimpleHttpController < Volt::HttpController def index render text: ‘this is just some text’ end def show render text: “You had me at “\ “#{store._simple_http_tests.first._name}” end def upload uploaded = params[:file][:tempfile] File.open(‘tmp/uploaded_file’, ‘wb’) do |f| f.write(uploaded.read) end render text: ‘Thanks for uploading’ end end
Scheduling Recurring Events with Ice Cube Gem
Ice_cube is a ruby library for effectively taking care of repeated events (schedules). The force lies in the ability to indicate multiple rules, and have ice_cube rapidly make sense of whether the schedule falls on a specific date (.occurs_on?), or what times it happens at (.occurrences, .first, .all_occurrences).
How to get ice cube
For install use the below syntax
gem install
if you want to get the code
gem clone git://github.com/seejohnrun/ice_cube
For creating icecube schedule
schedule = IceCube::Schedule.new if we want to speciy startdate and enddate we have option to specify in the above mentioned schedule schedule = IceCube::Schedule.new(start = Time.now, :end_time => start + 600)
Daily schedules
After creating schedule we have an option to add recurrence rule for the above mentioned schedule
consider “schedule every day” on above mentioned time
schedule.add_recurrence_rule IceCube::Rule.daily
consider the same schedule with repeat “n” number of days
schedule.add_recurrence_rule IceCube::Rule.daily(repeat_every_n_days)
in place of repeat_every_n_days you have option to specify the number of days For Weekly Monthly & Hourly You can Read It From Here http://goo.gl/XGmXp1
How to use Acts_As_Votable Gem
Acts_As_Votable is ruby gem specifically written for Rails/ActiveRecord models and This gem allows any model to be voted on upvote/downvote like/dislike, etc. It allows any model to be voted under arbitrary scopes using this gem we can vote any model. votes do not have to come from a user, they can come from any model (such as a Group or Team) and it provide an easy to write/read syntax.
Gem Installation
gem ‘acts_as_votable’
Add above line in Gemfile and run bundle install
Supported ruby and rails versions
Ruby 1.8.7, 1.9.2, 1.9.3, 2.0.0, 2.1.0 Rails 3.0, 3.1, 3.2, 4.0, 4.1+
This Gem uses vote table to save all voting information. To generate vote migration run below commands
rails generate acts_as_votable:migration rake db:migrate
To rate any model just use “acts_as_votable” in model
Example:
class Article < ActiveRecord::Base acts_as_votable end @article = Article.new(:name => ‘my new article’) @article.save @article.liked_by @user @article.votes_for.size # => 1
Read More From Here http://goo.gl/emtP8K
Clarifying the confusing example
since exit is a keyword in Ruby, the example may be confusing. The following example might be less so:
module Foo begin # this raises an error b/c baz is not defined here alias_method :other_baz, :baz rescue NameError =>e puts e end def baz puts "first baz called" end # now that baz method is defined, we can define an alias alias_method :other_baz, :baz # we can now overwrite baz. # If we want the original baz, use the alias we just defined def baz puts "second baz called" end def qux puts "qux called" end alias_method :bar, :qux end include Foo # calls the second baz method, b/c it overwrites the first baz #=> "second baz called" # calls the first baz method, due to the alias_method making a copy other_baz #=> "first baz called" bar #=> "qux called" qux #=> "qux called"
The resulting output is:
undefined method `baz' for module `Foo' second baz called first baz called qux called qux called