delorean_lang 1.1.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9255b38f00277f412eb2a42699d03646470199d261d6cc66298e9e55aa8bd7c0
-  data.tar.gz: 3ae838764cd7a0f7355d1586b60112b1e073feb367d4b513a239a495b63940ca
+  metadata.gz: e0116cc5a84f3c0e7c2efc68c31862529ce3172f7bc7a8f1ee61c8804de3d6da
+  data.tar.gz: d29819d73fd26cd4057b6badd1eb831c2c86c095683f14039b61d1165f13fd8b
 SHA512:
-  metadata.gz: 3d05eb327cd542977ff5eb795cb57326bd2daed68b6d599e62365adf6a0d828df2bcc7514095605a9318ce281d7dcf6bfb636b1dbdae6055708b2cb4c32835ff
-  data.tar.gz: b315ab0405e667e6484b2a109b435f0a53a403fec92baa41d483be8b1978477002a82930d8457c1819c076f37f009494c80c313867cabed1af2f3e307c10f65a
+  metadata.gz: c448503aec6a6929311129849be0223d5ab0dbed702c22e67ab72fd5ad6c40cb71f60b169299e57795a61731505d458b474a040995790fc948ee50ef183dd318
+  data.tar.gz: 56f0224391bc1d1401033c0301297ccb8fb993180196d827c07b5a5f986d19c5f5cf1d051f42af8206e280a6fb0840ee8c434b5fcfe21d3f0fcf26581837f555

data/.gitlab-ci.yml

@@ -1,6 +1,7 @@
-image: thepry/docker-ruby-ci:2.4.2-latest
+image: ruby:2.6.3-buster
 
 before_script:
+  - gem install bundler:2.0.2
   - bundle install --jobs $(nproc) --path vendor "${FLAGS[@]}"
 
 .base-test:
@@ -28,7 +29,7 @@ cache:
 
 variables:
   GIT_SSL_NO_VERIFY: "true"
-  BUNDLER_VERSION: "2.0.1"
+  BUNDLER_VERSION: "2.0.2"
   POSTGRES_USER: "runner"
   POSTGRES_PASSWORD: ""
   RAILS_ENV: "test"

data/.rubocop_todo.yml

@@ -42,7 +42,7 @@ Metrics/AbcSize:
 # Offense count: 2
 # Configuration parameters: CountComments.
 Metrics/ClassLength:
-  Max: 266
+  Max: 300
 
 # Offense count: 6
 Metrics/CyclomaticComplexity:

data/Gemfile

@@ -4,3 +4,9 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in delorean.gemspec
 gemspec
+
+group :development, :test do
+  gem 'benchmark-ips'
+  gem 'pry'
+  gem 'rspec-instafail', require: false
+end

data/lib/delorean/engine.rb

@@ -378,7 +378,7 @@ module Delorean
         raise "bad node '#{node}'" unless node =~ /^[A-Z][a-zA-Z0-9_]*$/
 
         begin
-          klass = @m.module_eval(node)
+          klass = @m.const_get(node)
         rescue NameError
           err(UndefinedNodeError, "node #{node} is undefined")
         end
@@ -386,15 +386,17 @@ module Delorean
 
       params[:_engine] = self
 
-      type_arr = attrs.is_a?(Array)
-      attrs = [attrs] unless type_arr
+      if attrs.is_a?(Array)
+        attrs.map do |attr|
+          raise "bad attribute '#{attr}'" unless attr =~ /^[a-z][A-Za-z0-9_]*$/
 
-      res = attrs.map do |attr|
-        raise "bad attribute '#{attr}'" unless attr =~ /^[a-z][A-Za-z0-9_]*$/
+          klass.send("#{attr}#{POST}".to_sym, params)
+        end
+      else
+        raise "bad attribute '#{attrs}'" unless attrs =~ /^[a-z][A-Za-z0-9_]*$/
 
-        klass.send("#{attr}#{POST}".to_sym, params)
+        klass.send("#{attrs}#{POST}".to_sym, params)
       end
-      type_arr ? res : res[0]
     end
 
     def eval_to_hash(node, attrs, params = {})

data/lib/delorean/nodes.rb

@@ -748,9 +748,63 @@ eos
 
     def rewrite(context)
       return '{}' unless defined?(args)
+      return rewrite_with_literal(context) if can_be_literal?
+      return rewrite_with_splat_optimisation(context) if can_optimise_splat?
 
       var = "_h#{context.hcount}"
-      "(#{var}={}; " + args.rewrite(context, var) + "; #{var})"
+      "(#{var}={}; #{args.rewrite(context, var)}; #{var})"
+    end
+
+    private
+
+    def rewrite_with_literal(context)
+      "{#{args.rewrite_with_literal(context)}}"
+    end
+
+    # By default { **hash1, **hash2 } is compiled to something like
+    # `h1 = {}; h1.merge!(hash1); h1.merge!(hash2)`.
+    # In cases when hash starts with two splats, we can skip empty hash
+    # assignment and compile it to `h1 = hash1.merge(hash2)`
+    # This would work faster in ruby 2.6+
+    def rewrite_with_splat_optimisation(context)
+      var = "_h#{context.hcount}"
+      args2 = args.args_rest.al
+
+      arg1_str = args.e0.rewrite(context)
+      arg2_str = args2.e0.rewrite(context)
+
+      args_rest = args.args_rest.al.args_rest
+
+      unless defined?(args_rest.al) && !args_rest.al.text_value.empty?
+        return "(#{var} = #{arg1_str}.merge(#{arg2_str}); #{var})"
+      end
+
+      args_rest_str = args_rest.al.rewrite(context, var)
+
+      "(#{var} = #{arg1_str}.merge(#{arg2_str}); #{args_rest_str} #{var})"
+    end
+
+    def can_be_literal?
+      return false if args.conditions?
+      return false if args.splats?
+
+      true
+    end
+
+    def can_optimise_splat?
+      # First argument must be splat without condition
+      return false unless args.splat?
+      return false if args.condition?
+
+      # Second argument must be splat without condition
+      return false unless defined?(args.args_rest.al)
+
+      args_rest = args.args_rest.al
+      return false unless args_rest.text_value.present?
+      return false unless args_rest.splat?
+      return false if args_rest.condition?
+
+      true
     end
   end
 
@@ -795,16 +849,48 @@ eos
     end
 
     def rewrite(context, var)
-      res = if defined?(splat)
+      res = if splat?
               "#{var}.merge!(#{e0.rewrite(context)})"
             else
               "#{var}[#{e0.rewrite(context)}]=(#{e1.rewrite(context)})"
             end
-      res += " if (#{ifexp.e3.rewrite(context)})" if defined?(ifexp.e3)
+      res += " if (#{ifexp.e3.rewrite(context)})" if condition?
       res += ';'
       res += args_rest.al.rewrite(context, var) if
         defined?(args_rest.al) && !args_rest.al.text_value.empty?
       res
     end
+
+    def rewrite_with_literal(context)
+      res = "#{e0.rewrite(context)} => #{e1.rewrite(context)},"
+      res += args_rest.al.rewrite_with_literal(context) if
+        defined?(args_rest.al) && !args_rest.al.text_value.empty?
+
+      res
+    end
+
+    def splat?
+      defined?(splat)
+    end
+
+    def condition?
+      defined?(ifexp.e3)
+    end
+
+    def conditions?
+      return true if condition?
+      return false unless defined?(args_rest.al)
+      return false if args_rest.al.text_value.empty?
+
+      args_rest.al.conditions?
+    end
+
+    def splats?
+      return true if splat?
+      return false unless defined?(args_rest.al)
+      return false if args_rest.al.text_value.empty?
+
+      args_rest.al.splats?
+    end
   end
 end

data/lib/delorean/ruby/whitelists/default.rb

@@ -296,6 +296,14 @@ module Delorean
             method.called_on Array
           end
 
+          add_method :to_h do |method|
+            method.called_on Object
+          end
+
+          add_method :abs do |method|
+            method.called_on Numeric
+          end
+
           add_method :to_time do |method|
             (DT_TYPES + [String]).each do |type|
               method.called_on type

data/lib/delorean/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Delorean
-  VERSION = '1.1.0'
+  VERSION = '2.0.0'
 end

data/spec/eval_spec.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'benchmark/ips'
+require 'pry'
+
 describe 'Delorean' do
   let(:sset) do
     TestContainer.new(

data/spec/parse_spec.rb

@@ -780,6 +780,7 @@ describe 'Delorean' do
     engine.parse defn('A:',
                       '    a =?',
                       "    d = {'a':1, 2:2, **a, **(a+a)}",
+                      '    c = {**a, **(a+a)}',
                      )
   end
 

data/spec/perf_spec.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'benchmark/ips'
+require 'pry'
+
+describe 'Delorean' do
+  let(:sset) do
+    TestContainer.new({})
+  end
+
+  let(:engine) do
+    Delorean::Engine.new 'XXX', sset
+  end
+
+  # FIXME: perhpas add more optimization to hash compilation
+  xit 'hash splat performance as expected' do
+    perf_test = <<-DELOREAN
+    A:
+        x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+        h = [[k, k.to_s] for k in x.product(x)].to_h
+        hh = {**h, "a":1, "b":2, **h, **h, **h, "c":3}
+    DELOREAN
+
+    engine.parse perf_test.gsub(/^    /, '')
+
+    bm = Benchmark.ips do |x|
+      x.report('delorean') { engine.evaluate('A', 'hh') }
+
+      x.report('ruby') do
+        il = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+        h = il.product(il).map { |i| [i, i.to_s] }.to_h
+        h.merge('a' => 1, 'b' => 2).merge(h).merge(h).merge(h).merge('c' => 3)
+      end
+
+      x.compare!
+    end
+
+    # get iterations/sec for each report
+    h = bm.entries.each_with_object({}) do |e, hh|
+      hh[e.label] = e.stats.central_tendency
+    end
+
+    factor = h['ruby'] / h['delorean']
+
+    # p factor
+
+    expect(factor).to be < 1.10
+  end
+
+  it 'hash splat performance (2) as expected' do
+    perf_test = <<-DELOREAN
+    A:
+        h =?
+        hh = {**h, **h, **h, **h}
+    DELOREAN
+
+    engine.parse perf_test.gsub(/^    /, '')
+
+    il = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    h = il.product(il).map { |i| [i, i.to_s] }.to_h
+
+    bm = Benchmark.ips do |x|
+      x.report('delorean') { engine.evaluate('A', 'hh', 'h' => h) }
+
+      x.report('ruby') do
+        h.merge(h).merge(h).merge(h)
+      end
+
+      x.report('ruby!') do
+        hh = {}
+        4.times { hh.merge!(h) }
+      end
+
+      x.compare!
+    end
+
+    # get iterations/sec for each report
+    h = bm.entries.each_with_object({}) do |e, hh|
+      hh[e.label] = e.stats.central_tendency
+    end
+
+    factor = h['ruby!'] / h['delorean']
+    # p factor
+    expect(factor).to be_within(0.25).of(0.9)
+
+    # perf of mutable vs immutable hash ops are as expected
+    factor = h['ruby!'] / h['ruby']
+    # p factor
+    expect(factor).to be_within(0.3).of(1.0)
+
+    factor = h['ruby'] / h['delorean']
+    # p factor
+    expect(factor).to be_within(0.15).of(1.0)
+  end
+
+  it 'hash literal performance as expected' do
+    il = (1..10).to_a
+
+    hdef1 = il.map { |i| "'#{'xo' * i}' : #{i}" }.join(',')
+    hdef2 = il.map { |i| "'#{'yo' * i}' : #{i}" }.join(',')
+
+    perf_test = <<-DELOREAN
+    A:
+        v =?
+        h = { #{hdef1}, #{hdef2} }
+    DELOREAN
+
+    engine.parse perf_test.gsub(/^    /, '')
+
+    bm = Benchmark.ips do |x|
+      x.report('delorean') { engine.evaluate('A', 'h', {}) }
+
+      x.report('ruby') do
+        {
+          'xo' => 1,
+          'xoxo' => 2,
+          'xoxoxo' => 3,
+          'xoxoxoxo' => 4,
+          'xoxoxoxoxo' => 5,
+          'xoxoxoxoxoxo' => 6,
+          'xoxoxoxoxoxoxo' => 7,
+          'xoxoxoxoxoxoxoxo' => 8,
+          'xoxoxoxoxoxoxoxoxo' => 9,
+          'xoxoxoxoxoxoxoxoxoxo' => 10,
+          'yo' => 1,
+          'yoyo' => 2,
+          'yoyoyo' => 3,
+          'yoyoyoyo' => 4,
+          'yoyoyoyoyo' => 5,
+          'yoyoyoyoyoyo' => 6,
+          'yoyoyoyoyoyoyo' => 7,
+          'yoyoyoyoyoyoyoyo' => 8,
+          'yoyoyoyoyoyoyoyoyo' => 9,
+          'yoyoyoyoyoyoyoyoyoyo' => 10,
+        }
+      end
+
+      x.compare!
+    end
+
+    # get iterations/sec for each report
+    h = bm.entries.each_with_object({}) do |e, hh|
+      hh[e.label] = e.stats.central_tendency
+    end
+
+    factor = h['ruby'] / h['delorean']
+    # p factor
+
+    # FIXME: locally the factor is around 4, but in Gitlab CI it's around 7
+    # expect(factor).to be_within(2.5).of(4)
+    expect(factor).to be < 8
+  end
+
+  it 'array and node call performance as expected' do
+    perf_test = <<-DELOREAN
+    A:
+        i =? 0
+        max =?
+        range = if i>max then [] else A(i=i+1, max=max).range + [i]
+
+        res = [x*2 for x in range]
+        result = res.sum
+    DELOREAN
+
+    engine.parse perf_test.gsub(/^    /, '')
+
+    bm = Benchmark.ips do |x|
+      lim = 100
+
+      x.report('delorean') { engine.evaluate('A', 'result', 'max' => lim) }
+
+      x.report('ruby') do
+        def range(max, counter = 0)
+          counter > max ? [] : range(max, counter + 1)
+        end
+
+        r = range(lim)
+        r.map { |i| i * 2 }.sum
+      end
+
+      x.compare!
+    end
+
+    # get iterations/sec for each report
+    h = bm.entries.each_with_object({}) do |e, hh|
+      hh[e.label] = e.stats.central_tendency
+    end
+
+    factor = h['ruby'] / h['delorean']
+
+    # p factor
+
+    expect(factor).to be < 135
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: delorean_lang
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Arman Bostani
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-08 00:00:00.000000000 Z
+date: 2019-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -171,6 +171,7 @@ files:
 - spec/eval_spec.rb
 - spec/func_spec.rb
 - spec/parse_spec.rb
+- spec/perf_spec.rb
 - spec/ruby/whitelist_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/arman000/delorean_lang
@@ -192,8 +193,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.8
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: Delorean compiler
@@ -203,5 +203,6 @@ test_files:
 - spec/eval_spec.rb
 - spec/func_spec.rb
 - spec/parse_spec.rb
+- spec/perf_spec.rb
 - spec/ruby/whitelist_spec.rb
 - spec/spec_helper.rb