ruby2js 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MThiMDkwZGYwN2EwNTUzNmM3ODY3NGExMzcwMDllMTUzODJmNWQ2MQ==
+  data.tar.gz: !binary |-
+    MzA3ODMzOWM1ZDcwMmI2YzhiNzFmZjdlNDE4NTU2ZGQ5OTkwZmIwNw==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ZWI1ODMwODg3YzgxODhhZDZjMjRmYzAxM2RmMDU5MGUzZmQ1OTUyNDY5NDdi
+    NDgyODdkNjFlNjZmMWU3MDE1ZTYyZGY5YTJmM2NmN2Y3NjVhNDRmMjVkMjYw
+    NmFhMDVjZWMwNGEwZDVhNWE3MzQyNmRlNjI2YjI4YmQ5MzgyNzY=
+  data.tar.gz: !binary |-
+    NGU1YTAwOWZiODUyMWJmOTM3YTYyMjNmNTEwNzkwNDExNjBmZjAwMjI2ODky
+    YzhmNmRhMjQxYjk0ZGJjZjZlODFkZDc1MjVjNzIzZTExMThkNDBlZTRhMjM3
+    ZDgyZDBiZjQ2OGIxM2NmNmMwZmQ3ZjUyYWVmY2JjNzM3NzA3M2M=

data/README.md

@@ -0,0 +1,52 @@
+ruby2js
+=======
+
+Minimal yet extensible Ruby to JavaScript conversion.  
+
+Description
+---
+
+The base package maps Ruby syntax to JavaScript semantics.  For example,
+a Ruby Hash literal becomes a JavaScript Object literal.  Ruby symbols
+become JavaScript strings.  Ruby method calls become JavaScript function
+calls IF there are either one or more arguments passed OR parenthesis are
+used, otherwise Ruby method calls become JavaScript property accesses.
+By default, methods, lambdas, and procs return `undefined`.
+
+Filters may be provided to add Ruby-specific or Framework specific
+behavior.  Filters are essentially macro facilities that operate on
+an AST representation of the code.
+
+Synopsis
+---
+
+```ruby
+require 'ruby2js/filter/functions'
+puts Ruby2JS.convert('"2A".to_i(16)', filters: [Ruby2JS::Filter::Functions])
+```
+
+License
+---
+
+(The MIT License)
+
+Copyright (c) 2009,2013 Macario Ortega, Sam Ruby
+
+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/lib/ruby2js.rb

@@ -0,0 +1,79 @@
+require 'parser/current'
+require 'ruby2js/converter'
+
+module Ruby2JS
+  def self.convert(source, options={})
+
+    if Proc === source
+      file,line = source.source_location
+      source = File.read(file)
+      ast = find_block( parse(source), line )
+    elsif Parser::AST::Node === source
+      ast = source
+      source = ast.loc.expression.source_buffer.source
+    else
+      ast = parse( source )
+    end
+
+    if options[:filters]
+      filter = Parser::AST::Processor
+      options[:filters].reverse.each do |mod|
+        filter = Class.new(filter) {include mod} 
+      end
+      ast = filter.new.process(ast)
+    end
+
+    ruby2js = Ruby2JS::Converter.new( ast )
+
+    if source.include? "\n"
+      ruby2js.enable_vertical_whitespace 
+      lines = ruby2js.to_js.split("\n")
+      pre = ''
+      pending = false
+      blank = true
+      lines.each do |line|
+        if line.start_with? '}' or line.start_with? ']'
+          pre.sub!(/^  /,'')
+          line.sub!(/;$/,";\n")
+          pending = true
+        else
+          pending = false
+        end
+
+        line.sub! /^/, pre
+        if line.end_with? '{' or line.end_with? '['
+          pre += '  ' 
+          line.sub!(/^/,"\n") unless blank or pending
+          pending = true
+        end
+
+        blank = pending
+      end
+      lines.join("\n")
+    else
+      ruby2js.to_js
+    end
+  end
+  
+  def self.parse(source)
+    # workaround for https://github.com/whitequark/parser/issues/112
+    buffer = Parser::Source::Buffer.new('__SOURCE__')
+    buffer.raw_source = source.encode('utf-8')
+    Parser::CurrentRuby.new.parse(buffer)
+  end
+
+  def self.find_block(ast, line)
+    if ast.type == :block and ast.loc.expression.line == line
+      return ast.children.last
+    end
+
+    ast.children.each do |child|
+      if Parser::AST::Node === child
+        block = find_block child, line
+        return block if block
+      end
+    end
+
+    nil
+  end
+end

data/lib/ruby2js/converter.rb

@@ -0,0 +1,281 @@
+require 'parser/current'
+
+module Ruby2JS
+  class Converter
+    LOGICAL   = :and, :not, :or
+    OPERATORS = [:[], :[]=], [:not, :!], [:*, :/, :%], [:+, :-], [:>>, :<<], 
+      [:<=, :<, :>, :>=], [:==, :!=], [:and, :or]
+    
+    def initialize( ast, vars = {} )
+      @ast, @vars = ast, vars.dup
+      @sep = '; '
+      @nl = ''
+    end
+    
+    def enable_vertical_whitespace
+      @sep = ";\n"
+      @nl = "\n"
+    end
+
+    def to_js
+      parse( @ast, :statement )
+    end
+
+    def operator_index op
+      OPERATORS.index( OPERATORS.find{ |el| el.include? op } ) || -1
+    end
+    
+    def scope( ast )
+      frame = self.class.new( nil, @vars )
+      frame.enable_vertical_whitespace if @nl == "\n"
+      frame.parse( ast, :statement )
+    end
+
+    def s(type, *args)
+      Parser::AST::Node.new(type, args)
+    end
+
+    def is_method?(node)
+      return false unless node.type == :send
+      return true unless node.loc
+      selector = node.loc.selector
+      return true unless selector.source_buffer
+      selector.source_buffer.source[selector.end_pos] == '('
+    end
+
+    def parse(ast, state=:expression)
+      return ast unless Parser::AST::Node === ast
+
+      case ast.type
+        
+      when :int, :float, :str
+        ast.children.first.inspect
+
+      when :sym
+        ast.children.first.to_s.inspect
+
+      when :lvar, :gvar
+        ast.children.first
+        
+      when :true, :false
+        ast.type.to_s
+        
+      when :nil
+        'null'
+
+      when :lvasgn
+        var, value = ast.children
+        output      = value ? "#{ 'var ' unless @vars.keys.include? var }#{ var } = #{ parse value }" : var
+        @vars[var] = true
+        output
+
+      when :op_asgn
+        var, op, value = ast.children
+
+        if [:+, :-].include?(op) and value.type==:int and value.children==[1]
+          if state == :statement
+            "#{ parse var }#{ op }#{ op }"
+          else
+            "#{ op }#{ op }#{ parse var }"
+          end
+        else
+          "#{ parse var } #{ op }= #{ parse value }"
+        end
+
+      when :casgn
+        cbase, var, value = ast.children
+        var = "#{cbase}.var" if cbase
+        output = "const #{ var } = #{ parse value }"
+        @vars[var] = true
+        output
+        
+      when :gvasgn
+        name, value = ast.children
+        "#{ name } = #{ parse value }"
+        
+      when :ivasgn
+        name, expression = ast.children
+        "#{ name.to_s.sub('@', 'this._') } = #{ parse expression }"
+        
+      when :or_asgn
+        var, value = ast.children
+        "#{ parse var } = #{parse var} || #{ parse value }"
+
+      when :and_asgn
+        var, value = ast.children
+        "#{ parse var } = #{parse var} && #{ parse value }"
+        
+      when :ivar
+        name = ast.children.first
+        name.to_s.sub('@', 'this._')
+        
+      when :hash
+        hashy  = ast.children.map do |node|
+          left, right = node.children
+          key = parse left
+          key = $1 if key =~ /\A"([a-zA-Z_$][a-zA-Z_$0-9]*)"\Z/
+          "#{key}: #{parse right}"
+        end
+        "{#{ hashy.join(', ') }}"
+
+      when :array
+        list = ast.children.map { |a| parse a }
+        if list.join(', ').length < 80
+          "[#{ list.join(', ') }]"
+        else
+          "[\n#{ list.join(",\n") }\n]"
+        end
+
+      when :begin
+        ast.children.map{ |e| parse e, :statement }.join(@sep)
+        
+      when :return
+        "return #{ parse ast.children.first }"
+        
+      when *LOGICAL
+        left, right = ast.children
+        left = left.children.first if left and left.type == :begin
+        right = right.children.first if right.type == :begin
+        op_index    = operator_index ast.type
+        lgroup      = LOGICAL.include?( left.type ) && op_index <= operator_index( left.type )
+        left        = parse left
+        left        = "(#{ left })" if lgroup
+        rgroup      = LOGICAL.include?( right.type ) && op_index <= operator_index( right.type ) if right.children.length > 0
+        right       = parse right
+        right       = "(#{ right })" if rgroup
+
+        case ast.type
+        when :and
+          "#{ left } && #{ right }"
+        when :or
+          "#{ left } || #{ right }"
+        else
+          "!#{ left }"
+        end
+    
+      when :send, :attr
+        receiver, method, *args = ast.children
+        if method == :new and receiver and receiver.children == [nil, :Proc]
+          return parse args.first
+        elsif method == :lambda and not receiver
+          return parse args.first
+        end
+
+        op_index   = operator_index method
+        if op_index != -1
+          target = args.first 
+          target = target.children.first if target and target.type == :begin
+          receiver = receiver.children.first if receiver.type == :begin
+        end
+
+        group_receiver = receiver.type == :send && op_index <= operator_index( receiver.children[1] ) if receiver
+        group_target = target.type == :send && op_index <= operator_index( target.children[1] ) if target
+
+        case method
+        when :!
+          group_receiver ||= (receiver.children.length > 1)
+          "!#{ group_receiver ? group(receiver) : parse(receiver) }"
+
+        when :call
+          "#{ parse receiver }(#{ parse args.first })"
+
+        when :[]
+          raise 'parse error' unless receiver
+          "#{ parse receiver }[#{ parse args.first }]"
+
+        when :-@, :+@
+          "#{ method.to_s[0] }#{ parse receiver }"
+          
+        when *OPERATORS.flatten
+          "#{ group_receiver ? group(receiver) : parse(receiver) } #{ method } #{ group_target ? group(target) : parse(target) }"  
+
+        when /=$/
+          "#{ parse receiver }#{ '.' if receiver }#{ method.to_s.sub(/=$/, ' =') } #{ parse args.first }"
+
+        else
+          if args.length == 0 and not is_method?(ast)
+            "#{ parse receiver }#{ '.' if receiver }#{ method }"
+          else
+            args = args.map {|a| parse a}.join(', ')
+            "#{ parse receiver }#{ '.' if receiver }#{ method }(#{ args })"
+          end
+        end
+        
+      when :const
+        receiver, name = ast.children
+        "#{ parse receiver }#{ '.' if receiver }#{ name }"
+
+      when :masgn
+        lhs, rhs = ast.children
+        block = []
+        lhs.children.zip rhs.children.zip do |var, val| 
+          block << s(var.type, *var.children, *val)
+        end
+        parse s(:begin, *block)
+      
+      when :if
+        condition, true_block, else_block = ast.children
+        if state == :statement
+          output = "if (#{ parse condition }) {#@nl#{ scope true_block }#@nl}"
+          while else_block and else_block.type == :if
+            condition, true_block, else_block = else_block.children
+            output <<  " else if (#{ parse condition }) {#@nl#{ scope true_block }#@nl}"
+          end
+          output << " else {#@nl#{ scope else_block }#@nl}" if else_block
+          output
+        else
+          "(#{ parse condition } ? #{ parse true_block } : #{ parse else_block })"
+        end
+        
+      when :while
+        condition, block = ast.children
+        "while (#{ parse condition }) {#@nl#{ scope block }#@nl}"
+
+      when :block
+        call, args, block = ast.children
+        block ||= s(:begin)
+        function = s(:def, name, args, block)
+        parse s(:send, *call.children, function)
+      
+      when :def
+        name, args, body = ast.children
+        body ||= s(:begin)
+        body   = s(:scope, body) unless body.type == :scope
+        body   = parse body
+        body.sub! /return var (\w+) = ([^;]+)\z/, "var \\1 = \\2#{@sep}return \\1"
+        "function#{ " #{name}" if name }(#{ parse args }) {#@nl#{ body }#@nl}"
+
+      when :scope
+        body = ast.children.first
+        body = s(:begin, body) unless body.type == :begin
+        block = body.children
+        scope body
+        
+      when :class
+        name, inheritance, *body = ast.children
+        body.compact!
+        body = body.first.children.dup if body.length == 1 and body.first.type == :begin
+        methods = body.select { |a| a.type == :def }
+        init    = (body.delete methods.find { |m| m.children.first == :initialize }) || s(:def, :initialize)
+        block   = body.collect { |m| parse( m ).sub(/function (\w+)/, "#{ parse name }.prototype.\\1 = function") }.join @sep
+        "#{ parse( s(:def, parse(name), init.children[1], init.children[2]) ).sub(/return (?:null|(.*))\}\z/, '\1}') }#{ @sep if block and not block.empty?}#{ block }"
+
+      when :args
+        ast.children.map { |a| a.children.first }.join(', ')
+        
+      when :dstr
+        ast.children.map{ |s| parse s }.join(' + ')
+        
+      when :self
+        'this'
+
+      else 
+        raise "unknown AST type #{ ast.type }"
+      end
+    end
+    
+    def group( ast )
+      "(#{ parse ast })"
+    end
+  end
+end

data/lib/ruby2js/filter/angularrb.rb

@@ -0,0 +1,167 @@
+require 'parser/current'
+require 'ruby2js'
+
+module Ruby2JS
+  module Filter
+    module AngularRB
+      def initialize(*args)
+        @ngApp = nil
+        super
+      end
+
+      # input: 
+      #   module Angular::AppName
+      #     use :Dependency
+      #     ...
+      #   end
+      #
+      # output: 
+      #   AppName = angular.module("AppName", ["Dependency"])
+      #   ...
+
+      def on_module(node)
+        module_name = node.children[0]
+        parent_name = module_name.children[0]
+
+        return super unless parent_name and parent_name.type == :const
+        return super unless parent_name.children == [nil, :Angular]
+
+        @ngApp = module_name.children[1]
+
+        # find the block
+        block = process_all(node.children[1..-1])
+        while block.length == 1 and block.first.type == :begin
+          block = block.first.children.dup
+        end
+
+        # find use class method calls
+        uses = block.find_all do |node|
+          node.type == :send and node.children[0..1] == [nil, :use]
+        end
+
+        # convert use calls into dependencies
+        depends = []
+        uses.each do |use|
+          pending = []
+          use.children[2..-1].each do |node|
+            break unless [:str, :sym].include? node.type
+            pending << node
+          end
+          depends += pending
+          block.delete use
+        end
+
+        # build constant assignment statement
+        casgn = s(:casgn, nil, @ngApp, s(:send, 
+                  s(:lvar, :angular), 
+                  :module,
+                  s(:str, @ngApp.to_s), 
+                  s(:array, *depends)))
+
+        @ngApp = nil
+
+        # replace module with a constant assign followed by the module contents
+        node.updated :begin, [casgn, *block]
+      end
+
+      # input: 
+      #   class Name < Angular::Controller
+      #     use :$service
+      #     ...
+      #   end
+      #
+      # output: 
+      #   AppName.controller :Name do |$service|
+      #     ...
+      #   end
+
+      def on_class(node)
+        return super unless @ngApp
+        return super unless node.children.length == 3
+
+        # (const nil :Name)
+        name = node.children.first
+        return super unless name.type == :const and name.children.first == nil
+
+        # (const (const nil :Angular) :Controller)
+        parent = node.children[1]
+        return super unless parent and parent.children.length == 2
+        return super unless parent.children[0]
+        return super unless parent.children[0].type == :const
+        return super unless parent.children[0].children == [nil, :Angular]
+        return super unless [:Controller].include? parent.children[1]
+
+        # find the block
+        block = process_all(node.children[2..-1])
+        while block.length == 1 and block.first.type == :begin
+          block = block.first.children.dup
+        end
+
+        # find use class method calls
+        uses = block.find_all do |node|
+          node.type == :send and node.children[0..1] == [nil, :use]
+        end
+
+        # convert use calls into args
+        args = []
+        uses.each do |use|
+          pending = []
+          use.children[2..-1].each do |node|
+            break unless [:str, :sym].include? node.type
+            pending << s(:arg, *node.children)
+          end
+          args += pending
+          block.delete use
+        end
+
+        # build Appname.controller call statement
+        call = s(:send,
+                 s(:const, nil, @ngApp),
+                 :controller,
+                 s(:sym, name.children.last))
+
+        # replace class with a block
+        node.updated :block, [call, s(:args, *args), s(:begin, *block)]
+      end
+
+      # input: 
+      #   filter :name do |input|
+      #     ...
+      #   end
+      #
+      # output: 
+      #   AppName.filter :name do
+      #     return lambda {|input| return ... }
+      #   end
+      def on_block(node)
+        return super unless @ngApp
+
+        call = node.children.first
+        return super unless call.children[0..1] == [nil, :filter]
+
+        # insert return
+        children = process_all(node.children[1..-1])
+        block = [children.pop || s(:nil)]
+        while block.length == 1 and block.first.type == :begin
+          block = block.first.children.dup
+        end
+        block.push s(:return, block.pop) unless block.last.type == :return
+        children.push (block.length == 1 ? block.first : s(:begin, *block))
+
+        # construct a function returning a function
+        inner = s(:block, s(:send, nil, :lambda), *children)
+        outer = s(:send, s(:lvar, @ngApp), :filter, *call.children[2..-1])
+
+        node.updated nil, [outer, s(:args), s(:return, inner)]
+      end
+
+      private
+
+      # construct an AST Node
+      def s(type, *args)
+        Parser::AST::Node.new type, args
+      end
+
+    end
+  end
+end

data/lib/ruby2js/filter/functions.rb

@@ -0,0 +1,41 @@
+require 'ruby2js'
+
+module Ruby2JS
+  module Filter
+    module Functions
+
+      # map $$ to $
+      def on_gvar(node)
+        if node.children[0] == :$$
+          node.updated nil, ['$']
+        else
+          super
+        end
+      end
+
+      def on_send(node)
+        if node.children[1] == :to_s
+          s(:send, node.children[0], :toString, *node.children[2..-1])
+
+        elsif node.children[1] == :to_i
+          node.updated nil, [nil, :parseInt, node.children[0], 
+            *node.children[2..-1]]
+
+        elsif node.children[1] == :to_f
+          node.updated nil, [nil, :parseFloat, node.children[0], 
+            *node.children[2..-1]]
+
+        else
+          super
+        end
+      end
+
+      private
+
+      # construct an AST Node
+      def s(type, *args)
+        Parser::AST::Node.new type, args
+      end
+    end
+  end
+end

data/lib/ruby2js/filter/return.rb

@@ -0,0 +1,63 @@
+require 'ruby2js'
+
+module Ruby2JS
+  module Filter
+    module Return
+      EXPRESSIONS = [ :array, :float, :hash, :if, :int, :lvar, :nil, :send ]
+
+      def on_block(node)
+        children = process_all(node.children)
+
+        # find the block
+        block = [children.pop || s(:nil)]
+        while block.length == 1 and block.first.type == :begin
+          block = block.first.children.dup
+        end
+
+        if EXPRESSIONS.include? block.last.type 
+          block.push s(:return, block.pop)
+else
+p block.last.type
+        end
+
+        if block.length == 1
+          children.push block.first
+        else
+          children.push s(:begin, *block)
+        end
+
+        node.updated nil, children
+      end
+
+      def on_def(node)
+        children = process_all(node.children[1..-1])
+        children.unshift node.children.first
+
+        # find the block
+        block = [children.pop || s(:nil)]
+        while block.length == 1 and block.first.type == :begin
+          block = block.first.children.dup
+        end
+
+        if EXPRESSIONS.include? block.last.type 
+          block.push s(:return, block.pop)
+        end
+
+        if block.length == 1
+          children.push block.first
+        else
+          children.push s(:begin, *block)
+        end
+
+        node.updated nil, children
+      end
+      
+      private
+
+      # construct an AST Node
+      def s(type, *args)
+        Parser::AST::Node.new type, args
+      end
+    end
+  end
+end

data/lib/ruby2js/version.rb

@@ -0,0 +1,10 @@
+module Ruby2JS
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end unless defined?(Ruby2JS::VERSION)
+

data/ruby2js.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "ruby2js"
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Sam Ruby"]
+  s.date = "2013-11-11"
+  s.description = "    The base package maps Ruby syntax to JavaScript semantics.\n    Filters may be provided to add Ruby-specific or Framework specific\n    behavior.\n"
+  s.email = "rubys@intertwingly.net"
+  s.files = ["ruby2js.gemspec", "README.md", "lib/ruby2js", "lib/ruby2js/version.rb", "lib/ruby2js/converter.rb", "lib/ruby2js/filter", "lib/ruby2js/filter/return.rb", "lib/ruby2js/filter/angularrb.rb", "lib/ruby2js/filter/functions.rb", "lib/ruby2js.rb"]
+  s.homepage = "http://github.com/rubys/ruby2js"
+  s.require_paths = ["lib"]
+  s.rubygems_version = "2.0.7"
+  s.summary = "Minimal yet extensible Ruby to JavaScript conversion."
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<parser>, [">= 0"])
+    else
+      s.add_dependency(%q<parser>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<parser>, [">= 0"])
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: ruby2js
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sam Ruby
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! "    The base package maps Ruby syntax to JavaScript semantics.\n    Filters
+  may be provided to add Ruby-specific or Framework specific\n    behavior.\n"
+email: rubys@intertwingly.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ruby2js.gemspec
+- README.md
+- lib/ruby2js/version.rb
+- lib/ruby2js/converter.rb
+- lib/ruby2js/filter/return.rb
+- lib/ruby2js/filter/angularrb.rb
+- lib/ruby2js/filter/functions.rb
+- lib/ruby2js.rb
+homepage: http://github.com/rubys/ruby2js
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.7
+signing_key: 
+specification_version: 4
+summary: Minimal yet extensible Ruby to JavaScript conversion.
+test_files: []