Ruby on Miro's World

Git bits 2

Wed, 23 Mar 2016 12:57:35 -0500

Using the Scala source repo to demonstrate - see Github

Show merged and unmerged branches
#

This command allows you to show all local branches merged / unmerged to current branch

➜  scala git:(2.12.x) git branch -a --merged
* 2.12.x
  remotes/origin/2.11.x
  remotes/origin/2.12.x
  remotes/origin/HEAD -> origin/2.12.x

➜  scala git:(2.12.x) git branch -a --no-merged
  remotes/origin/2.10.x
  remotes/origin/2.8.x
  remotes/origin/2.9.x
  remotes/origin/DarkDimius-patch-1
  remotes/origin/gh-pages
  remotes/origin/legacy/msil

This shows you all local branches merged into named branch:

Git - find unmerged commits

Tue, 22 Mar 2016 12:57:35 -0500

This is Ruby script I found way back and was using it since.

The credits for creation goes to Zach Dennis. The script is decribed in his blog post

The source is here

Example
#

This is beginning of very long output from Groovy source

The code
#

#!/usr/bin/env ruby

require 'rubygems'

gem 'term-ansicolor', '>=1.0.5'
require 'term/ansicolor'

class GitCommit
  attr_reader :content

  def initialize(content)
    @content = content
  end

  def sha
    @content.split[1]
  end

  def to_s
    `git log --pretty=format:"%h %ad %an - %s" #{sha}~1..#{sha}`
  end

  def unmerged?
    content =~ /^\+/
  end

  def equivalent?
    content =~ /^\-/
  end
end

class GitBranch
  attr_reader :name, :commits

  def initialize(name, commits)
    @name = name
    @commits = commits
  end

  # Returns origin from origin/some/branch/here
  def repository
    name.split("/", 2).first
  end

  # Returns some/branch/here from origin/some/branch/here
  def branch_name
    name.split("/", 2).last
  end

  def unmerged_commits
    commits.select{ |commit| commit.unmerged? }
  end

  def equivalent_commits
    commits.select{ |commit| commit.equivalent? }
  end

end

class GitBranches < Array
  def self.clean_branch_output(str)
    str.split(/\n/).map{ |e| e.strip.gsub(/\*\s+/, '') }.reject{ |branch| branch =~ /\b#{Regexp.escape(UPSTREAM)}\b/ }.sort
  end

  def self.local_branches
    clean_branch_output `git branch`
  end

  def self.remote_branches
    clean_branch_output `git branch -r`
  end

  def self.load(options)
    git_branches = new
    branches = if options[:local]
      local_branches
    elsif options[:remote]
      remote_branches
    end

    branches.each do |branch|
      raw_commits = `git cherry -v #{UPSTREAM} #{branch}`.split(/\n/).map{ |c| GitCommit.new(c) }
      git_branches << GitBranch.new(branch, raw_commits)
    end
    git_branches
  end

  def unmerged
    reject{ |branch| branch.commits.empty? }.sort_by{ |branch| branch.name }
  end

  def any_missing_commits?
    select{ |branch| branch.commits.any? }.any?
  end
end

class GitUnmerged
  VERSION = "1.1"

  include Term::ANSIColor

  attr_reader :branches

  def initialize(args)
    @options = {}
    @branches_to_prune = []
    extract_options_from_args(args)
  end

  def load
    @branches ||= GitBranches.load(:local => local?, :remote => remote?)
    @branches.reject!{|b| @options[:exclude].include?(b.name)} if @options[:exclude].is_a?(Array)
    @branches.select!{|b| @options[:only].include?(b.name)} if @options[:only].is_a?(Array)
  end

  def print_overview
    load
    if @options[:exclude] && @options[:exclude].length > 0
      puts "The following branches have been excluded"
      @options[:exclude].each do |branch_name|
        puts "  #{branch_name}"
      end
      puts
    end

    if @options[:only] && @options[:only].length > 0
      puts "The following branches will be compared against:"
      @options[:only].each do |branch_name|
        puts "  #{branch_name}"
      end
      puts
    end

    if branches.any_missing_commits?
      puts "The following branches possibly have commits not merged to #{upstream}:"
      branches.each do |branch|
        num_unmerged = yellow(branch.unmerged_commits.size.to_s)
        num_equivalent = green(branch.equivalent_commits.size.to_s)
        puts %|  #{branch.name} (#{num_unmerged}/#{num_equivalent} commits)|
      end
    end
  end

  def print_help
    puts <<-EOT.gsub(/^\s+\|/, '')
      |Usage: #{$0} [-a] [--upstream <branch>] [--remote] [--prune]
      |
      |This script wraps the "git cherry" command. It reports the commits from all local
      |branches which have not been merged into an upstream branch.
      |
      |  #{yellow("yellow")} commits have not been merged
      |  #{green("green")} commits have equivalent changes in <upstream> but different SHAs
      |
      |The default upstream is 'master' (or 'origin/master' if running with --remote)
      |
      |OPTIONS:
      |  -a   display all unmerged commits (verbose)
      |  --remote (-r)  compare remote branches instead of local branches
      |  --upstream <branch>   specify a specific upstream branch (defaults to master)
      |  --exclude <branch>[,<branch>,...]   specify a comma-separated list of branches to exclude
      |  --only <branch>[,<branch>,...]   specify a comma-separated list of branches to include
      |  --prune  prompts user to delete branches which have no differences with the upstream
      |
      |EXAMPLE: check for all unmerged commits
      |  #{$0}
      |
      |EXAMPLE: check for all unmerged commits and merged commits (but with a different SHA)
      |  #{$0} -a
      |
      |EXAMPLE: use a different upstream than master
      |  #{$0} --upstream otherbranch
      |
      |EXAMPLE: compare remote branches against origin/master
      |  #{$0} --remote (-r)
      |
      |EXAMPLE: delete branches without unmerged commits
      |  #{$0} --prune
      |
      |EXAMPLE: delete remote branches without unmerged commits
      |  #{$0} --remote --prune
      |
      |GITCONFIG:
      |  If you name this file git-unmerged and place it somewhere in your PATH
      |  you will be able to type "git unmerged" to use it. If you'd like to name
      |  it something else and still refer to it with "git unmerged" then you'll
      |  need to set up an alias:
      |      git config --global alias.unmerged \\!#{$0}
      |
      |Version: #{VERSION}
      |Author: Zach Dennis <zdennis@mutuallyhuman.com>
    EOT
    exit
  end

  def print_version
    puts "#{VERSION}"
  end

  def branch_description
    local? ? "local" : "remote"
  end

  def print_specifics
    load

    if branches.any_missing_commits?
      print_breakdown
    else
      puts "There are no #{branch_description} branches out of sync with #{upstream}"
    end
  end

  def print_breakdown
    puts "Below is a breakdown for each branch. Here's a legend:"
    puts
    print_legend
    branches.each do |branch|
      puts
      print "#{branch.name}:"
      if branch.unmerged_commits.empty? && !show_equivalent_commits?
        print "(no unmerged commits"
        if prune?
          print ",", red(" this will be pruned")
          @branches_to_prune << branch
        end
        print ")\n"
      else
        puts
      end
      branch.unmerged_commits.each { |commit| puts yellow(commit.to_s) }

      if show_equivalent_commits?
        branch.equivalent_commits.each do |commit|
          puts green(commit.to_s)
        end
      end
    end
  end

  def print_legend
    load
    puts "  " + yellow("yellow") + " commits have not been merged"
    puts "  " + green("green") + " commits have equivalent changes in #{UPSTREAM} but different SHAs" if show_equivalent_commits?
  end

  def prune
    return unless prune?
    if @branches_to_prune.empty?
      puts "", "There are no branches to prune."
    else
      # Protects Heroku repo's
      rejected_master_branches = @branches_to_prune.reject!{|branch| branch.branch_name =~ /master/}
      puts "", "Are you sure you want to prune the following #{@branches_to_prune.size} branches?", ""
      puts red("(Keep in mind this will remove these branches from the remote repository)") if @remote
      @branches_to_prune.each do |branch|
        puts red(" #{branch.name}")
      end
      puts "(omitting branches named master)" if rejected_master_branches
      puts
      print "y or n: "
      if STDIN.gets=~/y/i
        @branches_to_prune.each do |branch|
          if local?
            `git branch -D #{branch.name}`
          elsif remote?
            puts "pruning: #{branch.branch_name} with 'git push #{branch.repository} :#{branch.branch_name}'"
            `git push #{branch.repository} :#{branch.branch_name}`
          end
        end
        puts "", "Pruned #{@branches_to_prune.size} branches."
      else
        puts "", "Pruning aborted. All branches were left unharmed."
      end
    end
  end

  def prune? ; @options[:prune ] ; end
  def show_help? ; @options[:show_help] ; end
  def show_equivalent_commits? ; @options[:show_equivalent_commits] ; end
  def show_version? ; @options[:show_version] ; end

  def upstream
    if @options[:upstream]
      @options[:upstream]
    elsif local?
      "master"
    elsif remote?
      "origin/master"
    end
  end

  private

  def extract_options_from_args(args)
    if args.include?("--remote") || args.include?("-r")
      @options[:remote] = true
    else
      @options[:local] = true
    end

    @options[:prune] = true if args.include?("--prune")
    @options[:show_help] = true if args.include?("-h") || args.include?("--help")
    @options[:show_equivalent_commits] = true if args.include?("-a")
    @options[:show_version] = true if args.include?("-v") || args.include?("--version")

    if index=args.index("--upstream")
      @options[:upstream] = args[index+1]
    end

    if index=args.index("--exclude")
      @options[:exclude] = args[index+1].split(',')
    end

    if index=args.index("--only")
      @options[:only] = args[index+1].split(',')
    end
  end

  def local? ; @options[:local] ; end
  def remote? ; @options[:remote] ; end
end


unmerged = GitUnmerged.new ARGV
UPSTREAM = unmerged.upstream
if unmerged.show_help?
  unmerged.print_help
  exit
elsif unmerged.show_version?
  unmerged.print_version
  exit
else
  unmerged.print_overview
  puts
  unmerged.print_specifics
  unmerged.prune
end

Finding unmerged commits in all branches

Thu, 05 Feb 2015 11:22:48 +0800

This one goes beyond git, but is very useful. Ruby script that produces this:

Here is the script


#!/usr/bin/env ruby
require 'rubygems'
gem 'term-ansicolor', '=1.3.0'
require 'term/ansicolor'
class GitCommit
  attr_reader :content
   
  def initialize(content)
    @content = content
  end
   
  def sha
    @content.split[1]
  end
  def to_s
    `git log --pretty=format:"%h %ad %an - %s" #{sha}~1..#{sha}`
  end
   
  def unmerged?
    content =~ /^\+/
  end
   
  def equivalent?
    content =~ /^\-/
  end
end
class GitBranch
  attr_reader :name, :commits
   
  def initialize(name, commits)
    @name = name
    @commits = commits
  end
   
  def unmerged_commits
    commits.select{ |commit| commit.unmerged? }
  end
  def equivalent_commits
    commits.select{ |commit| commit.equivalent? }
  end
end
class GitBranches < Array
  def self.clean_branch_output(str)
    str.split(/\n/).map{ |e| e.strip.gsub(/\*\s+/, '') }.reject{ |branch| branch =~ /\b#{Regexp.escape(UPSTREAM)}\b/ }.sort
  end
   
  def self.local_branches
    clean_branch_output `git branch`
  end
   
  def self.remote_branches
    clean_branch_output `git branch -r`
  end
   
  def self.load(options)
    git_branches = new
    branches = if options[:local]
      local_branches
    elsif options[:remote]
      remote_branches
    end
     
    branches.each do |branch|
      raw_commits = `git cherry -v #{UPSTREAM} #{branch}`.split(/\n/).map{ |c| GitCommit.new(c) }
      git_branches << GitBranch.new(branch, raw_commits)
    end
    git_branches
  end
   
  def unmerged
    reject{ |branch| branch.commits.empty? }.sort_by{ |branch| branch.name }
  end
   
  def any_missing_commits?
    select{ |branch| branch.commits.any? }.any?
  end
end
class GitUnmerged
  VERSION = "1.0.1"
   
  include Term::ANSIColor
   
  attr_reader :branches
  def initialize(args)
    @options = {}
    extract_options_from_args(args)
  end
   
  def load
    @branches ||= GitBranches.load(:local => local?, :remote => remote?)
  end
   
  def print_overview
    load
    if branches.any_missing_commits?
      puts "The following branches possibly have commits not merged to #{upstream}:"
      branches.each do |branch|
        num_unmerged = yellow(branch.unmerged_commits.size.to_s)
        num_equivalent = green(branch.equivalent_commits.size.to_s)
        puts %|  #{branch.name} (#{num_unmerged}/#{num_equivalent} commits)|
      end
    end
  end
   
  def print_help
    puts <<-EOT.gsub(/^\s+\|/, '')
      |Usage: #{$0} [-a] [--upstream <branch>] [--remote]
      |
      |This script wraps the "git cherry" command. It reports the commits from all local
      |branches which have not been merged into an upstream branch.
      |
      |  #{yellow("yellow")} commits have not been merged
      |  #{green("green")} commits have equivalent changes in <upstream> but different SHAs
      |
      |The default upstream is 'master'.
      |
      |OPTIONS:
      |  -a   display all unmerged commits (verbose)
      |  --remote   compare remote branches instead of local branches
      |  --upstream <branch>   specify a specific upstream branch
      |
      |EXAMPLE: check for all unmerged commits
      |  #{$0}
      |
      |EXAMPLE: check for all unmerged commits and merged commits (but with a different SHA)
      |  #{$0} -a
      |
      |EXAMPLE: use a different upstream than master
      |  #{$0} --upstream otherbranch
      |
      |EXAMPLE: compare remote branches against origin/master
      |  #{$0} --remote
      |
      |GITCONFIG:
      |  If you name this file git-unmerged and place it somewhere in your PATH
      |  you will be able to type "git unmerged" to use it. If you'd like to name
      |  it something else and still refer to it with "git unmerged" then you'll
      |  need to set up an alias:
      |      git config --global alias.unmerged \\!#{$0}
      |
      |Version: #{VERSION}
      |Author: Zach Dennis <zdennis@mutuallyhuman.com>
    EOT
    exit
  end
   
  def print_version
    puts "#{VERSION}"
  end
     
  def branch_description
    local? ? "local" : "remote"
  end
   
  def print_specifics
    load
    if branches.any_missing_commits?
      print_breakdown
    else
      puts "There are no #{branch_description} branches out of sync with #{upstream}"
    end
  end
   
  def print_breakdown
    puts "Below is a breakdown for each branch. Here's a legend:"
    puts
    print_legend
    branches.each do |branch|
      puts
      print "#{branch.name}:"
      if branch.unmerged_commits.empty? && !show_equivalent_commits?
        print "(no umerged commits, must have merged commits with different SHAs)\n"
      else
        puts
      end
      branch.unmerged_commits.each { |commit| puts yellow(commit.to_s) }
      if show_equivalent_commits?
        branch.equivalent_commits.each do |commit|
          puts green(commit.to_s)
        end
      end
    end
  end
   
  def print_legend
    load
    puts "  " + yellow("yellow") + " commits have not been merged"
    puts "  " + green("green") + " commits have equivalent changes in #{UPSTREAM} but different SHAs" if show_equivalent_commits?
  end
   
  def show_help? ; @options[:show_help] ; end
  def show_equivalent_commits? ; @options[:show_equivalent_commits] ; end
  def show_version? ; @options[:show_version] ; end
  def upstream
    if @options[:upstream]
      @options[:upstream]
    elsif local?
      "master"
    elsif remote?
      "origin/master"
    end
  end
   
  private
   
  def extract_options_from_args(args)
    if args.include?("--remote")
      @options[:remote] = true
    else
      @options[:local] = true
    end
    @options[:show_help] = true if args.include?("-h") || args.include?("--help")
    @options[:show_equivalent_commits] = true if args.include?("-a")
    @options[:show_version] = true if args.include?("-v") || args.include?("--version")
    if index=args.index("--upstream")
      @options[:upstream] = args[index+1]
    end
  end
   
  def local? ; @options[:local] ; end
  def remote? ; @options[:remote] ; end
end
 
unmerged = GitUnmerged.new ARGV
UPSTREAM = unmerged.upstream
if unmerged.show_help?
  unmerged.print_help
  exit
elsif unmerged.show_version?
  unmerged.print_version
  exit
else
  unmerged.print_overview
  puts
  unmerged.print_specifics
end

Bye bye Ruby, hello Groovy

Tue, 17 Mar 2009 19:08:35 -0400

I first time discovered Ruby back in 2006 (yes, I know, I was late to the game), and immediately fell in love with it. The dynamic nature of the language, the consistency, pure esthaetics and practicality certainly changed the way how I saw software development and programming languages.

Since that time, I made several attempts to integrate Ruby into my professional life and make it part of the toolbox. It was cool to play with Ruby in my spare time, but I wanted to use it on projects whose main development language/platform was mainly Java. Use it as scripting, glue language. Use it as toolkit language to e.g. generate test data, access databases, convert files, build projects and maybe even build a piece of Web applications (admin apps for example).

Rails 2 - really good tutorial

Tue, 25 Mar 2008 23:09:55 -0400

Akita published two part tutorial that leads you through building the famous 15 minute blog application in Rails 2.0. Read the parts one and two - or follow the screencast by the same author.

Thanks a lot, Akita - very nicely done !

Starting Ruby on Rails 2 with Netbeans and AWDWR book

Mon, 17 Mar 2008 20:11:08 -0400

After some break, I got back to Rails land. The return is not as smooth as I hoped: since Rails 2.0, many things work differently and quite a few steps learned from "The Book" do not work any more. The issues are more often than not quite easy to fix, but there is quite a few of them.

All the following is related to NetbeansRuby build 6327 from Jan 26th with JRuby 1.1RC1

Showstopper issue with JRuby ?

Sun, 16 Mar 2008 23:36:26 -0400

After some break, I dusted off the Ruby to try out one interesting idea Peter presented yesterday that literally ASKS for Rails. So I grabbed the latest and greatest RubyNetBeans from Ruby Hudson. For some reason it stopped updates on January 26th so the latest version I have got was build 6327. It is bundled with JRuby 1.1RC1 and the Rails version that comes preinstalled is 1.2.6. Using the menu Tools -> Ruby Gems, they can be easily upgraded to latest and greatest 2.0.2.

JRuby - keeping your database.yml really DRY

Thu, 03 Jan 2008 11:15:26 -0500

I am experimenting in JRuby and use database in virtual machine (VMWare Fusion). This is great because you can have multiple versions of multiple databases ready without polluting the notebook. One downsize though is that IP address of the database will change between the VM restarts.

First important setting in Fusion is to use the 'NAT' option rather than 'Bridged'. With NAT, you database host IP address will not follow the network. It was quite annoying to change it from 192.168.X to 192.168.Y everytime I reconnected at home from work or vice versa.

JRuby trunk - issues with JDBC connectivity

Fri, 28 Dec 2007 22:24:37 -0500

Following the book on JRuby I am discovering small differences when trying the examples. After installing activerecord-jdbc gem which is available in version 0.5, the shoplet application fails with Rails 2.0, as soon as you click on the 'About your application environment' link.

    => Booting Mongrel (use 'script/server webrick' to force WEBrick)
    => Rails application starting on http://0.0.0.0:3000
    => Call with -d to detach
    => Ctrl-C to shutdown server
    ** Starting Mongrel listening at 0.0.0.0:3000
    ** Starting Rails with development environment...
    ** Rails loaded.
    ** Loading any Rails specific GemPlugins
    ** Signals ready.  TERM => stop.  USR2 => restart.  INT => stop (no restart).
    ** Rails signals registered.  HUP => reload (without restart).  It might not work well.
    ** Mongrel 1.1.2 available at 0.0.0.0:3000
    ** Use CTRL-C to stop.

    Processing InfoController#properties (for 127.0.0.1 at 2007-12-23 23:13:25) [GET]
    Session ID: BAh7BiIKZmxhc2hJQzonQWN0aW9uQ29udHJvbGxlcjo6Rmxhc2g6OkZsYXNo%0ASGFzaHsABjoKQHVzZWR7AA%3D%3D--9791be23205677745e457b5bf62c50eba6e3813f
    Parameters: {"controller"=>"rails/info", "action"=>"properties"}
    Exception in thread "Ruby Thread11043409" java.lang.NoSuchMethodError: org.jruby.runtime.builtin.IRubyObject.setInstanceVariable(Ljava/lang/String;Lorg/jruby/runtime/builtin/IRubyObject;)Lorg/jruby/runtime/builtin/IRubyObject;
    at JdbcAdapterInternalService.set_connection(JdbcAdapterInternalService.java:122)
    at JdbcAdapterInternalServiceInvoker$set_connection_FS1.call(Unknown Source)
    at org.jruby.runtime.callback.FastInvocationCallback.execute(FastInvocationCallback.java:55)
    at org.jruby.internal.runtime.methods.SimpleCallbackMethod.call(SimpleCallbackMethod.java:70)
    at org.jruby.runtime.CallSite$InlineCachingCallSite.call(CallSite.java:158)
    at org.jruby.runtime.CallSite$ArgumentBoxingCallSite.call(CallSite.java:103)
    at org.jruby.evaluator.ASTInterpreter.fCallNode(ASTInterpreter.java:1092)
    at org.jruby.evaluator.ASTInterpreter.evalInternal(ASTInterpreter.java:345)
    at org.jruby.evaluator.ASTInterpreter.blockNode(ASTInterpreter.java:626)
    at org.jruby.evaluator.ASTInterpreter.evalInternal(ASTInterpreter.java:293)
    at org.jruby.evaluator.ASTInterpreter.eval(ASTInterpreter.java:168)
    at org.jruby.internal.runtime.methods.DefaultMethod.call(DefaultMethod.java:147)
    at org.jruby.runtime.CallSite$InlineCachingCallSite.call(CallSite.java:158)
    at org.jruby.runtime.CallSite$ArgumentBoxingCallSite.call(CallSite.java:76)
    at org.jruby.evaluator.ASTInterpreter.vcallNode(ASTInterpreter.java:1734)
    at org.jruby.evaluator.ASTInterpreter.evalInternal(ASTInterpreter.java:474)
    at org.jruby.evaluator.ASTInterpreter.blockNode(ASTInterpreter.java:626)
    at org.jruby.evaluator.ASTInterpreter.evalInternal(ASTInterpreter.java:293)
    at org.jruby.evaluator.ASTInterpreter.rescueNode(ASTInterpreter.java:1499)
    at org.jruby.evaluator.ASTInterpreter.evalInternal(ASTInterpreter.java:442)
    at org.jruby.evaluator.ASTInterpreter.eval(ASTInterpreter.java:168)

I found out that there is newer version of activerecord-jdbc, which is also renamed to activerecord-jdbc-adapter. It is important to uninstall the old gem as well as install the new one, otherwise the application will not work.

Installation of Mongrel gem on JRuby

Sun, 23 Dec 2007 20:22:50 -0500

I bought the Ola Bini's eBook on JRuby and started to work through the examples. The installation of the Mongrel gem in JRuby (trunk revision 5341 fails with the following error code:

``` $ jruby -S gem install -y mongrel> INFO: `gem install -y` is now default and will be removed> INFO: use --ignore-dependencies to install only the gems you list> Building native extensions. This could take a while...> extconf.rb:1:in `require': no such file to load -- mkmf (LoadError)> ERROR: Error installing mongrel:> ERROR: Failed to build gem native extension.[/sourcecode]> This error is logged in JIRA with id JRUBY-1771Workaround (possibly applicable for other gems is to explicitly specify the plaform:> [sourcecode language='ruby']> $ jruby -S gem install -y mongrel --platform jruby> INFO: `gem install -y` is now default and will be removed> INFO: use --ignore-dependencies to install only the gems you list> Successfully installed mongrel-1.1.2> 1 gem installed> Installing ri documentation for mongrel-1.1.2...> Installing RDoc documentation for mongrel-1.1.2... ```

Free PDF ebook 'Build your own Ruby on Rails Application'

Tue, 02 Oct 2007 23:09:17 -0400

For sixty more days (actually 59 days and 17 hours as of Time.now, or if you prefer to speak Javaish rather than Rubyish, new java.util.Date()) you will be able to download free PDF version of the book by Patrick Lenz Build Your Own Ruby on Rails Web Applications - courtesy of nice guys of Sitepoint.

The book download page is here, no strings attached - all it will cost you is disclosing an email address (book download link will be emailed to you) and bandwidth to get the 20 MB PDF. Mine is downloading right now, so I cannot tell anything about the book yet. It has 447 pages and from the table of content it looks like solid beginner's book.

Petstore for Ruby/JRuby

Mon, 01 Oct 2007 23:27:37 -0400

There is - after all - a Petstore implementation for Ruby. Somebody asked a question at the DZone and the response posted by Raphael Valyi was:

Re: Is there a Pet Store in Grails/Rails?

I'm speaking here for the Rails (JRuby) side:
there is actually a petstore, it can be found there:
http://viewvc.rubyforge.mmmultiworks.com/cgi/viewvc.cgi/?root=tw-commons

Some guys used it to compare C-Ruby vs JRuby performance:
http://www.nabble.com/JRuby-vs-MRI---Petstore-shootout-t4289470.html

Ruby is in top ten programming languages

Sun, 30 Sep 2007 23:04:14 -0400

According to the TIOBE Programming Community index (which gives an indication of the popularity of programming languages), Ruby jumped 3 places and made it to top ten. Congratulations !

If you look closely on the trends down on the page, the dynamically languages popularity has risen over 3.6% during year period. Which is A Good Thing (TM).

Should I make my personal Top Ten of the programming languages, ordering languages by my degree of comfort of using the language, the language beauty (which is, in the eye of the beholder ;-)). Factoring in also how much I do enjoy reading/writing code in that language and it's usefulness from both personal as well professional point of view, the index would look like this:

Netbeans Ruby IDE - great tool getting even better !

Sun, 24 Jun 2007 23:08:11 -0400

I have spent last two days (and few evenings before) playing with Rails and using Netbeans Ruby IDE. What a great experience ! Unlike before, it is so much easier to have really good debugger that allows put breakpoints not only into the Ruby code in controllers and model - but even into the RHTML view files !

Netbeans team works hard on improving the tool. With latest build - 2434, I have noticed great addition - Rails console. The IDE had IRB window even before, but the environment did not load the Rails context and would not recognize e.g. ActiveRecord. Now with latest build, everything works like charm.

BOTD: Railscast

Tue, 19 Jun 2007 22:06:03 -0400

Today's blog of the day is not really a blog, but a screencast. Dedicated to Ruby on Rails, the Railscast offers (as of today) 46 episodes of short, targeted practical advice on various aspects of Rails development.

Unlike some other screencasts who try to record the screen action as MPEG movie, this one is perfectly legible. In addition to the Rails enlightenment, you can also enjoy the speed and aesthetics of using TextMate - with many great Ruby editing shortcuts and beautiful OS-X typography.

Swing-ing back - to Netbeans

Mon, 11 Jun 2007 22:22:35 -0400

It has been quite some time since I used a Swing based Java application. Compared to beauty and close-to-native feeling of Eclipse based application, Swing just did not feel right - it looked differently and behaved a bit differently. For long time, my desktop was Swing-free (not counting the JDK demo). Not any more, though.

What made me to reconsider, is new release of the Netbeans v 6. In the latest milestone builds (M6 to M9), Netbeans team built amazing Ruby development environment. Compared to Ruby plugin in Eclipse, it has way more functionality, better debugging, really impressive editing support and very cool Rails extensions. The full description of new features is here.

Martin Fowler's article on Ruby and Microsoft

Sun, 03 Jun 2007 22:25:44 -0400

There has been lots of interesting news related to Microsof and Ruby recently, mostly about DLR's support of dynamic languages. One of my favorite tech authors stirred the waters once again last Friday with an article that goes beyond this and tries to paint larger picture of the uneasy relation between Ruby platform, Agile movement, OpenSource Community and Microsoft.

One quote from the article:

The attitude to open-source is a large part of this problem. When Java appeared there were yawning gaps in its portfolio, and worse some dreadful standard tools in its API (visions of Entity Beans spring to mind). Those gaps and bad ideas were fixed by the open-source community. Ant gave us a build tool, EJB was displaced by Spring and Hibernate. .NET has also got its gaps, and again the open source community has stepped up to fill them. Yet Microsoft refuses to collaborate with these efforts, even seems to go out of its way to undermine them. I was particularly sickened by Microsoft's reaction to NUnit - an excellent XUnit testing tool, elements of whose design were lauded by Anders Hejlsberg at OOPSLA. Microsoft ended not just bringing out a competitive library, but deliberately making it incompatible. That's not the kind of reaction that encourages people to invest their time in the platform.

Code in Ruby under ASP.NET: coming soon ?

Sat, 02 Jun 2007 22:33:27 -0400

The support for using dynamic languages such as Ruby or Python to code ASP.NET pages was announced for future versions of ASP.NET in the ASP.NET futures.

Unless I am mistaken, it means that we eventually will be able to write control event handlers in Python or even Ruby - which is certainly more fun than in VB.NET or even in C#, but is it really so important ?

What would be *really* cool if the whole ASP.NET become more agile and more "rail-ish". To make overall architecture more flexible - such as departure from not very flexible page-centric architecture towards MVC and routing. Maybe some version of ActiveRecord ? Or even multiple (and pluggable) template languages ? That would be really something.

Rails' ideas everywhere

Wed, 09 May 2007 22:22:10 -0400

Since I got through "Rails immersion", I keep seeing the implementations of the same idea everywhere. Latest find is Subsonic, which implements Active Records in .NET space. Rather than writing more, see this screencast.

Best book for Ruby on Rails

Mon, 07 May 2007 20:41:16 -0400

During last two weeks I have been reading and playing a lot with Rails. Now I am in the state where I think I started to "get it" and understand how things work under the surface. Which means I am ready actually start using the framework for real work and become proficient as I get my hands dirty.

To get to this state, absolutely essential and by far the best book is the classic one - Agile Web development with Rails co-authored by the original Rails designer and one of the Pragmatic Programmers. Like other books, the first part is sort of step-by-step code tutorial, which leads you through creation of a Rails application, shows you how you access data, create UI, use scaffolding, etc etc. Unlike other books, this does not stop there and the second part of the book is an excellent coverage of Rails internals - ActiveRecord, ActiveView and templating system. Very well written and offering great balance between covering important features without becoming reference manual.

Microsoft is getting more dynamic

Tue, 01 May 2007 22:08:12 -0400

at least as the programming language languages are concerned. One of the things that will be presented on the MIX07 is Dynamic Language Runtime, a new platform suitable to host high level, dynamic languages such as Python and Ruby. For Python, there is already pretty decent .NET implementation - namely IronPython. What is coming now is IronPython 2.0 based on the DLR as well as - yesss - IronRuby.

It is great that this is happening. In Java world, JRuby is very close to being full implementation of the language. The speed of the JRuby is still not quite in the proximity of the C implementation, but the large selling point of JRuby is its capability of deploying Ruby application (or even a Rails application) inside Tomcat or any other Java Web container. This removes largest obstacle of using Ruby in enterprise environment - namely being "new" and not approved platform. When the .NET runtime will be able to host Ruby code, acceptance in enterprise space will be even higher.

Accessing SQL Server 2005 from Ruby

Wed, 25 Apr 2007 23:58:13 -0400

The natural gravity of our environment keeps pulling me out of scripting and Ruby world back to .Net zone :-). Out of curiosity, I looked into how easy or hard is it to access other database from Ruby, than the default MySQL which dominates all books, samples and tutorials.

I have found three ways (at least), one likely platform independent and two Windows only. The platform independent requires module ADO.rb and works with the DBI interface. This sounds very similar to the way how Perl used to access databases, so I put this at the end of the list (some details are here). First Windows only methods used ODBC - no, thanks. Configuring machine specific data sources is not the way I wanted.

In praise of the polyglot

Tue, 24 Apr 2007 23:55:34 -0400

If you've ever envied the ability of multilingual friends to bridge language gaps wherever they travel or gained new appreciation for your native language by learning a new one, then you can probably see the advantage of being a programming language polyglot. Developer polyglots travel the IT world more freely than do monolinguists (sure that they can apply their skills in any environment), and they also tend to better appreciate the programming language called home, because among other things they know the roots from which that home is sprung. Isn't it time you became a polyglot?

Gems and bookmarks

Mon, 09 Apr 2007 22:36:06 -0400

This was one great weekend ! Easter should be more often than once a year, I guess. Unlike Christmas, there was no shopping craziness before and much less overeating danger. Not counting overdose of chocolate, of course, but that's OK.

I managed do mostly nothing for about one day - up to Friday evening. Then I dived into the Ruby and Ruby on Rails world. After reading this and one third of this book, I like Ruby even more. I actually did write some code - not much, but rewrote some of my old Python scripts I use to manage files and repositories. The new Ruby version is shorter and IMHO more elegant (even with my limited command of Ruby idioms), much better readable - albeit a bit slower than Python version. But that does not change my very positive impression of new language. In addition to these (and btw, the mixin's are so great it is even scary), I learned to love the Rake and gem tools. Gem is pre-packaged Ruby component, managed as unit, that can be installed and updated remotely using the gem tool. It solves the problem of versioning - something I wished Java had from the beginning. It also provide similar functionality as the GAC in .NET: allows side-by-side existence of multiple versions of the same component and makes component available to other programs. Very clever, very convenient. Same story as with the language - gem is something similar that Perl did have with CPAN, but it is just cleaner, nicer and polished ...

Couple of things I really like about Ruby

Sun, 01 Apr 2007 22:45:29 -0400

I guess it is too early to write any more systematic opinion about the language you know less than 10 days, but after reading the Programming Ruby 2nd edition (thank you, Safari Books) I have found out that I actually do like couple of Ruby features a lot. Your mileage may vary - what speaks here is my Java/C#/C++/C/Python/Perl background and bias. Here there are my favorite Ruby-isms (so far) in no particular order:

Managing knowledge portfolio

Sun, 25 Mar 2007 22:50:43 -0400

There are few technical books which you enjoy first time you read them, remember the experience and keep coming back. One of such classic books is The Pragmatic Programmer - from journeyman to master - by David Thomas and Andrew Hunt. If you have not read it, get it, it is worth every cent. Since the book was written - ages ago, back in 2000 - it did not loose anything of its freshness and value - which one cannot say about most of technical books written earlier than 2-3 years ago. Inspired by the success of their initial creation, Dave and Andrew started the website and continued writing whole Pragmatic Programmer series of books.