Understanding Ruby Blocks, Procs and Lambdas

Blocks, Procs and lambdas (referred to as closures in Computer Science) are one of the most powerful aspects of Ruby, and also one of the most misunderstood. This is probably because Ruby handles closures in a rather unique way. Making things more complicated is that Ruby has four different ways of using closures, each of which is a tad bit different, and sometimes nonsensical. There are quite a few sites with some very good information about how closures work within Ruby.

http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/

.irbrc for Win32

Create a file called anything you like (e.g. “_irbrc” or “irb.rc”) and place it anywhere you like (say C:\Documents and Settings\), and set that full path to the ENV variable IRBRC, e.g. C:\Documents and Settings\\_irbrc

Utility Belt

Utility Belt is a grab-bag of tricks, tools, techniques, trifles, and toys for IRB, including convenience methods, language patches, and useful extensions. It also includes a couple command-line widgets. Its primary inspirations were an awesome gem called Wirble and a blog post by Amy Hoy called "Secrets Of The Rails Console Ninjas".

FEATURES

• Interactively edit IRB code in your preferred text editor
• Read from and write to OS X clipboard
• Post your code to Pastie with one command (OS X only)
• Kick-ass Unix-style history buffer
• Write command history to file or vi
• Grep classes and methods for strings
• Verbosity controls for regular IRB and Rails console
• Finder shortcuts for Rails console
• Upload shortcut for Amazon S3
• Command-line Amazon S3 upload script
• Command-line Google shortcut (OS X only)
• Auto-indentation
• _ special variable (like Unix shell var !!)
• Extremely basic themes for Wirble syntax coloring
• Pascal/JavaScript-style "with" statement
• String#to_proc
• Grammatically-correct is_an? method - no more "is_a? Array" statements
• One-character exit command

http://utilitybelt.rubyforge.org/
http://www.rubyinside.com/irb-lets-bone-up-on-the-interactive-ruby-shell-1771.html
http://rors.org/2009/12/20/10-rails-console-tricks.html

history, separate rails/console history, syntax highliting, ...

# .irbrc - last change: 2008-01-22 (ab)

### rubygems
require 'rubygems' rescue nil

### pretty print
require 'pp'

### less verbose prompt

#IRB.conf[:PROMPT_MODE] = :SIMPLE

IRB.conf[:PROMPT][:SHORT] = {
  :PROMPT_C => "%03n:%i* ",
  :RETURN   => "%s\n",
  :PROMPT_I => "%03n:%i> ",
  :PROMPT_N => "%03n:%i ",
  :PROMPT_S => "%03n:%i%l "
}
#IRB.conf[:PROMPT_MODE] = :SHORT

### automatic indentation
IRB.conf[:AUTO_INDENT] = true

### tab completion
require 'irb/completion'
IRB.conf[:USE_READLINE] = true

### preserve history
require 'irb/ext/save-history'
IRB.conf[:SAVE_HISTORY] = 1000
IRB.conf[:EVAL_HISTORY] = 100

### syntax highlighting
require 'wirble'
Wirble.init(:skip_prompt => true, :skip_history => true)
Wirble.colorize

### irb session duration
require 'duration'
IRB_START_TIME = Time.now
at_exit { puts "\nirb session duration: #{Duration.new(Time.now - IRB_START_TIME)}" }

### aliases
alias r require

### easy YAML
def y(*data); require 'yaml'; puts YAML::dump(*data); end

### Object#tap
class Object; def tap; yield self; self; end; end

### map by method
# http://drnicwilliams.com/2006/10/04/i-love-map-by-pluralisation/
require 'map_by_method'

### method finder, e.g. "foo".what?
# http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/32844
# http://www.nobugs.org/developer/ruby/method_finder.html
# http://redhanded.hobix.com/inspect/stickItInYourIrbrcMethodfinder.html
require 'what_methods'

### gaining temporary access to private methods
# http://blog.jayfields.com/2007/11/ruby-testing-private-methods.html
class Class
  def publicize_methods
    saved_private_instance_methods = self.private_instance_methods
    self.class_eval { public *saved_private_instance_methods }
    yield
    self.class_eval { private *saved_private_instance_methods }
  end
end

### System-wide script/console logging
# http://toolmantim.com/article/2007/2/6/system_wide_script_console_logging
script_console_running = ENV.include?('RAILS_ENV') && IRB.conf[:LOAD_MODULES] && IRB.conf[:LOAD_MODULES].include?('console_with_helpers')
rails_running = ENV.include?('RAILS_ENV') && !(IRB.conf[:LOAD_MODULES] && IRB.conf[:LOAD_MODULES].include?('console_with_helpers'))
irb_standalone_running = !script_console_running && !rails_running

if script_console_running
  require 'logger'
  Object.const_set(:RAILS_DEFAULT_LOGGER, Logger.new(STDOUT))
end

### different history file for rails
IRB.conf[:HISTORY_FILE] = "#{ENV['HOME']}/.irb_history_rails" unless irb_standalone_running

http://dotfiles.org/~localhost/.irbrc

mondrian-olap

JRuby gem for performing multidimensional queries of relational database data using Mondrian OLAP Java library.

DESCRIPTION
SQL language is good for doing ad-hoc queries from relational databases but it becomes very complicated when doing more complex analytical queries to get summary results. Alternative approach is OLAP (On-Line Analytical Processing) databases and engines that provide easier multidimensional analysis of data at different summary levels.
One of the most popular open-source OLAP engines is Mondrian (mondrian.pentaho.com). Mondrian OLAP engine can be put in front of relational SQL database and it provides MDX multidimensional query language which is much more suited for analytical purposes.
mondrian-olap is JRuby gem which includes Mondrian OLAP engine and provides Ruby DSL for creating OLAP schemas on top of relational database schemas and provides MDX query language and query builder Ruby methods for making analytical queries.

USAGE
Schema definition
At first you need to define OLAP schema mapping to relational database schema tables and columns. OLAP schema consists of:

• Cubes Multidimensional cube is a collection of measures that can be accessed by dimensions. In relational database cubes are stored in fact tables with measure columns and dimension foreign key columns.
  
• Dimensions Dimension can be used in one cube (private) or in many cubes (shared). In relational database dimensions are stored in dimension tables.
  
• Hierarchies and levels Dimension has at least one primary hierarchy and optional additional hierarchies and each hierarchy has one or more levels. In relational database all levels can be stored in the same dimension table as different columns or can be stored also in several tables.
  
• Members Dimension hierarchy level values are called members.
  
• Measures Measures are values which can be accessed at detailed level or aggregated (e.g. as sum or average) at higher dimension hierarchy levels. In relational database measures are stored as columns in cube table.
  
• Calculated measures Calculated measures are not stored in database but calculated using specified formula from other measures.
  

Read more about about defining Mondrian OLAP schema at mondrian.pentaho.com/documentation/schema.php.

https://github.com/rsim/mondrian-olap

Multidimensional Data Analysis with Ruby (sample)

Check out this SlideShare Presentation:

Multidimensional Data Analysis with Ruby (sample)

View more presentations from rsim.

How to develop rails plugin from scratch?

Generate Plugin with command: ruby script/generate plugin hello_world
It will create file system as bellow:
- lib
    - hello_world.rb
- tasks
    - hello_world_tasks.rake
- test
    - hello_world_test.rb
- init.rb
- install.rb
- uninstall.rb
- README
- Rakefile
- MIT-LICENSE

init.rb will be executed every time when your application runs. Generally hook code is to be included here like you want to make all methods of your plugin available in your app’s models, controllers, views and helpers

http://abdul-barek-rails.blogspot.com/2010/02/how-to-develop-rails-plugin-from.html