node_module 0.1.3 → 0.1.4

data/README.md

@@ -4,33 +4,23 @@
 >
 > &mdash; <cite>https://twitter.com/shit_hn_says/status/234856345579446272</cite>
 
-Ruby is a pretty high level language, so isn't perfectly suited to
-things such as:
+Dropping down to node.js has a number of problems:
 
-1. Systems programming
-2. Being web-scale
+1. You introduce a new, fairly large dependency to your codebase
+2. You have to maintain certain stuff in a different language
+3. You open yourself up to various debates about callbacks and promises
 
-It's also difficult to represent basic concepts in Ruby, as the sheer
-amount of dynamism and expressivity baked into the language compels
-the programmer to only think of code in terms of objects and
-orientation, and Dijkstra. This is way too high level.
+On the other hand, it has a couple of major advantages over every other language ever:
 
-Thankfully, there is a burgeoning language on the scene that empowers
-the programmer to really think about the nuts and bolts of their
-implementation. Your code no longer explains to you what you want to
-happen, but how it should do it.
+1. It's web-scale
+2. It's *web-scale*!
 
-Naturally, issuing commands to a computer -- typically in the form of
-an assembly language, compiled C code, or JavaScript -- allows the
-program to scale effortlessly under extreme loads, and allows you to reason
-about what exactly your hardware is doing.
+Wouldn't it be nice if you could drop down to Node... *implicitly*?
+You wouldn't need to significantly change anything to fine-tune
+portions of your app, right down to the individual method level.
 
-To that end, this library lets you drop down to JavaScript at the method level,
-so parts of your class can be executed more efficiently. This makes Ruby *perfectly*
-suited to things such as:
-
-1. Systems programming
-2. Being web-scale
+Enter `node_module`, which does just that. All you need to do is add the gem, and
+tell it which methods you want to run as javascript instead of Ruby.
 
 ## How to install
 
@@ -63,6 +53,14 @@ class AbstractConcepts
     (constants - [self.class]).map(&:remove_const)
   end
 
+  def meaning_of_life
+    42
+  end
+
+  # run a specific method as javascript
+  node_module :meaning_of_life
+
+  # run everything after this point as javascript
   node_module
 
   def pythagorean_triplet?(a, b, c)
@@ -71,21 +69,23 @@ class AbstractConcepts
 end
 ```
 
-Any method you define after `node_module` will be converted to JavaScript before being
-executed.
+`node_module` behaves like the `public`, `private`, and `protected`
+methods Ruby gives you. You can pass in specific methods as symbols,
+or call it without any arguments to change every subsequently
+defined method.
 
 This is a ridiculous proof of concept, so there are a few issues...
 
 ## Current limitations
 
-- Things might break if your methods aren't fully self-contained. This
-  is because they're currently compiled outside of the scope of the
-  class they were defined in. (Although there's nothing preventing an entire class
-  being parsed as javascript in future).
+- Sharing state between methods or across a class is unpredictable,
+  and will probably cause bad things to happen.
 
-- It doesn't actually use Node yet
+- It's destructive, so you'll lose the body of the original
+  method. This means you can't yet switch a method between its Ruby
+  and Javascript versions.
 
-- It buggers up IRB
+- It doesn't actually use Node yet
 
 - It probably can't handle anything too clever.
 

data/lib/node_module/opal_js_context.rb

@@ -0,0 +1,23 @@
+require 'v8'
+require 'json'
+require 'opal'
+
+class NodeModule::OpalJsContext < V8::Context
+
+  def initialize
+    super do |ctx|
+      ctx.eval Opal::Builder.build('opal')
+    end
+  end
+
+  def compile(code)
+    eval Opal.parse(code)
+  end
+
+  def run(name, args=[])
+    eval <<-JS
+      Opal.Object['$#{name}'].apply(Opal.Object, #{args.to_json})
+    JS
+  end
+
+end

data/lib/node_module/version.rb

@@ -1,3 +1,3 @@
 module NodeModule
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

data/lib/node_module.rb

@@ -1,28 +1,17 @@
 require 'node_module/version'
 require 'live_ast/to_ruby'
 require 'live_ast/irb_spy' if defined?(IRB)
-require 'opal'
-require 'json'
-require 'v8'
 
 module NodeModule
 
+  autoload :OpalJsContext, 'node_module/opal_js_context'
+
   def self.included(base)
     base.extend ClassMethods
   end
 
-  def self.js_context
-    @ctx ||= V8::Context.new do |ctx|
-      ctx.eval Opal::Builder.build('opal')
-    end
-  end
-
-  def self.convert_method_to_javascript(fn)
-    NodeModule.js_context.eval Opal.parse(fn)
-  end
-
-  def self.call_javascript_function(name, args = [])
-    NodeModule.js_context.eval "Opal.Object['$#{name}'].apply(this, #{args.to_json})"
+  def self.opal_js_context
+    @ctx ||= OpalJsContext.new
   end
 
   module ClassMethods
@@ -40,10 +29,11 @@ module NodeModule
   def self.execute_methods_as_javascript!(methods, receiver)
     methods.each do |name|
       meth = receiver.instance_method(name).to_ruby
-      NodeModule.convert_method_to_javascript(meth)
+
+      NodeModule.opal_js_context.compile(meth)
 
       receiver.send :define_method, name do |*args|
-        NodeModule.call_javascript_function(__method__, args)
+        NodeModule.opal_js_context.run(__method__, args)
       end
     end
   end

data/node_module.gemspec

@@ -23,4 +23,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency "opal"
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
 end

data/spec/lib/node_module/opal_js_context_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe NodeModule::OpalJsContext do
+
+  subject { NodeModule::OpalJsContext.new }
+
+  let(:predicate_method) { "def equal?(a, b); a == b; end;" }
+  let(:bang_method) { "def boom!; 'BOOM!'; end;" }
+  let(:mixed_method) { "def boom?(a, b); boom! if a == b; end;" }
+
+  describe "#load" do
+    it "successfully turns Ruby into Opal-style Javascript" do
+      js = subject.compile(predicate_method)
+      js.to_s.must_match /function \(a, b\) \{\s+ return a\['\$=='\]\(b\);\s+\}/
+    end
+  end
+
+  describe "#run" do
+    before do
+      subject.compile(predicate_method)
+      subject.compile(bang_method)
+      subject.compile(mixed_method)
+    end
+
+    it "handles Ruby style predicate methods" do
+      result = subject.run('equal?', [1, 1])
+      result.must_equal true
+
+      result = subject.run('equal?', [1, 2])
+      result.must_equal false
+    end
+
+    it "handles Ruby style bang methods" do
+      result = subject.run('boom!')
+      result.must_equal 'BOOM!'
+    end
+
+    it "can refer to previously defined methods from within a method" do
+      result = subject.run('boom?', [1, 1])
+      result.must_equal 'BOOM!'
+    end
+  end
+
+end

data/spec/lib/node_module_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-describe NodeModule do
+describe NodeModule, "integration into other classes" do
 
-  class TestClass
+  class ExampleClass
     include NodeModule
 
     node_module
@@ -10,48 +10,31 @@ describe NodeModule do
     def hello_you(*names)
       "hello #{names.join(', ')}"
     end
-  end
-
-
-
-  describe "integration" do
-    let(:test_class) { TestClass.new }
 
-    it "says 'hello' to all the people" do
-      test_class.hello_you("Sarah", "Jess").must_equal "hello Sarah, Jess"
+    def goodbye_you(*names)
+      "goodbye #{names.join(', ')}"
     end
-  end
-
-  describe "#convert_method_to_javascript" do
-    let(:test_method) { "def equal?(a, b); a == b; end;" }
 
-    it "successfully turns Ruby into Opal-style Javascript" do
-      js = NodeModule.convert_method_to_javascript(test_method)
-      js.to_s.must_match /function \(a, b\) \{\s+ return a\['\$=='\]\(b\);\s+\}/
+    def equal?(a, b)
+      a == b
     end
-  end
 
-  describe "#call_javascript_function" do
-    let(:predicate_method) { "def equal?(a, b); a == b; end;" }
-    let(:bang_method) { "def boom!; 'BOOM!'; end;" }
-
-    before do
-      NodeModule.convert_method_to_javascript(predicate_method)
-      NodeModule.convert_method_to_javascript(bang_method)
+    def not_equal?(a, b)
+      ! equal?(a, b)
     end
+  end
 
-    it "handles Ruby style predicate methods" do
-      result = NodeModule.call_javascript_function('equal?', [1, 1])
-      result.must_equal true
+  let(:example_class) { ExampleClass.new }
 
-      result = NodeModule.call_javascript_function('equal?', [1, 2])
-      result.must_equal false
-    end
+  it "says 'hello' to all the people" do
+    example_class.hello_you("Sarah", "Jess").must_equal "hello Sarah, Jess"
+  end
 
-    it "handles Ruby style bang methods" do
-      result = NodeModule.call_javascript_function('boom!')
-      result.must_equal 'BOOM!'
-    end
+  it "says 'goodbye' to all the people" do
+    example_class.goodbye_you("Tom", "Hayley").must_equal "goodbye Tom, Hayley"
   end
 
+  it "returns true if 1 is not equal to 2" do
+    example_class.not_equal?(1, 2).must_equal true
+  end
 end

data/spec/spec_helper.rb

@@ -1,6 +1,5 @@
+require 'minitest/autorun'
 require 'minitest/spec'
-require 'minitest/mock'
 require 'minitest/pride'
-require 'minitest/autorun'
 
 require File.expand_path('../../lib/node_module.rb', __FILE__)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: node_module
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-18 00:00:00.000000000 Z
+date: 2013-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: live_ast
@@ -91,6 +91,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Evaluate methods in Ruby as Javascript instead
 email:
 - lee@new-bamboo.co.uk
@@ -105,8 +121,10 @@ files:
 - README.md
 - Rakefile
 - lib/node_module.rb
+- lib/node_module/opal_js_context.rb
 - lib/node_module/version.rb
 - node_module.gemspec
+- spec/lib/node_module/opal_js_context_spec.rb
 - spec/lib/node_module_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/leemachin/node_module
@@ -124,7 +142,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2154653241690516822
+      hash: -2723743550254407902
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -133,7 +151,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2154653241690516822
+      hash: -2723743550254407902
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -141,5 +159,6 @@ signing_key:
 specification_version: 3
 summary: Get really close to the metal in Ruby
 test_files:
+- spec/lib/node_module/opal_js_context_spec.rb
 - spec/lib/node_module_spec.rb
 - spec/spec_helper.rb