jsrb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d11a911afb7baddbd00ec547cd0b5679be9873a7
+  data.tar.gz: 0e28f797a62a8f8b640039b13f8ab54203e12602
+SHA512:
+  metadata.gz: 31518c3f3adceb687937556bec2c598db034812662c48505616acd46462fed85a0ce1448b2aaea336ec3b3c5cf43605956079b3a1b6516a8035f6ce5265b837a
+  data.tar.gz: d29797e2528c20b83ed3f54573a0cde76f665b6aa9773f6860481187461c2ec1f597c9505dae97f4ef35204f519464a5d27ee095439deb136910b9290315f2fa

data/.circleci/config.yml

@@ -0,0 +1,32 @@
+# Ruby CircleCI 2.0 configuration file
+#
+# Check https://circleci.com/docs/2.0/language-ruby/ for more details
+#
+version: 2
+jobs:
+  build:
+    docker:
+      - image: circleci/ruby:2.5.1-node-browsers
+    working_directory: ~/repo
+    steps:
+      - checkout
+      - run:
+          name: install dependencies
+          working_directory: ~/repo
+          command: |
+            bundle install --jobs=4 --retry=3 --path vendor/bundle
+      - run:
+          name: run tests
+          working_directory: ~/repo
+          command: |
+            bundle exec rspec
+      - run:
+          name: run rubocop
+          working_directory: ~/repo
+          command: |
+            bundle exec rubocop
+      - run:
+          name: report coverage
+          working_directory: ~/repo
+          command: |
+            bash <(curl -s https://codecov.io/bash) -f coverage/.resultset.json

data/.gitignore

@@ -0,0 +1,10 @@
+/bin/
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,37 @@
+AllCops:
+  Exclude:
+    - 'tmp/**/*'
+    - 'vendor/**/*'
+  TargetRubyVersion: 2.5
+
+Metrics/LineLength:
+  Max: 130
+
+Metrics/MethodLength:
+  Max: 30
+
+Metrics/AbcSize:
+  Max: 25
+
+Metrics/ClassLength:
+  Max: 200
+
+Style/MissingRespondToMissing:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/AccessModifierDeclarations:
+  Enabled: false
+
+Style/NumericPredicate:
+  Enabled: false
+
+Style/LambdaCall:
+  Exclude:
+    - 'spec/**/*'
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*'

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.13.6

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in jsrb.gemspec
+gemspec
+
+group :development, :test do
+  gem 'pry-byebug'
+  gem 'rubocop', '~> 0.61.0'
+  gem 'simplecov'
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Shun MIZUKAMI
+
+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,20 @@
+[![CircleCI](https://circleci.com/gh/effective-spa/jsrb.svg?style=svg)](https://circleci.com/gh/effective-spa/jsrb) [![codecov](https://codecov.io/gh/effective-spa/jsrb/branch/master/graph/badge.svg)](https://codecov.io/gh/effective-spa/jsrb) [![Maintainability](https://api.codeclimate.com/v1/badges/8bf4666ed7b983f01519/maintainability)](https://codeclimate.com/github/effective-spa/jsrb/maintainability)
+
+**This library is still development version. It's currently not recommended to be used in production environment.**
+
+# Jsrb
+
+Jsrb is a template engine to generate JavaScript code in simple Ruby DSL.
+
+## Usage
+
+TODO
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/effective-spa/jsrb.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/jsrb.gemspec

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jsrb/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'jsrb'
+  spec.version       = Jsrb::VERSION
+  spec.authors       = ['Shun MIZUKAMI']
+  spec.email         = ['norainu234@gmail.com']
+
+  spec.summary       = 'generates JavaScript code with Ruby DSL'
+  spec.description   = 'Jsrb is a template engine to generate JavaScript code in simple Ruby DSL.'
+  spec.homepage      = 'https://github.com/effective-spa/jsrb'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+      'public gem pushes.'
+  end
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'execjs', '~> 2.7', '>= 2.7.0'
+  spec.add_runtime_dependency 'stitch-rb', '~> 0.0.8'
+
+  spec.add_development_dependency 'bundler', '~> 1.13'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

data/lib/jsrb/base.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Jsrb
+  class Base
+    def initialize
+      @context = JSStatementContext.new
+    end
+
+    def generate_code
+      generator = self.class.code_generator_class.new
+      generator.call type: 'Program',
+                     sourceType: 'script',
+                     body: @context.stacks.first
+    end
+
+    def var!(id = nil)
+      id ||= @context.gen_var_name!
+      if block_given?
+        raw_expr = yield
+        val = raw_expr.is_a?(ExprChain) ? raw_expr : expr(@context.ruby_to_js_ast(raw_expr))
+        val.as_variable_declaration!(id)
+      else
+        expr.as_variable_declaration!(id)
+      end
+      expr.member!(id)
+    end
+
+    def if!(cond_expr, &block)
+      CondChain.new(@context, false).elsif(cond_expr, &block)
+    end
+
+    def if(cond_expr, &block)
+      CondChain.new(@context, true).elsif(cond_expr, &block)
+    end
+
+    def expr(object = nil)
+      @context.new_expression(object)
+    end
+
+    class << self
+      def code_generator_class
+        @code_generator_class ||= Object.const_get(code_generator)
+      end
+
+      def code_generator
+        @code_generator || 'Jsrb::NotFastGenerator'
+      end
+
+      attr_writer :code_generator
+    end
+  end
+end

data/lib/jsrb/cond_chain.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Jsrb
+  class CondChain
+    def initialize(context, as_expr)
+      @context = context
+      @as_expr = as_expr
+      @stack = []
+    end
+
+    def elsif(expr, &block)
+      add_case(expr, block)
+      self
+    end
+
+    def else(&block)
+      finalize(block)
+    end
+
+    def end
+      finalize(nil)
+    end
+    alias end! end
+
+    private
+
+    def add_case(expr, block)
+      @stack << [@context.ruby_to_js_ast(expr), block]
+    end
+
+    def finalize(block)
+      if_value = @context.new_expression(
+        type: 'CallExpression',
+        callee: @context.ruby_to_js_ast(create_proc(block)),
+        arguments: []
+      )
+      if @as_expr
+        if_value
+      else
+        @context.push(
+          type: 'ExpressionStatement',
+          expression: if_value.unwrap!
+        )
+      end
+    end
+
+    def create_proc(block)
+      lambda do
+        final_alternate_stmt = block && @context.new_block do
+          @context.new_expression(
+            type: 'CallExpression',
+            callee: @context.ruby_to_js_ast(block),
+            arguments: []
+          ).as_return!
+        end
+        if_stmt = @stack.reverse.reduce(final_alternate_stmt) do |alternate_stmt, cond_block|
+          condition_expr, cond_block = cond_block
+          consequent_stmt = @context.new_block do
+            @context.new_expression(
+              type: 'CallExpression',
+              callee: @context.ruby_to_js_ast(cond_block),
+              arguments: []
+            ).as_return!
+          end
+          stmt_ast = {
+            type: 'IfStatement',
+            test: condition_expr,
+            consequent: consequent_stmt
+          }
+          stmt_ast[:alternate] = alternate_stmt if alternate_stmt
+          stmt_ast
+        end
+        @context.push(if_stmt)
+      end
+    end
+  end
+end

data/lib/jsrb/expr_chain.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module Jsrb
+  class ExprChain
+    JS_LOGICAL_OPS = %w[&& ||].freeze
+
+    def initialize(context, object = nil)
+      @context = context
+      @object = object
+    end
+
+    # rubocop:disable Style/MethodMissingSuper
+    def method_missing(name, *args, &block)
+      if (matches = name.to_s.match(/\A(.+)\?\z/))
+        member!(matches[1]).cond?(*args)
+      elsif (matches = name.to_s.match(/\A(.+)=\z/))
+        member!(matches[1]).set!(*args)
+      elsif (function_name = self.class.custom_chains[name.to_sym])
+        bind_chain!(function_name, *args, &block)
+      elsif args.empty? && !block
+        member!(name.to_s)
+      else
+        member!(name.to_s).call(*args, &block)
+      end
+    end
+    # rubocop:enable Style/MethodMissingSuper
+
+    def [](value)
+      member!(value)
+    end
+
+    %i[** + - * / % >> << & ^ | <= < > >= == === != !].each do |operator|
+      define_method(operator) do |*args|
+        op!(operator, *args)
+      end
+    end
+
+    def unwrap!
+      @object
+    end
+
+    def as_statement!
+      raise ArgumentError, "Can't chain as_statement! on empty context" unless @object
+
+      @context.push(
+        type: 'ExpressionStatement',
+        expression: @object
+      )
+      nil # chain ends
+    end
+
+    def as_variable_declaration!(id)
+      if @object
+        @context.push(
+          type: 'VariableDeclaration',
+          declarations: [{
+            type: 'VariableDeclarator',
+            id: {
+              type: 'Identifier',
+              name: id.to_s
+            },
+            init: @object
+          }],
+          kind: 'var'
+        )
+      else
+        @context.push(
+          type: 'VariableDeclaration',
+          declarations: [{
+            type: 'VariableDeclarator',
+            id: {
+              type: 'Identifier',
+              name: id.to_s
+            }
+          }],
+          kind: 'var'
+        )
+      end
+    end
+
+    def as_return!
+      @context.push(
+        type: 'ReturnStatement',
+        argument: @object
+      )
+    end
+
+    def member!(value)
+      if @object
+        self.class.new @context, type: 'MemberExpression',
+                                 computed: true,
+                                 object: @object,
+                                 property: @context.ruby_to_js_ast(value)
+      else
+        self.class.new @context, type: 'Identifier',
+                                 name: value.to_s
+      end
+    end
+
+    def assign!(value)
+      raise ArgumentError, "Can't chain assign! on empty context" unless @object
+
+      self.class.new @context, type: 'AssignmentExpression',
+                               operator: '=',
+                               left: @object,
+                               right: @context.ruby_to_js_ast(value)
+    end
+
+    def set!(value)
+      assign!(value).as_statement!
+    end
+
+    def call(*args, &block)
+      raise ArgumentError, "Can't chain call on empty context" unless @object
+
+      js_args = args.map do |arg|
+        @context.ruby_to_js_ast(arg)
+      end
+      js_args << @context.ruby_to_js_ast(block) if block
+      self.class.new @context, type: 'CallExpression',
+                               callee: @object,
+                               arguments: js_args
+    end
+
+    def new!(*args)
+      raise ArgumentError, "Can't chain new! on empty context" unless @object
+
+      arguments = args.map do |arg|
+        @context.ruby_to_js_ast(arg)
+      end
+      self.class.new @context, type: 'NewExpression',
+                               callee: @object,
+                               arguments: arguments
+    end
+
+    def op!(operator, *args)
+      raise ArgumentError, "Can't chain op! on empty context" unless @object
+
+      opstr = operator.to_s
+      if args.size == 1
+        _binary_op!(opstr, *args)
+      elsif args.empty?
+        _unary_op!(opstr)
+      else
+        raise ArgumentError, "#{opstr} is not a valid operator"
+      end
+    end
+
+    private def _binary_op!(opstr, arg)
+      if JS_LOGICAL_OPS.include? opstr
+        self.class.new @context, type: 'LogicalExpression',
+                                 operator: opstr,
+                                 left: @object,
+                                 right: @context.ruby_to_js_ast(arg)
+      else
+        self.class.new @context, type: 'BinaryExpression',
+                                 operator: opstr,
+                                 left: @object,
+                                 right: @context.ruby_to_js_ast(arg)
+      end
+    end
+
+    private def _unary_op!(opstr)
+      self.class.new @context, type: 'UnaryExpression',
+                               operator: opstr,
+                               argument: @object,
+                               prefix: true
+    end
+
+    def cond?(consequent, alternate)
+      raise ArgumentError, "Can't chain cond? on empty context" unless @object
+
+      self.class.new @context, type: 'ConditionalExpression',
+                               test: @object,
+                               consequent: @context.ruby_to_js_ast(consequent),
+                               alternate: @context.ruby_to_js_ast(alternate)
+    end
+
+    def for_all!(*args)
+      raise ArgumentError, "Can't chain for_all! on empty context" unless @object
+
+      self.class.new @context, type: 'FunctionExpression',
+                               id: nil,
+                               params: args.map { |arg| @context.ruby_to_js_ast(arg) },
+                               body: {
+                                 type: 'BlockStatement',
+                                 body: [
+                                   {
+                                     type: 'ReturnStatement',
+                                     argument: @object
+                                   }
+                                 ]
+                               }
+    end
+
+    def bind_chain!(function_name, *args, &block)
+      raise ArgumentError, "Can't bind_chain! on empty context" unless @object
+
+      arg_asts = [@object]
+      args.each do |arg|
+        arg_asts << @context.ruby_to_js_ast(arg)
+      end
+      arg_asts << @context.ruby_to_js_ast(block) if block_given?
+      self.class.new @context, type: 'CallExpression',
+                               callee: self.class.new(@context).member!(function_name).unwrap!,
+                               arguments: arg_asts
+    end
+
+    class << self
+      def add_custom_chain(chain_method_name, function_name)
+        @_custom_chains ||= {}
+        @_custom_chains[chain_method_name] = function_name
+      end
+
+      def custom_chains
+        @_custom_chains || {}
+      end
+    end
+  end
+end