marty 2.0.2 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: '08f9abbd9c473713331bb0ade7453ac85f1c4842'
-  data.tar.gz: d0251f02426640781822b048f6203f0597f73227
+  metadata.gz: da7cae1ae6b567cbf3f8674cea6376869f6c81f8
+  data.tar.gz: 5eede83f082569ef70cba547e2a654b1697b95c5
 SHA512:
-  metadata.gz: 2cab552bb2a885d177007686a476e57a28a72ab02af0ce904b0e81c0dde0dd63ed0ce773399000ea3283ee618023909259618e5e1e95e6547372ca31cefb2077
-  data.tar.gz: f39020a718bcb428a4c3171c6e21c0973b6b5bb3f8efb02bbc7237f4f386606e5c321cadaaea77ed375f39f2b07dfc239f8b55ad849d6be08591a2408c1626ac
+  metadata.gz: 5611d1364fd1ecea6dc10c7c90d27c57bfdc7e4b27949ac5811fc3e709546a2aae03063afb786418bef2b28d82da14af50ea869143b1bc29a69e2262ab305dff
+  data.tar.gz: 235f9cd65d8e63075fbe546b70f796293fda42f332090e5acf16436ab90a2d4b059d40ce2d34051ca141667ecfe85f9221f5de8c21b073a28c328c96df7b1dee

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    marty (2.0.1)
+    marty (2.0.3)
       axlsx (= 3.0.0pre)
       coderay
       delorean_lang (~> 0.3.37)

data/app/models/marty/api_auth.rb

@@ -9,15 +9,11 @@ class Marty::ApiAuth < Marty::Base
 
   class ApiAuthValidator < ActiveModel::Validator
     def validate(api)
-      api.errors.add(
-        :base,
-        "API Key length must be #{KEY_SIZE*2}") if
+      api.errors.add(:base, "API Key length must be #{KEY_SIZE*2}") if
         api.api_key && api.api_key.length != KEY_SIZE*2
 
-        api.errors.add(
-          :base,
-          "Script Name must reference a valid script") if
-        Marty::Script.find_script(api.script_name, nil).nil?
+      api.errors.add(:base, "Script Name must reference a valid script") unless
+        Marty::Script.find_script(api.script_name, nil)
     end
   end
 
@@ -41,5 +37,4 @@ class Marty::ApiAuth < Marty::Base
                          script_name: script_name,
                          obsoleted_dt: 'infinity').pluck(:app_name).first
   end
-
 end

data/app/models/marty/base.rb

@@ -25,18 +25,16 @@ class Marty::Base < ActiveRecord::Base
   class << self
     attr_accessor :struct_attrs
   end
+
   def self.get_struct_attrs
-    self.struct_attrs ||= self.attribute_names -
-                   ["id", "group_id", "created_dt", "obsoleted_dt", "user_id",
-                    "o_user_id"] -
-                   (self.const_defined?('MCFLY_UNIQUENESS') &&
-                    self.const_get('MCFLY_UNIQUENESS') || []).map(&:to_s)
+    self.struct_attrs ||=
+      self.attribute_names - Mcfly::COLUMNS.to_a -
+      (self.const_defined?('MCFLY_UNIQUENESS') &&
+       self.const_get('MCFLY_UNIQUENESS') || []).map(&:to_s)
   end
 
-  def self.get_final_attrs(opts)
-    return [] if opts["no_convert"] == true
-    include_attrs = [opts["include_attrs"] || []].flatten
-    final_attrs = get_struct_attrs + include_attrs
+  def self.get_final_attrs
+    final_attrs = get_struct_attrs
     return final_attrs if final_attrs.present?
 
     # otherwise raise with error line
@@ -58,20 +56,19 @@ class Marty::Base < ActiveRecord::Base
     # end
   end
 
-  def self.make_openstruct(inst, opts={})
+  def self.make_hash(inst)
+    fa = get_final_attrs
+    inst.attributes.slice(*fa)
+  end
+
+  def self.make_openstruct(inst)
     return nil unless inst
-    return inst if opts["no_convert"] == true
-    fa = opts["fa"] || get_final_attrs(opts)
+    fa = get_final_attrs
     os = OpenStruct.new(inst.attributes.slice(*fa))
-    (opts['link_attrs'] || []).each do |col, attr|
-      os[col] ||= OpenStruct.new
-      attrs = [attr].flatten
-      attrs.map { |attr| os[col][attr] = inst.send(col).try(attr) }
-    end
     if self == Marty::DataGrid
       def os.lookup_grid_distinct_entry(pt, params)
-        dgh = self.to_h.stringify_keys.slice("id","group_id","created_dt",
-                                             "metadata", "data_type")
+        dgh = self.to_h.stringify_keys.slice(
+          "id", "group_id", "created_dt", "metadata", "data_type")
         Marty::DataGrid.lookup_grid_distinct_entry_h(pt, params, dgh)
       end
     end

data/app/models/marty/posting.rb

@@ -49,10 +49,10 @@ class Marty::Posting < Marty::Base
   # may allow deletion of postings.  i.e. a new one with same name
   # might be created.  Or, use regular validates_uniqueness_of instead
   # of mcfly_validates_uniqueness_of.
-  delorean_fn :lookup, sig: [1, 2] do
-    |name, opts={}|
+  delorean_fn :lookup, sig: 1 do
+    |name|
     p = select(get_struct_attrs).find_by_name(name)
-    make_openstruct(p, opts)
+    make_openstruct(p)
   end
 
   delorean_fn :lookup_dt, sig: 1 do

data/app/models/marty/script.rb

@@ -12,10 +12,10 @@ class Marty::Script < Marty::Base
 
   gen_mcfly_lookup :lookup, [:name], cache: true
 
-  # find script by name/tag
+  # find script by name/tag (not cached)
   def self.find_script(sname, tag=nil)
     tag = Marty::Tag.map_to_tag(tag)
-    Marty::Script.lookup(tag.created_dt, sname, {"no_convert"=>true})
+    Marty::Script.mcfly_pt(tag.created_dt).find_by(name: sname)
   end
 
   def find_tag
@@ -32,7 +32,7 @@ class Marty::Script < Marty::Base
   end
 
   def self.load_a_script(sname, body, dt=nil)
-    s = Marty::Script.lookup('infinity', sname, {"no_convert"=>true})
+    s = Marty::Script.find_by(obsoleted_dt: 'infinity', name: sname)
 
     if !s
       s = Marty::Script.new

data/app/models/marty/tag.rb

@@ -42,7 +42,6 @@ class Marty::Tag < Marty::Base
   def self.map_to_tag(tag_id)
     # FIXME: this is really hacky. This function should not take so
     # many different types of arguments.
-    nc = {"no_convert"=>true}
     case tag_id
     when Integer, /\A[0-9]+\z/
       tag = find_by_id(tag_id)
@@ -51,9 +50,9 @@ class Marty::Tag < Marty::Base
       # if tag name wasn't found, look for a matching
       # posting, then find the tag whose created_dt <= posting dt.
       if !tag
-        posting = Marty::Posting.lookup(tag_id, nc)
-        tag = find_match(Mcfly.normalize_infinity(posting['created_dt'])) if
-          posting
+        cdt = Marty::Posting.where(name: tag_id).pluck('created_dt').first
+
+        tag = find_match(Mcfly.normalize_infinity(cdt)) if cdt
       end
     when nil
       tag = get_latest1

data/lib/marty/mcfly_model.rb

@@ -55,23 +55,10 @@ module Mcfly::Model
     def base_mcfly_lookup(meth, name, options = {}, &block)
 
       priv = options[:private]
-      sig = priv ? -1 : options[:sig]
 
-      # add an extra argument to the sig to receive the openstruct conversion
-      # options hash (unless private)
-      newsig = sig.is_a?(Array) ? [sig[0], sig[1]+1] :
-                 sig == -1 ? sig : [sig, sig+1]
-      options[:sig] = newsig
-
-      send(meth, name, options) do |ts, *pargs|
+      send(meth, name, options) do |ts, *args|
         raise "time cannot be nil" if ts.nil?
 
-        # get the options hash if method is not private and last arg is a hash
-        # and pargs len = max sig (-1 because ts is separated in the arg list)
-        args, opts = !priv && pargs.last.is_a?(Hash) &&
-                     pargs.length == newsig[1]-1 ? [pargs[0..-2], pargs.last] :
-                       [pargs, {}]
-
         ts = Mcfly.normalize_infinity(ts)
 
         q = self.where("#{table_name}.obsoleted_dt >= ? AND " +
@@ -80,19 +67,17 @@ module Mcfly::Model
         end
         next q if priv
 
-        fa = get_final_attrs(opts)
-        opts += {"fa"=>fa}
+        fa = get_final_attrs
         q = q.select(*fa) if fa.present? && q.is_a?(ActiveRecord::Relation)
 
         case
-        when opts["no_convert"] == true
-          q
         when q.is_a?(ActiveRecord::Relation)
-          # shouldn't happen - lookups that are mode nil should be private
-          # raise "#{self}.#{name} can't convert ActiveRecord::Relation to OpenStruct"
+          # shouldn't happen - lookups that are mode nil should be
+          # private raise "#{self}.#{name} can't convert
+          # ActiveRecord::Relation to OpenStruct"
           q
         when q.is_a?(ActiveRecord::Base)
-          make_openstruct(q, opts)
+          make_openstruct(q)
         else
           q
         end
@@ -102,12 +87,11 @@ module Mcfly::Model
     def cached_mcfly_lookup(name, options = {}, &block)
       base_mcfly_lookup(:cached_delorean_fn, name, options, &block)
     end
+
     def mcfly_lookup(name, options = {}, &block)
       base_mcfly_lookup(:delorean_fn, name, options, &block)
     end
 
-    # FIXME: add private mode.  This should make the function
-    # unavailable to delorean.
     def gen_mcfly_lookup(name, attrs, options={})
       raise "bad options #{options.keys}" unless
         (options.keys - [:mode, :cache, :private]).empty?

data/lib/marty/version.rb

@@ -1,3 +1,3 @@
 module Marty
-  VERSION = "2.0.2"
+  VERSION = "2.0.3"
 end

data/lib/pyxll/README.txt

@@ -8,10 +8,12 @@ PyXLL - Gemini interface
 * Install PyXLL package from Canopy
 
 * Install gemini.py and pyxll.cfg in the canopy pyxll/ folder.
-  Usually installs at:
+  Usually installs at. [OLD STEP -- this should not be needed now]
 
   c:/Users/<usr>/AppData/Local/Enthought/Canopy32/User/Lib/site-packages/pyxll/
 
+* pip install requests
+
 * Should be able to see the addAdd-Ins tab in Excel and it should
   include the PyXLL menu.
 

data/spec/controllers/rpc_import_spec.rb

@@ -20,7 +20,7 @@ describe Marty::RpcController do
 
 
     # create an untagged version for DEV
-    s = Marty::Script.lookup('infinity', "A", {"no_convert"=>true})
+    s = Marty::Script.find_by(obsoleted_dt: 'infinity', name: "A")
     s.body = "A:\n    a = 3\n"
     s.save!
   }

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

@@ -90,7 +90,5 @@ module Gemini
       where(entity_id: e_id, bud_category_id: bc_id).
         order(:settlement_mm)
     end
-
-
   end
 end

data/spec/features/rule_spec.rb

@@ -117,21 +117,21 @@ feature 'rule view', js: true do
                                             "results"=>"",
                                            })
 
-    r = Gemini::MyRule.lookup('infinity','abc', {"no_convert"=>true})
+    r = Gemini::MyRule.find_by(obsoleted_dt: 'infinity', name: 'abc')
     expect(r.attributes).to include({"user_id"=>1,
-                                  "o_user_id"=>nil,
-                                  "name"=>"abc",
-                                  "engine"=>"Gemini::MyRuleScriptSet",
-                                  "rule_type"=>"SimpleRule",
-                                  "simple_guards"=>{"g_bool"=>false,
-                                                    "g_bool_def"=>false,
-                                                    "g_nbool_def"=>false,
-                                                    "g_has_default"=>
-                                                    "string default"},
-                                  "computed_guards"=>{},
-                                  "grids"=>{},
-                                  "results"=>{},
-                                  })
+                                     "o_user_id"=>nil,
+                                     "name"=>"abc",
+                                     "engine"=>"Gemini::MyRuleScriptSet",
+                                     "rule_type"=>"SimpleRule",
+                                     "simple_guards"=>{"g_bool"=>false,
+                                                       "g_bool_def"=>false,
+                                                       "g_nbool_def"=>false,
+                                                       "g_has_default"=>
+                                                       "string default"},
+                                     "computed_guards"=>{},
+                                     "grids"=>{},
+                                     "results"=>{},
+                                    })
     # type validation (string with values list)
     mrv.select_row(1)
     press("Edit")
@@ -240,8 +240,8 @@ feature 'rule view', js: true do
     fill_in("Range Guard 2", with: "[30,40)")
     press("OK")
     r = Gemini::XyzRule.get_matches('infinity', {}, {"g_range1"=> 150,
-                                                     "g_range2"=> 35},
-                                    {"no_convert"=>true})
+                                                     "g_range2"=> 35})
+
     expect(r.to_a.count).to eq(1)
     exp = {"user_id"=>1,
            "o_user_id"=>nil,

data/spec/features/scripting_spec.rb

@@ -54,7 +54,7 @@ feature 'under Applications menu, Scripting workflows', js: true do
 
       # create 3 additional tags and modify A5 in the process
       (1..3).each { |i|
-        body = Marty::Script.find_script("A5").body
+        body = Marty::Script.find_by(name: "A5").body
 
         Marty::Script.
           load_script_bodies({

data/spec/features/scripting_test_spec.rb

@@ -54,7 +54,7 @@ DELOREAN
                            }, Date.today)
 
       # add a DEV version of M1.
-      s = Marty::Script.lookup('infinity', "M1", {"no_convert"=>true})
+      s = Marty::Script.find_by(obsoleted_dt: 'infinity', name: "M1")
       s.body = sample_script.gsub(/A/, "AA") + '    e =? "hello"'
       s.save!
     }

data/spec/lib/mcfly_model_spec.rb

@@ -35,43 +35,32 @@ A:
     pt        =?
     entity    =?
     note_rate =?
+    e_id      =?
+    bc_id     =?
 
-    extra = {"include_attrs": ["settlement_mm", "settlement_yy"],
-             "link_attrs": {"entity": "name",
-                            "bud_category": "name"}}
-    ex2 = {"include_attrs": ["settlement_mm", "settlement_yy", "entity_id",
-                             "bud_category_id"]}
+    lookup   = Gemini::FannieBup.lookup(  pt, entity, note_rate)
+    clookup  = Gemini::FannieBup.clookup( pt, entity, note_rate)
 
-    lookup            = Gemini::FannieBup.lookup(  pt, entity, note_rate)
-    lookup_extra      = Gemini::FannieBup.lookup(  pt, entity, note_rate, extra)
+    lookupn  = Gemini::FannieBup.lookupn( pt, entity, note_rate)
 
-    clookup     = Gemini::FannieBup.clookup( pt, entity, note_rate)
-
-    lookupn            = Gemini::FannieBup.lookupn( pt, entity, note_rate)
-    lookupn_extra      = Gemini::FannieBup.lookupn(  pt, entity, note_rate, ex2)
-
-    clookupn    = Gemini::FannieBup.clookupn(pt, entity, note_rate)
-
-    a_func = Gemini::FannieBup.a_func('infinity', 1, 2)
-    a_func_extra = Gemini::FannieBup.a_func('infinity', 1, 2, ex2)
-    b_func = Gemini::FannieBup.b_func('infinity',1, 2, 12)
-    b_func_extra = Gemini::FannieBup.b_func('infinity',1, 2, 12, extra)
-    ca_func = Gemini::FannieBup.ca_func('infinity',1, 2, ex2)
+    clookupn = Gemini::FannieBup.clookupn(pt, entity, note_rate)
 
+    a_func = Gemini::FannieBup.a_func('infinity', e_id, bc_id)
+    b_func = Gemini::FannieBup.b_func('infinity', e_id, bc_id, 12)
 EOF
 errscript =<<EOF
 Err:
     pt        =?
     entity    =?
     note_rate =?
-    result = Gemini::FannieBup.%s(pt, entity, note_rate)
+    result = Gemini::FannieBup.%s(pt, entity, note_rate, 1)
 EOF
 errscript2 =<<EOF
 Err:
     pt    =?
     e_id  =?
     bc_id =?
-    result = Gemini::FannieBup.%s(pt, e_id, bc_id)
+    result = Gemini::FannieBup.%s(pt, e_id, bc_id, nil)
 EOF
 errscript3 =<<EOF
 Err:
@@ -79,7 +68,7 @@ Err:
     e_id  =?
     bc_id =?
     mm    =?
-    result = Gemini::FannieBup.%s(pt, e_id, bc_id, mm)
+    result = Gemini::FannieBup.%s(pt, e_id, bc_id, mm, {})
 EOF
 
   describe 'McflyModel' do
@@ -131,84 +120,32 @@ EOF
     end
 
     it "lookup non generated" do
-      # a1-a3 will be AR Relations
-      # b1-b2 will be OpenStructs because the b fns return #first
-      a1 = @engine.evaluate("A", "a_func", {})
-      a2 = @engine.evaluate("A", "ca_func", {})
-      a3 = @engine.evaluate("A", "a_func_extra", {})
-      b1 = @engine.evaluate("A", "b_func", {})
-      b2 = @engine.evaluate("A", "b_func_extra", {})
+      # a1 will be AR Relations
+      # b1 will be OpenStructs because the b fns return #first
+      e_id = Gemini::Entity.where(name: "PLS").first.id
+      bc_id = Gemini::BudCategory.where(name: "Conv Fixed 20").first.id
+      p = {"e_id"=>e_id, "bc_id"=>bc_id}
+      a1 = @engine.evaluate("A", "a_func", p)
+      b1 = @engine.evaluate("A", "b_func", p)
 
       # all return relations
       expect(ActiveRecord::Relation === a1).to be_truthy
-      expect(ActiveRecord::Relation === a2).to be_truthy
-      expect(ActiveRecord::Relation === a3).to be_truthy
       expect(ActiveRecord::Base === a1.first).to be_truthy
-      expect(ActiveRecord::Base === a2.first).to be_truthy
-      expect(ActiveRecord::Base === a3.first).to be_truthy
 
       expect(a1.to_a.count).to eq(2)
-      expect(a2.to_a.count).to eq(2)
-      expect(a3.to_a.count).to eq(2)
 
       # a1 lookup did not include extra attrs
       expect(a1.first.attributes.keys.to_set).to eq(Set["id", "buy_up", "buy_down"])
 
-      # a2 and a3 did
-      s = Set["id", "entity_id", "bud_category_id",  "buy_up", "buy_down",
-              "settlement_mm", "settlement_yy"]
-      expect(a2.first.attributes.keys.to_set).to eq(s)
-      expect(a3.first.attributes.keys.to_set).to eq(s)
-
       # a1 is AR but still missing the FK entity_id so will raise
       expect{a1.first.entity}.to raise_error(/missing attribute: entity_id/)
 
-      # a3 included those so can access them
-      expect(a3.first.entity.name).to eq('PLS')
-      expect(a3.first.bud_category.name).to eq('Conv Fixed 20')
-
       expect(b1.class).to eq(OpenStruct)
-      expect(b2.class).to eq(OpenStruct)
 
-      # make sure b1-b2 have correct keys and extra stuff
+      # make sure b1 has correct keys
       expect(b1.to_h.keys.to_set).to eq(Set[:buy_up, :buy_down])
-      expect(b2.to_h.keys.to_set).to eq(
-               Set[:buy_up, :buy_down, :settlement_mm, :settlement_yy,
-                :entity, :bud_category])
-      expect(b2.entity.name).to eq('PLS')
-      expect(b2.bud_category.name).to eq('Conv Fixed 20')
     end
-    it "lookup extra values" do
-      a2 = @engine.evaluate("A", "lookup_extra", params)
-      expect(a2.class).to eq(OpenStruct)
 
-      # check that extra values are there
-      expect(a2.to_h.keys.to_set).to eq(Set[:buy_up, :buy_down, :settlement_mm,
-                                            :settlement_yy, :entity,
-                                            :bud_category])
-      # check that linked values are there
-      expect(a2.entity.name).to eq("PLS")
-      expect(a2.bud_category.name).to eq("Conv Fixed 20")
-    end
-    it "lookup mode nil extra values" do
-      all = @engine.evaluate("A", "lookupn_extra", params)
-
-      # mode nil always returns AR
-      expect(ActiveRecord::Relation === all).to be_truthy
-
-      # check keys returned
-      all.each do |a2|
-        expect(a2.attributes.keys.to_set).to eq(
-                       Set["id", "buy_up", "buy_down", "settlement_mm",
-                           "settlement_yy", "entity_id", "bud_category_id"])
-        if a2.entity_id
-          expect(a2.entity.name).to eq("PLS")
-          expect(ActiveRecord::Base === a2.entity).to be_truthy
-          expect(a2.bud_category.name).to eq("Conv Fixed 20")
-          expect(ActiveRecord::Base === a2.bud_category).to be_truthy
-        end
-      end
-    end
     it "lookup mode nil" do
       # make sure ARs are returned
       a1 = @engine.evaluate("A", "lookupn", params)
@@ -217,16 +154,21 @@ EOF
       expect(ActiveRecord::Relation === a1).to be_truthy
       expect(a1.to_a.count).to eq(4)
     end
+
     it "private methods can't be called by delorean" do
       # generated methods
       aggregate_failures "errors" do
         @errs.in_groups_of(2) do |name, fn|
           err = /Too many args to #{fn}/
-          expect{Marty::ScriptSet.new.get_engine(name)}.to raise_error(
-                                                   Delorean::BadCallError, err)
+
+          expect{
+            Marty::ScriptSet.new.get_engine(name)
+          }.to raise_error(Delorean::BadCallError, err)
         end
       end
+    end
 
+    it "private methods can't be called by delorean (2)" do
       # non-generated
       aggregate_failures "errors" do
         ['E5', 'a_func_p', 'E6', 'b_func_p'].in_groups_of(2) do |scr, fn|
@@ -236,6 +178,7 @@ EOF
         end
       end
     end
+
     it "caching times" do
       ts = DateTime.now
       x=Benchmark.measure { 10000.times {
@@ -244,7 +187,7 @@ EOF
                           }
       }
       y=Benchmark.measure { 10000.times {
-                            Gemini::FannieBup.ca_func(ts, 
+                            Gemini::FannieBup.ca_func(ts,
                                                      1, 2)
                           }
       }

data/spec/models/api_auth_spec.rb

@@ -50,7 +50,7 @@ module Marty
 
       it "should allow a tagged script version to be associated when a DEV " +
         "version of that script also exists" do
-        s = Marty::Script.lookup('infinity', 'Script1', {"no_convert"=>true})
+        s = Marty::Script.find_by(obsoleted_dt: 'infinity', name: 'Script1')
         s.body = "A:\n    a = 3\n"
         s.save!
 

data/spec/models/data_grid_spec.rb

@@ -197,19 +197,6 @@ EOS
     end
 
     describe "validations" do
-      it "a basic data grid should load ok" do
-        dg_from_import("G1", G1)
-        dg_from_import("G2", G2)
-        dg_from_import("G3", G3)
-        dg_from_import("G8", G8)
-        dg_from_import("Ga", Ga)
-
-        inc = {"include_attrs"=>"name"}
-        expect(Marty::DataGrid.lookup('infinity', "G1", inc).name).to eq "G1"
-        expect(Marty::DataGrid.lookup('infinity', "G2", inc).name).to eq "G2"
-        expect(Marty::DataGrid.lookup('infinity', "G3", inc).name).to eq "G3"
-      end
-
       it "should not allow bad axis types" do
         expect {
           dg_from_import("Gi", Gi)
@@ -416,7 +403,7 @@ EOS
           expect(res).to eq [5.6,"G2"]
         }
 
-        dg = Marty::DataGrid.lookup('infinity', "G1", {"no_convert"=>true})
+        dg = Marty::DataGrid.find_by(obsoleted_dt: 'infinity', name: "G1")
 
         h = {
           "fico" => 600,
@@ -581,7 +568,7 @@ EOS
       end
 
       it "should handle DataGrid typed data grids" do
-        g1 = Marty::DataGrid.lookup('infinity', "G1", {"no_convert"=>true})
+        g1 = Marty::DataGrid.find_by(obsoleted_dt: 'infinity', name: "G1")
 
         res = lookup_grid_helper('infinity',
                                  "Ga",
@@ -716,19 +703,15 @@ EOS
                   "\u201C", "\u201D"]
         100.times do
           st = 30.times.map{quotes[rand(9)]}.join
-          res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt, { "ltv" => 10,
-                                                    "fico" => 690,
-                                                    "state" => st }, dgh, nil,
-                                              false, true)
+          res = Marty::DataGrid.lookup_grid_distinct_entry_h(
+            pt, {"ltv" => 10, "fico" => 690, "state" => st}, dgh, nil, false, true)
         end
       end
       it "should handle quote chars in object name" do
         dgh = Marty::DataGrid.lookup_h(pt, 'G1')
         st = Gemini::State.new(name: "'\\")
-        res = Marty::DataGrid.lookup_grid_distinct_entry_h(pt, { "ltv" => 10,
-                                                  "fico" => 690,
-                                                  "state" => st }, dgh, nil,
-                                            false, true)
+        res = Marty::DataGrid.lookup_grid_distinct_entry_h(
+          pt, {"ltv" => 10, "fico" => 690, "state" => st}, dgh, nil, false, true)
       end
     end
 
@@ -814,19 +797,13 @@ EOS
 
         res11 = res.sub(/G1/, "G11")
 
-        sum = do_import_summary(Marty::DataGrid,
-                                res11,
-                                'infinity',
-                                nil,
-                                nil,
-                                ",",
-                               )
+        sum = do_import_summary(
+          Marty::DataGrid, res11, 'infinity', nil, nil, ",")
 
         expect(sum).to eq({create: 1})
 
-        nc = {"no_convert"=>true}
-        g1 = Marty::DataGrid.lookup('infinity', "G1", nc)
-        g11 = Marty::DataGrid.lookup('infinity', "G11", nc)
+        g1  = Marty::DataGrid.find_by(obsoleted_dt: 'infinity', name: "G1")
+        g11 = Marty::DataGrid.find_by(obsoleted_dt: 'infinity', name: "G11")
 
         expect(g1.export).to eq g11.export
       end

data/spec/models/rule_spec.rb

@@ -170,68 +170,67 @@ module Marty::RuleSpec
 
     context "lookups" do
       it "matches" do
-        nc = {"no_convert"=>true}
         lookup = Gemini::MyRule.get_matches('infinity',
                                             {'rule_type'=>'SimpleRule'},
-                                            {'g_array'=>'G1V3'}, nc)
+                                            {'g_array'=>'G1V3'})
         expect(lookup.to_a.count).to eq(1)
         expect(lookup.first.name).to eq("Rule1")
         lookup = Gemini::MyRule.get_matches('infinity',
                                             {'rule_type'=>'SimpleRule',
 
                                             'other_flag'=>true},
-                                            {}, nc)
+                                            {})
         expect(lookup.to_a.count).to eq(4)
         expect(lookup.map{|l|l.name}.to_set).to eq(Set["Rule2","Rule2a",
                                                        "Rule2b", "Rule2c"])
         lookup = Gemini::MyRule.get_matches('infinity',
                                             {'rule_type'=>'ComplexRule',
                                             'other_flag'=>false},
-                                            {}, nc)
+                                            {})
         expect(lookup.to_a.count).to eq(1)
         expect(lookup.first.name).to eq("Rule3")
         # bool false matches bool nil
         lookup = Gemini::MyRule.get_matches('infinity',
                                             {'rule_type'=>'ComplexRule',
                                             'other_flag'=>false},
-                                            {'g_bool'=>false}, nc)
+                                            {'g_bool'=>false})
         expect(lookup.to_a.count).to eq(1)
         expect(lookup.first.name).to eq("Rule3")
         lookup = Gemini::MyRule.get_matches('infinity',
                                             {'rule_type'=>'ComplexRule'},
-                                            {'g_string'=>'def'}, nc)
+                                            {'g_string'=>'def'})
         expect(lookup.to_a.count).to eq(1)
         expect(lookup.first.name).to eq("Rule3")
         lookup = Gemini::MyRule.get_matches('infinity',
                                             {'rule_type'=>'ComplexRule'},
-                                            {'g_string'=>'abc'}, nc)
+                                            {'g_string'=>'abc'})
         expect(lookup).to eq([])
         lookup = Gemini::MyRule.get_matches('infinity',
                                             {'rule_type'=>'SimpleRule'},
                                             {'g_bool'=>true, "g_range"=>25,
-                                             'g_integer'=>99}, nc)
+                                             'g_integer'=>99})
         expect(lookup.to_a.count).to eq(1)
         expect(lookup.first.name).to eq("Rule2a")
         lookup = Gemini::MyRule.get_matches('infinity',
                                             {'rule_type'=>'SimpleRule'},
-                                            {'g_bool'=>true, "g_range"=>75}, nc)
+                                            {'g_bool'=>true, "g_range"=>75})
         expect(lookup.to_a.count).to eq(1)
         expect(lookup.first.name).to eq("Rule1")
         lookup = Gemini::MyRule.get_matches('infinity',
                                             {'rule_type'=>'SimpleRule'},
                                             {'g_bool'=>true, "g_range"=>75,
-                                             'g_integer'=>11}, nc)
+                                             'g_integer'=>11})
         expect(lookup).to eq([])
         lookup = Gemini::MyRule.get_matches('infinity',
                                             {'rule_type'=>'SimpleRule'},
                                             {'g_bool'=>true, "g_range"=>75,
-                                             'g_integer'=>10}, nc)
+                                             'g_integer'=>10})
         expect(lookup.to_a.count).to eq(1)
         expect(lookup.first.name).to eq("Rule1")
         lookup = Gemini::MyRule.get_matches('infinity',
                                             {'rule_type'=>'SimpleRule'},
                                             {'g_bool'=>false, "g_range"=>25,
-                                             'g_integer'=>10}, nc)
+                                             'g_integer'=>10})
         expect(lookup.to_a.count).to eq(1)
         expect(lookup.first.name).to eq("Rule2c")
         lookup = Gemini::MyRule.get_matches('infinity',
@@ -239,13 +238,13 @@ module Marty::RuleSpec
         expect(lookup.to_a.count).to eq(5)
         lookup = Gemini::MyRule.get_matches('infinity',
                                             {'rule_dt'=>"2017-3-1 02:00:00"},
-                                            {}, nc)
+                                            {})
         expect(lookup.to_a.count).to eq(6)
         expect(lookup.pluck(:name).to_set).to eq(Set["Rule1", "Rule2", "Rule2a",
                                                    "Rule2b", "Rule2c", "Rule3"])
         lookup = Gemini::MyRule.get_matches('infinity',
                                             {'rule_dt'=>"2017-4-1 16:00:00"},
-                                            {}, nc)
+                                            {})
         expect(lookup.to_a.count).to eq(1)
         expect(lookup.pluck(:name).first).to eq("Rule4")
         lookup = Gemini::MyRule.get_matches('infinity',
@@ -256,40 +255,39 @@ module Marty::RuleSpec
         expect(lookup.to_a).to eq([])
         lookup = Gemini::MyRule.get_matches('infinity', {},
                                             {"g_bool_def"=>false,
-                                             "g_nbool_def"=>true}, nc)
+                                             "g_nbool_def"=>true})
         expect(lookup.to_a.count).to eq(1)
         expect(lookup.pluck(:name).first).to eq("Rule1")
       end
     end
     context "rule compute" do
-      let(:nc) {{"no_convert"=>true}}
       let(:complex) { Gemini::MyRule.get_matches('infinity',
                                             {'rule_type'=>'ComplexRule'},
-                                            {'g_string'=>'def'}, nc).first }
+                                            {'g_string'=>'def'}).first }
       let(:xyz) { Gemini::XyzRule.get_matches('infinity',
                                               {'rule_type'=>'ZRule'},
-                                              {'g_integer'=> 2}, nc).first }
+                                              {'g_integer'=> 2}).first }
       let(:simple) {
         Gemini::MyRule.get_matches('infinity',
                                    {'rule_type'=>'SimpleRule'},
-                                   {'g_bool'=>true, "g_range"=>25}, nc).first }
+                                   {'g_bool'=>true, "g_range"=>25}).first }
       let(:simple2a) {
         Gemini::MyRule.get_matches('infinity',
                                    {'rule_type'=>'SimpleRule'},
-                                   {'g_bool'=>true, "g_integer"=>99}, nc).first }
+                                   {'g_bool'=>true, "g_integer"=>99}).first }
       let(:simple2b) {
         Gemini::MyRule.get_matches('infinity',
                                    {'rule_type'=>'SimpleRule'},
-                                   {'g_bool'=>true, "g_integer"=>999}, nc).first }
+                                   {'g_bool'=>true, "g_integer"=>999}).first }
       let(:altgridmethod) {
         Gemini::MyRule.get_matches('infinity',
                                    {'rule_type'=>'ComplexRule'},
-                                   {"g_integer"=>3757}, nc).first }
+                                   {"g_integer"=>3757}).first }
       let(:gridcomputedname) {
         Gemini::MyRule.get_matches('infinity',
                                    {'rule_type'=>'ComplexRule'},
                                    {"g_string"=>"Hi Mom",
-                                    "g_integer"=>11}, nc).first }
+                                    "g_integer"=>11}).first }
       it "computed guards work" do
         c = complex.compute({"pt"=>Time.zone.now,
                              'param2'=>'def'})
@@ -313,11 +311,12 @@ module Marty::RuleSpec
                                         "sr2"=>true,
                                         "sr3"=>123})
         # 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({"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

data/spec/models/script_spec.rb

@@ -17,9 +17,8 @@ describe Marty::Script do
     it "creates a new script if it doesn't already exist" do
       expect { Marty::Script.load_a_script('TestNew', s1, now) }.
         to change(Marty::Script, :count).by(1)
-      expect(Marty::Script.lookup('infinity', 'TestNew', {"no_convert"=>true}).
-              created_dt.to_s).
-        to eq(now.to_s)
+      expect(Marty::Script.find_by(obsoleted_dt: 'infinity', name: 'TestNew').
+               created_dt.to_s).to eq(now.to_s)
     end
 
     it "doesn't create a new script entry if it already exists and is the " +
@@ -40,8 +39,9 @@ describe Marty::Script do
                                            s2, now) }.
         to change { Marty::Script.where(name: 'TestExistsAndDifferent2',
                                         obsoleted_dt: 'infinity').count }.by(0)
-      expect(Marty::Script.lookup('infinity', 'TestExistsAndDifferent2',
-                         {"no_convert"=>true}).created_dt.to_s).to eq(now.to_s)
+      expect(Marty::Script.find_by(
+               obsoleted_dt: 'infinity', name: 'TestExistsAndDifferent2').
+               created_dt.to_s).to eq(now.to_s)
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: marty
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.0.3
 platform: ruby
 authors:
 - Arman Bostani
@@ -14,7 +14,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-11 00:00:00.000000000 Z
+date: 2018-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg