marty 2.3.10 → 2.3.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82cb1e811619559b239be3b6b9cfbc667f7a185b0f413624d950cc2aabd0033f
-  data.tar.gz: 632d8afa1b77da5c04d79a4c6402991d90ab1cc15496b8266236dd1444fd84a8
+  metadata.gz: e7f7e9505911744ae6176df440699f8b59620c9cd6a003347fdd152e44f08d6f
+  data.tar.gz: 75e04ea3b70b4970dd2b3062fa39847128f8e0f20ae852bd3a44ca97ca9bad40
 SHA512:
-  metadata.gz: 289e52fc9bd6e1c59d189142dd15ff30ba3a13c39c9ef4b8f7a60754cf1883dc1b8e708b958dec5b8561002ec4c0d12b3b0a22eed48620d6f43403ef4f1548ca
-  data.tar.gz: d0ad40461a84317f2cb9ab87a36e851bc1b952d87a9216094a0f812310d16c5d71c96c1b2a6a90535c1fc594a986e6791772c8740ce6fafd7f4b693ff32d5abe
+  metadata.gz: 301260304d97650534613145146e9356fa6c32cac58bcebc977c619aa8e347f024c22ab0d3c7e3717ae8c40ff7ef5aa3e2917a89e5eee84ede603ede83997631
+  data.tar.gz: 503a1bc5a0cc8eba84c02c33296ff01afe709b4872aa96e3072f07a3728d15c90fc1ba452ae9fc1826441d20bbfe559eabf7f52085987b4df9799244a5609a95

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    marty (2.3.9)
+    marty (2.3.11)
       aws-sigv4 (~> 1.0, >= 1.0.2)
       axlsx (= 3.0.0pre)
       coderay

data/app/models/marty/delorean_rule.rb

@@ -48,8 +48,9 @@ class Marty::DeloreanRule < Marty::BaseRule
     computed_guards.keys
   end
 
-  def self.comp_res_keys(results, grids, ecl, pcfg = nil)
-    defkeys = (pcfg || Marty::Config[results_cfg_var] || {}).keys
+  def self.comp_res_keys(results, grids, ecl, pcfg)
+    # FIXME in May 2019: remove this check (use as passed)
+    defkeys = pcfg.is_a?(Hash) ? pcfg.keys : pcfg
     results.keys.map {|k| k.ends_with?("_grid") ? ecl.grid_final_name(k) : k}.
        select{|k| defkeys.include?(k)} + grid_keys(grids, ecl)
   end
@@ -73,6 +74,7 @@ class Marty::DeloreanRule < Marty::BaseRule
       id, name, eclassname, computed_guards, grids, results, fixed_results =
           ruleh.values_at("id", "name", "engine", "computed_guards", "grids",
                           "results", "fixed_results")
+      raise "Error in rule '#{id}:#{name}': bad metadata_opts" if !metadata_opts
       eclass = eclassname && eclassname.constantize || Marty::RuleScriptSet
       engine = eclass.new(params["pt"]).get_engine(ruleh) if
         computed_guards.present? || results.present?
@@ -157,9 +159,7 @@ class Marty::DeloreanRule < Marty::BaseRule
       end
     end
   end
-  def self.base_compute(ruleh, params, dgparams=params)
-    base_compute2(ruleh, nil, params, dgparams)
-  end
+
   delorean_fn :route_compute, sig: 4 do
     |ruleh, pt, params, grid_names_p|
     kl = ruleh["classname"].constantize
@@ -186,8 +186,8 @@ class Marty::DeloreanRule < Marty::BaseRule
     kl.validate_grid_attrs(ruleh, gridname, addl_attrs)
   end
 
-  def base_compute(params, dgparams=params)
-    self.class.base_compute(self_as_hash, params, dgparams)
+  def base_compute2(metadata_opts, params, dgparams=params)
+    self.class.base_compute2(self_as_hash, metadata_opts, params, dgparams)
   end
 
   def self.get_matches_(pt, attrs, params)

data/lib/marty/version.rb

@@ -1,3 +1,3 @@
 module Marty
-  VERSION = "2.3.10"
+  VERSION = "2.3.11"
 end

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

@@ -51,6 +51,6 @@ class Gemini::MyRule < Marty::DeloreanRule
   end
 
   def compute(*args)
-    base_compute(*args)
+    base_compute2(*args)
   end
 end

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

@@ -44,7 +44,7 @@ class Gemini::XyzRule < Marty::DeloreanRule
   end
 
   def compute(*args)
-    base_compute(*args)
+    base_compute2(*args)
   end
   def compute_xyz(pt, xyz_param)
     # Given a set of parameters, compute the RULE adjustment.  Returns

data/spec/features/rule_spec.rb

@@ -334,6 +334,7 @@ EOL
     fill_in("Range Guard 1", with: "[100,200)")
     fill_in("Range Guard 2", with: "[30,40)")
     press("OK")
+    wait_for_ajax
     r = Gemini::XyzRule.get_matches('infinity', {}, {"g_range1"=> 150,
                                                      "g_range2"=> 35})
 

data/spec/models/rule_spec.rb

@@ -7,16 +7,9 @@ module Marty::RuleSpec
       save_clean_db(@save_file)
       marty_whodunnit
       Marty::Script.load_scripts
-      Marty::Config['RULEOPTS_MYRULE']={'simple_result'=>{},
-                                        'computed_value'=>{},
-                                        'final_value'=>{},
-                                        'grid_sum'=>{},
-                                        'c1'=>{},
-                                        'sr2'=>{},
-                                       }
-      Marty::Config['RULEOPTS_XYZ']={'bvlength'=>{},
-                                     'bv'=>{},
-                                    }
+      @ruleopts_myrule=['simple_result', 'computed_value', 'final_value',
+                        'grid_sum', 'c1', 'sr2']
+      @ruleopts_xyz=['bvlength', 'bv']
     end
     after(:all) do
       restore_clean_db(@save_file)
@@ -266,7 +259,7 @@ module Marty::RuleSpec
       let(:complex) { Gemini::MyRule.get_matches('infinity',
                                             {'rule_type'=>'ComplexRule'},
                                             {'g_string'=>'def'}).first }
-          let(:xyz) { Gemini::XyzRule.get_matches('infinity',
+      let(:xyz) { Gemini::XyzRule.get_matches('infinity',
                                               {'rule_type'=>'ZRule'},
                                               {'g_integer'=> 2}).first }
       let(:simple) {
@@ -291,8 +284,8 @@ module Marty::RuleSpec
                                    {"g_string"=>"Hi Mom",
                                     "g_integer"=>11}).first }
       it "computed guards work" do
-        c = complex.compute({"pt"=>Time.zone.now,
-                             'param2'=>'def'})
+        c = complex.compute(@ruleopts_myrule, {"pt"=>Time.zone.now,
+                                               'param2'=>'def'})
         expect(c).to eq({"cguard2"=>false})
       end
       it "returns simple results via #fixed_results" do
@@ -306,50 +299,53 @@ module Marty::RuleSpec
         expect(simple.fixed_results.count).to eq(5)
         allow_any_instance_of(Delorean::Engine).
           to receive(:evaluate).and_raise('hi mom')
-        expect{simple.compute({"pt"=>Time.now})}.to raise_error(/hi mom/)
+        expect{simple.compute(@ruleopts_myrule,
+                              {"pt"=>Time.now})}.to raise_error(/hi mom/)
         # simple2a should return results without evaluation (they are all fixed)
-        expect(simple2a.compute({"pt"=>Time.zone.now})).to eq(
+        expect(simple2a.compute(@ruleopts_myrule, {"pt"=>Time.zone.now})).to eq(
                                        {"simple_result"=>"b value",
                                         "sr2"=>true,
                                        })
         # simple2b should return grid results without evaluation
-        expect(simple2b.
-                 compute({"pt"=>Time.zone.now,
-                          'param1'=> 66,
-                          'param2'=>'abc',
-                          'paramb'=>false})).to eq({"grid1_grid_result"=>3,
-                                                    "grid2_grid_result"=>1300})
+        expect(simple2b.compute(@ruleopts_myrule,
+                                {"pt"=>Time.zone.now,
+                                 'param1'=> 66,
+                                 'param2'=>'abc',
+                                 'paramb'=>false})).
+          to eq({"grid1_grid_result"=>3,
+                 "grid2_grid_result"=>1300})
 
       end
       it "returns computed results" do
-        c = complex.compute({"pt"=>Time.zone.now,
-                             'param1'=> 66,
-                             'param2'=>'abc',
-                             'paramb'=>false})
+        c = complex.compute(@ruleopts_myrule, {"pt"=>Time.zone.now,
+                                               'param1'=> 66,
+                                               'param2'=>'abc',
+                                               'paramb'=>false})
         expect(c).to eq({"simple_result"=>"c value",
                          "computed_value"=>19, "grid1_grid_result"=>3,
                          "grid2_grid_result"=>1300})
       end
       it "returns computed results (with delorean import)" do
-        c = xyz.compute({"pt"=>Time.zone.now+1,
-                         "p1"=>12,
-                         "p2"=>3,
-                         "flavor"=>"cherry"})
+        c = xyz.compute(@ruleopts_xyz, {"pt"=>Time.zone.now+1,
+                                        "p1"=>12,
+                                        "p2"=>3,
+                                        "flavor"=>"cherry"})
         expect(c).to eq({"bvlength"=>13,"bv"=>"cherry --> 36",
                          "grid1_grid_result"=>19})
       end
       it "reports bad grid name" do
         exp = Regexp.new("Error .results. in rule '\\d+:Rule4': "\
                          "DataGridX grid not found")
-        expect{gridcomputedname.compute({"pt"=>Time.zone.now,
-                             'param1'=> 66,
-                             'param2'=>'abc',
-                             'paramb'=>false})}.to raise_error(exp)
+        expect{gridcomputedname.compute(@ruleopts_myrule,
+                                        {"pt"=>Time.zone.now,
+                                         'param1'=> 66,
+                                         'param2'=>'abc',
+                                         'paramb'=>false})}.to raise_error(exp)
       end
       it "grids embedded in result work properly and receive prior attrs" do
-        v = altgridmethod.compute({"pt"=>Time.zone.now,
-                                   'param1'=> 45,
-                                   'param2' => 1})
+        v = altgridmethod.compute(@ruleopts_myrule, {"pt"=>Time.zone.now,
+                                                     'param1'=> 45,
+                                                     'param2' => 1})
         expect(v["final_value"]).to eq(15)
       end
       it "exceptions/logging" do
@@ -363,9 +359,9 @@ module Marty::RuleSpec
                  "p1"=>12,
                  "p2"=>3,
                  "flavor"=>"cherry"}
-        v1 = r6.compute(input)
+        v1 = r6.compute(@ruleopts_xyz, input)
         begin
-          v2 = r7.compute(input)
+          v2 = r7.compute(@ruleopts_xyz, input)
         rescue Marty::DeloreanRule::ComputeError => e
           exp = 'no implicit conversion of Integer into String'
           expect(e.message).to include(exp)
@@ -379,7 +375,7 @@ module Marty::RuleSpec
           expect(e.section).to eq('results')
         end
         begin
-          v2 = r8.compute(input)
+          v2 = r8.compute(@ruleopts_xyz, input)
         rescue Marty::DeloreanRule::ComputeError => e
           exp = 'divided by 0'
           expect(e.message).to include(exp)

metadata

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