coffee_machine 0.1.0

data/.gitignore

@@ -0,0 +1,3 @@
+coffee_machine.gemspec
+pkg
+doc

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = 'coffee_machine'
+    gem.summary = 'Run Java classes and jars from Ruby.'
+    gem.homepage = 'http://github.com/codespeaks/coffee_machine'
+    gem.authors = ['Tobie Langel', 'Samuel Lebeau']
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts 'Jeweler not available. Install it with: gem install jeweler'
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/coffee_machine.rb

@@ -0,0 +1,107 @@
+module CoffeeMachine
+  extend self
+  
+  def run_class(java_class, *args, &block)
+    java_class = java_class.inspect if java_class =~ /\.class$/
+    JavaRunner.run(java_class, *args, &block)
+  end
+  
+  def run_jar(path_to_jar, *args, &block)
+    JavaRunner.run("-jar #{path_to_jar.inspect}", *args, &block)
+  end
+  
+  class JavaRunner # :nodoc:
+    autoload :Tempfile, 'tempfile'
+    
+    TEMPFILE_BASENAME = 'coffee_machine'.freeze
+    
+    DEFAULT_OPTIONS = {
+      :java       => 'java'.freeze,
+      :java_args  => nil,
+      :class_path => nil
+    }.freeze
+    
+    attr_reader :class_or_jar, :options, :stderr
+    
+    def self.run(*args, &block)
+      new(*args).run(&block)
+    end
+    
+    def initialize(class_or_jar, program_args = nil, options = {})
+      @class_or_jar = class_or_jar
+      options, program_args = program_args, nil if options?(program_args)
+      @program_args, @options = program_args, DEFAULT_OPTIONS.merge(options)
+    end
+    
+    def run
+      create_stderr do |stderr|
+        @stderr = stderr
+        IO.popen(command, IO::RDWR) do |pipe|
+          if block_given?
+            return yield(pipe, stderr)
+          else
+            return pipe.read, stderr.read
+          end
+        end
+      end
+    end
+    
+    protected
+      def options?(arg)
+        arg.is_a?(Hash) && arg.keys.any? { |k| k.is_a?(Symbol) }
+      end
+      
+      def create_stderr(&block)
+        tempfile = Tempfile.open(TEMPFILE_BASENAME)
+        tempfile.close
+        File.open(tempfile.path, &block)
+      end
+      
+      def command
+        cmd = []
+        cmd << options[:java]
+        cmd << java_args
+        cmd << classpath
+        cmd << class_or_jar
+        cmd << program_args
+        cmd << redirect_stderr
+        cmd.compact.join(' ')
+      end
+      
+      def java_args
+        format_args(options[:java_args])
+      end
+      
+      def classpath
+        if (classpath = options[:classpath]) && !classpath.empty?
+          if classpath.is_a?(Enumerable) && !classpath.is_a?(String)
+            classpath = classpath.collect { |dir| dir.inspect }.join(':')
+          end
+          "-classpath #{classpath}"
+        end
+      end
+      
+      def program_args
+        format_args(@program_args)
+      end
+      
+      def format_args(args)
+        case args
+        when Hash
+          args.inject([]) do |array, (key, value)|
+            array << key
+            array << value unless value == true
+            array
+          end.join(' ')
+        when String
+          args
+        when Enumerable
+          args.to_a.join(' ')
+        end
+      end
+      
+      def redirect_stderr
+        "2> #{stderr.path.inspect}"
+      end
+  end
+end

data/test/coffee_machine_test.rb

@@ -0,0 +1,128 @@
+require File.dirname(__FILE__) + '/../lib/coffee_machine'
+
+begin
+  gem 'test-unit'
+rescue Gem::LoadError
+  puts "Run `gem install test-unit` if encountering the following exception:"
+  puts "uninitialized constant Test::Unit::TestResult::TestResultFailureSupport (NameError)".inspect
+end if RUBY_PLATFORM =~ /(win|w)32/
+
+require 'test/unit'
+require 'mocha'
+require 'stringio'
+require 'set'
+
+class CoffeeMachineTest < Test::Unit::TestCase
+  def test_run_class
+    CoffeeMachine::JavaRunner.expects(:run).with('Foo')
+    CoffeeMachine.run_class('Foo')
+    
+    CoffeeMachine::JavaRunner.expects(:run).with('"path/to/Foo.class"')
+    CoffeeMachine.run_class('path/to/Foo.class')
+  end
+  
+  def test_run_jar
+    CoffeeMachine::JavaRunner.expects(:run).with('-jar "path/to/foo.jar"')
+    CoffeeMachine.run_jar('path/to/foo.jar')
+  end
+  
+  def test_run_methods_forward_args
+    CoffeeMachine::JavaRunner.expects(:run).with('Foo', '--foo -bar')
+    CoffeeMachine.run_class('Foo', '--foo -bar')
+    CoffeeMachine::JavaRunner.expects(:run).with('Foo', '--foo -bar', :foo => :bar)
+    CoffeeMachine.run_class('Foo', '--foo -bar', :foo => :bar)
+  end
+  
+  def test_program_args_as_string
+    should_run_command %{java Foo -bar --baz}
+    CoffeeMachine::JavaRunner.run('Foo', '-bar --baz')
+  end
+  
+  def test_program_args_as_hash
+    should_run_command do |command|
+      if command =~ /^java Foo (.*) 2>/
+        $1.scan(/--?\w+(?: \w+)?/).to_set == Set.new(['-bar', '--baz', '--foo 42'])
+      end
+    end
+    CoffeeMachine::JavaRunner.run('Foo', {
+      '-bar'  => true,
+      '--baz' => true,
+      '--foo' => 42
+    })
+  end
+  
+  def test_program_args_as_array
+    should_run_command %{java Foo -bar --baz --foo 42}
+    CoffeeMachine::JavaRunner.run('Foo', ['-bar', '--baz', '--foo 42'])
+  end
+  
+  def test_java_option
+    should_run_command %{/path/to/java Foo}
+    CoffeeMachine::JavaRunner.run('Foo', :java => '/path/to/java')
+  end
+  
+  def test_java_args_options_as_string
+    should_run_command %{java -bar --baz Foo}
+    CoffeeMachine::JavaRunner.run('Foo', :java_args => '-bar --baz')
+  end
+  
+  def test_java_args_options_as_hash
+    should_run_command do |command|
+      if command =~ /^java (.*) Foo/
+        $1.scan(/--?\w+(?: \w+)?/).to_set == Set.new(['-bar', '--baz', '--foo 42'])
+      end
+    end
+    CoffeeMachine::JavaRunner.run('Foo', :java_args => {
+      '-bar'  => true,
+      '--baz' => true,
+      '--foo' => 42
+    })
+  end
+  
+  def test_classpath_option
+    should_run_command %{java -classpath /path/to/foo:bar Foo}
+    CoffeeMachine::JavaRunner.run('Foo', :classpath => '/path/to/foo:bar')
+    
+    should_run_command %{java -classpath "/path/to/foo":"bar"}
+    CoffeeMachine::JavaRunner.run('Foo', :classpath => ['/path/to/foo', 'bar'])
+  end
+  
+  def test_block_given
+    should_run_command(/^java Foo 2> "(.*)"$/).yields(:a_stream)
+    return_value = CoffeeMachine::JavaRunner.run('Foo') do |pipe, stderr|
+      assert_equal(:a_stream, pipe)
+      assert_respond_to stderr, :read
+      assert_equal stderr.path, @match.captures.first
+      :value_returned_by_block
+    end
+    assert_equal :value_returned_by_block, return_value
+  end
+  
+  def test_stdout_return_value
+    should_run_command(%{java Foo}).yields(StringIO.new('STDOUT content'))
+    stdout_content, stderr_content = CoffeeMachine::JavaRunner.run('Foo')
+    assert_equal 'STDOUT content', stdout_content
+    assert_equal '', stderr_content
+  end
+  
+  def test_stderr_return_value
+    stdout_content, stderr_content = CoffeeMachine::JavaRunner.run('',
+      :java => 'ruby',
+      :java_args =>  %{-e "STDERR.print('STDERR content')"}
+    )
+    assert_equal '', stdout_content
+    assert_equal 'STDERR content', stderr_content
+  end
+  
+  protected
+    def should_run_command(pattern = nil)
+      pattern = Regexp.compile("^#{pattern}") unless pattern.nil? || pattern.is_a?(Regexp)
+      IO.expects(:popen).with do |command, mode|
+        if block_given?
+          yield(command)
+        else
+          @match = pattern.match(command)
+        end
+      end
+    end
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+name: coffee_machine
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Tobie Langel
+- Samuel Lebeau
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-24 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: 
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- .gitignore
+- README
+- Rakefile
+- VERSION
+- lib/coffee_machine.rb
+- test/coffee_machine_test.rb
+has_rdoc: true
+homepage: http://github.com/codespeaks/coffee_machine
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Run Java classes and jars from Ruby.
+test_files: 
+- test/coffee_machine_test.rb