javascript 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 544e1722b5fdd2b8b5e4413429f6b2dbcc712510
+  data.tar.gz: 3223853a5070525beec270b95deb495daeef882d
+SHA512:
+  metadata.gz: 87f978520f3e4852bae730566faac9b46685ef8874991a2ef2151827ba3d50e52d4de43910d4dbc893dea83350fecf45bbeaba7aea5fcc8284130fcf46e90d97
+  data.tar.gz: 3180b93400097eee3fd7d6e09d135f2c3d4e2cb39d87d48bf3298bf856dd4fddea42f1e24f5829b9e28d42dc417d2212b794c6e096634683dee2f343e9ce5756

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 2.1.3
+  - ruby-head
+
+notifications:
+  email: false

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in javascript.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Godfrey Chan
+
+MIT License
+
+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/README.md

@@ -0,0 +1,164 @@
+# JavaScript
+
+As much as we love writing Ruby, when you need to *get closer to the metal*, you
+have no choice but to use JavaScript. With this gem, Rubyists can finally
+harness the raw power of their machines by dropping down to the metal *right
+inside their Ruby applications*.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'javascript'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install javascript
+
+## Usage
+
+```ruby
+require "javascript"
+
+puts "This is totally Ruby"
+
+javascript {
+
+  console.log("ZOMG JavaScript");
+
+  var a = 1;
+
+  console.log(a);
+
+  a = a + 1;
+
+  console.log(a);
+
+  var b = function(x) {
+    console.log(x + 1);
+  };
+
+  b(3);
+
+  function c(x) {
+    console.log(x + 2);
+  }
+
+  c(4);
+
+  function inspectArguments() {
+    var args = Array.prototype.join.call(arguments, ", ");
+    console.log("Arguments: " + args);
+  }
+
+  inspectArguments("a", "b", "c");
+
+  inspectArguments(1, 2, 3, 4, 5);
+
+}
+
+puts "This is Ruby again"
+```
+
+Output:
+
+```
+% ruby test.rb
+This is totally Ruby
+ZOMG JavaScript
+1
+2
+4
+6
+Arguments: a, b, c
+Arguments: 1, 2, 3, 4, 5
+This is Ruby again
+%
+```
+
+### JavaScript + Rails = <3
+
+Because Rails embraces callbacks, this gem is the perfectly compliment for your
+Rails application. For example:
+
+```ruby
+require "javascript"
+
+class Post < ActiveRecord::Base
+  before_create &javascript {
+    function(post) {
+      post.slug = post.title.parameterize();
+    }
+  }
+end
+```
+
+Alternatively:
+
+```ruby
+require "javascript"
+
+class Post < ActiveRecord::Base
+  before_create &javascript {
+    function() {
+      this.slug = this.title.parameterize();
+    }
+  }
+end
+```
+
+### No Conflict Mode
+
+If the `javascript` helper conflicts with an existing method, you use this gem
+in the "no conflict" mode:
+
+```ruby
+require "javascript/no_conflict"
+
+# Or add this to your Gemfile:
+#
+#   gem "javascript", require: "javascript/no_conflict"
+#
+
+JavaScript.eval {
+  console.log("JavaScript here");
+}
+
+# You can also define your own helper method
+
+module Kernel
+  private def metal(&block)
+    JavaScript.eval(&block)
+  end
+end
+
+metal {
+  console.log("JavaScript here");
+}
+```
+
+## Pros
+
+* Gives you the illusion of programming in a *closer to the metal* syntax.
+* The examples in this README actually work.
+  [![Build Status](https://travis-ci.org/vanruby/javascript.svg)](https://travis-ci.org/vanruby/javascript)
+
+## Cons
+
+* Things that aren't covered in the examples probably won't ever work.
+  ([Check the tests](/test/javascript_test.rb))
+* [Not enough jQuery](http://meta.stackexchange.com/questions/45176/when-is-use-jquery-not-a-valid-answer-to-a-javascript-question)
+
+## Contributing
+
+1. Fork it ( https://github.com/vanruby/javascript/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+desc 'Run tests'
+test_task = Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+task default: :test

data/javascript.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "javascript/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "javascript"
+  spec.version       = JavaScript::VERSION
+  spec.authors       = ["Godfrey Chan"]
+  spec.email         = ["godfreykfc@gmail.com"]
+  spec.summary       = "Seamlessly drop down to the metal with JavaScript"
+  spec.description   = "With this gem you can finally get closer to the metal" \
+                       "and harness the raw power of your machine by writing " \
+                       "JavaScript code right within your Ruby applications."
+  spec.homepage      = "https://github.com/vanruby/javascript"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^test/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">= 2.1.0"
+
+  spec.add_dependency "binding_of_caller", "~> 0.7.0"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "activesupport", "~> 4.1.0"
+end

data/lib/javascript.rb

@@ -0,0 +1,326 @@
+require "javascript/version"
+require "binding_of_caller"
+
+def supress_warnings
+  verbose, $VERBOSE = $VERBOSE, nil
+  yield
+ensure
+  $VERBOSE = verbose
+end
+
+module JavaScript
+  def self.eval(&block)
+    Scope.new.__eval__(&block)
+  end
+
+  def self.current_scope
+    @scope
+  end
+
+  def self.current_scope=(scope)
+    @scope = scope
+  end
+
+  # Make it an `Object` instead of `BasicObject` so that we can bind
+  # any instance methods from `Object` and call them here
+  class BlankObject
+    supress_warnings do
+      instance_methods(true).each { |meth| undef_method(meth) }
+      private_instance_methods(true).each { |meth| undef_method(meth) }
+    end
+  end
+
+  module Internals
+    supress_warnings do
+      def __send__(meth, *args, &block)
+        __method__(:public_send).call(meth, *args, &block)
+      end
+    end
+
+    private
+      def __method__(name)
+        ::Object.instance_method(name).bind(self)
+      end
+
+      def __binding__
+        __method__(:binding).call.of_caller(1)
+      end
+
+      def __caller__
+        __binding__.of_caller(2)
+      end
+  end
+
+  class Object < BlankObject
+    include Internals
+
+    def initialize(proto = nil)
+      @hash = { __proto__: proto }
+    end
+
+    def [](key)
+      if @hash.key?(key)
+        @hash[key]
+      elsif __proto__
+        __proto__[key]
+      else
+        nil
+      end
+    end
+
+    def []=(key, value)
+      @hash[key.to_sym] = value
+    end
+
+    def ==(other)
+      __method__(:==).call(other)
+    end
+
+    def ===(other)
+      self == other
+    end
+
+    def !=(other)
+      !(self == other)
+    end
+
+    def __hash__
+      @hash
+    end
+
+    def __proto__
+      @hash[:__proto__]
+    end
+
+    def __defined__?(key)
+      @hash.key?(key) || (__proto__ && __proto__.__defined__?(key))
+    end
+
+    private
+      def method_missing(name, *args, &block)
+        if name =~ /=\z/
+          self[name[0...-1].to_sym] = args[0]
+        elsif Function === self[name]
+          self[name].apply(self, args)
+        else
+          self[name]
+        end
+      end
+  end
+
+  class GlobalObject < Object
+    def initialize
+      super
+      @hash[:console] = Console.new
+    end
+  end
+
+  module Syntax
+    private
+      def window
+        @global
+      end
+
+      def global
+        @global
+      end
+
+      def this
+        @target
+      end
+
+      def undefined
+        nil
+      end
+
+      def var(*identifiers)
+      end
+
+      def new(identifier)
+        ::Object.const_get(identifier.name).new(*identifier.args)
+      end
+
+      def function(*args, &block)
+        if args.length == 1 && Function === args[0]
+          hash = @parent ? @locals : global.__hash__
+          hash[args[0].name] = args[0]
+        else
+          Function.new(nil, args, block)
+        end
+      end
+  end
+
+  class Scope < BlankObject
+    include Internals
+    include Syntax
+
+    def initialize(parent = nil, target = nil, locals = {})
+      @parent = parent
+      @global = parent ? parent.__global__ : GlobalObject.new
+      @locals = locals
+
+      if Scope === target
+        @target = target.__target__
+      else
+        @target = target || global
+      end
+    end
+
+    def __global__
+      @global
+    end
+
+    def __target__
+      @target
+    end
+
+    def __spawn__(target = nil, locals = {})
+      Scope.new(self, target, locals)
+    end
+
+    def __eval__(*args, &block)
+      JavaScript.current_scope = self
+      __method__(:instance_exec).call(*args, &block)
+    ensure
+      JavaScript.current_scope = @parent
+    end
+
+    private
+      def method_missing(name, *args, &block)
+        found   = false
+        value   = nil
+        defined = __caller__.local_variable_defined?(name) rescue nil
+
+        if defined
+          found = true
+          value = __caller__.local_variable_get(name)
+        elsif @locals.key?(name)
+          found = true
+          value = @locals[name]
+        elsif !@parent && @global.__defined__?(name)
+          found = true
+          value = @global[name]
+        end
+
+        if found && Function === value
+          value.apply(nil, args)
+        elsif found
+          value
+        elsif @parent
+          @parent.__send__(name, *args, &block)
+        elsif block.nil?
+          Identifier.new(name, args)
+        else
+          Function.new(name, args, block)
+        end
+      end
+  end
+
+  class Identifier < Struct.new(:name, :args); end
+
+  class Function < Struct.new(:name, :args, :body)
+    def initialize(*)
+      @scope = JavaScript.current_scope
+      super
+    end
+
+    def arity
+      args.length
+    end
+
+    def call(target = nil, *arg_values)
+      ::Object.instance_method(:instance_exec).bind(target).call(*arg_values, &self)
+    end
+
+    def apply(target = nil, arg_values)
+      call(target, *arg_values)
+    end
+
+    def bind(target)
+      BoundFunction.new(target, name, args, body)
+    end
+
+    def to_proc
+      parent_scope = @scope
+      arg_names    = args.map(&:name)
+      unwrapped    = body
+
+      FunctionWrapper.new(arg_names) do |*arg_values|
+        locals = Hash[ arg_names.zip(arg_values) ]
+        locals[:arguments] = arg_values
+        parent_scope.__spawn__(self, locals).__eval__(*arg_values, &unwrapped)
+      end
+    end
+  end
+
+  class BoundFunction < Function
+    def initialize(target, name, args, body)
+      super(name, args, body)
+      @target = target
+    end
+
+    def call(_, *arg_values)
+      super(@target, *arg_values)
+    end
+
+    def apply(_, arg_values)
+      super(@target, arg_values)
+    end
+
+    def bind(_)
+      self
+    end
+  end
+
+  class FunctionWrapper < Proc
+    def initialize(args, &block)
+      @args = args
+      super(&block)
+    end
+
+    def arity
+      @args.length
+    end
+
+    def parameters
+      @args.map { |arg| [:required, arg.to_sym] }
+    end
+  end
+
+  class Prototype < Object
+    def initialize(klass)
+      super(nil)
+      @klass = klass
+    end
+
+    private
+      def method_missing(name, *args, &block)
+        meth = @klass.instance_method(name)
+        args = meth.parameters.map { |_, name| name && Identifier.new(name) }.compact
+        body = ->(*args) { meth.bind(this).call(*args) }
+        Function.new(name, args, body)
+      rescue NameError
+        super
+      end
+  end
+
+  class Console
+    def log(*args)
+      puts(*args)
+    end
+  end
+end
+
+unless defined?(JavaScript::NO_CONFLICT)
+  module Kernel
+    def javascript(&block)
+      JavaScript.eval(&block)
+    end
+  end
+
+  class Class
+    def prototype
+      JavaScript::Prototype.new(self)
+    end
+  end
+end

data/lib/javascript/no_conflict.rb

@@ -0,0 +1,5 @@
+module JavaScript
+  NO_CONFLICT = true
+end
+
+require "javascript"

data/lib/javascript/version.rb

@@ -0,0 +1,3 @@
+module JavaScript
+  VERSION = "0.0.1"
+end

data/test/javascript_test.rb

@@ -0,0 +1,276 @@
+require "test_helper"
+
+$messages = []
+
+module JavaScript
+  class Console
+    private def puts(message)
+      $messages << message
+    end
+  end
+end
+
+class JavaScriptTest < TestCase
+  teardown do
+    $messages.clear
+  end
+
+  test "undefined" do
+    require "javascript"
+    assert_nil javascript { undefined }
+  end
+
+  test "this" do
+    require "javascript"
+
+    javascript do
+      console.log(this === window);
+      console.log(this === global);
+    end
+
+    assert_messages true, true
+  end
+
+  test "Local variables" do
+    require "javascript"
+
+    javascript {
+      var a = 1, b = 2;
+
+      console.log(a);
+      console.log(b);
+
+      a = a + 1;
+      b = a + b;
+
+      console.log(a);
+      console.log(b);
+    }
+
+    assert_messages 1, 2, 2, 4
+  end
+
+  test "Global variables" do
+    require "javascript"
+
+    javascript {
+      window.a = 1;
+      global.b = 2;
+
+      console.log(a);
+      console.log(b);
+
+      console.log(a === window.a);
+      console.log(a === global.a);
+
+      console.log(b === window.b);
+      console.log(b === global.b);
+    }
+
+    assert_messages 1, 2, true, true, true, true
+  end
+
+  test "Global object is not shared between different javascript blocks" do
+    require "javascript"
+
+    javascript { window.a = 1; }
+    assert_nil javascript { window.a; }
+  end
+
+  test "Functions" do
+    require "javascript"
+
+    javascript {
+      var a = function(msg) {
+        console.log("a: " + msg);
+      };
+
+      function b(msg) {
+        console.log("b: " + msg);
+      }
+
+      var c = "c";
+
+      a("hello");
+      b("hello");
+
+      a(c);
+      b(c);
+    }
+
+    assert_messages "a: hello", "b: hello", "a: c", "b: c"
+  end
+
+  test "arguments" do
+    require "javascript"
+
+    javascript {
+      function inspect() {
+        console.log(arguments.length);
+        console.log(arguments);
+      }
+
+      inspect("a", "b", "c");
+      inspect(1, 2, 3, 4, 5);
+      inspect();
+    }
+
+    assert_messages 3, ["a", "b", "c"], 5, [1, 2, 3, 4, 5], 0, []
+  end
+
+  test "Function#call" do
+    require "javascript"
+
+    javascript do
+      var thisCheck = function(expected) {
+        console.log(this === expected);
+      };
+
+      thisCheck(this);
+      thisCheck("abc");
+
+      thisCheck.call(this, this);
+      thisCheck.call(this, "abc");
+
+      thisCheck.call("abc", "abc");
+      thisCheck.call("abc", this);
+
+      var argsCheck = function() {
+        console.log(this == arguments);
+      };
+
+      argsCheck.call([1, 2, 3], 1, 2, 3);
+      argsCheck.call([1, 2, 3], 4, 5, 6);
+      argsCheck.call([1, 2, 3], [1, 2, 3]);
+    end
+
+    assert_messages true, false, true, false, true, false, true, false, false
+  end
+
+  test "Function#apply" do
+    require "javascript"
+
+    javascript do
+      var thisCheck = function(expected) {
+        console.log(this === expected);
+      };
+
+      thisCheck(this);
+      thisCheck("abc");
+
+      thisCheck.apply(this, [this]);
+      thisCheck.apply(this, ["abc"]);
+
+      thisCheck.apply("abc", ["abc"]);
+      thisCheck.apply("abc", [this]);
+
+      var argsCheck = function() {
+        console.log(this == arguments);
+      };
+
+      argsCheck.apply([1, 2, 3], [1, 2, 3]);
+      argsCheck.apply([1, 2, 3], [4, 5, 6]);
+    end
+
+    assert_messages true, false, true, false, true, false, true, false
+  end
+
+  test "Function#bind" do
+    require "javascript"
+
+    javascript do
+      var thisCheck = function(expected) {
+        console.log(this === expected);
+      };
+
+      thisCheck = thisCheck.bind("abc");
+
+      thisCheck(this);
+      thisCheck("abc");
+
+      thisCheck.call(this, this);
+      thisCheck.call(this, "abc");
+      thisCheck.call("abc", "abc");
+
+      var argsCheck = function() {
+        console.log(this == arguments);
+      };
+
+      argsCheck = argsCheck.bind([1, 2, 3]);
+
+      argsCheck.call("abc", 1, 2, 3);
+      argsCheck.apply("abc", [1, 2, 3]);
+
+      argsCheck.call("abc", 4, 5, 6);
+      argsCheck.apply("abc", [4, 5, 6]);
+    end
+
+    assert_messages false, true, false, true, true, true, true, false, false
+  end
+
+  test "Prototype" do
+    require "javascript"
+
+    javascript {
+      var join = Array.prototype.join;
+
+      console.log(join.call(["a", "b", "c"], "+"));
+      console.log(join.call([1, 2, 3, 4, 5], "-"));
+    }
+
+    assert_messages "a+b+c", "1-2-3-4-5"
+  end
+
+  test "Callback" do
+    require "javascript"
+    require "active_support/callbacks"
+    require "active_support/core_ext/string/inflections"
+
+    class Post < Struct.new(:title, :slug)
+      include ActiveSupport::Callbacks
+
+      define_callbacks :create, :destroy
+
+      set_callback :create, :before, &javascript {
+        function(post) {
+          console.log("Before");
+          post.slug = post.title.parameterize();
+        }
+      }
+
+      set_callback :destroy, :after, &javascript {
+        function() {
+          console.log("After");
+          this.slug = undefined;
+        }
+      }
+
+      def create
+        run_callbacks(:create)
+      end
+
+      def destroy
+        run_callbacks(:destroy)
+      end
+    end
+
+    post = Post.new("Hello world!")
+
+    assert_nil post.slug
+
+    post.create
+
+    assert_equal "hello-world", post.slug
+
+    post.destroy
+
+    assert_nil post.slug
+
+    assert_messages "Before", "After"
+  end
+
+  private
+    def assert_messages(*messages)
+      assert_equal messages, $messages
+    end
+end

data/test/no_conflict_test.rb

@@ -0,0 +1,23 @@
+require "test_helper"
+
+class NoConflictTest < TestCase
+  test "Global `javascript` helper is not available in no-conflict mode" do
+    require "javascript/no_conflict"
+    assert_raises(NoMethodError) { javascript { 1 } }
+  end
+
+  test "Global monkey-patch is not available in no-conflict mode" do
+    require "javascript/no_conflict"
+    assert_raises(NoMethodError) { JavaScript.eval { Array.prototype } }
+  end
+
+  test "Defining custom helper in no-conflict mode" do
+    require "javascript/no_conflict"
+
+    def metal(&block)
+      JavaScript.eval(&block)
+    end
+
+    assert_equal 1, metal { 1 }
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,15 @@
+require "bundler/setup"
+require "minitest/autorun"
+require "minitest/pride"
+require "active_support"
+require "active_support/testing/declarative"
+require "active_support/testing/setup_and_teardown"
+require "active_support/testing/isolation"
+
+I18n.enforce_available_locales = true
+
+class TestCase < Minitest::Test
+  extend ActiveSupport::Testing::Declarative
+  include ActiveSupport::Testing::SetupAndTeardown
+  include ActiveSupport::Testing::Isolation
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: javascript
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Godfrey Chan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: binding_of_caller
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+description: With this gem you can finally get closer to the metaland harness the
+  raw power of your machine by writing JavaScript code right within your Ruby applications.
+email:
+- godfreykfc@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- javascript.gemspec
+- lib/javascript.rb
+- lib/javascript/no_conflict.rb
+- lib/javascript/version.rb
+- test/javascript_test.rb
+- test/no_conflict_test.rb
+- test/test_helper.rb
+homepage: https://github.com/vanruby/javascript
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Seamlessly drop down to the metal with JavaScript
+test_files:
+- test/javascript_test.rb
+- test/no_conflict_test.rb
+- test/test_helper.rb