ruby2js 4.1.4 → 4.2.0

data/lib/ruby2js/filter/lit.rb

@@ -0,0 +1,290 @@
+require 'ruby2js'
+
+module Ruby2JS
+  module Filter
+    module Lit
+      include SEXP
+      extend  SEXP
+
+      LITELEMENT_IMPORT = s(:import,
+        [s(:pair, s(:sym, :from), s(:str, "lit"))],
+        [s(:const, nil, :LitElement), s(:attr, nil, :css), s(:attr, nil, :html)]) 
+
+      def initialize(node)
+        super
+        @le_props = nil
+      end
+
+      def on_ivar(node)
+        return super unless @le_props&.include?(node.children.first)
+        process s(:attr, s(:self), node.children.first.to_s[1..-1])
+      end
+
+      def on_ivasgn(node)
+        return super unless @le_props&.include?(node.children.first)
+        return super unless node.children.length > 1
+
+        process s(:send, s(:self), node.children.first.to_s[1..-1]+'=',
+          process(node.children[1]))
+      end
+
+      def on_op_asgn(node)
+        return super unless node.children.first.type == :ivasgn
+        var = node.children.first.children.first
+        return super unless @le_props&.include?(var)
+        super node.updated(nil, [s(:attr, s(:attr, nil, :this),
+          var.to_s[1..-1]), *node.children[1..-1]])
+      end
+
+      def on_class(node)
+        class_name, inheritance, *body = node.children
+        return super unless inheritance == s(:const, nil, :LitElement)
+
+        @le_props = {}
+        le_walk(node)
+
+        prepend_list << LITELEMENT_IMPORT if modules_enabled?
+
+        nodes = body.dup
+        if nodes.length == 1 and nodes.first&.type == :begin
+          nodes = nodes.first.children.dup
+        end
+
+        # insert/update static get properties() {}
+        unless @le_props.empty?
+          values = nodes.find_index {|child| 
+            (child.type == :defs and child.children[0..1] == [s(:self), :properties]) or
+            (child.type == :send and child.children[0..1] == [s(:self), :properties=])
+          }
+
+          if values == nil
+            if es2022
+              nodes.unshift process(s(:casgn, nil, :properties, 
+                s(:hash, *@le_props.map {|name, type| s(:pair, s(:sym, name.to_s[1..-1]), 
+                s(:hash, s(:pair, s(:sym, :type), s(:const, nil, type || :String))))})))
+            else
+              nodes.unshift process(s(:defp, s(:self), :properties, s(:args), s(:return, 
+                s(:hash, *@le_props.map {|name, type| s(:pair, s(:sym, name.to_s[1..-1]), 
+                s(:hash, s(:pair, s(:sym, :type), s(:const, nil, type || :String))))}))))
+            end
+          elsif nodes[values].children.last.type == :hash
+            le_props = @le_props.map {|name, type| 
+              [s(:sym, name.to_s[1..-1].to_sym), 
+              s(:hash, s(:pair, s(:sym, :type), s(:const, nil, type || :String)))]
+            }.to_h.merge(
+              nodes[values].children.last.children.map {|pair| pair.children}.to_h
+            )
+
+            nodes[values] = nodes[values].updated(nil,
+              [*nodes[values].children[0..-2], s(:hash,
+              *le_props.map{|name, value| s(:pair, name, value)})])
+          end
+        end
+
+        # customElement is converted to customElements.define
+        customElement = nodes.find_index {|child| 
+          child&.type == :send and (child.children[0..1] == [nil, :customElement] || child.children[0..1] == [nil, :custom_element])
+        }
+        if customElement and nodes[customElement].children.length == 3
+          nodes[customElement] = nodes[customElement].updated(nil,
+            [s(:attr, nil, :customElements), :define,
+            nodes[customElement].children.last, class_name])
+        end
+
+        # render of a string is converted to a taglit :html
+        render = nodes.find_index {|child| 
+          child&.type == :def and child.children.first == :render
+        }
+        if render and %i[str dstr begin if block].include?(nodes[render].children[2]&.type)
+          nodes[render] = nodes[render].updated(:deff,
+            [*nodes[render].children[0..1],
+            s(:autoreturn, html_wrap(nodes[render].children[2]))])
+        end
+
+        # self.styles returning string is converted to a taglit :css
+        styles = nodes.find_index {|child| 
+          (child&.type == :ivasgn and child.children[0] == :@styles) or
+          (child&.type == :defs and child.children[0..1] == [s(:self), :styles]) or
+          (child&.type == :send and child.children[0..1] == [s(:self), :styles=])
+        }
+        if styles and %i[str dstr].include?(nodes[styles].children.last&.type)
+          string = nodes[styles].children.last
+          string = s(:dstr, string) if string.type == :str
+          children = string.children.dup
+
+          while children.length > 1 and children.last.type == :str and
+            children.last.children.last.strip == ''
+            children.pop
+          end
+
+          if children.last.type == :str
+            children << s(:str, children.pop.children.first.chomp)
+          end
+
+          if es2022
+            nodes[styles] = nodes[styles].updated(:casgn,
+              [nil, :styles, s(:taglit, s(:sym, :css),
+              s(:dstr, *children))])
+          else
+            nodes[styles] = nodes[styles].updated(:defp,
+              [s(:self), :styles, s(:args),
+              s(:autoreturn, s(:taglit, s(:sym, :css),
+              s(:dstr, *children)))])
+          end
+        end
+
+        # insert super calls into initializer
+        initialize = nodes.find_index {|child| 
+          child&.type == :def and child.children.first == :initialize
+        }
+        if initialize and nodes[initialize].children.length == 3
+          statements = nodes[initialize].children[2..-1]
+
+          if statements.length == 1 and statements.first.type == :begin
+            statements = statements.first.children 
+          end
+
+          unless statements.any? {|statement| %i[super zuper].include?  statement.type}
+            nodes[initialize] = nodes[initialize].updated(nil,
+            [*nodes[initialize].children[0..1],
+            s(:begin, s(:zsuper), *statements)])
+          end
+        end
+
+        # props/methods inherited from LitElement
+        props = {
+          hasUpdated: s(:self),
+          performUpdate: s(:autobind, s(:self)),
+          renderRoot: s(:self),
+          requestUpdate: s(:autobind, s(:self)),
+          shadowRoot: s(:self),
+          updateComplete: s(:self),
+        }
+
+        # local props
+        props.merge! @le_props.keys.map {|prop| [prop.to_sym, s(:self)]}.to_h
+
+        nodes.unshift s(:defineProps, props)
+
+        nodes.pop unless nodes.last
+
+        node.updated(nil, [*node.children[0..1], s(:begin, *process_all(nodes))])
+      ensure
+        @le_props = nil
+      end
+
+      def html_wrap(node)
+        return node unless node.is_a?(Parser::AST::Node)
+
+        if node.type == :str and node.children.first.strip.start_with? '<'
+          s(:taglit, s(:sym, :html), s(:dstr, node))
+        elsif node.type == :dstr
+          prefix = ''
+          node.children.each do |child|
+            break unless child.type == :str
+            prefix += child.children.first
+          end
+
+          return node unless prefix.strip.start_with? '<'
+
+          children = node.children.map do |child|
+            if child.type == :str
+              child
+            else
+              html_wrap(child)
+            end
+          end
+
+          while children.length > 1 and children.last.type == :str and
+            children.last.children.last.strip == ''
+            children.pop
+          end
+
+          if children.last.type == :str
+            children << s(:str, children.pop.children.first.chomp)
+          end
+
+          s(:taglit, s(:sym, :html), node.updated(nil, children))
+        elsif node.type == :begin
+          node.updated(nil, node.children.map {|child| html_wrap(child)})
+        elsif node.type == :if
+          node.updated(nil, [node.children.first,
+            *node.children[1..2].map {|child| html_wrap(child)}])
+        elsif node.type == :block and
+          node.children.first.children[1] == :map
+          node.updated(nil, [*node.children[0..1],
+            html_wrap(node.children[2])])
+        else
+          node
+        end
+      end
+
+      def on_def(node)
+        node = super
+        return node if [:constructor, :initialize].include?(node.children.first)
+
+        children = node.children[1..-1]
+
+        node.updated nil, [node.children[0], children.first,
+          *(children[1..-1].map {|child| html_wrap(child) })]
+      end
+
+      # analyze ivar usage
+      def le_walk(node)
+        node.children.each do |child|
+          next unless child.is_a? Parser::AST::Node
+
+          if child.type == :ivar
+            next if child.children.first.to_s.start_with?("@_")
+
+            @le_props[child.children.first] ||= nil
+          elsif child.type == :ivasgn || child.type == :op_asgn
+            prop = child.children.first
+            unless prop.is_a? Symbol
+              prop = prop.children.first if prop.type == :ivasgn
+              next unless prop.is_a? Symbol
+            end
+
+            next if prop.to_s.start_with?("@_")
+
+            @le_props[prop] = case child.children.last.type
+              when :str, :dstr
+                :String
+              when :array
+                :Array
+              when :int, :float
+                :Number
+              when :true, :false
+                :Boolean
+              else
+                @le_props[prop] || :Object
+            end
+          else
+            le_walk(child)
+          end
+        end
+      end
+
+      def on_send(node)
+        target, method, *args = node.children
+
+        return super if target
+        return super unless %i{query queryAll queryAsync}.include? method
+        return super unless args.length == 1
+
+        result = s(:csend, s(:attr, s(:self), :renderRoot),
+          (method == :query ? 'querySelector' : 'querySelectorAll'),
+          args.first)
+
+        if method == :queryAsync
+          result = s(:block, s(:send, s(:attr, s(:self), :updateComplete),
+            :then), s(:args), result)
+        end
+
+        result
+      end
+    end
+
+    DEFAULTS.push Lit
+  end
+end

data/lib/ruby2js/filter/react.rb

@@ -41,9 +41,16 @@ module Ruby2JS
       #
       def self.genAttrs
         unless RUBY_ENGINE == 'opal'
-          require 'nokogumbo'
-          page = 'https://facebook.github.io/react/docs/tags-and-attributes.html'
-          doc = Nokogiri::HTML5.get(page)
+          require 'nokogiri'
+          require 'uri'
+          require 'net/http'
+
+          page = 'https://reactjs.org/docs/dom-elements.html'
+          uri = URI.parse(page)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          data = http.get(uri.request_uri).body
+          doc = Nokogiri::HTML5::Document.parse(data)
 
           # delete contents of page prior to the list of supported attributes
           attrs = doc.at('a[name=supported-attributes]')
@@ -51,7 +58,7 @@ module Ruby2JS
           attrs.previous_sibling.remove while attrs and attrs.previous_sibling
 
           # extract attribute names with uppercase chars from code and format
-          attrs = doc.search('code').map(&:text).join(' ')
+          attrs = doc.search('div[data-language=text] pre code').map(&:text).join(' ')
           attrs = attrs.split(/\s+/).grep(/[A-Z]/).sort.uniq.join(' ')
           puts "ReactAttrs = %w(#{attrs})".gsub(/(.{1,72})(\s+|\Z)/, "\\1\n")
         end
@@ -1492,7 +1499,13 @@ module Ruby2JS
        source = Ruby2JS.jsx2_rb(source)
        ast =  Ruby2JS.parse(source).first
        ast = s(:block, s(:send, nil, :_), s(:args), ast) if ast.type == :begin
-       process ast
+
+       begin
+         react, @react = @react, @react || :react
+         process ast
+       ensure
+         @react = react
+       end
       end
     end
 

data/lib/ruby2js/filter/stimulus.rb

@@ -9,12 +9,12 @@ module Ruby2JS
 
       STIMULUS_IMPORT = s(:import,
         [s(:pair, s(:sym, :as), s(:const, nil, :Stimulus)),
-          s(:pair, s(:sym, :from), s(:str, "stimulus"))],
+          s(:pair, s(:sym, :from), s(:str, "@hotwired/stimulus"))],
           s(:str, '*'))
 
       STIMULUS_IMPORT_SKYPACK = s(:import,
         [s(:pair, s(:sym, :as), s(:const, nil, :Stimulus)),
-          s(:pair, s(:sym, :from), s(:str, "https://cdn.skypack.dev/stimulus"))],
+          s(:pair, s(:sym, :from), s(:str, "https://cdn.skypack.dev/@hotwired/stimulus"))],
           s(:str, '*'))
 
       def initialize(*args)

data/lib/ruby2js/filter/underscore.rb

@@ -18,6 +18,12 @@ module Ruby2JS
           else
             super
           end
+        elsif [:take, :drop].include? method and node.is_method?
+          process S(:send, s(:lvar, :_), method, node.children[0], node.children[2])
+        elsif method == :each_slice and node.is_method?
+          process S(:send, s(:lvar, :_), :chunk, node.children[0], node.children[2])
+        elsif [:min, :max].include? method and node.children.length == 2
+          process S(:send, s(:lvar, :_), method, node.children[0])
         elsif method == :sample and  node.children.length <= 3
           process S(:send, s(:lvar, :_), :sample, node.children[0],
             *node.children[2..-1])
@@ -62,14 +68,14 @@ module Ruby2JS
         elsif method == :reduce
           if node.children.length == 3 and node.children[2].type == :sym
             # input: a.reduce(:+)
-            # output: _.reduce(_.rest(a), 
+            # output: _.reduce(_.rest(a),
             #                  proc {|memo, item| return memo+item},
             #                  a[0])
-            process S(:send, s(:lvar, :_), :reduce, 
+            process S(:send, s(:lvar, :_), :reduce,
               s(:send, s(:lvar, :_), :rest, node.children.first),
-              s(:block, s(:send, nil, :proc), 
+              s(:block, s(:send, nil, :proc),
                 s(:args, s(:arg, :memo), s(:arg, :item)),
-                s(:autoreturn, s(:send, s(:lvar, :memo), 
+                s(:autoreturn, s(:send, s(:lvar, :memo),
                   node.children[2].children.first, s(:lvar, :item)))),
                 s(:send, node.children.first, :[], s(:int, 0)))
           elsif node.children.last.type == :block_pass
@@ -79,9 +85,9 @@ module Ruby2JS
             # input: a.reduce(n, :+)
             # output: _.reduce(a, proc {|memo, item| return memo+item}, n)
             process S(:send, s(:lvar, :_), :reduce, node.children.first,
-              s(:block, s(:send, nil, :proc), 
+              s(:block, s(:send, nil, :proc),
                 s(:args, s(:arg, :memo), s(:arg, :item)),
-                s(:autoreturn, s(:send, s(:lvar, :memo), 
+                s(:autoreturn, s(:send, s(:lvar, :memo),
                 node.children[3].children.first, s(:lvar, :item)))),
                 node.children[2])
           else
@@ -93,8 +99,8 @@ module Ruby2JS
           # 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, 
+          process S(:send, target, :splice, s(:int, 0),
+            s(:attr, target, :length), s(:splat, s(:send, target,
             :"#{method.to_s[0..-2]}", *node.children[2..-1])))
         else
           super
@@ -111,14 +117,14 @@ module Ruby2JS
           # output: _.sortBy {return expression}
           method = method.to_s.sub(/\_by$/,'By').to_sym
           process S(:block, s(:send, s(:lvar, :_), method,
-            call.children.first), node.children[1], 
+            call.children.first), node.children[1],
             s(:autoreturn, node.children[2]))
         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, :_), method, 
-              call.children.first), node.children[1], 
+            process S(:block, s(:send, s(:lvar, :_), method,
+              call.children.first), node.children[1],
               s(:autoreturn, node.children[2]))
           else
             super
@@ -127,25 +133,25 @@ module Ruby2JS
         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, :_), method, 
+          process S(:block, s(:send, s(:lvar, :_), method,
             call.children.first), node.children[1], node.children[2])
 
         elsif method == :reduce
           if call.children.length == 2
             # input: a.reduce {|memo, item| memo+item}
-            # output: _.reduce(_.rest(a), 
+            # output: _.reduce(_.rest(a),
             #                  proc {|memo, item| return memo+item},
             #                  a[0])
-            process S(:call, s(:lvar, :_), :reduce, 
+            process S(:call, s(:lvar, :_), :reduce,
               s(:send, s(:lvar, :_), :rest, call.children.first),
-              s(:block, s(:send, nil, :proc), 
+              s(:block, s(:send, nil, :proc),
                 node.children[1], s(:autoreturn, node.children[2])),
                 s(:send, call.children.first, :[], s(:int, 0)))
           elsif call.children.length == 3
             # input: a.reduce(n) {|memo, item| memo+item}
             # output: _.reduce(a, proc {|memo, item| return memo+item}, n)
             process S(:call, s(:lvar, :_), :reduce, call.children.first,
-              s(:block, s(:send, nil, :proc), 
+              s(:block, s(:send, nil, :proc),
                 node.children[1], s(:autoreturn, node.children[2])),
                 call.children[2])
           end
@@ -155,7 +161,7 @@ module Ruby2JS
           # output: a.splice(0, a.length, *a.map {expression})
           method = :"#{method.to_s[0..-2]}"
           target = call.children.first
-          process S(:call, target, :splice, s(:splat, s(:send, s(:array, 
+          process S(:call, target, :splice, s(:splat, s(:send, s(:array,
             s(:int, 0), s(:attr, target, :length)), :concat,
             s(:block, s(:send, target, method, *call.children[2..-1]),
             *node.children[1..-1]))))

data/lib/ruby2js/version.rb

@@ -1,8 +1,8 @@
 module Ruby2JS
   module VERSION #:nodoc:
     MAJOR = 4
-    MINOR = 1
-    TINY  = 4
+    MINOR = 2
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/tasks/install/{litelement.rb → lit-webpacker.rb}

@@ -1,5 +1,5 @@
-@ruby2js_options = {filters: ['lit-element']}
-@yarn_add='lit-element'
+@ruby2js_options = {filters: ['lit']}
+@yarn_add='lit'
 eval IO.read "#{__dir__}/webpacker.rb"
 
 directory File.expand_path("app/javascript/elements", __dir__),

data/lib/tasks/install/stimulus-rollup.rb

@@ -0,0 +1,44 @@
+# install rollup plugin
+run "yarn add @ruby2js/rollup-plugin"
+
+# configure rollup for ruby2js with stimulus filters
+insert_into_file Rails.root.join("rollup.config.js").to_s,
+  "import ruby2js from '@ruby2js/rollup-plugin';\n",
+  after: /import resolve from .*\n/
+
+insert_into_file Rails.root.join("rollup.config.js").to_s,
+  <<-CONFIG, after: "resolve()\n"
+    ,ruby2js({
+      eslevel: 2020,
+      autoexports: 'default',
+      filters: ['stimulus', 'esm', 'functions']
+    })
+  CONFIG
+
+# monkey patch stimulus:manifest:update to find .rb.js controllers too.
+# See https://github.com/hotwired/stimulus-rails/issues/76
+append_to_file Rails.root.join('config/application.rb').to_s,
+  "\n" + <<~'CONFIG'
+    require 'stimulus/manifest'
+
+    module Stimulus::Manifest
+      def import_and_register_controller(controllers_path, controller_path)
+        controller_path = controller_path.relative_path_from(controllers_path).to_s
+        module_path = controller_path.split('.').first
+        controller_class_name = module_path.camelize.gsub(/::/, "__")
+        tag_name = module_path.remove(/_controller/).gsub(/_/, "-").gsub(/\//, "--")
+
+        <<~JS
+
+          import #{controller_class_name} from "./#{controller_path}"
+          application.register("#{tag_name}", #{controller_class_name})
+        JS
+      end
+
+      def extract_controllers_from(directory)
+        (directory.children.select { |e| e.to_s =~ /_controller\.js(\.\w+)?$/ } +
+          directory.children.select(&:directory?).collect { |d| extract_controllers_from(d) }
+        ).flatten.sort
+      end
+    end
+  CONFIG

data/lib/tasks/install/stimulus-sprockets.rb

@@ -1,32 +1,25 @@
 create_file Rails.root.join('config/initializers/ruby2js.rb').to_s,
   <<~CONFIG
-    require 'ruby2js/filter/esm'
-    require 'ruby2js/filter/functions'
-    require 'ruby2js/filter/stimulus'
+    require 'stimulus/manifest'
 
-    Ruby2JS::SprocketsTransformer.options = {
-      autoexports: :default,
-      eslevel: 2020
-    }
+    module Stimulus::Manifest
+      def import_and_register_controller(controllers_path, controller_path)
+        controller_path = controller_path.relative_path_from(controllers_path).to_s
+        module_path = controller_path.split('.').first
+        controller_class_name = module_path.camelize.gsub(/::/, "__")
+        tag_name = module_path.remove(/_controller/).gsub(/_/, "-").gsub(/\//, "--")
 
-    require 'stimulus/importmap_helper'
+        <<~JS
 
-    module Stimulus::ImportmapHelper
-      def find_javascript_files_in_tree(path)
-         exts = {'.js' => '.js', '.jsm' => '.jsm'}.merge(
-           Sprockets.mime_exts.map {|key, value|
-             next unless Sprockets.transformers[value]["application/javascript"]
-             [key, '.js']
-           }.compact.to_h)
-
-         Dir[path.join('**/*')].map {|file|
-           file_ext, web_ext = Sprockets::PathUtils.match_path_extname(file, exts)
-           next unless file_ext
-
-           next unless File.file? file
+          import #{controller_class_name} from "./#{controller_path}"
+          application.register("#{tag_name}", #{controller_class_name})
+        JS
+      end
 
-           Pathname.new(file.chomp(file_ext) + web_ext)
-         }.compact
+      def extract_controllers_from(directory)
+        (directory.children.select { |e| e.to_s =~ /_controller\.js(\.\w+)?$/ } +
+          directory.children.select(&:directory?).collect { |d| extract_controllers_from(d) }
+        ).flatten.sort
       end
     end
   CONFIG

data/lib/tasks/install/stimulus-webpacker.rb

@@ -3,3 +3,6 @@ eval IO.read "#{__dir__}/webpacker.rb"
 
 insert_into_file Rails.root.join("app/javascript/controllers/index.js").to_s,
   '(\\.rb)?', after: '_controller\\.js'
+
+insert_into_file Rails.root.join("app/javascript/packs/application.js").to_s,
+  "import \"../controllers\"\n", after: "import \"channels\"\n"

data/lib/tasks/ruby2js_tasks.rake

@@ -1,4 +1,6 @@
-Thor::Actions::WARNINGS[:unchanged_no_flag] = 'unchanged'
+if defined? Thor
+  Thor::Actions::WARNINGS[:unchanged_no_flag] = 'unchanged'
+end
 
 def template(location)
   system "#{RbConfig.ruby} #{Rails.root.join("bin")}/rails app:template " + 
@@ -9,7 +11,7 @@ namespace :ruby2js do
   namespace :install do
     desc "Install Ruby2JS with LitElement support"
     task :litelement do
-      template 'install/litelement.rb'
+      template 'install/lit-webpacker.rb'
     end
 
     desc "Install Ruby2JS with Preact support"
@@ -24,9 +26,9 @@ namespace :ruby2js do
     end
 
     namespace :stimulus do
-      desc "Install Ruby2JS with Stimulus Sprockets support"
-      task :sprockets => :"stimulus:install:asset_pipeline" do
-        template 'install/stimulus-sprockets.rb'
+      desc "Install Ruby2JS with Stimulus Rollup support"
+      task :rollup do
+        template 'install/stimulus-rollup.rb'
       end
 
       desc "Install Ruby2JS with Stimulus Webpacker support"
@@ -34,6 +36,18 @@ namespace :ruby2js do
         template 'install/stimulus-webpacker.rb'
       end
     end
+
+    namespace :lit do
+      desc "Install Ruby2JS with Lit Rollup support"
+      task :rollup do
+        template 'install/lit-rollup.rb'
+      end
+
+      desc "Install Ruby2JS with Lit Webpacker support"
+      task :webpacker do
+        template 'install/lit-webpacker.rb'
+      end
+    end
   end
 end
 

data/ruby2js.gemspec

@@ -12,12 +12,14 @@ Gem::Specification.new do |s|
   s.authors = ["Sam Ruby".freeze, "Jared White".freeze]
   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".freeze
   s.email = "rubys@intertwingly.net".freeze
-  s.files = %w(ruby2js.gemspec README.md) + Dir.glob("{lib}/**/*")
+  s.files = %w(ruby2js.gemspec README.md bin/ruby2js demo/ruby2js.rb) + Dir.glob("{lib}/**/*")
   s.homepage = "http://github.com/rubys/ruby2js".freeze
   s.licenses = ["MIT".freeze]
   s.required_ruby_version = Gem::Requirement.new(">= 2.3".freeze)
   s.summary = "Minimal yet extensible Ruby to JavaScript conversion.".freeze
 
+  s.executables << 'ruby2js'
+
   s.add_dependency('parser')
   s.add_dependency('regexp_parser', '~> 2.1.1')
 end