therubyrhino 1.72.1-jruby

data/History.txt

@@ -0,0 +1,12 @@
+=== 1.72.1 2009-10-XX
+* N major enhancements:
+  * easily manipulate javascript objects from ruby (NativeObject)
+  * make NativeObject Enumerable
+  * to_h and to_json for NativeObject
+  * embed ruby instances and call methods from javascript
+
+=== 1.72.0 2009-09-24
+
+* 2 major enhancements:
+  * evaluate javascript in jruby
+  * embed callable ruby objects in javascript

data/Manifest.txt

@@ -0,0 +1,16 @@
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile
+lib/rhino.rb
+lib/rhino/context.rb
+lib/rhino/java.rb
+lib/rhino/rhino-1.7R2.jar
+script/console
+script/destroy
+script/generate
+spec/rhino/context_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+tasks/jruby.rake
+tasks/rspec.rake

data/README.rdoc

@@ -0,0 +1,78 @@
+= therubyrhino
+
+* http://github.com/cowboyd/therubyrhino
+
+== DESCRIPTION:
+
+Embed the Mozilla Rhino Javascript interpreter into Ruby
+
+== FEATURES/PROBLEMS:
+
+* Evaluate Javascript from with in Ruby
+* Embed your Ruby objects into the Javascript world
+
+== SYNOPSIS:
+
+1. Javascript goes into Ruby
+1. Ruby Objects goes into Javascript
+1. Our shark's in the Javascript!
+
+
+  include Rhino
+# evaluate some simple javascript
+
+  Rhino::Context.open do |context|
+    context.evaljs("7 * 6") #=> 42
+  end
+
+# evaluate a ruby function from javascript
+  
+  Rhino::Context.open do |context|
+    scope = context.init_standard_objects
+    scope["say"] = function {|word, times| word * times}
+    context.evaljs("say("Hello", 3)") #=> HelloHelloHello
+  end
+
+# Configure your embedding setup
+
+  Rhino::Context.open do |context|
+    # Make your standard objects (Object, String, etc...) immutable
+    scope = context.init_standard_objects(:sealed => true)
+    context.evaljs("Object.prototype.toString = function() {}") # this is an error!
+    
+    #Turn on Java integration from javascript (probably a bad idea)
+    scope = context.init_standard_objects(:java => true)
+    context.evaljs("java.lang.System.exit()") #it's dangerous!
+  end
+== REQUIREMENTS:
+
+* JRuby >= 1.3.0
+
+== INSTALL:
+
+* jgem install therubyrhino
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Charles Lowell
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,21 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+require './lib/rhino'
+
+Hoe.plugin :newgem
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.spec 'therubyrhino' do
+  self.developer 'Charles Lowell', 'cowboyd@thefrontside.net'
+  self.rubyforge_name   = self.name 
+  self.summary          = "Embed the Rhino Javascript engine into JRuby"
+
+  self.spec_extras['platform'] = 'jruby' # JRuby gem created, e.g. therubyrhino-X.Y.Z-jruby.gem
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }
+

data/lib/rhino.rb

@@ -0,0 +1,12 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+
+module Rhino
+  VERSION = '1.72.1'
+  require 'rhino/java'
+  require 'rhino/context'
+  require 'rhino/wormhole'
+  require 'rhino/native_object'
+  require 'rhino/ruby_object'
+end

data/lib/rhino/context.rb

@@ -0,0 +1,83 @@
+module Rhino
+  
+  def function(&impl)
+    Function.new &impl
+  end
+  
+  class Context
+
+    class << self
+      def open
+        J::ContextFactory.new.call do |native|
+          yield new(native)
+        end
+      end
+      
+      def open_std(options = {})
+        open do |cxt|
+          yield cxt, cxt.init_standard_objects(options)
+        end
+      end
+                
+      private :new
+    end    
+    
+    def initialize(native) #:nodoc:
+      @native = native
+    end
+        
+    def init_standard_objects(options = {})
+      NativeObject.new(@native.initStandardObjects(nil, options[:sealed] == true)).tap do |objects|
+        unless options[:java]
+          for package in ["Packages", "java", "org", "com"]
+            objects.j.delete(package)
+          end
+        end
+      end
+    end
+    
+    def eval(str, scope = @native.initStandardObjects())
+      str = str.to_s
+      begin
+        To.ruby @native.evaluateString(To.javascript(scope), str, "<eval>", 1, nil)
+      rescue J::RhinoException => e
+        raise Rhino::RhinoError, e
+      end
+    end
+    
+    def standard
+      yield @native.initStandardObjects()
+    end
+    
+  end
+    
+  class Function < J::BaseFunction
+    def initialize(callable = nil, &block)
+      super()
+      @block = callable || block
+    end
+    
+    def call(cxt, scope, this, args)
+      @block.call(*(args.map {|a| To.ruby(a)}))
+    end
+    
+    def to_json(*args)
+      '"[Native Function]"'
+    end
+  end
+    
+    
+  class RhinoError < StandardError
+    def initialize(native)
+      @native = native
+    end
+    
+    def message      
+      @native.cause.details
+    end
+    
+    def javascript_backtrace
+      @native.getScriptStackTrace()
+    end        
+  end
+end

data/lib/rhino/java.rb

@@ -0,0 +1,17 @@
+require 'java'
+require 'rhino/rhino-1.7R2.jar'
+
+module Rhino
+  module J
+    import "org.mozilla.javascript"
+  end
+end
+
+unless Object.method_defined?(:tap)
+  class Object
+    def tap
+      yield self
+      self
+    end
+  end
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env jruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/rhino.rb'}"
+puts "Loading therubyrhino gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/spec/rhino/context_spec.rb

@@ -0,0 +1,100 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+include Rhino
+  
+describe Rhino::Context do  
+  
+  it "can evaluate some javascript" do
+    Context.open do |cxt|
+      cxt.eval("5 + 3").should == 8
+    end
+  end
+  
+  it "treats nil and the empty string as the same thing when it comes to eval" do
+    Context.open do |cxt|
+      cxt.eval(nil).should == cxt.eval('')
+    end
+  end
+  
+  it "can embed primitive ruby object into javascript" do
+    Context.open do |cxt|
+      cxt.init_standard_objects.tap do |scope|
+        scope["foo"] = "Hello World"
+        cxt.eval("foo", scope).should == "Hello World"
+      end
+    end
+  end  
+  
+  describe "Initalizing Standard Javascript Objects" do
+    it "provides the standard objects without java integration by default" do
+      Context.open do |cxt|
+        cxt.init_standard_objects.tap do |scope|
+          scope["Object"].should_not be_nil
+          scope["Math"].should_not be_nil
+          scope["String"].should_not be_nil
+          scope["Function"].should_not be_nil
+          scope["Packages"].should be_nil
+          scope["java"].should be_nil
+          scope["org"].should be_nil
+          scope["com"].should be_nil
+        end
+      end
+    end
+    
+    it "provides unsealed standard object by default" do
+      Context.open do |cxt|
+        cxt.init_standard_objects.tap do |scope|
+          cxt.eval("Object.foop = 'blort'", scope)
+          scope["Object"]['foop'].should == 'blort'
+        end
+      end
+    end
+    
+    it "allows you to seal the standard objects so that they cannot be modified" do
+      Context.open do |cxt|
+        cxt.init_standard_objects(:sealed => true).tap do |scope|
+          lambda {
+            cxt.eval("Object.foop = 'blort'", scope)            
+          }.should raise_error(Rhino::RhinoError)
+          
+          lambda {
+            cxt.eval("Object.prototype.toString = function() {}", scope)            
+          }.should raise_error(Rhino::RhinoError)
+          
+        end
+      end
+    end
+    
+    it "allows java integration to be turned on when initializing standard objects" do
+      Context.open do |cxt|
+        cxt.init_standard_objects(:java => true).tap do |scope|
+          scope["Packages"].should_not be_nil
+        end
+      end
+    end
+    
+    it "provides a convenience method for initializing scopes" do
+      Context.open_std(:sealed => true, :java => true) do |cxt, scope|
+        scope["Object"].should_not be_nil
+        scope["java"].should_not be_nil
+        cxt.eval("new java.lang.String('foo')", scope).should == "foo"
+      end
+    end    
+  end
+  
+  
+  it "can call ruby functions from javascript" do
+    Context.open do |cxt|
+      cxt.standard do |scope|
+        scope.put("say", scope, function {|word, times| word * times})
+        cxt.eval("say('Hello',2)", scope).should == "HelloHello"
+      end
+    end
+  end
+    
+  it "has a private constructor" do
+    lambda {
+      Context.new(nil)
+    }.should raise_error
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  gem 'rspec'
+  require 'spec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'rhino'

data/tasks/jruby.rake

@@ -0,0 +1,7 @@
+if RUBY_PLATFORM =~ /java/
+  require 'java'
+else
+  puts "Java RubyGem only! You are not running within jruby."
+  puts "Try: jruby -S rake #{ARGV.join(' ')}"
+  exit(1)
+end

data/tasks/rspec.rake

@@ -0,0 +1,21 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  require 'spec'
+end
+begin
+  require 'spec/rake/spectask'
+rescue LoadError
+  puts <<-EOS
+To use rspec for testing you must install rspec gem:
+    gem install rspec
+EOS
+  exit(0)
+end
+
+desc "Run the specs under spec/models"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', "spec/spec.opts"]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: therubyrhino
+version: !ruby/object:Gem::Version 
+  version: 1.72.1
+platform: jruby
+authors: 
+  - Charles Lowell
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-09 00:00:00 -05:00
+default_executable: 
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: hoe
+    type: :development
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Requirement 
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: 2.3.3
+      version: 
+description: Embed the Mozilla Rhino Javascript interpreter into Ruby
+email: 
+  - cowboyd@thefrontside.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+  - History.txt
+  - Manifest.txt
+files: 
+  - History.txt
+  - Manifest.txt
+  - README.rdoc
+  - Rakefile
+  - lib/rhino.rb
+  - lib/rhino/context.rb
+  - lib/rhino/java.rb
+  - lib/rhino/rhino-1.7R2.jar
+  - script/console
+  - script/destroy
+  - script/generate
+  - spec/rhino/context_spec.rb
+  - spec/spec.opts
+  - spec/spec_helper.rb
+  - tasks/jruby.rake
+  - tasks/rspec.rake
+has_rdoc: true
+homepage: http://github.com/cowboyd/therubyrhino
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+  - --main
+  - README.rdoc
+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: therubyrhino
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Embed the Rhino Javascript engine into JRuby
+test_files: []
+