Example groovy2ruby translation

gistfile1.groovy

class Foo {

  String firstName

  Foo (firstName) {
    this.firstName = firstName
    firstName.each { letter -> letter.upcase() }
  }

  def fooBar () {
    println "foo"
    (1..10).each { i ->
      println i
    }

    (1..10).inject(1) { sum, i ->
      sum + i
    }

    try {
      twoArguments(1, 3)
    } catch (Exception e) {
      e.doSomething()
    } finally {
      this.somethingElse()
      1 + 1
    }

    def someArray = ['foo', 'bar']
    def someMap = [ someKey : 'bar', someOtherKey : 'foo' ]
    def anotherMap = [:]

    someArray[0]
    someMap['foo']




    switch (order.orderType.id) {
      case 'PO' : return updatePurchaseOrderDependentProperties (order) ; break
      case 'SO' : return updateSalesOrderDependentProperties (order) ; break
      case 'TRANSFER' : return updateTransferOrderDependentProperties (order) ; break
      case 'RETURN' : return updateReturnOrderDependentProperties (order) ; break
      default   : throw new RuntimeException ("ERROR: Unhandled order type: ${order.orderType.id}.")
    }

  }

  def somethingElse () {
    println "somethingElse"
  }

  def twoArguments (foo, bar) {
    if (foo instanceof Bar) {
      "woohoo"
    }
    "foo = ${foo} self.bar(self.foo()) =  ${self.bar(self.getFoo())} twoArguments(foo, bar) = ${twoArguments foo, bar}"
  }
}

class Bar extends Foo {
  def fooBar () {
    println "bar"
  }
}

gistfile2.rb

# This file was created using groovy2ruby.

class Foo

  attr_accessor :first_name 

  def initialize (first_name)
    self.first_name = first_name
    first_name.each do |letter|
      letter.upcase
    end
  end

  def foo_bar
    puts('foo')
    (1..10).each do |i|
      puts(i)
    end
    (1..10).inject(1) do |sum, i|
      sum + i
    end
    begin
      self.two_arguments(1, 3)
    rescue e
      e.do_something
    ensure
      self.something_else
      1 + 1
    end
    some_array = ['foo', 'bar']
    some_map = {'some_key' => 'bar', 'some_other_key' => 'foo'}
    another_map = {}
    some_array[0]
    some_map['foo']
    case order.order_type.id
      when 'PO'
        return self.update_purchase_order_dependent_properties(order)
        break
      when 'SO'
        return self.update_sales_order_dependent_properties(order)
        break
      when 'TRANSFER'
        return self.update_transfer_order_dependent_properties(order)
        break
      when 'RETURN'
        return self.update_return_order_dependent_properties(order)
        break
      else
        raise RuntimeException.new("ERROR: Unhandled order type: #{order.order_type.id}.")
    end
  end

  def something_else
    puts('somethingElse')
  end

  def two_arguments (foo, bar)
    if foo.is_a(Bar)
      'woohoo'
    end
    "foo = #{foo} self.bar(self.foo()) =  #{self.bar(self.get_foo)} twoArguments(foo, bar) = #{self.two_arguments(foo, bar)}"
  end

end

class Bar < Foo

  def foo_bar
    puts('bar')
  end

end