marty 1.2.3 → 1.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4869432086cbb253966cbb6dc2b723bf3e1e39fb
-  data.tar.gz: 60ed80fcbf3f7ba5c28d6d8178fd0756f3fa241d
+  metadata.gz: 7a63225a41641bfe7a573dd21373cef1746df111
+  data.tar.gz: 46359fc851683968330d72b02a5695072ea81eec
 SHA512:
-  metadata.gz: c05a246f66a03be87ee1a9ae7ba9ab45044716a12a05b9ca5268e370f23898650596ed4380989bb6a33719d3beb2576d70d3c292a9af18a4f6f2fca80bd79fa1
-  data.tar.gz: e2d7751ee36906871b524a13a9888571ab18eb35dc678d131505f84c6c559a8bbb27ac8cf8881b675f61af220b665d7b2d863e56d6e8b35643c56305f8114bc5
+  metadata.gz: 456016ef7f36a7474dcf5ce564b5616c2616525701db782a6f6582e9e3d638627b41c027838c603c89bec34f723ccac9b7cc94a6e59768a8c24b762d62efa27a
+  data.tar.gz: d1ba3c2c1366c034d76629ab4643a85ffd11d2d06400111fb30f33cf974a9b6ff6c8d43a55dda9bee7a964fd3a684c4e33b1aa14c50aeac477e745d1597c0ba4

data/app/models/marty/delorean_rule.rb

@@ -11,13 +11,16 @@ class Marty::DeloreanRule < Marty::BaseRule
     if computed_guards.present? || results.present?
       begin
         eclass = engine && engine.constantize || Marty::RuleScriptSet
-        eng = eclass.new('infinity').get_engine(self)
+        eng = eclass.new('infinity').get_engine(self_as_hash)
       rescue => e
         return errors[:computed] = "- " + e.message
       end
     end
   end
 
+  def self_as_hash
+    self.as_json + {"classname"=>self.class.name}
+  end
   def self.find_fixed(results)
     results.each_with_object({}) do |(k, v), h|
       v_wo_comment = /\A([^#]+)/.match(v)[1] if v.include?("#")
@@ -41,36 +44,40 @@ class Marty::DeloreanRule < Marty::BaseRule
     "NOT DEFINED"
   end
 
-  def compg_keys
+  def self.compg_keys(computed_guards)
     computed_guards.keys
   end
 
-  def comp_res_keys(ecl)
-    defkeys = (Marty::Config[self.class.results_cfg_var] || {}).keys
+  def self.comp_res_keys(results, grids, ecl)
+    defkeys = (Marty::Config[results_cfg_var] || {}).keys
     results.keys.map {|k| k.ends_with?("_grid") ? ecl.grid_final_name(k) : k}.
-       select{|k| defkeys.include?(k)} + grid_keys(ecl)
+       select{|k| defkeys.include?(k)} + grid_keys(grids, ecl)
   end
-  def grid_keys(eclass)
+  def self.grid_keys(grids, eclass)
       grids.keys.map{|k| eclass.grid_final_name(k) }
   end
-  def base_compute(params, dgparams=params)
+  def self.base_compute(ruleh, params, dgparams=params)
+    id, name, engine, computed_guards, grids, results, fixed_results =
+        ruleh.values_at("id", "name", "engine", "computed_guards", "grids",
+                        "results", "fixed_results")
     eclass = engine && engine.constantize || Marty::RuleScriptSet
-    engine = eclass.new(params["pt"]).get_engine(self) if
+    engine = eclass.new(params["pt"]).get_engine(ruleh) if
       computed_guards.present? || results.present?
 
     if computed_guards.present?
       begin
         res = engine.evaluate(eclass.node_name,
-                              compg_keys,
+                              compg_keys(computed_guards),
                               params.clone)
       rescue => e
         raise e, "Error (guard) in rule '#{id}:#{name}': #{e}", e.backtrace
       end
-      return Hash[compg_keys.zip(res).select{|k,v| !v}] unless res.all?
+      return Hash[compg_keys(computed_guards).zip(res).select{|k,v| !v}] unless
+        res.all?
     end
     grids_computed = false
     grid_results = {}
-    crkeys = comp_res_keys(eclass)
+    crkeys = comp_res_keys(results, grids, eclass)
     if (results.keys - fixed_results.keys).present?
         begin
           eval_result = engine.evaluate(
@@ -100,6 +107,14 @@ class Marty::DeloreanRule < Marty::BaseRule
     end
     result + grid_results
   end
+  delorean_fn :route_compute, sig: 4 do
+    |ruleh, pt, params, grid_names_p|
+    kl = ruleh["classname"].constantize
+    kl.compute(ruleh, pt, params, grid_names_p)
+  end
+  def base_compute(params, dgparams=params)
+    self.class.base_compute(self_as_hash, params, dgparams)
+  end
 
   def self.get_matches_(pt, attrs, params)
     q = super(pt, attrs.except("rule_dt"), params)

data/lib/marty/data_exporter.rb

@@ -72,7 +72,7 @@ class Marty::DataExporter
         csv << x.map { |v|
           case v
           when Array, Hash
-            readable ? v.to_s : encode_json(v.to_json)
+            readable ? v.to_json : encode_json(v.to_json)
           when nil
             nil
           else

data/lib/marty/rule_script_set.rb

@@ -72,25 +72,27 @@ class Marty::RuleScriptSet < Delorean::AbstractContainer
     newh.map { |k, v| write_attr(k, v) }.join("\n") + "\n"
   end
 
-  def grid_code(rule)
+  def grid_code(ruleh)
     dgcache = {}
     h = {}
-    rule.grids.each do |k, v|
-      expand_grid_code(h, k.ends_with?('_grid')?k:k+'_grid', %Q("#{v}"), dgcache, {})
+    ruleh["grids"].each do |k, v|
+      expand_grid_code(h, k.ends_with?('_grid')?k:k+'_grid', %Q("#{v}"),
+                                                dgcache, {})
     end
     h.map { |k, v| write_attr(k, v) }.join("\n") + "\n"
   end
 
-  def guard_code(rule)
-    write_code(rule.computed_guards)
+  def guard_code(ruleh)
+    write_code(ruleh["computed_guards"])
   end
 
-  def result_code(rule)
-    write_code(rule.results)
+  def result_code(ruleh)
+    write_code(ruleh["results"])
   end
 
-  def grid_init(rule)
-    if rule.grids.present? || rule.results.keys.any?{|k|k.ends_with?("_grid")}
+  def grid_init(ruleh)
+    if ruleh["grids"].present? ||
+       ruleh["results"].keys.any?{|k|k.ends_with?("_grid")}
       write_code({ "pt" => :parameter,
                    "dgparams__" => :parameter,
                  })
@@ -98,18 +100,18 @@ class Marty::RuleScriptSet < Delorean::AbstractContainer
       ''
     end
   end
-  def get_code(rule)
-    grid_i = grid_init(rule)
-    grid_c = grid_code(rule)
-    result_c = result_code(rule)
-    guard_c = guard_code(rule)
+  def get_code(ruleh)
+    grid_i = grid_init(ruleh)
+    grid_c = grid_code(ruleh)
+    result_c = result_code(ruleh)
+    guard_c = guard_code(ruleh)
 
     code = self.class.body_start + self.class.indent(grid_i +
                                                      guard_c +
                                                      grid_c +
                                                      result_c)
     #puts '='*40
-    #puts rule.name
+    #puts ruleh["name"]
     #puts '-'
     #puts code
     #puts '-'*10
@@ -117,17 +119,17 @@ class Marty::RuleScriptSet < Delorean::AbstractContainer
     code
   end
 
-  def code_section_counts(rule)
+  def code_section_counts(ruleh)
     errs = {}
-    errs[:grid_params] = grid_init(rule).count("\n")
-    errs[:computed_guards] = guard_code(rule).count("\n")
-    errs[:grids] = grid_code(rule).count("\n")
-    errs[:results] = result_code(rule).count("\n")
+    errs[:grid_params] = grid_init(ruleh).count("\n")
+    errs[:computed_guards] = guard_code(ruleh).count("\n")
+    errs[:grids] = grid_code(ruleh).count("\n")
+    errs[:results] = result_code(ruleh).count("\n")
     errs
   end
-  def get_parse_error_field(rule, exc)
+  def get_parse_error_field(ruleh, exc)
     line = exc.line ? exc.line - self.class.body_lines : 0
-    errs = code_section_counts(rule)
+    errs = code_section_counts(ruleh)
     line_count = 0
     errs.each do |k,v|
       line_count += v
@@ -136,24 +138,24 @@ class Marty::RuleScriptSet < Delorean::AbstractContainer
     errs.keys.last
   end
 
-  def get_engine(rule)
+  def get_engine(ruleh)
     begin
       # if rule is a str => importing a regular Script (i.e. not rule)
-      return sset.get_engine(rule) if rule.is_a? String
+      return sset.get_engine(ruleh) if ruleh.is_a? String
 
       # on create rule doesn't have an id => don't cache
-      return sset.parse_check("New RULE #{rule.name}", get_code(rule)) unless
-        rule.id
+      return sset.parse_check("New RULE #{ruleh['name']}", get_code(ruleh)) unless
+        ruleh["id"]
 
-      rule_pfx = rule.class.name.demodulize
+      rule_pfx = ruleh["classname"].demodulize
 
       # unique name for specific version of rule
-      sname = "#{rule_pfx}_#{rule.group_id}_#{rule.created_dt.to_f}"
+      sname = "#{rule_pfx}_#{ruleh['group_id']}_#{ruleh['created_dt'].to_f}"
 
       # is it a dev posting?
       if Mcfly.is_infinity(pt)
-        max_dt = rule.class.
-                 order("created_dt DESC").limit(1).pluck(:created_dt).first
+        max_dt = ruleh["classname"].constantize.order("created_dt DESC").
+                 limit(1).pluck(:created_dt).first
 
         @@dengines_dt ||= max_dt
 
@@ -164,17 +166,17 @@ class Marty::RuleScriptSet < Delorean::AbstractContainer
 
         return engine if engine
 
-        @@dengines[sname] = sset.parse_check(sname, get_code(rule))
+        @@dengines[sname] = sset.parse_check(sname, get_code(ruleh))
       else
         engine = @@engines[[pt, sname]]
 
         return engine if engine
 
-        @@engines[[pt, sname]] = sset.parse_check(sname, get_code(rule))
+        @@engines[[pt, sname]] = sset.parse_check(sname, get_code(ruleh))
       end
     rescue Delorean::ParseError => e
-      f = get_parse_error_field(rule, e)
-      raise "Error in rule '#{rule.name}' field '#{f}': #{e}"
+      f = get_parse_error_field(ruleh, e)
+      raise "Error in rule '#{ruleh['name']}' field '#{f}': #{e}"
     end
   end
 

data/lib/marty/version.rb

@@ -1,3 +1,3 @@
 module Marty
-  VERSION = "1.2.3"
+  VERSION = "1.2.4"
 end

data/spec/dummy/app/models/gemini/xyz_rule.rb

@@ -53,7 +53,7 @@ class Gemini::XyzRule < Marty::DeloreanRule
     return {} unless xyz_keys.present?
 
     eclass = engine && engine.constantize || Marty::RuleScriptSet
-    engine = eclass.new(pt).get_engine(self)
+    engine = eclass.new(pt).get_engine(self_as_hash)
     res = engine.evaluate("XyzNode", xyz_keys, {"xyz_param"=>xyz_param})
 
     res.all?

data/spec/dummy/lib/gemini/xyz_rule_script_set.rb

@@ -5,18 +5,18 @@ class Gemini::XyzRuleScriptSet < Marty::RuleScriptSet
   def self.body_start
     "import BaseCode\n#{node_name}: BaseCode::BaseCode\n"
   end
-  def xyz_code(rule)
-    write_code(rule.computed_guards.select{|k,_|k.starts_with?("xyz_")})
+  def xyz_code(ruleh)
+    write_code(ruleh["computed_guards"].select{|k,_|k.starts_with?("xyz_")})
   end
-  def guard_code(rule)
-    write_code(rule.computed_guards.reject{|k,_|k.starts_with?("xyz_")})
+  def guard_code(ruleh)
+    write_code(ruleh["computed_guards"].reject{|k,_|k.starts_with?("xyz_")})
   end
-  def get_code(rule)
-    x = xyz_code(rule)
+  def get_code(ruleh)
+    x = xyz_code(ruleh)
     super + (x.blank? ? '' :
       "XyzNode:\n    xyz_param =? nil\n" + self.class.indent(x))
   end
-  def code_section_counts(rule)
-    super + { xyz: xyz_code(rule).count("\n") }
+  def code_section_counts(ruleh)
+    super + { xyz: xyz_code(ruleh).count("\n") }
   end
 end

data/spec/models/rule_spec.rb

@@ -5,6 +5,7 @@ module Marty::RuleSpec
     before(:all) do
       @save_file = "/tmp/save_#{Process.pid}.psql"
       save_clean_db(@save_file)
+      marty_whodunnit
       Marty::Script.load_scripts
       Marty::Config['RULEOPTS_MYRULE']={'simple_result'=>{},
                                         'computed_value'=>{},
@@ -19,7 +20,6 @@ module Marty::RuleSpec
       restore_clean_db(@save_file)
     end
     before(:each) do
-      marty_whodunnit
       dt = DateTime.parse('2017-1-1')
       p = File.expand_path('../../fixtures/csv/rule', __FILE__)
       [Marty::DataGrid, Gemini::XyzRule, Gemini::MyRule].each do |klass|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: marty
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 1.2.4
 platform: ruby
 authors:
 - Arman Bostani
@@ -14,7 +14,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-06 00:00:00.000000000 Z
+date: 2018-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg