I have just released ruby-plsql gem version 0.4.0 which provides many new features. You can read about initial versions of ruby-plsql in previous blog posts.

Oracle complex data type support

Initial versions of ruby-plsql supported just simple Oracle types like NUMBER, VARCHAR2, DATE, TIMESTAMP, CLOB, BLOB as PL/SQL procedure parameters. Now support for many more complex data types is added. See examples below how to call PL/SQL procedures with these complex data types.

PL/SQL Record

Let’s assume you have PL/SQL procedure with PL/SQL record type parameter (which most typically will be in table%ROWTYPE format):

CREATE TABLE test_employees (
          employee_id   NUMBER(15),
          first_name    VARCHAR2(50),
          last_name     VARCHAR2(50),
          hire_date     DATE
        );
CREATE OR REPLACE FUNCTION test_full_name (p_employee test_employees%ROWTYPE)
RETURN VARCHAR2 IS
BEGIN
  RETURN p_employee.first_name || ' ' || p_employee.last_name;
END;

Then you can create Ruby Hash with record field values (specifying field names as Symbols), e.g.:

p_employee = {
  :employee_id => 1,
  :first_name => 'First',
  :last_name => 'Last',
  :hire_date => Time.local(2000,01,31)
}

and pass this Hash as a parameter which will be translated to PL/SQL record parameter by ruby-plsql:

plsql.test_full_name(p_employee) #=> "First Last"
# or
plsql.test_full_name(:p_employee => p_employee) #=> "First Last"

In the same way you can get PL/SQL function return values or output parameter values as Hash values.

Object type

In similar way also object type parameters can be passed as Hash values. In this case also nested objects or nested collections of objects are supported:

CREATE OR REPLACE TYPE t_address AS OBJECT (
  street    VARCHAR2(50),
  city      VARCHAR2(50),
  country   VARCHAR2(50)
);
CREATE OR REPLACE TYPE t_phone AS OBJECT (
  type            VARCHAR2(10),
  phone_number    VARCHAR2(50)
);
CREATE OR REPLACE TYPE t_phones AS TABLE OF T_PHONE;
CREATE OR REPLACE TYPE t_employee AS OBJECT (
  employee_id   NUMBER(15),
  first_name    VARCHAR2(50),
  last_name     VARCHAR2(50),
  hire_date     DATE,
  address       t_address,
  phones        t_phones
);
CREATE OR REPLACE FUNCTION test_full_name (p_employee t_employee)
  RETURN VARCHAR2
IS
BEGIN
  RETURN p_employee.first_name || ' ' || p_employee.last_name;
END;

and from Ruby side you can call this PL/SQL function as:

p_employee = {
  :employee_id => 1,
  :first_name => 'First',
  :last_name => 'Last',
  :hire_date => Time.local(2000,01,31),
  :address => {:street => 'Main street 1', :city => 'Riga', :country => 'Latvia'},
  :phones => [{:type => 'mobile', :phone_number => '123456'}, {:type => 'home', :phone_number => '654321'}]
}
plsql.test_full_name(p_employee) #=> "First Last"
# or
plsql.test_full_name(:p_employee => p_employee) #=> "First Last"

And also object type return values and output parameters will be returned as Ruby Hash values (with nested Hashes or Arrays if necessary).

There is one limitation that these object types should be defined as database types and not just inside PL/SQL package definition. Unfortunately you cannot access type definitions inside packages from OCI or JDBC drivers and as a result cannot call such procedures from outside of PL/SQL.

TABLE and VARRAY collections

TABLE and VARRAY collection parameters can be passed as Array values:

CREATE OR REPLACE TYPE t_numbers AS TABLE OF NUMBER(15);
CREATE OR REPLACE FUNCTION test_sum (p_numbers IN t_numbers)
  RETURN NUMBER
IS
  l_sum   NUMBER(15) := 0;
BEGIN
  IF p_numbers.COUNT > 0 THEN
    FOR i IN p_numbers.FIRST..p_numbers.LAST LOOP
      IF p_numbers.EXISTS(i) THEN
        l_sum := l_sum + p_numbers(i);
      END IF;
    END LOOP;
    RETURN l_sum;
  ELSE
    RETURN NULL;
  END IF;
END;

And from Ruby side:

plsql.test_sum([1,2,3,4]) #=> 10

CURSOR

You can get also cursor return values from PL/SQL procedures:

CREATE OR REPLACE FUNCTION test_cursor
  RETURN SYS_REFCURSOR
IS
  l_cursor  SYS_REFCURSOR;
BEGIN
  OPEN l_cursor FOR
  SELECT * FROM test_employees ORDER BY employee_id;
  RETURN l_cursor;
END;

can be called from Ruby in the following way:

plsql.test_cursor do |cursor|
  cursor.fetch #=> first row from test_employees will be returned
end

It is important to pass block parameter in this case and do something with returned cursor within this block as after ruby-plsql finishes PL/SQL procedure call it will close all open cursors and therefore it will not be possible to do anything with returned cursor outside this block.

It is also possible to use returned cursor as input parameter for another PL/SQL procedure:

CREATE OR REPLACE FUNCTION test_cursor_fetch(p_cursor SYS_REFCURSOR)
  RETURN test_employees%ROWTYPE
IS
  l_record  test_employees%ROWTYPE;
BEGIN
  FETCH p_cursor INTO l_record;
  RETURN l_record;
END;

plsql.test_cursor do |cursor|
  plsql.test_cursor_fetch(cursor) #=> first record as Hash
end

Note: you can pass cursors as PL/SQL procedure input parameter just when using ruby-plsql on MRI 1.8/1.9 with ruby-oci8, unfortunately I have not found a way how to pass cursor as input parameter when using JRuby and JDBC.

BOOLEAN

And finally you can use also PL/SQL BOOLEAN type – it is quite tricky data type as it is supported just by PL/SQL but not supported as data type in Oracle tables. But now you can also use it with ruby-plsql:

CREATE OR REPLACE FUNCTION test_boolean
  ( p_boolean BOOLEAN )
  RETURN BOOLEAN
IS
BEGIN
  RETURN p_boolean;
END;

plsql.test_boolean(true) #=> true

You can find more PL/SQL procedure call usage examples in ruby-plsql RSpec tests.

Table and sequence operations

I have been using and promoting to others ruby-plsql as PL/SQL procedure unit testing tool. As current PL/SQL unit testing tools are not so advanced and easy to use as Ruby unit testing tools then I like better to use Ruby testing tools (like RSpec) together with ruby-plsql to write short and easy to understand PL/SQL unit tests.

In unit tests in setup and teardown methods you typically need some easy way how to create some sample data in necessary tables as well as to validate resulting data in tables after test execution.

If you are Ruby on Rails developer then you probably will use ActiveRecord (or DataMapper) for manipulation of table data. But if Ruby is used just for unit tests then probably ActiveRecord would be too complicated for this task.

Therefore I added some basic table operations to ruby-plsql which might be useful e.g. in unit tests. Some syntax ideas for these table operations are coming from Sequel Ruby library.

INSERT

# insert one record
employee = { :employee_id => 1, :first_name => 'First', :last_name => 'Last', :hire_date => Time.local(2000,01,31) }
plsql.employees.insert employee # INSERT INTO employees VALUES (1, 'First', 'Last', ...)

# insert many records
employees = [employee1, employee2, ... ]  # array of many Hashes
plsql.employees.insert employees

If primary key values should be selected from sequence then you can get next sequence values with

plsql.employees_seq.nextval # SELECT employees_seq.NEXTVAL FROM dual
plsql.employees_seq.currval # SELECT employees_seq.CURRVAL FROM dual

SELECT

# select one record
plsql.employees.first # SELECT * FROM employees
                      # fetch first row => {:employee_id => ..., :first_name => '...', ...}
plsql.employees.first(:employee_id => 1)  # SELECT * FROM employees WHERE employee_id = 1
plsql.employees.first("WHERE employee_id = 1")
plsql.employees.first("WHERE employee_id = :employee_id", 1)
# select many records
plsql.employees.all                       # => [{...}, {...}, ...]
plsql.employees.all(:order_by => :employee_id)
plsql.employees.all("WHERE employee_id > :employee_id", 5)

# count records
plsql.employees.count                     # SELECT COUNT(*) FROM employees
plsql.employees.count("WHERE employee_id > :employee_id", 5)

UPDATE

# update records
plsql.employees.update(:first_name => 'Second', :where => {:employee_id => 1})
                      # UPDATE employees SET first_name = 'Second' WHERE employee_id = 1

DELETE

# delete records
plsql.employees.delete(:employee_id => 1) # DELETE FROM employees WHERE employee_id = 1

Other SQL statements

Any other SELECT statement can be executed with

plsql.select :first, "SELECT ..."
# or
plsql.select :all, "SELECT ..."

or any other non-SELECT SQL statement can be executed with

plsql.execute "..."

And also COMMIT or ROLLBACK could be executed simply with

plsql.commit
plsql.rollback

I plan to write a separate blog post about how I recommend to create PL/SQL unit tests using Ruby and ruby-plsql and RSpec.

Install

As always you can install latest version of ruby-plsql with

gem install ruby-plsql

Latest gem version is just on Gemcutter but now it should be available as default gem source for all Ruby installations.

And as always ruby-plsql is supported both on

• Ruby 1.8.6/1.8.7 or Ruby 1.9.1 with ruby-oci8 gem version 2.0.3 or later (some specific issues with complex data types will be fixed in later versions of ruby-oci8)
• JRuby 1.3/1.4 with Oracle JDBC driver (testing mainly with ojdbc14.jar but also ojdbc5.jar or ojdbc6.jar should be fine)

Please try it out and tell me if there are any issues with some particular data types or if there are still some unsupported PL/SQL data types that you would like to be supported in ruby-plsql. And also I encourage you to try ruby-plsql out for PL/SQL unit testing if you had no PL/SQL unit tests previously

There are lots of options available for deploying #juby on #rails apps, from glassfish, to mongrel, to jboss. Along came an excellent solution for #jruby on #rails developers called #torquebox. It’s an enterprise level deployment environment for #jruby on #rails apps built ontop of #jboss, with several nice features built into it. These currently include support for job scheduling outside of cron that actually deploys with your application, task queues built on top of JMS topics, and even SOAP & SIP (telecom) integration.

Torquebox can be installed two different ways:
1) Download the entire #torquebox package and follow the instructions on torquebox.org. This includes jruby, JBoss AS 5 and torquebox gems and jars for deploying apps.
2) Modify an existing JBoss AS 5 with a single jar.

Since most users of ruby on rails already have some version of ruby on their system, but most don’t have jboss, I’ll provide an easy way to get started with option #1. I know this is only a small contribution back to the j/ruby community, but I think it will help provide the lowest cost to entry for most #ruby on #rails developers wishing to transition to a stable #jruby on #rails deployment environment.

To help get you started, I’ve put together a script to download #torquebox, unzip it, add a symlink, append the .bash_profile, & install jruby-openssl.
I put together a script to download #torquebox, unzip it, add a symlink, append the .bash_profile, & install jruby-openssl.

require 'rubygems'
require 'net/http'
require 'logger'

class TorqueboxInstaller

  def initialize( torquebox_version = '1.0.0.Beta18' )
    @torquebox_version = torquebox_version
    yield self if block_given?
  end

  def download
    if File.exist?( torquebox_zip_file )
      logger.info "#{torquebox_zip_file} already exists."
    else
      logger.info "About to download #{torquebox_zip_file}..."
      uri = "http://repository.torquebox.org/maven2/releases" +
               "/org/torquebox/torquebox-bin/" +
              "#{@torquebox_version}/#{torquebox_zip_file}"
      `curl #{uri} -O #{torquebox_zip_file}`
      logger.info "Downloading of #{torquebox_zip_file} complete."
    end
  end

  def unzip
    if File.exist?( "#{torquebox_directory}" )
      logger.info "#{torquebox_directory} already exists.  Not unzipping."
    else
      logger.info "Unzipping #{torquebox_zip_file}"
      `unzip #{torquebox_zip_file}`
    end
  end

  def symlink
    logger.info "Creating symlink torquebox-current " +
         " for #{torquebox_directory}"
    `rm torquebox-current` if File.exist?( "torquebox-current" )
    `ln -s #{torquebox_directory}/ torquebox-current`
  end

  def append_bash_profile
    logger.info "Append the bash profile"
    File.open("#{ENV['HOME']}/.bash_profile", "a") do |file|
      file.puts("# environment variables for torquebox ")
      file.puts("export TORQUEBOX_HOME=#{ENV['PWD']}" +
                                "/#{torquebox_directory}")
      file.puts("export JRUBY_HOME=$TORQUEBOX_HOME/jruby")
      file.puts("export JBOSS_HOME=$TORQUEBOX_HOME/jboss")
      file.puts("export PATH=$TORQUEBOX_HOME/bin:" +
                    "$JRUBY_HOME/bin:$JBOSS_HOME/bin:$PATH")
    end
  end

  def install_dependencies
    logger.info "Installing SSL support"
    exec "source ~/.bash_profile && jruby -S gem install jruby-openssl"
  end

  def torquebox_zip_file
    torquebox_zip_file = "torquebox-bin-#{@torquebox_version}.zip"
  end

  def torquebox_directory
    "torquebox-#{@torquebox_version}-bin"
  end

  def logger
    @logger ||= Logger.new( STDOUT )
  end
end

TorqueboxInstaller.new do |installer|
  installer.download
  installer.unzip
  installer.symlink
  installer.append_bash_profile
  installer.install_dependencies
end

Estes dias, estava vendo uns projetos antigos e lembrei de um framework bem legal para Java chamado ZK. O problema do ZK é que você consegue aproveitar o máximo dele quando você programa usando Servlets, e não usando o modelo ZUL dele. Lembrei de alguns projetos que fiz, de algumas coisas interessantes que ele fazia e também lembrei que eu cheguei a programar com Servlet em Ruby, e aqui vai como eu fiz mais esse trabalho para evitar Java. NOTA: Isso funciona com qualquer framework Java, seja ele ZK ou Echo2 ou qualquer outro, porque na verdade o que você faz é escrever algumas linhas de código de “cola” e depois passa o controle para o JRuby

A primeira coisa que você precisa é do JRuby instalado, e de um compilador Java. Crie seu projeto normalmente, e provavelmente você terá uma classe que será responsável por instanciar a primeira classe (janela, página, seja lá o que for) do seu Servlet. Nesse ponto que a “mágica” acontece. Para simplificar as coisas, que vou criar uma classe (chamada Inicial) que instanciará uma JFrame. Toda a JFrame será definida em JRuby.

O processo: Basicamente, o que faremos é o seguinte: Criaremos uma classe abstrata (Janela), e nesta classe criaremos uma função, que será usada pelo JRuby. Na classe de “cola”, instanciaremos um interpretador JRuby, rodaremos um código para instanciar a classe do Ruby e faremos um “casting” desse objeto para a classe abstrata. Primeiro, a classe abstrata:

Arquivo Janela.java:
import javax.swing.*;

public abstract class Janela extends JFrame {
        public abstract void exibir();
}

Até aqui, nenhum segredo. A classe extende JFrame (quando você for usar seu Framework, ela deverá extender a “Window” do seu framework) e possui um método abstrato “exibir”. Agora, a classe em JRuby

Arquivo ruby/janela.rb
java_import 'javax.swing.JFrame'
java_import 'javax.swing.JButton'
java_import 'javax.swing.JOptionPane'

class Janela < Java::Janela
  def exibir
    set_size 300, 200

    self.default_close_operation = JFrame::EXIT_ON_CLOSE
    self.title = 'Uma janela qualquer'
    show

    puts "Exibi uma janela!!!"
  end
end

Caso você não esteja acostumado com JRuby usando Swing, ignore os detalhes da implementação. O que é importante é pensar que você está criando uma classe JRuby, que herda de Java::Janela (a janela que definimos no Java), e cria um método “exibir”. Agora, vem o código mais complicado, a classe Inicial que instanciará a classe Ruby:

Arquivo Inicial.java:
import java.util.*;
import org.jruby.*;
import org.jruby.javasupport.*;
import org.jruby.runtime.builtin.*;

public class Inicial {
    public static void main(String[] args) {
        Ruby rubyRuntime;

        //Inicia os "load paths", para indicar aonde o JRuby procurará os "require"s
        List<String> pathsLoad = new ArrayList<String>();
        pathsLoad.add("ruby/");
        pathsLoad.add("ruby/lib");

        //Instancia os serviços do JRuby
        rubyRuntime = JavaEmbedUtils.initialize(pathsLoad);
        //Carrega o arquivo "janela.rb"
        rubyRuntime.getLoadService().load("janela.rb", false);

        //Roda um comando JRuby, e captura o resultado
        Object janela_rb = rubyRuntime.evalScriptlet("Janela.new");
        //Transforma na classe abstrata
        Janela janela = (Janela)JavaEmbedUtils.rubyToJava(rubyRuntime,
                                 (IRubyObject) janela_rb, Janela.class);

        janela.exibir();
    }
}

Aqui, a mágica acontece: Cria-se um rubyRuntime, cria-se uma lista com os loadPaths (aonde o Ruby buscará os “require”s, que no meu caso eu destinei para a pasta “ruby” e “ruby/lib”. Então, instancia-se o rubyRuntime, pede-se para ele carregar o arquivo “janela.rb”, roda-se um comando bem simples (“Janela.new”) e captura o resultado, depois convertemos isso para uma classe Java. Como não temos uma definição de classe mesmo para Ruby, fazemos um “casting” para o Janela (classe abstrata no Java) e então finalmente rodamos o código “exibir”. Aparentemente, as novas versões do JRuby tornarão isso mais fácil porque permitirão que os códigos JRuby sejam compilados para Bytecode (e esses Bytecodes serão realmente classes Java válidas), mas até o momento essa é a solução mais elegante para o problema.

Nota: não será possível carregar Gems ou bibliotecas instaladas no seu sistema, a não ser que elas sejam descompactadas na pasta “ruby/lib”.

Mais informações:

• Página oficial do JRuby
• Wiki do JRuby
• Framework ZK

Ok, o título parece estranho, mas é algo que me preocupa: Afinal, POR QUE as pessoas confundem tanto desenvolvimento orientado a objeto com procedural? Recentemente eu fiz uma integração do Jasper com Ruby (projeto Jasper on Rails, no meu github) e me vi tendo que usar a API do Jasper. É mais ou menos assim (em JRuby):

  modelo = "#{DIR}/arquivo.jasper"
  dados = File.read("#{DIR}/dados.xml")
  str_reader = java.io.StringReader.new(dados)
  input_source = org.xml.sax.InputSource.new(str_reader)
  documento = JRXmlUtils.parse(input_source)

  params = {
    JRXPathQueryExecuterFactory::PARAMETER_XML_DATA_DOCUMENT => documento
  }
  fill = JasperFillManager.fill_report(modelo, params)
  pdf = JasperExportManager.export_report_to_pdf(fill)
  return String.from_java_bytes(pdf)

Ok, tudo bem… temos classes, temos métodos, mas… não parece estranho? Esse código é a cara dos códigos que eu já tive que fazer em pascal ou basic, com a diferença que eu acabo escrevendo MUITO mais porque eu preciso me entender com esse monte de Objeto.métodoEstático. A orientação a objeto não foi feita para evitar isso? Não seria mais belo se fosse possível escrever o código assim:

  modelo = "#{DIR}/#{modelo}.jasper"
  dados = File.read("#{DIR}/dados.xml")
  report = JasperReport.new_from_file(modelo)
  report.fill_report_from_string(dados)

  pdf = report.export_report_to_pdf(fill)
  return pdf.to_string

Simples, um “new” que cria um OBJETO, que recebe MÉTODOS… ao invés de classes funcionando como “containers de métodos” que nem o exemplo acima. Claro que no exemplo acima eu simplifiquei o máximo do máximo, mas ainda assim é possível fazer algo mais bonito. A idéia dos “params” é boa… para Ruby, aonde você declara um Hash praticamente sem dificuldade. E para Java, que você precisa IMPORTAR o HashMap, DEFINIR um novo HashMap, criar um monte de “add” (ou “push”, não lembro a sintaxe de Java) com um monte de constantes que estão dentro de uma classe, para DEPOIS passar isso para uma função… não seria mais fácil definir uma classe que recebe parâmetros tipo “setXmlDataDocument”?

Aonde eu quero chegar? Que mesmo se a linguagem te obrigar a usar um determinado paradigma, se a linguagem for simples, fácil de programar, ainda assim é possível escrever códigos mal escritos. Que a orientação a objeto não significa “tudo precisa estar numa classe”, significa que “uma classe representa um possível objeto, que tem comportamentos específicos”. Programar orientado a objeto significa pegar um objeto e mudá-lo até ele atender as suas necessidades, e então rodar algum comando que o transforma no que você quer. De preferência se você conseguir pegar algo que as pessoas fazem muito (como no caso do Jasper – imagino que muitos queiram gerar um PDF) e criar um método que automatiza todas as chamadas (digamos, um JasperReport#to_pdf, mais ou menos como eu fiz no exemplo acima) você finalmente criará um código LIMPO. Não interessa se aquele código que você escreveu só faz chamadas a outros métodos públicos.

E principalmente, mantenha o código conciso. Se você criou um método “to_pdf”, não crie outro “to_xls_file”. Mantenha as definições semelhantes (mais uma vez, no Jasper, eu tive que enfrentar coisas estranhas – alguns relatórios você precisa chamar o exportReportToPdf(), e outros você precisava criar um “Exporter”, falar que ele vai exportar para um Stream e depois chamar o “export” do exporter…).

Por fim, para quem entende inglês, segue um vídeo extremamente interessante: The Art of Application Development (http://www.mefeedia.com/watch/24603213)

Na dúvida, lembrem-se do princípio KISS – Keep It Simple, Stupid!

Lately I have been doing some interesting work integrating Terracotta in our application. We use Terracotta in a very limited scenario: as a tool to implement asynchronous DB replication on PostgreSQL (unfortunately the existing tools out there are not suitable for the kind of usage that we do of PostgreSQL – anyways, I’ll talk more in details about this in further posts).
At a certain point in time we decided to drive some java code with JRuby, in order to process information like log files more efficiently. The java code needed to integrate with Terracotta, so we have had to modify jruby scripts in the following way (eg.: jruby_tc.bat on Windows):

@echo off
rem ---------------------------------------------------------------------------
rem jruby.bat - Start Script for the JRuby Interpreter
rem
rem for info on environment variables, see internal batch script _jrubyvars.bat

setlocal

rem Terracotta
set TC_INSTALL_DIR="C:\Program Files\terracotta\terracotta-3.0.1"
set TC_CONFIG_PATH="C:\whatever\tc-config.xml"
call %TC_INSTALL_DIR%\bin\dso-env.bat -q
set JAVA_OPTS=%JAVA_OPTS% %TC_JAVA_OPTS%

rem Sometimes, when jruby.bat is being invoked from another BAT file,
rem %~dp0 is incorrect and points to the current dir, not to JRuby's bin dir,
rem so we look on the PATH in such cases.
IF EXIST "%~dp0_jrubyvars.bat" (set FULL_PATH=%~dp0) ELSE (set FULL_PATH=%~dp$PATH:0)

call "%FULL_PATH%_jrubyvars.bat" %*

if %JRUBY_BAT_ERROR%==0 "%_STARTJAVA%" %_VM_OPTS% -Xbootclasspath/a:"%JRUBY_CP%" -classpath ^
   "%CP%;%CLASSPATH%" -Djruby.home="%JRUBY_HOME%" -Djruby.lib="%JRUBY_HOME%\lib" ^
   -Djruby.shell="cmd.exe" -Djruby.script=jruby.bat org.jruby.Main %JRUBY_OPTS% %_RUBY_OPTS%
set E=%ERRORLEVEL%

call "%FULL_PATH%_jrubycleanup"

rem 1. exit must be on the same line in order to see local %E% variable!
rem 2. we must use cmd /c in order for the exit code properly returned!
rem    See JRUBY-2094 for more details.
endlocal & cmd /d /c exit /b %E%

The relevant differences are in bold in the batch file above. I’ve called the batch jruby_tc.bat in order to differentiate it from usual jruby.bat. As you can see these changes are for Terracotta 3.0.1 but they should work just the same for Terracotta 3.1

Depois de ter me impressionado com a qualidade do evento Rails Summit 2008 e a força da comunidade Ruby, não poderia de forma alguma deixar de marcar presença novamente este ano. O evento foi realizado nos dias 13 e 14 de outubro na cidade de São Paulo no auditório Elis Regina do Anhembi, e com uma organização novamente fantástica, contando com excelentes palestrantes, e uma audiência que sem dúvida está acima da média, o evento foi mais uma vez um sucesso total. Parabéns Akita e equipe Locaweb!

Nesta série de posts que começa com este, quero registrar os pontos mais importantes e minhas principais impressões sobre a edição 2009 do evento.

Chad Fowler deu largada com a apresentação do keynote “Insurgência Ruby on Rails” em que explorou estratégias para insurgências de Ruby on Rails em ambientes pouco amigáveis. Logo no inicio da palestra Chad digiriu-se aos desenvolvedores dizendo “parem de fazer coisas que vocês sabem que estão erradas“,  sabemos que todos os dias, muitos de nós desenvolvedores realizamos nosso trabalho de forma burocrática e pouco produtiva, nem sempre utilizamos as melhores práticas e nem sempre temos coragem suficiente para transformar essa realidade.

Chad Fowler por Daniel Cukier

Segundo Chad, ao se tentar introduzir desenvolvimento ágil, ruby, rails e novas tecnologias nas organizações geralmente nos deparamos com monstros guardiões que tentam proteger suas empresas de mudanças a todo o custo, e eles o fazem por causa do fenômeno FUD (Fear, uncertainty and doubt – medo, incerteza e dúvida), por alguma razão eles tem medo, medo de sair da zona de conforto, medo de lutar contra a inércia, medo perder suas posições, medo de errar, e é então que buscam todo tipo de argumento estúpido para tentar evitar algo novo seja feito.

Esse é o caso da velha conversa mole de que rails não escala, isso graças aos problemas que o twitter, um famoso case de rails, enfrentou no passado, “o twitter não escalava por causa de sua arquitetura” disse Chad. A lista de desculpas dos tais guardiões não pára por aí, eles dizem que ruby é lento, “mas é claro que é, e quem se importa? O ruby é responsável por em torno de apenas 6% do tempo de request de uma aplicação web tradicional” afirma Chad. Eles perguntarão “mas dá pra fazer isso? e aquilo?” e não vão parar até que finalmente encontrem alguma coisas que lhes sirva de desculpa. Mas afinal de contas quem são esses caras? Será que você tem sido um deles?

Two dragons... (the gate to the end) por Giampaolo Macorig

Para ajudá-lo na batalha contra os guardiões, Chad recomendou a leitura do artigo “beating the averages” de Paul Graham e acrescentou procure fazer as coisas de forma gradual, se você tentar fazer uma mudança massiva, provavelmente vai acabar fazendo uma bagunça. Você pode até mesmo começar a usar rails como uma ferramenta case, é possível fazer algo parecido com o que propõe o naked objects com java. Use também  Ruby para criar scripts. Use Ruby para testar java, .net, c++.  Use Ruby para gerar código. Use Ruby como template engine. Automatize o seu deployment com capistrano. Use Ruby para construir protótipos de UI. Crie metas mensuráveis, meça e apresente resultados!

Um outro ponto importante é que para introduzir Rails você não precisa necessariamente jogar fora o seu investimento anterior, IronRuby, JRuby e etc estão aí para entre outras coisas, te ajudar com isso, mas tome cuidado para não acabar escrevendo código Ruby da mesma forma que você escreve código Java ou C#, entenda que os paradigmas são diferentes e não tente abrir a casa nova com a chave da velha.

Chad recomendou ainda a leitura de sua série de artigos “The Big Rewrite” e enfatizou conserve a paixão pelo seu trabalho.

Assista a palestra na integra gentilmente gravada e disponibilizada por Hugo Borges:

Em breve publicarei sobre mais palestras, assine o feed e acompanhe!

I’ve recently ecountered a problem with freezing java platform gems in a Rails application I’m working on. The problem was, that the Rails::GemDependency class would assume that a gem’s version is the last part of it’s directory name:

      directory_name_parts = File.basename(directory_name).split('-')
      name    = directory_name_parts[0..-2].join('-')
      version = directory_name_parts.last
      result = self.new(name, :version => version)

For java platform gems, directory names often look like e.g. RedCloth-2.2.2-universal-java. In this case we would end up with the version variable to be set to ‘java’, and the attempt to create a new object would result in an error. Since I really needed those JRuby compatible gems, I’ve prepared a small patch and filed a ticket in the Rails project. Both can be found here: https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/3356. I hope this helps somebody with unpacking the java platform gems into the Rails’ vendor directory.

I’ve been fiddling with JRuby for about a month now and I have to say it’s
great. For those of you who don’t know what it is – it’s an implementation of
the Ruby language written in Java. Most people are familiar only with the
Matz’s implementation in C (MRI = Matz’s Ruby Interpreter also known as
CRuby). Having Ruby available on top of the JVM is a big leverage. I was
surprised how easy it was to incorporate Java code into Ruby code and vice
versa.

The most work I do is web development with Rails. JRuby supports Rails since
version 0.9. Right now it runs all Rails test cases, is compatible partialy compatible with Ruby
1.9 and improved performance. The existing Rails applications
I’ve worked on run significantly faster on JRuby than on CRuby (JVM rocks).
You also get to compile your Ruby classes to Java classes or use your
favourite Java libraries in you Ruby apps.

The only downside at the moment is the Gem compatibility issues (not all Ruby
code runs on JRuby, however can be adjusted in most cases). JRuby doesn’t
support the use of native extensions which in consequence forces you to swap
some gems for others or to find pure Ruby (which means JRuby compatible)
implementations.

The bottom line is, JRuby provides you with exciting new possibilities. I’m
looking forward to see the next releases by the JRuby team.

While working with many projects that uses different ruby versions and rails versions, one big problem arises that how do we manage all this ?

We know that managing multiple rails versions wont be problem at all.
but what about ruby versions, How one can manage multiple ruby versions. also while upgrading or degrading ruby version, we need to install all gems again including rails.
i know this is a big pain
How we can overcome this headache. meantime there must be some incompatibilities between two different ruby and rails versions.

Yesterday, i did some research and came to know that…

+ ruby 1.8.7 and rails 2.3.3 got quite stability and effectively. we can use it in next developments.
+ Also, after installing ruby 1.9.1 and dependent gems for my project,
and wondering that there are many incompatibilities while installing new gems with ruby 1.9.1

Some of the gems are mysql, ferret, acts_as_ferret, erubies, etc.

Today, while google, i found rvm gem and that seems very nice to manage multiple ruby versions.

Here are some steps explaining how to use it.

# Install rvm gem to manage multiple ruby version
# pre-requisite is that we already have ruby and rubygems installation
1. sudo gem install rvm

# Install rvm for a particular user
# It will also show how to use gem
2. rvm-install

3. Open new shell

# Show all ruby, jruby installations
4. rvm list

# Install ruby
# specify ruby version
5. rvm install RUBY_VERSION_TO_BE_INSTALLED
(rvm install 1.9.1)

# Install jruby
# By default it will install jruby-1.3.1
6. rvm install jruby

# Specify which ruby version to use ?
# Note: Be sure that ruby version is installed
7. rvm use RUBY_VERSION_TO_USE
(rvm use 1.9.1)

#. Default i.e. version before rvm gem installation
8. rvm use default

Sounds, cool

# install mysql if you dont have already installed
sudo apt-get install mysql-server mysql-client libhtml-template-perl mailx dbishell libcompress-zlib-perl mysql-doc-5.0 tinyca

# install ant and jdk
sudo apt-get install ant sun-java6-jdk

# install jruby
mkdir software
cd software
wget http://dist.codehaus.org/jruby/jruby-bin-1.1.5.tar.gz
tar xvfz jruby-bin-1.1.5.tar.gz
ln -s jruby-1.1.5 jruby
export PATH=$PATH:$HOME/software/jruby/bin

# install the version of rails wanted by jruby
jruby -S gem install jruby-openssl
jruby -S gem install rails

# list your gems
jruby -S gem list

# install the gems needed for db
jruby -S gem install activerecord-jdbc-adapter activerecord-jdbcmysql-adapter

# generate some code
cd ~/scripts/ruby
jruby -S rails wherehaveyoubeen -d mysql
cd wherehaveyoubeen
jruby script/generate controller states index

# configure access to the database server
vi config/database.yml

#development:
# adapter: jdbcmysql <- very important!
# encoding: utf8
# database: test_development
# username: root
# password: database
# socket: /var/run/mysqld/mysqld.sock

# generate the db
jruby -S rake db:create:all
jruby -S rake db:migrate

# edit your app
sudo apt-get install emacs ruby-elisp irb1.8 emacs22-el
emacs -bg black -fg wheat app/views/states/index.html.erb

# uncomment the secret in app/controllers/application.rb
vi app/controllers/application.rb

# run your app
jruby script/server

During the last months many new features have been implemented for ActiveRecord Oracle enhanced adapter which are now included in Oracle enhanced adapter version 1.2.2. You can find full list in change history file, here I will tell about the main ones.

Documentation

Now Oracle enhanced adapter has improved RDoc documentation for all public methods. So you can go to RDoc documentation of installed gem or go and view published documentation on-line.

Schema definition

There are many new features in schema definition methods that you can use in migration files:

• When you use add_index then ActiveRecord is automatically generating index name using format index_table_name_on_column1_and_column2_… which previously could cause Oracle errors as Oracle identifiers should be up to 30 characters long. Now default index names are automatically shortened down to 30 or less characters (of course you can always use also :name option to specify shortened version by yourself).
• Now adapter is ignoring :limit option for :text and :binary columns (as in Oracle you cannot specify limit for CLOB and BLOB data types). Previously it could cause errors if you tried to migrate Rails application from e.g. MySQL where :text and :binary columns could have :limit in schema definition.
• If you define :string column with :limit option then it will define VARCHAR2 column with size in characters and not in bytes (this makes difference if you use UTF-8 with language where one character might be stored as several bytes). This is expected behavior from ActiveRecord that you define maximum string size in UTF-8 characters.
• Now you can use add_foreign_key and remove_foreign_key to define foreign key constraints in migrations (see RDoc documentation for details). Syntax and some implemenatation for foreign key definition was taken from foreigner Rails plugin as well as some ideas taken from active_record_oracle_extensions plugin.
• add_foreign_key definitions will be also extracted in schema.rb by rake db:schema:dump task. Therefore they will be also present in test database when you will recreate it from schema.rb file.
• Foreign keys are also safe for loading of fixtures (in case you are still using them instead of factories ). disable_referential_integrity method is implemented for Oracle enhanced adapter which is called by ActiveRecord before loading fixtures and which disables all currently active foreign key constraints during loading of fixtures.
• You can use add_synonym and remove_synonym to define database synonyms to other tables, views or sequences. add_synonym definitions will also be extracted in schema.rb file.
• It is possible to create tables with primary key trigger. There will be no difference in terms how you would create new records in such table using ActiveRecord but in case you have also need to do direct INSERTs into the table then it will be easier as you can omit primary key from INSERT statement and primary key trigger will populate it automatically from corresponding sequence.
• ActiveRecord schema dumper is patched to work correctly when default table prefixes or suffixes are used – they are now removed from schema.rb dump to avoid duplicate prefixes and suffixes when recreating schema from schema.rb.

Legacy schema support

Some features which can support “weird” legacy database schemas:

• If you are using ActiveRecord with legacy schema which have tables with triggers that populate primary key triggers (and not using default Rails and Oracle enhanced adapter conventions) then you can use set_sequence_name :autogenerated in class definition to tell adapter to omit primary key value from INSERTs.
• You can use ActiveRecord also with tables that you can access over database link. To do that you need to define local synonym to remote table (and also remote sequence if you want to insert records as well) and then use local synonym in set_table_name in class definition. Previously adapter could not get remote table columns, now it will get table columns also over database link.
  But still you cannot specify remote table (like “table_name@db_link”) directly in set_table_name as table_name will be used as column prefix in generated SQL statements where “@db_link” will not be valid syntax.
  And when you define local synonyms then please use the new add_synonym feature

Connection options

• cursor_sharing option default value is changed from “similar” to “force” – please read explanation in discussion group post what it is and why the new default value is recommended choice.
• When using JRuby and JDBC you can set TNS_ADMIN environment variable to tnsnames.ora directory and then use TNS database alias in database.yml file (specify just database: option and remove host: option). This might be useful for more complex TNS connection definitions, e.g. connection to load balanced Oracle RAC.
• Adapter will not raise error if it cannot locate ojdbc14.jar file. So either put it in $JRUBY_HOME/lib or ensure that it will be loaded by application server. Would love to hear feedback from people who are using this adapter with JRuby to find out if this behaves well now

Logging

• Now you can get PL/SQL debugging information into your ActiveRecord log file. Use dbms_output.put_line in your PL/SQL procedures and functions (that are called from ActiveRecord models) and in your ActiveRecord model use connection.enable_dbms_output and connection.disable_dbms_output around your database calls to get dbms_output logging information into ActiveRecord log file. But please use it just in development environment with debug log level as in production it would add too much overhead for each database call. And this feature also requires that you install ruby-plsql gem.

As you see this probably is the largest “point” release that I have had Thanks also to other contributors which patches were included in this release.

As always you can install Oracle enhanced adapter on any Ruby platform (Ruby 1.8.6 / 1.8.7 or Ruby 1.9.1 or JRuby) with

gem install activerecord-oracle_enhanced-adapter

If you have any questions please use discussion group or post comments here.

Installing rubygems is failrly easy and it’s great to have a package manager so you can forget about manually installing and upgrading the components you use. After installing a gem, you can require it from any ruby script and use it hassle-free. Well, given your ruby interpreter can find it.

When you install rubygems, a lot of default configuration is done behind the scenes. If you must see to believe, you can run

gem environment

do you believe me now?

Unless you are on windows, you have probably experienced already that gems can get installed in different locations. If using a superuser account, the global configuration will be used, but with a regular account gems install under your home directory.

If you are not careful about how you install your gems, or if you are using rake gems:install from regular accounts, you might end up installing the same version of a gem twice. That’s not only WET (not DRY, bear with me here) but it eats up your poor HD.

Things can get a lot worse than that. Suppose you are working with both JRuby and Ruby MRI. When you use rubygems from JRuby, it will try to use a different gem location by default. So, depending on how you are installing gems, you could have up to three different copies of exactly the same version.

And if you are on ubuntu and you upgrade from an old version of rubygems to the latest one —you will have to if you install Rails 2.3.4; if you are having problems you can read right here how to update it— you might be surprised that your gems are being installed *again*. The reason is under older versions the default location was “/var/lib/gems” and the latest one defaults to “/usr/lib/ruby/gems”.

Well, four different copies of ActiveRecord 2.3.4 are three and a half more copies than I wanted, mind you.

So.. how can we stop this gem install frenzy? Easy. Don’t use the defaults. Each of your installations is using default values, but they can be easily overridden with command line parameters or much more conveniently with environment variables.

Remember the title of this post? Can you see anything there that would make a good candidate for environment variables? That’s right, all the rubygems versions honor the GEM_HOME and GEM_PATH variables, so if they are set they will be used.

Depending on your OS, you can set these variables in different places. I’m on ubuntu and a bit lazy, so I chose the easiest, which is by adding this to my .bashrc file.

export GEM_HOME=/var/lib/gems/1.8
export GEM_PATH=/var/lib/gems/1.8

And now, no matter what I’m using: Ruby MRI, JRuby, or the latest rubygems, my already installed gems will be used, and the new ones will be put in the same place.

Saving the world is a hard job, but someone has to do it.

When using OpenSSL encryption in standard Ruby, the length of an initialization vector (IV) can apparently be as large as you want it to be as long as it is at least the minimum size. This is odd. This can also cause trouble when switching over to JRuby. JRuby appear to be much pickier about IV length.

This works in MRI but not in JRuby:

unencrypted_data = "test"

des = OpenSSL::Cipher::Cipher.new("des-ede3-cbc")
des.encrypt
des.key = '0123456789abcdef01234567890'

des.iv = "ed87acdcca419954edccb736f7dc77a74f5ac8dfe3861c3d5f77248e21592131a5423d63ff91f07956ce1aa386f8359931b5" # 100 characters
encrypted_data = des.update(unencrypted_data) + des.final

puts encrypted_data

JRuby gives you this very helpful message:
ruby_string_encryption.rb:27:in `encrypt': No message available (OpenSSL::Cipher::CipherError)
from ruby_string_encryption.rb:37

Change the IV to 8 characters and everything works fine.

Update 10/14/2009 The code that I originally posted was incorrect. I have updated it. Also I opened a ticket for this issue.

If you are looking for what size an initialization vector should be check out my post on encrypting a string with Ruby.

We have been working with Glassfish v2 now for a couple of years. We’re developing mostly using Java, but last year we wanted to try implementing one part of our enterprise application with JRuby and Rails. The experiment was good and we decided to continue using Rails on Glassfish.

Our setup was a standalone WAR which included everything needed packaged inside. I wasn’t personally involved with this application from the beginning and when I started making changes in it I thought that a standalone WAR is the only option. After getting more familiar with Glassfish, I tried the Update Center application and noticed that it’s possible to install JRuby to Glassfish as a shared component. I started wondering what would be the added benefit of installing JRuby on the application server instead of bundling that in the WAR – specially as at the moment we only have one Rails application.. Nobody from our team could answer the question and it wasn’t considered important enough to start investigating it any further.

It was only until two weeks ago when I started wondering about this issue again. It really bothered me since the only thing I could think of as an added benefit of installing JRuby as shared component on the container was that the Rails application WARs become a lot smaller. This was also what Arun Gupta hinted to me in Twitter – see his blog entry for more details…

Not enought I thought… Also what’s the point – imagine you have two Glassfish Clusters in production, both having e.g. three nodes. Using shared JRuby would mean having to maintain versions of JRuby and all the related Gems on six servers in production. And each separately. Using standalone WAR, it’s maximum two deployments to upgrade JRuby on all six nodes.

Finally last week I got my answer – and of course it was obvious, one of those when you slap your forehead! Why didn’t I figure that out myself?! One of the reasons I participated in Sun’s webinar about deploying Rails apps on Glassfish was the opportunity to ask this one question. The answer I got was:

A: When you go in to production , you freeze your gems with app.

And of course! I’m going to set up my own development environment so that Rails app WARs can be made as small as possible, there are also other benefits (like simpler configuring of JRuby options). WARs ending up in the production environment will still be made using the old style standalone configuration.

On the other hand… I’m a bit tempted to install Glassfish v3 on my development box just to see the differences in compared to GF v2.1 which we now have in use – it would also support directory based deployment of Rails apps.

Or maybe I could get directory based Rails deployment work with GF v2.1 as well – similarly as Java based web application deployment using exploded WARs…

Jruby

Website – http://jruby.org/

Code:

ravi.rb

require “java”

stringHello= “Raveendran in Ruby”
stringDate = java.util.Date.new

puts “#{stringHello.to_s}”
puts “Now in Java –> Date := #{stringDate.to_s}”

Run the JRuby code:

Go to command promt>jruby ravi.rb

Output:

C:\raveendran\jruby_examples>jruby ravi.rb
Raveendran in Ruby
Now in Java –> Date := Thu Sep 10 17:03:30 GMT+05:30 2009

C:\raveendran\jruby_examples>

Any issues in installation of JRuby  in windows mnachine then just post a comemnt here.

Instalasi JRuby pada Windows

1. Download JDK disini.
2. Download distribusi JRuby terbaru disini.
3. Install JDK.
4. Unzip JRuby pada sembarang directory (dianjurkan “C:\JRuy).
5. Ubahlah environtment variable anda seperti dibawah ini:
   • Tambahkan environtment variable JAVA_HOME , yang berisi path instalasi JDK (Jika lokasi instalasi tidak dirubah maka path untuk JAVA_HOME adalah “C:\Program Files\Java\jdk<VERSI JDK ANDA>”).
   • Tambahkan path direcory bin ,yang terdapat pada directory instalasi JRuby, pada environtment variable PATH (Jika JRuby di unzip sesuai dengan yang dianjurkan yakni “C:\JRuby” maka directory bin terletak di “C:\JRuby\bin”).
6. Ketik jruby -v untuk memastikan bahwa JRuby telah sukses di install

Merubah environtment variable

1. Klik kanan pada My Computer kemudian pilih Properties



2. Kemudian pada System Properties pilihlah tab Advanced, kemudian pilih Environtment Variables



3. Tambahkan environtment variable JAVA_HOME dan edit environtment variable PATH seperti diatas.

I just knew the video of my talk about JRuby on Rails at the Sun Open communities Forum is already online. Funny how a google alert let me know this video has been published even before the official web page of the event was updated.

The talk is in Spanish and the slides I used are available at slideshare.

If you are a Java developer interested in JRuby and you are going to be in Madrid in September, stay tuned because it’s very likely I will be speaking again about JRuby in SIMO

Como o título sugere, as linhas abaixo, devidamente CTRL+C/CTRL+V baseadas no tutorial oficial do Netbeans, mostram como implantar sua aplicação Rails num servidor de aplicações Java. Lógicamente você deverá usar o JRuby para isso.

O tutorial usa como servidor o Glassfish, porém os procedimentos são os mesmos para qualquer servidor que aceite um projeto na extensão .war.

Aí vai o texto na íntegra:

Por padrão, as aplicações JRuby são executadas no WEBrick. Se você quiser implantar uma aplicação JRuby no servidor da aplicação GlassFish, poderá empacotar a aplicação e suas dependências em um arquivo WAR (web archive). Em seguida, você pode tornar o arquivo WAR disponível para o servidor da aplicação, conforme mostrado nas etapas a seguir.

1. A aplicação implantada usará o banco de dados de produção. Abra o arquivo database.yml para garantir que a configuração de produção esteja definida corretamente.
2. Ao criar a aplicação JRuby, você recebe a opção de adicionar destinos Rake para oferecer suporte ao deployment do servidor da aplicação, conforme mostrado na figura a seguir. Se você pretende implantar no GlassFish, deve marcar esta caixa de verificação.Se você tiver um projeto JRuby existente que não ofereça este destino Rake, conclua as etapas a seguir para adicionar o plug-in Goldspike ao projeto. Este plug-in adiciona tarefas de Rake que permitem que você crie arquivos WAR.
   1. Na janela Projetos, clique com o botão direito do mouse no nó e escolha Gerar código no menu pop-up.
   2. Na caixa de diálogo Plug-ins Rails, clique na aba Novos plug-ins.
   3. Caso você não veja uma entrada para Goldspike, conclua as etapas a seguir para registrar o repositório que fornece o plug-in Goldspike.
      1. Clique na aba Cabeçalhos.
      2. Clique em Adicionar URL.
      3. Na caixa de diálogo Adicionar URL do repositório, digite http://jruby-extras.rubyforge.org/svn/trunk/rails-integration/plugins e clique em OK.
      4. Depois que o repositório for adicionado, clique em Fechar.
      5. Clique na aba Novos plug-ins. Agora você deve ver uma entrada para o Goldspike.
   4. Selecione a entrada para Goldspike e clique em Instalar.
   5. Clique em OK para iniciar a instalação.
   6. Feche as caixas de diálogo Instalação e Plug-ins Rails.
   7. Clique com o botão direito do mouse no nó do projeto e escolha Executar tarefa Rake > Atualizar lista do menu pop-up.
3. Para empacotar a sua aplicação em um arquivo WAR, clique com o botão direito do mouse no nó do projeto e escolha Executar tarefa Rake > War > Independente > Criar.O IDE cria o arquivo WAR e o coloca na pasta superior do projeto.
4. Se você estiver usando o adaptador JDBC, coloque uma cópia do driver JDBC do servidor do banco de dados em glassfish-install-dir/lib e inicie (ou reinicie) o servidor GlassFish.No momento desta escrita, você deve usar o adaptador JDBC a menos que esteja se conectando a um banco de dados MySQL.
5. Coloque uma cópia do arquivo WAR recém-criado na pasta autodeploy do GlassFish. Por exemplo, copie pasta de projetos/MyRubyApp/MyRubyApp.war para glassfish-install-dir/domains/domain1/autodeploy.
6. Em um navegador, vá para a URL da aplicação, por exemplo, http://localhost:8080/MyRubyApp.

Bem é isso pessoal, espero que seja útil…

I was recently tasked with writing a command-line script in Jruby that performed simple CRUD operations against a simple database table. I’ve written tons of scripts in the past that manipulated tables, but I had never done so using Jruby. I therefore decided to first write a “bare-minimum” test script that would help me dip my toes in this unfamiliar water.

I wanted to write my test script against a database manager that ran on my laptop, but I didn’t want to go through the hassle of installing and configuring Oracle or MySql. Also, I soon learned that a lot of Ruby database drivers don’t work with Jruby, so I needed a small, simple database that had a good JDBC driver. I ended up installing and configuring Apache Derby, and it worked out very well for me.

So anyways, here’s the script (jdbctest.rb):

 require 'java'
 require './derbyclient.jar'
 require './derbytools.jar'

 # This example assumes that you have the free DerbyDB software installed on
 # your machine.  It also assumes that you are running it in "server" mode by
 # executing the startNetworkServer.bat script.

 # This is what I'm using instead of Class.forName("org.apache.derby.jdbc.ClientDriver").newInstance()
 import 'org.apache.derby.jdbc.ClientDriver'

 connString = "jdbc:derby://localhost:1527/MyDbTest"
 conn = Java::JavaSql::DriverManager.getConnection(connString)

 stmt = conn.createStatement

 rs = stmt.executeQuery("select * from derbyDb")

 while (rs.next) do
     puts "#{rs.getString("NUM")} -- #{rs.getString("ADDR")}"
 end

 rs.close
 stmt.close
 conn.close()

I then placed the jdbctest.rb script in a folder with the derbyclient.jar and derbytools.jar file, and then executed the script like this:

 c:\Dev\jruby\somefolder>jruby .\jdbctest.rb
 180 -- Grand Ave.
 1910 -- Union St.

To make this script work, you need to do the following:

1. Install Derby using this tutorial: Step 1 – Install Software
   • This is a very simple task that took me all of 6 minutes after downloading the software.
2. Create the MyDbTest database and the derbyDB table using this tutorial: Step 2 – ij Basics
   • You should also populate this table using the SQL located under the Execute SQL Statements section.
3. Once you’ve created and queried your table using ij, start your Derby server using this tutorial: Step 4 – Derby Network Server
   • You should validate the server using ij. Please see the Test network server connection with ij section in the Step 4 tutorial for help.

Please note that this might seem like a lot of work, but it’s really very simple, especially when you compare it installing and configuring most relational database managers. It took me about 20 minutes from A to Z, and I had no prior experience with Derby.

That’s it! I hope that this tutorial helps a few other people who want to get started with Jruby and JDBC.

I am familiar with iText , but not familiar with Ruby, I know Dreamhost supports Ruby on Rails(ROR), but never have a chance to run a real application, though I have a Dreamhost space.

Getting rjb, also known as “Ruby Java Bindings’ to work in a Dreamhost account can be somewhat problematic. Fortunately, it is also fairly straightforward. You just have to install all the dependencies in the user directory.

In my case, I was setting up a Rails Application that used the iText Java library to fill in PDF documents for user download. Of course, the server environment was not using Sun Java and the Java headers were not present, so gem install rjb failed. Joy.

The first course of action was to do a local install of Java.

Download jdk-6u7-linux-x64.bin and jre-6u7-linux-x64.bin from the Sun Java site. Then create an ~/opt directory and extract the JRE and JDK (you will need to chmod u+x both files then call them from the command line). Move the resulting folders to ~/opt . I renamed the folders to jdk and jre for simplicity.

Now you ensure that user gems are enabled in cPanel. Then add the following 3 lines to ~/.bash_profile

export JAVA_HOME=/home/username/opt/jdk
export GEM_PATH=/home/username/ruby/gems
export GEM_HOME=/home/username/ruby/gems

Run source ~/.bash_profile to load the paths.

Now you can run gem install rjb without any problems. You will likely have to re-install Rails and other gems because we will be telling our Rails app to load gems from the user directory. Just use the regular gem install syntax.

Add the following 2 lines to your config/environment.rb at the top

ENV['GEM_PATH']=’/home/username/ruby/gems’
ENV['JAVA_HOME']=’/home/username/opt/jdk’

That’s pretty much it.

I will concede that these probably aren’t the best instructions, but this is the real meat of the solution. If you keep getting “no such file to load” errors, you will need to extract the gems to the vendor/plugins directory. cd RAILS_ROOT/vendor/plugins and gem unpack gem_name for each problematic gem. I believe this is an issue with Passenger.

Please correct me if I am wrong about any of this, it was a very long day!

source: http://blog.patrick-morgan.net/2008/10/using-ruby-java-bindings-on-dreamhost.html

Work has been busy. Scratch that work has been absolutely insane and confusing and at times, baffeling, but I have to say that I wouldn’t trade the experience for the world! On the bright side, I’ve been distracted during what were the two worst weeks for the Brewer’s season (right now they are beating-up on Houston). Now that I have some time to myself I have had dinner w/ the Mrs., read some of the Bourne Identity, and have gotten back to porting my Ruby On Rails Knowledge Base application to JRuby on Rails on JBoss. The past few sessions I’ve spent with the technology have been plagued with the error message:

2009-08-16 00:27:28,101 ERROR [STDERR] (main) Warning: JRuby home "/home/sam/usr/jboss-5.1.0.GA/server/default/deploy/railskb.war/WEB-INF/lib/jruby-complete-1.3.0RC1.jar/META-INF/jruby.home" does not exist, using /tmp

2009-08-16 00:27:28,507 ERROR [STDERR] (main) Rails requires RubyGems >= . Please install RubyGems and try again: http://rubygems.rubyforge.org

2009-08-16 00:27:28,512 ERROR [org.apache.catalina.core.ContainerBase.[jboss.web].[localhost].[/railskb]] (main) unable to create shared application instance org.jruby.rack.RackInitializationException: exit

from /home/sam/usr/jboss-5.1.0.GA/server/default/tmp/3j001-au64oi-fyfc3ruh-1-fyfc4xzj-9p/railskb.war/WEB-INF/config/boot.rb:38:in `run'

from /home/sam/usr/jboss-5.1.0.GA/server/default/deploy/railskb.war/WEB-INF/lib/jruby-rack-0.9.4.jar/jruby/rack/rails_boot.rb:20:in `run'

from /home/sam/usr/jboss-5.1.0.GA/server/default/tmp/3j001-au64oi-fyfc3ruh-1-fyfc4xzj-9p/railskb.war/WEB-INF/config/boot.rb:11:in `boot!'

from /home/sam/usr/jboss-5.1.0.GA/server/default/tmp/3j001-au64oi-fyfc3ruh-1-fyfc4xzj-9p/railskb.war/WEB-INF/config/boot.rb:109

from /home/sam/usr/jboss-5.1.0.GA/server/default/tmp/3j001-au64oi-fyfc3ruh-1-fyfc4xzj-9p/railskb.war/WEB-INF/config/boot.rb:20:in `require'

from /home/sam/usr/jboss-5.1.0.GA/server/default/tmp/3j001-au64oi-fyfc3ruh-1-fyfc4xzj-9p/railskb.war/WEB-INF/config/environment.rb:20

Notice the odd line “Rails requires RubyGems >= .”. Eh? I did a log of digging in google and found about 4 sets of forum posts that identify this problem and correlate it with an upgrade to Rack 0.9.4 from 0.9.3. I also noticed that Warbler had included in it a copy of jruby-complete-1.3.0RC1.jar and jruby-rack-0.9.4.jar when the version I would like it to use is jruby 1.3.1.

After a little failed convincing and JBoss continually showing that while it had included in it jruby 1.3.1 that it was choosing to use, and fail to find the ruby gems, on the 1.3.0RC1 jruby jar mentioned in the log above.

Finally, I bit the bullet and decided to punt on Warbler’s automagically included jars and manually include. To do this I:

1. created lib/java in my rails application directory.
2. copied into it jruby-complete-1.3.1.jar
3. copied into it jruby-rack-0.9.jar
4. add the line config.java_libs = FileList["lib/java/*.jar"] to  conf/warble.rb

Loading this into JBoss the application loads! When I access it, it explodes in another fashion, but that’s fine! I’m still learning and I’m past my deployment problems for now!

JRuby é uma implementação da linguagem Ruby escrita 100% em Java que oferece total suporte a Ruby on Rails. O objetivo deste tutorial é configurar um ambiente de desenvolvimento Ruby on Rails no Windows utilizando JRuby e o banco de dados SQLite3. Apesar de ter sido escrito especificamente para Windows, ele pode ser facilmente adaptado para outras plataformas.

No momento da publicação deste tutorial as versões das tecnologias envolvidas eram:

• Java – JDK 6 update 14
• JRuby – 1.3.1
• Ruby on Rails – 2.3.3
• SQLite3 – 3.6.17

Vamos lá:

Passo 1 – baixe o JDK diretamente do site da Sun e instale-o conforme recomendado, criando a variável de ambiente JAVA_HOME que aponta para o diretório de instalação e adicionando o caminho %JAVA_HOME%\bin ao PATH.

Passo 2 – baixe o JRuby clicando no link Download e selecionando a versão mais atual. Descompacte o arquivo em um local de sua preferência. Crie uma variável de ambiente JRUBY_HOME que aponta para esse local e adicione o caminho %JRUBY_HOME%\bin ao PATH.

Passo 3 – Entre no site do SQLite3 e clique no link Download. Na seção “Precompiled Binaries for Windows” baixe os arquivos sqlite-<VERSÃO>.zip e sqlitedll-<VERSÃO>.zip (conforme dito anteriormente, a versão contemporânea a este tutorial é a 3.6.17). Crie um diretório no local de sua preferência denominado sqlite3. Descompacte os arquivos .zip baixados dentro desse diretório e configure a variável PATH para apontar para ele.

Passo 4 – Vamos testar o que instalamos até agora. Abra um prompt de comando e digite:

jruby -v

A versão do JRuby instalada no seu computador deve aparecer na tela. Digite agora a linha:

sqlite3

O SQLite3 será executado e ficará aguardando a entrada de comandos de administração. Digite “.exit” sem as aspas para sair do SQLite3.

Passo 5 – Vamos agora instalar o Rails. Abra o prompt de comando, digite a linha:

jruby -S gem install rails

e aguarde até o final da instalação. Quando ela terminar, digite:

jruby -S rails -v

para visualizar a versão do Rails instalada.

OBS: o parâmetro -S força o JRuby a procurar o script dentro da pasta “bin” ou na variável de sistema PATH.

Passo 6 – Precisamos instalar também o driver do SQLite3 para o JRuby. Isso pode ser feito digitando a seguinte linha no prompt de comando e pressionando ENTER:

jruby -S gem install activerecord-jdbcsqlite3-adapter

Lembrando de aplicar as configurações de proxy conforme visto anteriormente, caso necessário.

Passo 7 – Finalmente, criaremos uma aplicação de exemplo para testarmos o ambiente. Navegue pelo prompt de comando até o diretório onde você mantém suas aplicações e digite:

jruby -S rails teste

Edite o arquivo “config\database.yml” com a ajuda de um editor de textos. Na configuração do ambiente de desenvolvimento, altere o valor da propriedade “adapter” para “jdbcsqlite3″.

Entre no diretório “teste” e digite a seguinte linha para criar um cadastro de pessoas:

jruby script/generate scaffold Person name:string phone:string

Crie o banco de dados:

rake db:migrate

Inicie o servidor:

jruby script/server

E acesse o endereço “http://localhost:3000/people”. Se tudo deu certo, você verá a página que mostra as pessoas cadastradas no sistema.

IMPORTANTE: se a rede onde está seu computador possui configuração de proxy, é preciso passar essa configuração através do parâmetro -p do comando gem usando a seguinte sintaxe:

-p http://usuario:senha@servidorproxy:porta

Isso deve ser feito para todos os comandos de instalação de gems que foram vistos nesse tutorial. Use o seguinte exemplo como referência:

jruby -S gem install rails -p http://tarso:123@meu.proxy.com.br:4321

Quaisquer dúvidas e/ou correções, favor postar nos comentários. Até mais!

Are you wondering how to install your JRuby on Rails application on Google’s App Engine?

If so, go to this cookbook.

I have not tried yet, but I’ll try soon.

See you! Leo