bind-it 0.2.1-java

data/LICENSE

@@ -0,0 +1,19 @@
+== BindIt Ruby Gem
+BindIt is a tool to facilitate the creation of Java bindings in Ruby.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+This license also applies to the included Stanford CoreNLP files.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Author: Louis-Antoine Mullie (louis.mullie@gmail.com). Copyright 2012.

data/README.md

@@ -0,0 +1,72 @@
+**About**
+  
+BindIt is a very simple tool that allows to make Ruby bindings to Java packages that work both on JRuby and MRI platforms. It provides a simplified interface to load JARs and Java classes, and allows logging of JVM output to a text file.
+
+BindIt uses the Ruby-Java-Bridge (Rjb) to access Java objects. It runs on Ruby 1.9.2 and 1.9.3.
+
+**Installing**
+
+`gem install bind-it`
+
+**Usage**
+
+1. Create a module into which Java classes will be loaded.
+2. Make sure that module extends `BindIt::Binding`.
+3. Set your configuration options (see examples below).
+4. Run YourModule.bind to load the default JARs and classes.
+5. Access loaded Java classes using YourModule::YourClass.
+
+**Example**
+
+```ruby
+
+require 'bind-it'
+
+module MyBindings 
+
+  extend BindIt::Binding
+
+  # Arguments to use when initializing the JVM.
+  self.jvm_args = ['-option1X', '-option2X']
+
+  # If set, JVM output is redirected to file.
+  self.log_file = 'log_file.txt'
+
+  # The path in which to look for JAR files.
+  self.jar_path = '/path/to/jars/'
+
+  # Default JAR files to load.
+  self.default_jars = [
+    'jar1.jar',
+    'jar2.jar'
+  ]
+
+  # Default namespace to use when loading classes.
+  self.default_namespace = 'path.to.default'
+
+  # Default classes to load under MyBindings.
+  # Shown are the three different ways of adding
+  # a class to the default list.
+  self.default_classes = [
+     # Will search for class in default_namespace.
+     ['MyClass'],
+     # Supply a non-default namespace.
+     ['MyClass', 'path.to.namespace'],
+     # Rename the Java class in Ruby.
+     ['MyClass', 'path.to.namespace', 'MyClass2']
+  ]
+
+  # Load the default JARs and classes.
+  self.bind
+
+end
+
+
+
+obj = MyBindings::MyClass.new
+
+```
+
+**Contributing**
+
+Feel free to fork the project and send me a pull request!

data/lib/bind-it.rb

@@ -0,0 +1,7 @@
+# BindIt is a tool to facilitate the creation of Java bindings in Ruby.
+module BindIt
+
+  VERSION = '0.2.1'
+  require 'bind-it/binding'
+
+end

data/lib/bind-it/binding.rb

@@ -0,0 +1,123 @@
+module BindIt
+  
+  # This is the module your namespace should extend.
+  module Binding
+
+    VERSION = '0.0.1'
+
+    if RUBY_PLATFORM =~ /java/
+      require 'java'
+      # require 'bind-it/jruby_proxy'
+    else
+      require 'rjb'
+      require 'bind-it/rjb_proxy'
+    end
+
+    require 'bind-it/jar_loader'
+    
+    
+   def self.extended(base)
+      super(base)
+      # Create configuration options.
+      base.module_eval do
+        class << self
+          # Are the default JARs/classes loaded?
+          attr_accessor :bound
+          # The default path to look in for JARs.
+          attr_accessor :jar_path
+          # The flags for starting the JVM machine.
+          attr_accessor :jvm_args
+          # A file to redirect JVM output to.
+          attr_accessor :log_file
+          # The default JARs to load.
+          attr_accessor :default_jars
+          # The default Java namespace to 
+          # search in for classes.
+          attr_accessor :default_namespace
+          # The default classes to load.
+          attr_accessor :default_classes
+        end
+        # Set default values.
+        self.jar_path = ''
+        self.jvm_args = []
+        self.log_file = nil
+        self.default_namespace = 'java'
+        self.default_classes = []
+        self.bound = false
+      end
+    end
+
+    ######
+    
+    # Load the default JARs and classes.
+    def bind
+      unless self.bound
+        BindIt::JarLoader.log_file = self.log_file
+        BindIt::JarLoader.jvm_args = self.jvm_args
+        self.load_default_jars
+        self.load_default_classes
+      end
+      self.bound = true
+    end
+
+    # Load a JAR file.
+    def load_jar(jar, path = nil)
+      BindIt::JarLoader.load(jar, path)
+    end
+
+    # Load the JARs, looking in default path.
+    def load_default_jars
+      self.default_jars.each do |jar|
+        file, path = *jar
+        path ||= self.jar_path
+        load_jar(jar, path)
+      end
+    end
+
+    # Public function to load classes inside
+    # the namespace. Makes sure the default
+    # JARs are loaded before.
+    def load_class(klass, base = nil, rename = nil)
+      base ||= self.default_namespace
+      self.load unless self.bound
+      self.load_klass(klass, base, rename)
+    end
+    
+    # Create the Ruby classes corresponding to
+    # the StanfordNLP core classes.
+    def load_default_classes
+      self.default_classes.each do |info|
+        klass, base, rename = *info
+        self.load_klass(klass, base, rename)
+      end
+    end
+    
+    protected
+    
+    # Private function to load classes.
+    # Doesn't check if initialized.
+    def load_klass(klass, base, name=nil)
+      base += '.' unless base == ''
+      fqcn = "#{base}#{klass}"
+      name ||= klass
+      if RUBY_PLATFORM =~ /java/
+        rb_class = java_import(fqcn)
+        if name != klass
+          const_set(name.intern, rb_class)
+        end
+      else
+        rb_class = Rjb::import(fqcn)
+        const_set(name.intern, rb_class)
+      end
+    end
+    
+    # Utility function to CamelCase names.
+    def camel_case(text)
+      text.to_s.gsub(/^[a-z]|_[a-z]/) do |a|
+        a.upcase
+      end.gsub('_', '')
+    end
+    
+  end
+  
+end

data/lib/bind-it/jar_loader.rb

@@ -0,0 +1,68 @@
+module BindIt
+  
+  class JarLoader
+    
+    # Configuration options.
+    class << self
+      # An array of flags to pass to the JVM machine.
+      attr_accessor :jvm_args
+      # A log file to send JVM output to.
+      attr_accessor :log_file
+    end
+    
+    # Default configuration options.
+    self.jvm_args = []
+    self.log_file = nil
+  
+    # Load a JAR through Jruby/Rjb.
+    def self.load(jar, path)
+      if !::File.readable?(path + jar)
+        raise "Could not find JAR file (looking in #{jar})."
+      end
+      if RUBY_PLATFORM =~ /java/
+        set_java_logging if self.log_file
+        load_jar_jruby(jar,path)
+      else
+        load_jar_rjb(jar,path)
+      end
+    end
+    
+    # Load a Jruby jar.
+    def self.load_jar_jruby(jar, path)
+      require path + jar
+    end
+    
+    # Laad an Rjb jar.
+    def self.load_jar_rjb(jar,path)
+      self.init_rjb unless ::Rjb::loaded?
+      jar = path + jar
+      ::Rjb::add_jar(jar)
+    end
+    
+    # Load Rjb and create Java VM.
+    def self.init_rjb
+      ::Rjb::load(nil, self.jvm_args)
+      set_java_logging if self.log_file
+    end
+
+    # Redirect the output of the JVM to log.
+    def self.set_java_logging
+      system, print_stream, file = nil, nil, nil
+      if RUBY_PLATFORM =~ /java/
+        system = java.lang.System
+        print_stream = java.io.PrintStream
+        file = java.io.File
+      else
+        system = Rjb::import('java.lang.System')
+        print_stream = Rjb::import('java.io.PrintStream')
+        file = Rjb::import('java.io.File')
+      end
+      ps = print_stream.new(file.new(self.log_file))
+      ps.write(::Time.now.strftime("[%m/%d/%Y at %I:%M%p]\n\n"))
+      system.setOut(ps)
+      system.setErr(ps)
+    end
+
+  end
+  
+end

data/lib/bind-it/rjb_proxy.rb

@@ -0,0 +1,28 @@
+module BindIt::RjbProxy
+
+  # Modify the Rjb JavaProxy class to add our own 
+  # methods to every proxied Java object.
+  Rjb::Rjb_JavaProxy.class_eval do
+
+    # Dynamically defined on all proxied Java objects.
+    # Shorthand for toString() defined by Java classes.
+    def to_s; to_string; end
+    
+    # Dynamically defined on all proxied Java objects.
+    # Shorthand for toArray() defined by Java classes.
+    def to_a; to_array; end
+    
+    # Dynamically defined on all proxied Java iterators.
+    # Provide Ruby-style iterators to wrap Java iterators.
+    def each
+      if !java_methods.include?('iterator()')
+        raise 'This object cannot be iterated.'
+      else
+        i = self.iterator
+        while i.has_next; yield i.next; end
+      end
+    end
+    
+  end
+
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification 
+name: bind-it
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.2.1
+platform: java
+authors: 
+  - Louis Mullie
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-12-18 00:00:00 Z
+dependencies: []
+
+description: " BindIt is a thin wrapper over the Ruby-Java-Bridge (Rjb) to facilitate the creation of Java bindings in Ruby. "
+email: 
+  - louis.mullie@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - lib/bind-it.rb
+  - lib/bind-it/binding.rb
+  - lib/bind-it/jar_loader.rb
+  - lib/bind-it/rjb_proxy.rb
+  - README.md
+  - LICENSE
+homepage: https://github.com/louismullie/bind-it
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: BindIt is a tool to facilitate the creation of Java bindings in Ruby.
+test_files: []
+