# using the fully-qualified class name

map = java.util.TreeMap.new



# using an import statement

import java.util.TreeMap

map = TreeMap.new

include_class 'EDU.oswego.cs.dl.util.concurrent.ConcurrentHashMap'



map = ConcurrentHashMap.new

include Java



include_class 'java.lang.String' do |package,name|

    "JString"

end



p JString.new("A quick brown fox").indexOf("brown")

include_class ['java.lang.String','java.lang.Integer'] do |package,name|

    case name

    when "String"

        "JString"

    when "Integer"

        "JInteger"

    end

end

# Set the HOME environment variable if USERPROFILE is set

ENV['HOME'] = ENV['USERPROFILE'] if (ENV['USERPROFILE'])



def require_from_maven(group,artifact,version)

    maven_path = "#{group}/#{artifact}/#{version}/#{artifact}-#{version}.jar"

    require "#{ENV['HOME']}/.m2/repository/#{maven_path}"

end

include Java



class MyThread < java.lang.Thread

    def run

        puts 'hello world'

    end

end



MyThread.new.start

package org.jrubycookbook.ch01;



public abstract class AbstractElement {

    public abstract void hello();



    public void sayHello(int count) {

        for (int i = 0; i < count; i++) {

            hello();

        }

    }

}

include Java



import org.jrubycookbook.ch01.AbstractElement



class RubyElement < AbstractElement

    def hello

        puts 'hello world'

    end

end



RubyElement.new.sayHello 5

include Java



class HelloThread

    def run

        puts 'hello world'

    end

end



java.lang.Thread.new(HelloThread.new).start

Balloon.java



public interface Balloon {

    void pop();

}



Bubble.java



public interface Bubble {

    void pop();

}



Child.java



public class Child{

    public void give(Bubble bubble){

        System.out.println("Thanks for the bubble.");

        bubble.pop();

    }

    public void give(Balloon balloon){

        System.out.println("Thanks for the balloon.");

        balloon.pop();

    }

}

include Java



import java.util.HashMap



class HashMap

    def is?(key,value)

        value == get(key)

    end

end

package org.jrubycookbook.ch01;

import java.util.*;



public class MapMaker {

    public static Map makeMap() {

        Map m = new HashMap();

        m.put("k1", "v1");

        m.put("k2", "v2");

        return m;

    }

}

include Java



import java.util.HashMap

import org.jrubycookbook.ch01.MapMaker



h = MapMaker.makeMap()



class HashMap

    def isNot?(key,value)

        value != get(key)

    end

end



puts (h.isNot? 'k1', 'v1')

puts (h.isNot? 'k2', 'v3')

class DetectionExample



  def generate_random_number

    if(defined?(JRUBY_VERSION))

     require 'java'

     puts 'executing java method'

     java.lang.Math.random

    else

     puts 'executing ruby method'

     rand(0)

    end

  end



end



d = DetectionExample.new

puts d.generate_random_number

development:

  adapter: jdbc

  url: jdbc:mysql://localhost:3306/jrubycookbook_development

  driver: com.mysql.jdbc.Driver

  username: jruby

  password: cookbook



production:

  adapter: jdbc

  jndi: java:comp/env/jdbc/rails_db

  driver: com.mysql.jdbc.Driver

# Value of RAILS_ENV for the webapp

config.webxml.rails.env = 'development'



# List of all your application's gems

config.gems << "activerecord-jdbcmysql-adapter"

config.gems << "jruby-openssl"

<context-param>

    <param-name>gem.path</param-name>

    <param-value>C:\projects\jruby\jruby-1.1\lib\ruby\gems</param-value>

  </context-param>



  <!-- Alternatively

  <context-param>

    <param-name>gem.home</param-name>

    <param-value>C:\projects\jruby\jruby-1.1\lib\ruby\gems</param-value>

  </context-param>-->

<?xml version="1.0"?>

<!DOCTYPE Configure PUBLIC "-//Mort Bay Consulting//DTD Configure//EN"

 "http://jetty.mortbay.org/configure.dtd">



<Configure class="org.mortbay.jetty.webapp.WebAppContext">



  <New id="rails_db" class="org.mortbay.jetty.plus.naming.Resource">

    <Arg>jdbc/rails_db</Arg>

    <Arg>

      <New class="com.mysql.jdbc.jdbc2.optional.MysqlConnectionPoolDataSource">

        <Set name="Url">jdbc:mysql://localhost:3306/jrubycookbook_development</Set>

        <Set name="User">root</Set>

        <Set name="Password">password</Set>

     </New>

    </Arg>

   </New>

</Configure>

development:

  adapter: jdbcmysql

  database: jrubycookbook_development

  host: localhost

  port: 3306

  username: root

  password: password

require 'rubygems'

gem 'activerecord-jdbcmysql-adapter'

require 'active_record'

require 'yaml'



@connections = YAML.load_file("database.yml")

ActiveRecord::Base.establish_connection(@connections["development"])



stmt = "select id, title from games"

@val = ActiveRecord::Base.connection.select_all(stmt)

@val.each do |g|

      puts "game id: #{g["id"]} #{g["title"]}"

end



class Game < ActiveRecord::Base

end



puts "found game id: #{Game.find(1).id}"

class HelloWorldController < ApplicationController

      def hello

        ctx = request.env['java.servlet_context']

        puts "server info: #{ctx.server_info}"

        puts "server info: #{$servlet_context.server_info}"



        req = request.env['java.servlet_request']

        puts "uri: #{req.request_uri}"

        puts "query string: #{req.query_string}"

        puts "port: #{req.server_port}"

        puts "param hello: #{req.get_parameter("hello")}"

        puts "session id: #{req.get_session.id}"

      end

end

PUBLIC_DIR = if defined?($servlet_context)

     $servlet_context.getRealPath('/')

   else

     "#{RAILS_ROOT}" + '/public'

   end

module Cookbook

 module PublicRescueExtensions

   protected

   def render_optional_error_file(status_code)

     status = interpret_status(status_code)

     path = "#{PUBLIC_DIR}/#{status[0,3]}.html"

     if File.exists?(path)

       render :file => path, :status => status

     else

       head status

     end

   end

 end

end

ActionController::Rescue.send :include,

  Cookbook::PublicRescueExtensions

package org.jrubycookbook.ch03;



import java.util.Collections;



import org.jruby.Ruby;

import org.jruby.javasupport.JavaEmbedUtils;



public class RubyRunner {



    public static void main(String[] args) {

        // Create an instance of the JRuby runtime. The parameter to initalize()

        // is a list of paths to be added to the Ruby load path.

        Ruby runtime = JavaEmbedUtils.initialize(Collections.EMPTY_LIST);

        runtime.evalScriptlet("puts 'hello world'");

    }



}

package org.jrubycookbook.ch03;



import java.util.Collections;



import org.jruby.Ruby;

import org.jruby.javasupport.JavaEmbedUtils;



public class RubyRunner2 {



    public static void main(String[] args) {

        // Enable ThreadLocal support

        System.setProperty("jruby.runtime.threadlocal", "true");

        // Create a JRuby instance

        Ruby runtime = JavaEmbedUtils.initialize(Collections.EMPTY_LIST);

        // Execute a bit of Ruby code that creates a variable

        runtime.evalScriptlet("$message = 'hello world from JRuby'");

        runtime.evalScriptlet("$counter = 0");

        for (int i = 0; i < 5; i++) {

            outputMessage();

        }

    }



    private static void outputMessage() {

        Ruby runtime = Ruby.getCurrentInstance();

        String scriptlet = "puts \"<#{$counter}> #{$message}\"";

        runtime.evalScriptlet("$counter = $counter.next");

        runtime.evalScriptlet(scriptlet);

    }

}

package org.jrubycookbook.ch03;



import org.apache.bsf.BSFException;

import org.apache.bsf.BSFManager;



public class RubyBSFRunner {



    public static void main(String[] args) throws BSFException {

        BSFManager.registerScriptingEngine("ruby",

                "org.jruby.javasupport.bsf.JRubyEngine", new String[] { "rb" });

        BSFManager manager = new BSFManager();

        manager.exec("ruby", "<script>", 1, 1, "puts 'hello world'");

    }



}

package org.jrubycookbook.ch03;



import javax.script.ScriptEngine;

import javax.script.ScriptEngineManager;

import javax.script.ScriptException;



public class Ruby223Runner {



    public static void main(String[] args) throws ScriptException {

        ScriptEngineManager scriptManager = new ScriptEngineManager();

        ScriptEngine engine = scriptManager.getEngineByName("ruby");

        engine.eval("puts 'hello world'");

    }



}

package org.jrubycookbook.ch03;



import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;



import org.jruby.RubyObject;



public class JRubyLogFactory {

    public static Log getLog(RubyObject o) {

        String rubyClassName = o.getMetaClass().getName();

        String logName = rubyClassName.replace("::", ".");

        return LogFactory.getLog(logName);

    }

}

include Java



import org.jrubycookbook.ch03.JRubyLogFactory



module Log

    class LogTest

        def initialize

            @log = JRubyLogFactory.getLog(self)

        end



        def hello

            @log.info("hello via jcl")

        end

    end

end



Log::LogTest.new.hello

include Java



class MyLongTask

    include java.util.concurrent.Callable



    def initialize(label)

        @label = label

    end



    def call

        puts "about to sleep in task labeled #{@label}\n"

        # artificially create a longer delay

        sleep 5

        puts "done sleeping in task labeled #{@label}\n"

        return "result of the long task labeled #{@label}\n"

    end

end



# create a new thread pool

executor = java.util.concurrent.Executors::newFixedThreadPool(2)



# create an array to store the future value references

future = Array.new



puts "submitting first task"

future[0] = executor.submit(MyLongTask.new("first"))



puts "submitting second task"

future[1] = executor.submit(MyLongTask.new("second"))



puts "submitting third task"

future[2] = executor.submit(MyLongTask.new("third"))



puts "All tasks have been submitted"



# this method call will block until the first task has completed

puts future[0].get()



# this method call will block until the second task has completed

puts future[1].get()



# this method call will block until the third task has completed

puts future[2].get()

module Helper

  def java_attr_accessor(*symbols)

    symbols.each { |symbol|

      camelcased = symbol.to_s.capitalize.gsub(/\_[a-zA-Z]/) {|s| s[1..1].upcase}

      module_eval( "def get#{camelcased}() @#{symbol}; end" )

      module_eval( "def set#{camelcased}(val) @#{symbol} = val; end" )

    }

  end

end



class Example

        extend Helper

        java_attr_accessor :title,:first_name

end



mc = Example.new

mc.setTitle('Cookbook')

mc.setFirstName("John")

include Java



import javax.xml.transform.TransformerFactory

import javax.xml.transform.stream.StreamResult

import javax.xml.transform.stream.StreamSource



# Create a new TransformerFactory instance

factory = TransformerFactory.new_instance



# Compile a stylesheet into a Template object

style_input = StreamSource.new("rss.xslt")

templates = factory.new_templates(style_input)



# Setup sources for input and output

input = StreamSource.new("http://www.mtv.com/rss/news/news_full.jhtml")

output = StreamResult.new(java.lang.System.out)



# Create a new Transformer from the Template object

transformer = templates.new_transformer



# Do the transformation

transformer.transform(input, output)



# Simplified – just create a new Transformer from the stylesheet

transformer = factory.new_transformer(style_input)

transformer.transform(input, output)

class ErrorCounter

  attr_reader :errors

  attr_reader :warnings

  attr_reader :fatals



  def error(ex)

    @errors = 0 if (@errors == nil)

    @errors = @errors + 1

  end



  def warning(ex)

    @warnings = 0 if (@warnings == nil)

    @warnings = @warnings + 1

  end



  def fatalError(ex)

    @fatals = 0 if (@fatals == nil)

    @fatals = @fatals + 1

  end

end



# Use the ErrorCounter class

counter = ErrorCounter.new

transformer = factory.new_transformer(style_input)

transformer.error_listener = counter

transformer.transform(input, output)



p "Errors: #{counter.errors}"

package org.jrubycookbook.ch03;



import java.util.Collections;

import java.util.Date;



import org.apache.commons.pool.BasePoolableObjectFactory;

import org.apache.commons.pool.impl.GenericObjectPool;

import org.jruby.Ruby;

import org.jruby.javasupport.JavaEmbedUtils;



public class JRubyRuntimePool extends GenericObjectPool {



    private static class JRubyRuntimeFactory extends BasePoolableObjectFactory {



        public Object makeObject() throws Exception {

            Ruby runtime = JavaEmbedUtils.initialize(Collections.EMPTY_LIST);

            return runtime;

        }



    }



    public JRubyRuntimePool() {

        super(new JRubyRuntimeFactory());

    }



    public Ruby borrowRuntime() throws Exception {

        return (Ruby) borrowObject();

    }



    public void returnRuntime(Ruby runtime) throws Exception {

        returnObject(runtime);

    }



    public static void main(String[] args) throws Exception {

        JRubyRuntimePool pool = new JRubyRuntimePool();

        // always have a minimum of five runtimes available in the pool.

        pool.setMinIdle(5);



        // if there are more than 10 runtimes in the pool, remove the extras

        pool.setMaxIdle(10);



        // and don't allow more than 40 runtimes to be in use at the same time

        pool.setMaxActive(40);



        // check every minute that the minimum and maximum idle counts are met

        pool.setTimeBetweenEvictionRunsMillis(60000);



        // start the application

    }

}

include Java



require 'rubygems'

gem 'jmx4r'

require 'jmx4r'



JMX::MBean.establish_connection :host => "localhost", :port => 1099



queues = JMX::MBean.find_all_by_name \

    "org.apache.activemq:BrokerName=localhost,Type=Queue,*"



queues.each do |queue|

    p "Queue #{queue.name} contains #{queue.queue_size} queued messages."

end

include Java



import com.sun.jna.ptr.LongByReference



Kernel32 = com.sun.jna.NativeLibrary.getInstance('kernel32')

GetDiskFreeSpace =  Kernel32.getFunction('GetDiskFreeSpaceExA')

avail = LongByReference.new

total = LongByReference.new

total_free = LongByReference.new

num = GetDiskFreeSpace.invokeInt(["C:\\", avail, total, total_free].to_java)

puts "available: #{avail.value}"

puts "total: #{total.value}"

puts "total_free #{total_free.value}"

include Java



import java.util.Hashtable

import javax.naming.InitialContext

import javax.naming.Context



env = {Context::INITIAL_CONTEXT_FACTORY => "com.sun.jndi.ldap.LdapCtxFactory",

       Context::PROVIDER_URL => "ldap://ldap.itd.umich.edu:389" }



ctx = InitialContext.new(Hashtable.new(env))

include Java



import java.util.Hashtable

import javax.naming.InitialContext

import javax.naming.Context

import javax.jms.Session



class JmsSender



  def initialize(environment)

     @context = InitialContext.new(Hashtable.new(environment))

     @connection_factory = @context.lookup("ConnectionFactory")

  end



  def send_text_message(destination_name, message_text)

    destination = @context.lookup(destination_name)

    connection = @connection_factory.create_connection()

    session = connection.create_session(false, Session::AUTO_ACKNOWLEDGE)

    producer = session.create_producer(destination)

    message = session.create_text_message

    message.text = message_text

    producer.send(message)

    session.close

  end

end



env = { Context::INITIAL_CONTEXT_FACTORY =>

        "org.apache.activemq.jndi.ActiveMQInitialContextFactory",

       Context::PROVIDER_URL =>

       "tcp://localhost:61616" }

sender = JmsSender.new(env)



sender.send_text_message("dynamicQueues/output.queue", "hello to JMS from Ruby")

include Java



import java.util.Hashtable

import javax.naming.InitialContext

import javax.naming.Context

import javax.jms.Session



env = { Context::INITIAL_CONTEXT_FACTORY =>

        "org.apache.activemq.jndi.ActiveMQInitialContextFactory",

       Context::PROVIDER_URL =>

       "tcp://localhost:61616" }



context = InitialContext.new(Hashtable.new(env))

connection_factory = context.lookup("ConnectionFactory")



destination = context.lookup("dynamicQueues/output.queue")

connection = connection_factory.create_connection()

session = connection.create_session(false, Session::AUTO_ACKNOWLEDGE)

consumer = session.create_consumer(destination)



connection.start



message = consumer.receive

if (message.respond_to? 'text')

 p "message = #{message.text}"

else

 p "message isn't a text message"

end



connection.stop

session.close

package org.jrubycookbook.j2ee.ejb;



import javax.ejb.Local;



@Local

public interface Reverser {

    public String reverse(String string);

}

package org.jrubycookbook.j2ee.ejb;



import javax.annotation.PostConstruct;

import javax.ejb.Stateless;



import org.jruby.Ruby;

import org.jruby.RubyString;

import org.jruby.javasupport.JavaEmbedUtils;



@Stateless

public class ReverserBean implements Reverser {



    private Ruby ruby;



    @PostConstruct

    public void init() {

        ruby = JavaEmbedUtils.initialize(Collections.EMPTY_LIST);

    }



    public String reverse(String string) {

        ruby.getGlobalVariables().set("$message", ruby.newString(string));

        return ruby.evalScriptlet("$message.reverse").asJavaString();

    }



}

package org.jrubycookbook.j2ee.servlet;



import java.io.IOException;



import javax.ejb.EJB;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;



import org.jrubycookbook.j2ee.ejb.Reverser;



public class ReverseServlet extends HttpServlet {



    @EJB

    private Reverser reverser;



    protected void doGet(HttpServletRequest req, HttpServletResponse resp)

            throws ServletException, IOException {

        String result = reverser.reverse(req.getParameter("word"));

        resp.getWriter().println(result);

    }



}

1 <?xml version="1.0" encoding="UTF-8"?>

2 <beans xmlns="http://www.springframework.org/schema/beans"

3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

4     xmlns:lang="http://www.springframework.org/schema/lang"

5     xsi:schemaLocation="http://www.springframework.org/schema/beans

6         http://www.springframework.org/schema/beans/spring-beans.xsd

7         http://www.springframework.org/schema/lang

8         http://www.springframework.org/schema/lang/spring-lang.xsd">

9

10    <lang:jruby id="rubyListener"

11        script-interfaces="org.jrubycookbook.ch04.Listener"

12        script-source="classpath:org/jrubycookbook/ch04/ruby_listener.rb">

13        <lang:property name="prefix" value="(from Ruby) " />

14    </lang:jruby>

15

16 </beans>

package org.jrubycookbook.ch04;



public interface Listener {

    public void receiveMessage(String message);

}

class RubyListener

    # setter for prefix property

    def setPrefix(p)

        @prefix = p

    end



    # implementation of Listener interface

    def receiveMessage(s)

        puts "#{@prefix}Got Message: #{s}"

    end

end



RubyListener.new

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xmlns:lang="http://www.springframework.org/schema/lang"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans.xsd

        http://www.springframework.org/schema/lang

        http://www.springframework.org/schema/lang/spring-lang.xsd">



    <lang:defaults refresh-check-delay="1000" />



    <lang:jruby id="rubyListener"

        script-interfaces="org.jrubycookbook.ch04.Listener "

        script-source="classpath:org/jrubycookbook/ch04/ruby_listener.rb">

        <lang:property name="prefix" value="(from Timer) " />

    </lang:jruby>



    <bean id="sendDateTask" class="org.jrubycookbook.ch04.SendDateTask">

        <property name="listener" ref="rubyListener"/>

    </bean>



    <bean id="scheduledTask"

        class="org.springframework.scheduling.timer.ScheduledTimerTask">

        <property name="period" value="5000" />

        <property name="timerTask" ref="sendDateTask" />

    </bean>



    <bean id="timerFactory"

        class="org.springframework.scheduling.timer.TimerFactoryBean">

        <property name="scheduledTimerTasks">

            <list>

                <ref bean="scheduledTask" />

            </list>

        </property>

    </bean>

</beans>

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xmlns:lang="http://www.springframework.org/schema/lang"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans.xsd

        http://www.springframework.org/schema/lang

        http://www.springframework.org/schema/lang/spring-lang.xsd">



    <lang:jruby id="rubyListener"

        script-interfaces="org.jrubycookbook.ch04.Listener">

        <lang:inline-script><![CDATA[

class RubyListener

    def setPrefix(p)

        @prefix = p

    end



    # implementation of Listener interface

    def receiveMessage(s)

        puts "#{@prefix}Got Message: #{s}"

    end

end



RubyListener.new

        ]]></lang:inline-script>

        <lang:property name="prefix" value="(from Ruby) " />

    </lang:jruby>



</beans>

<lang:jruby id="rubyListener"

    script-interfaces="org.jrubycookbook.ch04.Listener,

               org.springframework.beans.factory.BeanNameAware">

    <lang:inline-script><![CDATA[

class RubyListener

    # implementation of BeanNameAware interface

    def setBeanName(beanName)

        @beanName = beanName

    end



    # implementation of Listener interface

    def receiveMessage(s)

        puts "Hello, I'm named #{@beanName}"

        puts "#{@prefix}Got Message: #{s}"

    end

end



RubyListener.new

    ]]></lang:inline-script>

</lang:jruby>

<beans xmlns="http://www.springframework.org/schema/beans"

  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

  xmlns:lang="http://www.springframework.org/schema/lang"

  xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

http://www.springframework.org/schema/lang

http://www.springframework.org/schema/lang/spring-lang-2.5.xsd">



  <lang:jruby id="hellocontroller" refresh-check-delay="3000"

    script-source="/WEB-INF/ruby/hello.rb"

    script-interfaces="org.springframework.web.servlet.mvc.Controller">

  </lang:jruby>



  <bean id="viewResolver"

    class="org.springframework.web.servlet.view.InternalResourceViewResolver">

    <property name="viewClass"

      value="org.springframework.web.servlet.view.JstlView"/>

    <property name="prefix" value="/WEB-INF/jsp/"/>

    <property name="suffix" value=".jsp"/>

  </bean>



  <bean id="urlMapping"

    class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">

    <property name="mappings">

      <props>

        <prop key="/hello.htm">hellocontroller</prop>

      </props>

    </property>

  </bean>

</beans>

include Java



import example.dao.PersonDao

import example.dao.DaoFactory

import example.dao.EventDao

import example.model.Person

import example.model.Event

import util.HibernateUtil



event_dao = EventDao.new

event_dao.set_session HibernateUtil::get_session_factory.get_current_session

dao.create(Event.new("JRuby Meeting",java.util.Date.new))

dao.find_all.each do |e| puts "#{e.get_title } #{e.get_date}"; end



person_dao = DaoFactory.instantiate(PersonDao.class)

dao.create(Person.new("Justin","Wood"))

dao.create(Person.new("Brian","Henry"))

dao.find_all.each do |p| puts "#{p.get_firstname} #{p.get_lastname}"; end

include Java



import javax.persistence.Persistence

import cookbook.User



def with_trans(em)

 t = em.getTransaction();

 begin

   t.begin()

   yield

   t.commit

 ensure

   t.rollback if t.isActive

 end

end



emf = Persistence.createEntityManagerFactory("hello-world")

em = emf.createEntityManager



with_trans(em) do

      u = User.new("stephen","lee","slee","password","stephen@ora.com")

      u2 = User.new("stephen","smith","ssmith","password","ssmith@ora.com")

      em.persist(u)

      em.persist(u2)

end

query = em.createQuery("select u from User u where u.firstname = :firstname").

query.set_parameter("firstname", "stephen").

hu = query.get_result_list



hu.each do |u|

  puts "found #{u.firstname} #{u.lastname}"

end



em.close

emf.close

include Java



require "rexml/document"

import org.mule.module.client.MuleClient



url = "axis:http://www.weather.gov/forecasts/xml/SOAP_server/ndfdXMLserver.php"

method = "method=LatLonListZipCode"

client = MuleClient.new

message = client.send("#{url}?#{method}", "10036", nil)

doc = REXML::Document.new message.payload

puts doc.root.elements[1].text

exit

include Java



import com.sun.jndi.ldap.LdapCtx



class LdapCtx

    def get_attribute_value(key)

        get_attributes("", [key].to_java(:string)).get(key).get

    end

    def get_attribute_values(key)

        values = []

        enum = get_attributes("", [key].to_java(:string)).get(key).get_all

        while enum.has_more

            values << enum.next

        end

        return values

    end

end

include Java

import javax.swing.JFrame



frame = JFrame.new "JRuby Message"

frame.default_close_operation = JFrame::EXIT_ON_CLOSE

msg = javax.swing.JLabel.new "JRuby Rocks"

frame.content_pane.add msg

frame.pack

frame.visible = true

include Java



import javax.swing.JFrame

import javax.swing.UIManager



frame = JFrame.new "JRuby Look And Feel"

frame.default_close_operation = JFrame::EXIT_ON_CLOSE

frame.content_pane.layout = java.awt.GridLayout.new(1, 2)



{:metal => "javax.swing.plaf.metal.MetalLookAndFeel",

 :system => UIManager::getSystemLookAndFeelClassName}.each do |l,c|

 but = javax.swing.JButton.new l.to_s

 but.add_action_listener do |evt|

    UIManager::look_and_feel = c

    javax.swing.SwingUtilities::updateComponentTreeUI frame

    frame.pack

 end

 frame.add(but)

end



frame.pack

frame.visible = true

include Java

import javax.swing.JFrame



frame = JFrame.new "Event Handler - Coerced"

frame.default_close_operation = JFrame::EXIT_ON_CLOSE



t = javax.swing.JTextField.new(10)

b = javax.swing.JButton.new("search")

b.add_action_listener { |evt| puts "searching" };

t.document.add_document_listener { |evt| puts "checking #{t.text}" };



frame.layout = java.awt.GridLayout.new(1, 2)

frame.add t

frame.add b

frame.pack

frame.visible = true

include Java

import javax.swing.JFrame



frame = JFrame.new

frame.default_close_operation = JFrame::EXIT_ON_CLOSE



bar = javax.swing.JMenuBar.new

menu = javax.swing.JMenu.new "File"

item = javax.swing.JMenuItem.new "Open"



menu.add_menu_listener(javax.swing.event.MenuListener.impl do |method, evt|

  puts evt.class

  case method.to_s

    when "menuDeselected"

        puts 'hidden'

    when "menuSelected"

        puts 'visible'

  end

end)



menu.add item

bar.add menu

frame.jmenu_bar = bar

frame.pack

frame.visible = true

include Java

import javax.swing.JFrame



frame = JFrame.new "Swing Worker"

frame.default_close_operation = JFrame::EXIT_ON_CLOSE



start = javax.swing.JButton.new("start")



#define the function using a block

start.add_action_listener do |evt|

  class MySwingWorker < javax.swing.SwingWorker

    attr_accessor :button

    def doInBackground

      10.times do

        puts "thread #{self.hashCode} working"

        sleep(1)

      end

      self.button.text = "Completed"

    end

  end



  sw = MySwingWorker.new

  sw.button = start

  sw.execute

end



frame.add start

frame.pack

frame.visible = true

# Name of the created jar file

project_name: jruby_cookbook_app



# Ruby file to invoke when jar is started

main_ruby_file: jruby_cookbook_main

web_start: { self_sign: true, self_sign_passphrase: password }



jnlp: {

    codebase: http://localhost:8080,

    description: My Webstart Demo,

    vendor: Your Name,

    homepage_href: http://www.ora.com

       }

JRubyApplet.java



package org.jrubycookbook;



import java.util.ArrayList;

import org.jruby.Ruby;

import org.jruby.javasupport.*;

import java.awt.Container;

import org.jruby.runtime.builtin.IRubyObject;

import org.jruby.runtime.*;



public class JrubyApplet extends javax.swing.JApplet {

    public void init(){

        Ruby runtime = JavaEmbedUtils.initialize(new ArrayList<String>());

        runtime.evalScriptlet("require \"java\"\nclass FreshForJava\nend\n");

        final IRubyObject blankRuby = runtime.evalScriptlet("FreshForJava.new");

        IRubyObject globValue = JavaUtil.convertJavaToRuby(runtime,

            this.getContentPane());

        globValue = Java.java_to_ruby(blankRuby, globValue, Block.NULL_BLOCK);

        GlobalVariable gv = new GlobalVariable(runtime, "$content_pane",

            globValue);

        runtime.defineVariable(gv);

        String bootRuby = "require 'appletmain' \n";

        runtime.evalScriptlet( bootRuby );

     }

}



appletmain.rb



include Java



import javax.swing.JPanel

import javax.swing.JButton



jp = JPanel.new

but = JButton.new("OK")

but.add_action_listener do |evt|

     puts "pressed"

end

jp.add(but)

$content_pane.add(jp)

<applet width="200" height="200" align="baseline"

    code="org.jrubycookbook.JrubyApplet.class"

    codebase="." pluginspage="http://java.sun.com/j2se/1.6.0/download.html"

        archive="jrubyapplet.jar,jruby-complete.jar">

</applet>

include Java

require 'swt'



import org.eclipse.swt.SWT

import org.eclipse.swt.layout.RowLayout

import org.eclipse.swt.widgets.Listener



d = org.eclipse.swt.widgets.Display.new

s = org.eclipse.swt.widgets.Shell.new(d)

but =  org.eclipse.swt.widgets.Button.new(s, SWT::PUSH)

but.text = "Search"

l = org.eclipse.swt.widgets.Label.new(s,SWT::NONE)

l.text = "Click to Search"

l.set_size(100,75)



but.addListener(SWT::Selection, Listener.impl do |method, evt|

      l.text = 'searching...'

end)



s.layout = RowLayout.new

s.set_size(300,200)

s.open



while(!s.is_disposed) do d.sleep if(!d.read_and_dispatch) end

d.dispose

include Java

require File.dirname(__FILE__) + "/../src/swt"



include Glimmer

import 'org.eclipse.swt.layout.GridLayout'



def user_name

    "default text"

end



def enabled

    true

end



@shell = shell {

  text "SWT"

  composite {

    layout GridLayout.new(2, false) #two columns with differing widths

    label { text "Hello World!"}

    text {

          text bind(self, :user_name)

          enabled bind(self, :enabled)

         }

    }

}

@shell.open

include Java

import java.awt.Desktop

import java.net.URI

import java.io.File



d = Desktop::desktop



# Open the browser

d.browse(URI.new("http://www.ora.com/")) if d.isSupported(Desktop::Action::BROWSE)



# Open your mail client and compose a message

d.mail(URI.new("mailto:jruby@ora.com")) if d.isSupported(Desktop::Action::MAIL)



# Launch the default jpg viewing application

d.open(File.new("conference_pic_1.jpg")) if d.isSupported(Desktop::Action::OPEN)



# Print a document

d.print(File.new("directions.twxt")) if d.isSupported(Desktop::Action::PRINT)

import javax.swing.*;



public class SearchDemoJava extends JFrame {

    private JLabel message = new JLabel("Click to search");

    private JButton search = new JButton("Search");



    public SearchDemoJava(){

        this.setLayout(new java.awt.FlowLayout());

        this.setSize(300,100);

        add(search);

        add(message);

    }

}

class SearchModel

      attr_accessor :search_message

      def initialize

            @search_message = "Starting"

      end

end

<?xml version="1.0" encoding="UTF-8"?>

<project name="project" default="package">

    <target name="simple">

        <script language="ruby">

               print "Hello World!"

        </script>

    </target>

</project>

<?xml version="1.0" encoding="UTF-8"?>

<project name="project" default="package">



    <property file="${user.home}/build.properties" />

    <path id="jruby">

        <fileset file="${jruby.home}/lib/jruby.jar" />

        <fileset file="${jsr223.engines.home}/lib/jruby-engine.jar" />

    </path>



    <target name="simple">

        <script language="ruby" classpathref="jruby">

               print "Hello #{$project.getProperty('user.name')}"

        </script>

    </target>

</project>

<target name="setup">

    <condition property="user_has_text_files">

        <scriptcondition language="ruby" value="false">

            cwd = Dir.pwd

            Dir.chdir $project.getProperty("user.home")

            $self.setValue(true) if Dir.glob("**/*.txt")

            Dir.chdir cwd

        </scriptcondition>

    </condition>

</target>

<target name="setup">

    <condition property="user_has_text_files">

        <and>

            <os family="windows"/>

            <scriptcondition language="ruby" value="false">

                puts "hello"

                cwd = Dir.pwd

                Dir.chdir $project.getProperty("user.home")

                $self.setValue(true) if Dir.glob("**/*.txt")

                Dir.chdir cwd

            </scriptcondition>

        </and>

    </condition>

</target>

<?xml version="1.0" encoding="UTF-8"?>

<project name="project" default="start">



    <scriptdef name="start-webrick" language="ruby">

        <attribute name="port"/>

        <attribute name="root"/>

        <![CDATA[

            require 'webrick'

            include WEBrick



            server = HTTPServer.new(:Port => $attributes.get('port').to_i)

            server.mount("/", HTTPServlet::FileHandler, $attributes.get('root'))

            server.start

        ]]>

    </scriptdef>



    <target name="start">

            <start-webrick port="8000" root="${basedir}/files"/>

    </target>



</project>

<project>

    <modelVersion>4.0.0</modelVersion>

    <groupId>org.jrubycookbook</groupId>

    <artifactId>maven-sample</artifactId>

    <packaging>pom</packaging>

    <version>1.0-SNAPSHOT</version>



    <build>

        <plugins>

            <plugin>

                <groupId>org.codehaus.mojo</groupId>

                <artifactId>jruby-maven-plugin</artifactId>

                <executions>

                    <execution>

                        <phase>generate-resources</phase>

                        <goals>

                            <goal>run</goal>

                        </goals>

                        <configuration>

                            <ruby>

                                require 'fileutils'

                                FileUtils.touch 'target/timestamp'

                            </ruby>

                        </configuration>

                    </execution>

                </executions>

                <!— These are necessary due to an issue with

                    JRuby's Maven distribution. -->

                <dependencies>

                    <dependency>

                        <groupId>backport-util-concurrent</groupId>

                        <artifactId>backport-util-concurrent</artifactId>

                        <version>3.0</version>

                    </dependency>

                    <dependency>

                        <groupId>asm</groupId>

                        <artifactId>asm-all</artifactId>

                        <version>2.2.3</version>

                    </dependency>

                </dependencies>

            </plugin>

        </plugins>

    </build>

</project>

<project>

    <modelVersion>4.0.0</modelVersion>

    <groupId>org.jrubycookbook</groupId>

    <artifactId>maven-textile-plugin</artifactId>

    <packaging>maven-plugin</packaging>

    <version>1.0-SNAPSHOT</version>

    <name>Maven Textile Plugin</name>

    <description>

        Generates site documentation from Textile sources using

        RedCloth.

    </description>

    <dependencies>

        <dependency>

            <groupId>org.codehaus.mojo</groupId>

            <artifactId>jruby-maven-plugin</artifactId>

            <version>1.0-beta-4</version>

        </dependency>

        <dependency>

            <groupId>backport-util-concurrent</groupId>

            <artifactId>backport-util-concurrent</artifactId>

            <version>3.0</version>

        </dependency>

        <dependency>

            <groupId>asm</groupId>

            <artifactId>asm-all</artifactId>

            <version>2.2.3</version>

        </dependency>

    </dependencies>

    <build>

        <plugins>

            <plugin>

                <artifactId>maven-plugin-plugin</artifactId>

                <dependencies>

                    <dependency>

                        <groupId>org.codehaus.mojo</groupId>

                        <artifactId>jruby-maven-plugin</artifactId>

                        <version>1.0-beta-4</version>

                    </dependency>

                    <dependency>

                        <groupId>backport-util-concurrent</groupId>

                        <artifactId>

                            backport-util-concurrent

                        </artifactId>

                        <version>3.0</version>

                    </dependency>

                    <dependency>

                        <groupId>asm</groupId>

                        <artifactId>asm-all</artifactId>

                        <version>2.2.3</version>

                    </dependency>

                </dependencies>

            </plugin>

        </plugins>

    </build>

</project>

require 'raven'



javac 'compile'

require 'raven'



javac 'compile' do |t|

    t.build_path << "src/java"

end

require 'raven'

require 'rake/clean'



CLEAN.include('target')



javac 'compile'

1 require 'raven'

2

3 dependency 'compile_deps' do |t|

4     t.deps << ['commons-logging', {'commons-httpclient' => '3.1'}]

5 end

6

7 javac 'compile' => 'compile_deps'

8

9 javadoc 'jdoc' => 'compile_deps'

require 'raven'



dependency 'compile_deps' do |t|

    t.deps << ['commons-logging', {'commons-httpclient' => '3.1'}]

end



dependency 'test_deps' => 'compile_deps' do |t|

    t.deps << {'junit' => '3.8.2'}

end



javac 'compile' => 'compile_deps'



junit 'test' => ['compile', 'test_deps'] do |t|

    t.test_classes << "**/*Test.java"

end

10 desc "The Chapter 6 buildr project"

11 define "ch06-buildr" do

12   project.version = "1.0"

13   project.group = "org.jrubycookbook"

14   package(:jar)

15 end

class TestArrayList < Test::Unit::TestCase



 def test_that_size_method_works

    list = java.util.ArrayList.new

    assert_equal(0, list.size)

    list << 'first'

    list << 'second'

    assert_equal(2, list.size)

  end



end

class TestArrayList < Test::Unit::TestCase



 def setup

     @list = java.util.ArrayList.new

 end



 def test_that_size_method_works

     assert_equal(0, @list.size)

    @list << 'first'

    @list << 'second'

    assert_equal(2, @list.size)

  end



  def test_that_empty_works

     assert(@list.empty)

     @list << 'first'

     @list << 'second'

     assert(!@list.empty)

   end



end

unit_tests do

    test "that size method works" do

        @list = java.util.ArrayList.new

        assert_equal(0, @list.size)

        @list << 'first'

        @list << 'second'

        assert_equal(2, @list.size)

    end



    test "that empty method works" do

        @list = java.util.ArrayList.new

        assert @list.empty

        @list << 'first'

        @list << 'second'

        assert !@list.empty

    end

end

Expectations do

    expect 0 do

        list = java.util.ArrayList.new

        list.size

    end



    expect 2 do

        list = java.util.ArrayList.new

        list << 'first'

        list << 'second'

        list.size

    end



    expect true do

        list = java.util.ArrayList.new

        list.empty

    end



    expect false do

        list = java.util.ArrayList.new

        list << 'first'

        list << 'second'

        list.empty

    end

end

unit_tests do

    test "that retainAll only calls contains" do

        list = java.util.ArrayList.new

        list << 'first'

        list << 'second'

        list << 'third'



        other = java.util.Collection.new

        other.expects(:contains).returns(true).times(3)



        list.retainAll(other)

    end

end

unit_tests do

    test "that retainAll calls contains once per item in the list" do

        list = java.util.ArrayList.new

        list << 'first'

        list << 'second'

        list << 'third'



        other = java.util.Collection.new

        other.expects(:contains).with('first').returns(true)

        other.expects(:contains).with('second').returns(true)

        other.expects(:contains).with('third').returns(true)



        list.retainAll(other)

    end

end