ruby2js 3.0.11 → 3.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6da7644d192eea8de1e3a6fe6b8550ef9b373912aed034a88d50cb0b0e27b988
-  data.tar.gz: 558b980ae2a39e47cb4b17f354a5378b183606acd5700ed30f44070b5e180131
+  metadata.gz: 33e8a99086fe503dbff4afab72211baf206981e2b0dd68174aa8cc2ea9a1d361
+  data.tar.gz: 9c86b76630c9c2dbe32032280db32e52b0569ba56ccfcafee0729f8f6d9d351c
 SHA512:
-  metadata.gz: a0819a2eeecd764f301f0bc8ec1d50cb4014dc715e850849e572fd0962247f46e2799a9265e474d79837f2cb17de201bb205762da018100eaa0b62eb7cb8a069
-  data.tar.gz: bc64c4729076b98dc9589e4e27a7d873c5a1185604eaca6ee38923b560f57dfcb51509e1f4e55caa4a9ec2fb5b20c539146a2cd5d4e365d9507356e22b9e5989
+  metadata.gz: b8a0f54b473fa2494ac736232e8e60487a96923d9cd4df5635329c532726836d15a7b465744e7441016e811b153dcc22993d3e0b7013fa99696c18674f3f66fe
+  data.tar.gz: c7806d2aefa3449e3f2e07438fdea60a1b222d0bb866f51035ddd95da67a44a009df109ba39bf9ab2da6ba866c8bf4a8fb9652fca5bfea43e5c688307b9141af

data/README.md

@@ -157,6 +157,20 @@ to `forEach`, `each!` will pass through the filter.  The final code that emits
 JavaScript function calls and parameter accesses will strip off these
 suffixes.
 
+This approach works well if it is an occasional change, but if the usage is
+pervasive, most filters support options to `exclude` a list of mappings,
+for example:
+
+```ruby
+puts Ruby2JS.convert('jQuery("li").each {|index| ...}', exclude: :each)
+```
+
+Alternatively, you can change the default:
+
+```ruby
+Ruby2JS::Filter.exclude :each
+```
+
 Static transformations and runtime libraries aren't aren’t mutually exclusive.
 With enough of each, one could reproduce any functionality desired.  Just be
 forewarned, that implementing a function like `method_missing` would require a
@@ -262,6 +276,11 @@ the script.
       of `Error` instead; and default constructors will be provided
     * `loop do...end` will be replaced with `while (true) {...}`
 
+    Additionally, there is one mapping that will only be done if explicitly
+    <a href="https://github.com/rubys/ruby2js/blob/master/lib/ruby2js/filter.rb">included</a>:
+
+    * `.class` becomes `.constructor`
+
 * <a id="rubyjs" href="https://github.com/rubys/ruby2js/blob/master/spec/rubyjs_spec.rb">rubyjs</a>
     * `.at()` becomes `_a.at()`
     * `.between?()` becomes `R().between()`

data/lib/ruby2js.rb

@@ -9,6 +9,7 @@ ensure
 end
 
 require 'ruby2js/converter'
+require 'ruby2js/filter'
 
 module Ruby2JS
   class SyntaxError < RuntimeError
@@ -48,6 +49,7 @@ module Ruby2JS
     end
 
     class Processor < Parser::AST::Processor
+      include Ruby2JS::Filter
       BINARY_OPERATORS = Converter::OPERATORS[2..-1].flatten
 
       def initialize(comments)
@@ -57,6 +59,14 @@ module Ruby2JS
 
       def options=(options)
         @options = options
+
+        @included = @@included
+        @excluded = @@excluded
+
+        include_all if options[:include_all]
+        include_only(options[:include_only]) if options[:include_only]
+        include(options[:include]) if options[:include]
+        exclude(options[:exclude]) if options[:exclude]
       end
 
       def es2015
@@ -148,11 +158,13 @@ module Ruby2JS
     filters = options[:filters] || Filter::DEFAULTS
 
     unless filters.empty?
+
       filter = Filter::Processor
       filters.reverse.each do |mod|
         filter = Class.new(filter) {include mod} 
       end
       filter = filter.new(comments)
+
       filter.options = options
       ast = filter.process(ast)
     end

data/lib/ruby2js/converter/block.rb

@@ -28,11 +28,11 @@ module Ruby2JS
           put "; "; parse var; 
           if call.children[2].type == :int and call.children[2].children[0] < 0
             put " #{comp.sub('<', '>')} "; parse expression.children.last
-            put "; "; parse var; put " -= "
-            parse s(:int, -call.children[2].children[0])
+            put "; "; parse s(:op_asgn, var, :-, 
+              s(:int, -call.children[2].children[0])), :statement
           else
             put " #{comp} "; parse expression.children.last
-            put "; "; parse var; put " += "; parse call.children[2]
+            put "; "; parse s(:op_asgn, var, :+, call.children[2]), :statement
           end
           puts ") {"
           scope block

data/lib/ruby2js/converter/hash.rb

@@ -87,6 +87,11 @@ module Ruby2JS
               then
                 @prop = left.children.first
                 parse right, :method
+              elsif
+                es2015 and left.type == :sym and right.type == :lvar and
+                left.children == right.children
+              then
+                parse right 
               else
 		if not [:str, :sym].include? left.type and es2015
 		  put '['

data/lib/ruby2js/converter/nthref.rb

@@ -4,7 +4,7 @@ module Ruby2JS
     # (nthref 1)
 
     handle :nth_ref do |var|
-      put "$#{var}"
+      put "RegExp.$#{var}"
     end
   end
 end

data/lib/ruby2js/converter/opasgn.rb

@@ -12,7 +12,14 @@ module Ruby2JS
       var = s(:lvar, var.children.first) if var.type == :lvasgn
       var = s(:cvar, var.children.first) if var.type == :cvasgn
 
-      if [:+, :-].include?(op) and value.type==:int and value.children==[1]
+      if 
+        [:+, :-].include?(op) and value.type==:int and 
+        (value.children==[1] or value.children==[-1])
+      then
+        if value.children.first == -1
+          op = (op == :+ ? :- : :+)
+        end
+
         if @state == :statement
           parse var; put "#{ op }#{ op }"
         else

data/lib/ruby2js/filter.rb

@@ -0,0 +1,96 @@
+#
+# Manage a list of methods to be included or excluded.  This allows fine
+# grained control over filters.
+#
+
+module Ruby2JS
+  module Filter
+
+    #
+    # module level defaults
+    #
+
+    @@included = nil
+    @@excluded = []
+
+    # indicate that the specified methods are not to be processed
+    def self.exclude(*methods)
+      if @@included
+        @@included -= methods.flatten
+      else
+        @@excluded += methods.flatten
+      end
+    end
+
+    # indicate that all methods are to be processed
+    def self.include_all
+      @@included = nil
+      @@excluded = []
+    end
+
+    # indicate that only the specified methods are to be processed
+    def self.include_only(*methods)
+      @@included = methods.flatten
+    end
+
+    # indicate that the specified methods are to be processed
+    def self.include(*methods)
+      if @@included
+        @@included += methods.flatten
+      else
+        @@excluded -= methods.flatten
+      end
+    end
+
+    # indicate that the specified methods are not to be processed
+    def self.exclude(*methods)
+      if @@included
+        @@included -= methods.flatten
+      else
+        @@excluded += methods.flatten
+      end
+    end
+
+    #
+    # instance level overrides
+    #
+
+    # determine if a method is NOT to be processed
+    def excluded?(method)
+      if @included
+        not @included.include? method
+      else
+        @excluded.include? method
+      end
+    end
+
+    # indicate that all methods are to be processed
+    def include_all
+      @included = nil
+      @excluded = []
+    end
+
+    # indicate that only the specified methods are to be processed
+    def include_only(*methods)
+      @included = methods.flatten
+    end
+
+    # indicate that the specified methods are to be processed
+    def include(*methods)
+      if @included
+        @included += methods.flatten
+      else
+        @excluded -= methods.flatten
+      end
+    end
+
+    # indicate that the specified methods are not to be processed
+    def exclude(*methods)
+      if @included
+        @included -= methods.flatten
+      else
+        @excluded += methods.flatten
+      end
+    end
+  end
+end

data/lib/ruby2js/filter/functions.rb

@@ -5,6 +5,9 @@ module Ruby2JS
     module Functions
       include SEXP
 
+      # require explicit opt-in to to class => constructor mapping
+      Filter.exclude :class
+
       VAR_TO_ASSIGN = {
         lvar: :lvasgn,
         ivar: :ivasgn,
@@ -14,6 +17,7 @@ module Ruby2JS
 
       def on_send(node)
         target, method, *args = node.children
+        return super if excluded?(method)
 
         if [:max, :min].include? method and args.length == 0
           return super unless node.is_method?
@@ -320,6 +324,9 @@ module Ruby2JS
         elsif es2017 and method==:ljust
           process node.updated(nil, [target, :padEnd, *args])
 
+        elsif method == :class and args.length==0 and not node.is_method?
+          process node.updated(:attr, [target, :constructor])
+
         else
           super
         end
@@ -327,50 +334,53 @@ module Ruby2JS
 
       def on_block(node)
         call = node.children.first
-        if [:setInterval, :setTimeout].include? call.children[1]
+        method = call.children[1]
+        return super if excluded?(method)
+
+        if [:setInterval, :setTimeout].include? method
           return super unless call.children.first == nil
           block = process s(:block, s(:send, nil, :proc), *node.children[1..-1])
           on_send call.updated nil, [*call.children[0..1], block,
             *call.children[2..-1]]
 
-        elsif [:sub, :gsub, :sub!, :gsub!, :sort!].include? call.children[1]
+        elsif [:sub, :gsub, :sub!, :gsub!, :sort!].include? method
           return super if call.children.first == nil
           block = s(:block, s(:send, nil, :proc), node.children[1],
             s(:autoreturn, *node.children[2..-1]))
           process call.updated(nil, [*call.children, block])
 
-        elsif call.children[1] == :select and call.children.length == 2
+        elsif method == :select and call.children.length == 2
           call = call.updated nil, [call.children.first, :filter]
           node.updated nil, [process(call), process(node.children[1]),
             s(:autoreturn, *process_all(node.children[2..-1]))]
 
-        elsif call.children[1] == :any? and call.children.length == 2
+        elsif method == :any? and call.children.length == 2
           call = call.updated nil, [call.children.first, :some]
           node.updated nil, [process(call), process(node.children[1]),
             s(:autoreturn, *process_all(node.children[2..-1]))]
 
-        elsif call.children[1] == :all? and call.children.length == 2
+        elsif method == :all? and call.children.length == 2
           call = call.updated nil, [call.children.first, :every]
           node.updated nil, [process(call), process(node.children[1]),
             s(:autoreturn, *process_all(node.children[2..-1]))]
 
-        elsif call.children[1] == :find and call.children.length == 2
+        elsif method == :find and call.children.length == 2
           node.updated nil, [process(call), process(node.children[1]),
             s(:autoreturn, *process_all(node.children[2..-1]))]
 
-        elsif call.children[1] == :find_index and call.children.length == 2
+        elsif method == :find_index and call.children.length == 2
           call = call.updated nil, [call.children.first, :findIndex]
           node.updated nil, [process(call), process(node.children[1]),
             s(:autoreturn, *process_all(node.children[2..-1]))]
 
-        elsif call.children[1] == :map and call.children.length == 2
+        elsif method == :map and call.children.length == 2
           node.updated nil, [process(call), process(node.children[1]),
             s(:autoreturn, *process_all(node.children[2..-1]))]
 
-        elsif [:map!, :select!].include? call.children[1]
+        elsif [:map!, :select!].include? method
           # input: a.map! {expression}
           # output: a.splice(0, a.length, *a.map {expression})
-          method = (call.children[1] == :map! ? :map : :select)
+          method = (method == :map! ? :map : :select)
           target = call.children.first
           process call.updated(:send, [target, :splice, s(:splat, s(:send, 
             s(:array, s(:int, 0), s(:attr, target, :length)), :concat,
@@ -382,7 +392,7 @@ module Ruby2JS
           # output: while(true) {statements}
           S(:while, s(:true), node.children[2])
 
-        elsif call.children[1] == :delete
+        elsif method == :delete
           # restore delete methods that are prematurely mapped to undef
           result = super
 
@@ -401,18 +411,18 @@ module Ruby2JS
 
           result
 
-        elsif call.children[1] == :downto
+        elsif method == :downto
           range = s(:irange, call.children[0], call.children[2])
           call = call.updated(nil, [s(:begin, range), :step, s(:int, -1)])
           process node.updated(nil, [call, *node.children[1..-1]])
 
-        elsif call.children[1] == :upto
+        elsif method == :upto
           range = s(:irange, call.children[0], call.children[2])
           call = call.updated(nil, [s(:begin, range), :step, s(:int, 1)])
           process node.updated(nil, [call, *node.children[1..-1]])
 
         elsif 
-          call.children[1] == :each and call.children[0].type == :send and
+          method == :each and call.children[0].type == :send and
           call.children[0].children[1] == :step
         then
           # i.step(j, n).each {|v| ...}
@@ -425,7 +435,7 @@ module Ruby2JS
 
         elsif 
           # (a..b).each {|v| ...}
-          call.children[1] == :each and
+          method == :each and
           call.children[0].type == :begin and
           call.children[0].children.length == 1 and
           [:irange, :erange].include? call.children[0].children[0].type and
@@ -435,7 +445,7 @@ module Ruby2JS
             call.children[0].children[0], node.children[2])
 
         elsif 
-          [:each, :each_value].include? call.children[1] and 
+          [:each, :each_value].include? method and 
           node.children[1].children.length == 1
         then
           if es2015
@@ -448,20 +458,20 @@ module Ruby2JS
           end
 
         elsif 
-          call.children[1] == :each_key and 
-          [:each, :each_key].include? call.children[1] and 
+          method == :each_key and 
+          [:each, :each_key].include? method and 
           node.children[1].children.length == 1
         then
           process node.updated(:for, 
             [s(:lvasgn, node.children[1].children[0].children[0]),
             node.children[0].children[0], node.children[2]])
 
-        elsif es2015 and call.children[1] == :inject
+        elsif es2015 and method == :inject
           process node.updated(:send, [call.children[0], :reduce,
             s(:block, s(:send, nil, :lambda), *node.children[1..2]),
             *call.children[2..-1]])
 
-        elsif es2017 and call.children[1] == :each_pair
+        elsif es2017 and method == :each_pair
           process node.updated(nil, [s(:send, s(:send, s(:const, nil, :Object),
             :entries, call.children[0]), :forEach), s(:args, s(:mlhs,
             *node.children[1].children)), node.children[2]])

data/lib/ruby2js/filter/rubyjs.rb

@@ -11,6 +11,9 @@ module Ruby2JS
         return super if target and [:_s, :_a, :_h, :_n, :_i, :_t].
           include? target.children[1]
 
+        method = node.children[1]
+        return super if excluded?(method)
+
         # leave classic ("OO") style call chains alone
         while target and target.type == :send
           return super if target.children[1] == :R
@@ -19,33 +22,33 @@ module Ruby2JS
 
         if 
           [:capitalize, :center, :chomp, :ljust, :lstrip, :rindex, :rjust,
-            :rstrip, :scan, :swapcase, :tr].include? node.children[1]
+            :rstrip, :scan, :swapcase, :tr].include? method
         then
           # map selected string functions
-          s(:send, s(:lvar, :_s), node.children[1],
+          s(:send, s(:lvar, :_s), method,
             *process_all([node.children[0], *node.children[2..-1]]))
 
         elsif 
           [:at, :compact, :compact!, :delete_at, :delete_at, :flatten, :insert,
           :reverse, :reverse!, :rotate, :rotate, :rotate!, :shift, :shuffle,
           :shuffle!, :slice, :slice!, :transpose, :union, :uniq, :uniq!]
-          .include? node.children[1]
+          .include? method
         then
           # map selected array functions
-          s(:send, s(:lvar, :_a), node.children[1].to_s.sub("!", '_bang'),
+          s(:send, s(:lvar, :_a), method.to_s.sub("!", '_bang'),
             *process_all([node.children[0], *node.children[2..-1]]))
 
 
-        elsif [:strftime].include? node.children[1]
+        elsif [:strftime].include? method
           # map selected time functions
-          s(:send, s(:lvar, :_t), node.children[1],
+          s(:send, s(:lvar, :_t), method,
             *process_all([node.children[0], *node.children[2..-1]]))
 
-        elsif node.children[1] == :<=>
+        elsif method == :<=>
           s(:send, s(:attr, s(:const, nil, :R), :Comparable), :cmp,
             node.children[0], *node.children[2..-1])
 
-        elsif node.children[1] == :between?
+        elsif method == :between?
           s(:send, s(:send, nil, :R, node.children[0]), :between,
             *node.children[2..-1])
 
@@ -56,31 +59,32 @@ module Ruby2JS
 
       def on_block(node)
         call, args, *block = node.children
+        method = call.children[1]
+        return super if excluded?(method)
 
         if 
           [:collect_concat, :count, :cycle, :delete_if, :drop_while,
           :each_index, :each_slice, :each_with_index, :each_with_object,
           :find, :find_all, :flat_map, :inject, :grep, :group_by, :keep_if,
           :map, :max_by, :min_by, :one?, :partition, :reject, :reverse_each,
-          :select!, :sort_by, :take_while].include? call.children[1]
+          :select!, :sort_by, :take_while].include? method
         then
           if 
             [:collect_concat, :count, :delete_if, :drop_while, :find,
             :find_all, :flat_map, :grep, :group_by, :keep_if, :map, :max_by,
             :min_by, :one?, :partition, :reject, :select!, :sort_by,
-            :take_while].include? call.children[1]
+            :take_while].include? method
           then
             block = [ s(:autoreturn, *block) ]
           end
 
-          lvar = [:each_index, :keep_if, :select!].
-            include?(call.children[1]) ? :_a : :_e
+          lvar = [:each_index, :keep_if, :select!].include?(method) ? :_a : :_e
 
-          if call.children[1] == :find and call.children.length == 2
+          if method == :find and call.children.length == 2
             call = s(:send, *call.children, s(:nil))
-          elsif call.children[1] == :inject and call.children.length == 3
+          elsif method == :inject and call.children.length == 3
             call = s(:send, *call.children, s(:nil))
-          elsif call.children[1] == :select!
+          elsif method == :select!
             call = s(:send, call.children.first, :select_bang,
               *call.children[2..-1])
           end

data/lib/ruby2js/filter/underscore.rb

@@ -8,43 +8,46 @@ module Ruby2JS
       def on_send(node)
         return super if node.children.first and node.children.first.children.last == :_
 
+        method = node.children[1]
+        return super if excluded?(method)
+
         if [:clone, :shuffle, :size, :compact, :flatten, :invert, :values,
-          :uniq].include? node.children[1]
+          :uniq].include? method
           if node.is_method?  and node.children.length == 2
-            process S(:send, s(:lvar, :_), node.children[1], node.children[0])
+            process S(:send, s(:lvar, :_), method, node.children[0])
           else
             super
           end
-        elsif node.children[1] == :sample and  node.children.length <= 3
+        elsif method == :sample and  node.children.length <= 3
           process S(:send, s(:lvar, :_), :sample, node.children[0],
             *node.children[2..-1])
-        elsif node.children[1] == :has_key? and  node.children.length == 3
+        elsif method == :has_key? and  node.children.length == 3
           process S(:send, s(:lvar, :_), :has, node.children[0],
             node.children[2])
-        elsif node.children[1] == :sort and  node.children.length == 2
+        elsif method == :sort and  node.children.length == 2
           if node.is_method?
             process S(:send, s(:lvar, :_), :sortBy, node.children[0],
               s(:attr, s(:lvar, :_), :identity))
           else
             super
           end
-        elsif node.children[1] == :map
+        elsif method == :map
           if node.children.length == 3 and node.children[2].type == :block_pass
             process S(:send, s(:lvar, :_), :pluck, node.children[0],
               node.children[2].children.first)
           else
             super
           end
-        elsif node.children[1] == :merge and node.children.length >= 3
+        elsif method == :merge and node.children.length >= 3
           process S(:send, s(:lvar, :_), :extend, s(:hash), node.children[0],
             *node.children[2..-1])
-        elsif node.children[1] == :merge! and node.children.length >= 3
+        elsif method == :merge! and node.children.length >= 3
           process S(:send, s(:lvar, :_), :extend, node.children[0],
             *node.children[2..-1])
-        elsif node.children[1] == :zip and node.children.length >= 3
+        elsif method == :zip and node.children.length >= 3
           process S(:send, s(:lvar, :_), :zip, node.children[0],
             *node.children[2..-1])
-        elsif node.children[1] == :invoke
+        elsif method == :invoke
           if node.children.length >= 3 and node.children.last.type==:block_pass
             process S(:send, s(:lvar, :_), :invoke, node.children[0],
               node.children.last.children.first,
@@ -52,11 +55,11 @@ module Ruby2JS
           else
             super
           end
-        elsif [:where, :find_by].include? node.children[1]
-          method = node.children[1] == :where ? :where : :findWhere
+        elsif [:where, :find_by].include? method
+          method = (method == :where ? :where : :findWhere)
           process S(:send, s(:lvar, :_), method, node.children[0],
             *node.children[2..-1])
-        elsif node.children[1] == :reduce
+        elsif method == :reduce
           if node.children.length == 3 and node.children[2].type == :sym
             # input: a.reduce(:+)
             # output: _.reduce(_.rest(a), 
@@ -86,13 +89,13 @@ module Ruby2JS
           end
 
         elsif [:compact!, :flatten!, :shuffle!, :uniq!].
-          include? node.children[1] and node.is_method?
+          include? method and node.is_method?
           # input: a.compact!
           # output: a.splice(0, a.length, *a.compact)
           target = node.children.first
           process S(:send, target, :splice, s(:int, 0), 
             s(:attr, target, :length), s(:splat, s(:send, target, 
-            :"#{node.children[1].to_s[0..-2]}", *node.children[2..-1])))
+            :"#{method.to_s[0..-2]}", *node.children[2..-1])))
         else
           super
         end
@@ -100,31 +103,34 @@ module Ruby2JS
 
       def on_block(node)
         call = node.children.first
-        if [:sort_by, :group_by, :index_by, :count_by].include? call.children[1]
+        method = call.children[1]
+        return super if excluded?(method)
+
+        if [:sort_by, :group_by, :index_by, :count_by].include? method
           # input: a.sort_by {}
           # output: _.sortBy {return expression}
-          method = call.children[1].to_s.sub(/\_by$/,'By').to_sym
+          method = method.to_s.sub(/\_by$/,'By').to_sym
           process S(:block, s(:send, s(:lvar, :_), method,
             call.children.first), node.children[1], 
             s(:autoreturn, node.children[2]))
-        elsif [:find, :reject].include? call.children[1]
+        elsif [:find, :reject].include? method
           if call.children.length == 2
             # input: a.find {|item| item > 0}
             # output: _.find(a) {|item| return item > 0}
-            process S(:block, s(:send, s(:lvar, :_), call.children[1], 
+            process S(:block, s(:send, s(:lvar, :_), method, 
               call.children.first), node.children[1], 
               s(:autoreturn, node.children[2]))
           else
             super
           end
 
-        elsif call.children[1] == :times and call.children.length == 2
+        elsif method == :times and call.children.length == 2
           # input: 5.times {|i| console.log i}
           # output: _.find(5) {|i| console.log(i)}
-          process S(:block, s(:send, s(:lvar, :_), call.children[1], 
+          process S(:block, s(:send, s(:lvar, :_), method, 
             call.children.first), node.children[1], node.children[2])
 
-        elsif call.children[1] == :reduce
+        elsif method == :reduce
           if call.children.length == 2
             # input: a.reduce {|memo, item| memo+item}
             # output: _.reduce(_.rest(a), 
@@ -144,10 +150,10 @@ module Ruby2JS
                 call.children[2])
           end
 
-        elsif [:map!, :reject!, :select!, :sort_by!].include? call.children[1]
+        elsif [:map!, :reject!, :select!, :sort_by!].include? method
           # input: a.map! {expression}
           # output: a.splice(0, a.length, *a.map {expression})
-          method = :"#{call.children[1].to_s[0..-2]}"
+          method = :"#{method.to_s[0..-2]}"
           target = call.children.first
           process S(:call, target, :splice, s(:splat, s(:send, s(:array, 
             s(:int, 0), s(:attr, target, :length)), :concat,

data/lib/ruby2js/filter/vue.rb

@@ -623,7 +623,11 @@ module Ruby2JS
                          hash['nativeOn']['input'] ||
                          hash['nativeOn']['change']
               attr = 'value'
-              event = 'input'
+              if hash[:attrs]['type'] == s(:str, 'file')
+                event = 'change'
+              else
+                event = 'input'
+              end
             end
 
             # search for the presence of a 'onClick' attribute

data/lib/ruby2js/version.rb

@@ -2,7 +2,7 @@ module Ruby2JS
   module VERSION #:nodoc:
     MAJOR = 3
     MINOR = 0
-    TINY  = 11
+    TINY  = 12
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby2js
 version: !ruby/object:Gem::Version
-  version: 3.0.11
+  version: 3.0.12
 platform: ruby
 authors:
 - Sam Ruby
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-08 00:00:00.000000000 Z
+date: 2018-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -93,6 +93,7 @@ files:
 - lib/ruby2js/es2017.rb
 - lib/ruby2js/es2017/strict.rb
 - lib/ruby2js/execjs.rb
+- lib/ruby2js/filter.rb
 - lib/ruby2js/filter/camelCase.rb
 - lib/ruby2js/filter/functions.rb
 - lib/ruby2js/filter/jquery.rb
@@ -130,7 +131,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.4
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Minimal yet extensible Ruby to JavaScript conversion.