marty 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5d9d9f5c0e9c2652723559940f1b2914b383a979
-  data.tar.gz: 2070a22df262364639b039d103fc788e0c98636d
+  metadata.gz: 31ab53bcb7bcc26bfa4bd1d400c5e0c7861558d3
+  data.tar.gz: c12dae6177787b1cd2eefb4416c11b15155a4395
 SHA512:
-  metadata.gz: a7548a3dd1274bbd4e8245cc7fc05186386b936801f22ab1ce3e8b1d9fdf17d4b7ffa096ed9a3d8232f612ee4a55f4c0295a3e27cad07aee8eb9665585547405
-  data.tar.gz: 65a33ee22a28c6aedd262b505f5fc83d12ecf33821fe725f132c8cdfa1b7f1823da0ecb84283ac12696ed3eb5b04cf18a07f60f60e09b41249c43afbcb371b61
+  metadata.gz: 6c435cd40922422b864e5dc5ed4d20536ca8a50317b917a4b53b299a9d949ef67594ceb8707c38c822efd3024264e7a1832f3707ed8d2ae039957848681cf627
+  data.tar.gz: 17a9348a816387d216a59739eac52b9cca47790ec8dd5cb469eaee93c660c83a29d40f8b9afac1ccc422d4ea6245386948732c5a87632fc612793b5a0677d4c0

data/Gemfile.lock

@@ -1,10 +1,10 @@
 PATH
   remote: .
   specs:
-    marty (1.2.9)
+    marty (2.0.1)
       axlsx (= 3.0.0pre)
       coderay
-      delorean_lang (~> 0.3.33)
+      delorean_lang (~> 0.3.37)
       json-schema
       mcfly (= 0.0.20)
       net-ldap (= 0.12.1)

data/app/models/marty/base.rb

@@ -21,4 +21,60 @@ class Marty::Base < ActiveRecord::Base
   PLUCK_SIG    = [1, 100]
   SELECT_SIG   = [1, 100]
   WHERE_SIG    = [0, 100]
+
+  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)
+  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
+    return final_attrs if final_attrs.present?
+
+    # otherwise raise with error line
+    raise "Marty::Base: no attributes for #{self}"
+
+    # for more detailed debugging use this code instead
+    # st = caller.detect{|s|s.starts_with?('DELOREAN__')}
+    # re = /DELOREAN__([A-Z][a-zA-Z0-9]*)[:]([0-9]+)[:]in `([a-z_0-9]+)__D'/
+    # m = re.match(st)
+    # if !m
+    #   st = "No attributes #{st} #{self}"
+    #   puts st unless File.readlines(Rails.root.join('tmp','dlchk')).
+    #                   map(&:chop).detect{|l|l==st}
+    # else
+    #   loc = "#{m[1]}::#{self}::#{m[2]}"
+    #   str = "*** No attributes %-40s %-20s   %s" % [loc, m[3], attr]
+    #   puts str unless File.readlines(Rails.root.join('tmp','dlchk')).
+    #                    map(&:chop).detect{|l|l==str}
+    # end
+  end
+
+  def self.make_openstruct(inst, opts={})
+    return nil unless inst
+    return inst if opts["no_convert"] == true
+    fa = opts["fa"] || get_final_attrs(opts)
+    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")
+        Marty::DataGrid.lookup_grid_distinct_entry_h(pt, params, dgh)
+      end
+    end
+    os
+  end
 end

data/app/models/marty/data_grid.rb

@@ -89,10 +89,11 @@ class Marty::DataGrid < Marty::Base
 
   def self.lookup_h(pt, name, fields = nil)
     fields ||= %w(id group_id created_dt metadata data_type)
-    dga = get_all(pt).where(name: name).pluck(*fields).first
+    dga = mcfly_pt(pt).where(name: name).pluck(*fields).first
     dga && Hash[fields.zip(dga)]
   end
 
+  # deprecated - remove 2018-Oct
   cached_mcfly_lookup :lookup_id, sig: 2 do
     |pt, group_id|
     find_by_group_id group_id
@@ -103,6 +104,10 @@ class Marty::DataGrid < Marty::Base
     Marty::DataGrid.mcfly_pt(pt).where(name: name).exists?
   end
 
+  def self.get_struct_attrs
+    self.struct_attrs ||= super + ["id", "group_id", "created_dt"]
+  end
+
   def to_s
     name
   end
@@ -216,11 +221,15 @@ class Marty::DataGrid < Marty::Base
     res
   end
 
+  # deprecated - remove 2018-Oct
   cached_delorean_fn :lookup_grid, sig: 4 do
     |pt, dg, h, distinct|
-    raise "bad DataGrid #{dg}" unless Marty::DataGrid === dg
+    dg_is_grid = Marty::DataGrid === dg
+    dg_is_os   =  dg.is_a?(OpenStruct)
+    raise "bad DataGrid #{dg}" unless dg_is_grid || dg_is_os
     raise "non-hash arg #{h}" unless Hash === h
-    dgh = dg.attributes.slice('id', 'group_id', 'created_dt', 'metadata')
+    dgh = dg_is_os ? dg.to_h.stringify_keys :
+            dg.attributes.slice('id', 'group_id', 'created_dt', 'metadata')
     res = plv_lookup_grid_distinct(h, dgh, false, distinct)
     res["result"]
   end
@@ -248,8 +257,8 @@ class Marty::DataGrid < Marty::Base
     end
   end
 
-  delorean_fn :lookup_grid_distinct_entry_h, sig: [3,6] do
-    |pt, h, dgh, visited=nil, follow=true, return_grid_data=false, distinct=true|
+  def self.lookup_grid_distinct_entry_h(pt, h, dgh, visited=nil, follow=true,
+                                        return_grid_data=false, distinct=true)
 
     # Perform grid lookup, if result is another data_grid, and follow is true,
     # then perform lookup on the resulting grid.  Allows grids to be nested
@@ -263,11 +272,11 @@ class Marty::DataGrid < Marty::Base
     #   "metadata" => <grid's metadata (array of hashes)>
     vhash = plv_lookup_grid_distinct(h, dgh, return_grid_data, distinct)
 
-    next vhash if vhash["result"].nil? || !dgh['data_type']
+    return vhash if vhash["result"].nil? || !dgh['data_type']
 
     c_data_type = Marty::DataGrid.convert_data_type(dgh['data_type'])
 
-    next vhash if String === c_data_type
+    return vhash if String === c_data_type
 
     res = vhash["result"]
 
@@ -282,7 +291,7 @@ class Marty::DataGrid < Marty::Base
                Marty::DataConversion.find_row(c_data_type, {"name" => res}, pt)
          end
 
-    next vhash.merge({"result" => v}) unless (Marty::DataGrid == c_data_type &&
+    return vhash.merge({"result" => v}) unless (Marty::DataGrid == c_data_type &&
                                               follow)
 
     visited ||= []
@@ -378,7 +387,7 @@ class Marty::DataGrid < Marty::Base
 
   def export
     # return null string when called from Netzke on add_in_form
-    return "" if metadata.nil? && data.nil?
+     return "" if metadata.nil? && data.nil?
 
     meta_rows, h_key_rows, data_rows = export_array
 
@@ -389,7 +398,11 @@ class Marty::DataGrid < Marty::Base
       gsub(/\"\"/, '') # remove "" to beautify output
   end
 
-  delorean_instance_method :export, []
+  delorean_fn :export, sig: 1 do
+    |os|
+    dg = find(os.id)
+    dg.export
+  end
 
   def self.parse_fvalue(pt, v, type, klass)
     return unless v

data/app/models/marty/delorean_rule.rb

@@ -19,7 +19,7 @@ class Marty::DeloreanRule < Marty::BaseRule
   end
 
   def self_as_hash
-    self.as_json + {"classname"=>self.class.name}
+    self.attributes + {"classname"=>self.class.name}
   end
   def self.find_fixed(results)
     results.each_with_object({}) do |(k, v), h|
@@ -75,6 +75,7 @@ class Marty::DeloreanRule < Marty::BaseRule
       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(results, grids, eclass)
@@ -94,6 +95,7 @@ class Marty::DeloreanRule < Marty::BaseRule
     elsif fixed_results.keys.sort == results.keys.sort
       result = fixed_results
     end
+
     if grids.present? && !grids_computed
       pt = params['pt']
       gres = {}
@@ -113,6 +115,22 @@ class Marty::DeloreanRule < Marty::BaseRule
     kl = ruleh["classname"].constantize
     kl.compute(ruleh, pt, params, grid_names_p)
   end
+  delorean_fn :route_compute_rs, sig: 3 do
+    |ruleh, pt, features|
+    kl = ruleh["classname"].constantize
+    kl.compute_rs(ruleh, pt, features)
+  end
+  delorean_fn :route_validate_results, sig: [1, 2] do
+    |ruleh, reqchk=false|
+    kl = ruleh["classname"].constantize
+    kl.validate_results(ruleh, reqchk)
+  end
+  delorean_fn :route_validate_grid_attrs, sig: [2, 3] do
+    |ruleh, gridname, addl_attrs=nil|
+    kl = ruleh["classname"].constantize
+    kl.validate_grid_attrs(ruleh, gridname, addl_attrs)
+  end
+
   def base_compute(params, dgparams=params)
     self.class.base_compute(self_as_hash, params, dgparams)
   end
@@ -140,5 +158,4 @@ class Marty::DeloreanRule < Marty::BaseRule
   def self.init_dg_handler
     Marty::DataGrid.register_rule_handler(get_grid_rename_handler(self))
   end
-
 end

data/app/models/marty/import_type.rb

@@ -40,13 +40,4 @@ class Marty::ImportType < Marty::Base
   def allow_import?
     Mcfly.whodunnit && Mcfly.whodunnit.roles.pluck(:id).include?(role_id)
   end
-
-  delorean_fn :lookup, sig: 1 do
-    |name|
-    self.find_by_name(name)
-  end
-
-  delorean_fn :get_all, sig: 0 do
-    self.all
-  end
 end

data/app/models/marty/posting.rb

@@ -40,19 +40,24 @@ class Marty::Posting < Marty::Base
     o
   end
 
+  def self.get_struct_attrs
+    self.struct_attrs ||= super + ["created_dt", "name"]
+  end
+
   # Not using mcfly_lookup since we don't want these time-warp markers
   # time-warped. FIXME: perhaps this should use mcfly_lookup since we
   # 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 do
-    |name|
-    self.find_by_name(name)
+  delorean_fn :lookup, sig: [1, 2] do
+    |name, opts={}|
+    p = select(get_struct_attrs).find_by_name(name)
+    make_openstruct(p, opts)
   end
 
   delorean_fn :lookup_dt, sig: 1 do
     |name|
-    lookup(name).try(:created_dt)
+    find_by_name(name).try(:created_dt)
   end
 
   delorean_fn :first_match, sig: [1, 2] do
@@ -62,35 +67,25 @@ class Marty::Posting < Marty::Base
 
     q = where("created_dt <= ?", dt)
     q = q.where(posting_type_id: posting_type.id) if posting_type
-    q.order("created_dt DESC").first
+    q.order("created_dt DESC").first.attributes
   end
 
-  delorean_fn :get_latest, sig: [1, 2] do
-    |limit, is_test=nil|
+  def self.get_latest(limit, is_test=nil)
     # IMPORTANT: is_test arg is ignored (KEEP for backward compat.)
 
-    where("created_dt <> 'infinity'").
-      order("created_dt DESC").limit(limit).to_a
+    q=where("created_dt <> 'infinity'").
+       order("created_dt DESC").limit(limit)
   end
 
-  delorean_fn :get_latest_by_type, sig: [2, 2] do
+  delorean_fn :get_latest_by_type, sig: [1, 2] do
     |limit, posting_types=[]|
     raise "missing posting types list" unless posting_types
     raise "bad posting types list" unless posting_types.is_a?(Array)
 
-    joins(:posting_type).where("created_dt <> 'infinity'").
-      where(marty_posting_types: { name: posting_types } ).
-      order("created_dt DESC").limit(limit || 1).to_a
-  end
-
-  delorean_fn :get_last, sig: [0, 1] do
-    |posting_type=nil|
-
-    raise "bad posting type" if
-      posting_type && !posting_type.is_a?(Marty::PostingType)
-
-    q = where("created_dt <> 'infinity'")
-    q = q.where(posting_type_id: posting_type.id) if posting_type
-    q.order("created_dt DESC").first
+    q=joins(:posting_type).where("created_dt <> 'infinity'").
+       where(marty_posting_types: { name: posting_types } ).
+       select(get_struct_attrs).
+       order("created_dt DESC").limit(limit || 1)
+    q.map{|ar| ar.attributes}
   end
 end

data/app/models/marty/posting_type.rb

@@ -3,10 +3,4 @@ class Marty::PostingType < Marty::Base
 
   validates_presence_of :name
   validates_uniqueness_of :name
-
-  # NOTE: lookup fn for backward compat -- to index enums, use []
-  delorean_fn :lookup, sig: 1 do
-    |name|
-    self.find_by_name(name)
-  end
 end

data/app/models/marty/script.rb

@@ -11,12 +11,11 @@ class Marty::Script < Marty::Base
   belongs_to :user, class_name: "Marty::User"
 
   gen_mcfly_lookup :lookup, [:name], cache: true
-  gen_mcfly_lookup :get_all, {}, mode: nil
 
   # find script by name/tag
   def self.find_script(sname, tag=nil)
     tag = Marty::Tag.map_to_tag(tag)
-    Marty::Script.lookup(tag.created_dt, sname)
+    Marty::Script.lookup(tag.created_dt, sname, {"no_convert"=>true})
   end
 
   def find_tag
@@ -33,7 +32,7 @@ class Marty::Script < Marty::Base
   end
 
   def self.load_a_script(sname, body, dt=nil)
-    s = Marty::Script.lookup('infinity', sname)
+    s = Marty::Script.lookup('infinity', sname, {"no_convert"=>true})
 
     if !s
       s = Marty::Script.new

data/app/models/marty/tag.rb

@@ -6,6 +6,10 @@ class Marty::Tag < Marty::Base
 
   belongs_to :user, class_name: "Marty::User"
 
+  def self.get_struct_attrs
+    self.struct_attrs ||= super + ["id", "created_dt"]
+  end
+
   def self.make_name(dt)
     return 'DEV' if Mcfly.is_infinity(dt)
 
@@ -38,7 +42,7 @@ 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)
@@ -47,8 +51,8 @@ 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)
-        tag = find_match(Mcfly.normalize_infinity(posting.created_dt)) if
+        posting = Marty::Posting.lookup(tag_id, nc)
+        tag = find_match(Mcfly.normalize_infinity(posting['created_dt'])) if
           posting
       end
     when nil
@@ -56,44 +60,28 @@ class Marty::Tag < Marty::Base
     else
       tag = tag_id
     end
-
-    raise "bad tag identifier #{tag_id.inspect}" unless tag.is_a? Marty::Tag
+    raise "bad tag identifier #{tag_id.inspect}" unless tag.is_a?(Marty::Tag)
     tag
   end
 
   cached_delorean_fn :lookup, sig: 1 do
     |name|
-    self.find_by_name(name)
+    t = self.find_by_name(name).select(get_struct_attrs)
+    t && t.attributes
   end
 
-  # Performance hack to cache AR object
-  cached_delorean_fn :lookup_id, sig: 1 do
-    |id|
-    find_by_id(id)
+  def self.get_latest1
+    order("created_dt DESC").find_by("created_dt <> 'infinity'")
   end
 
-  delorean_fn :lookup_dt, sig: 1 do
-    |name|
-    lookup(name).try(:created_dt)
-  end
-
-  delorean_fn :get_latest1, sig: 0 do
-    where("created_dt <> 'infinity'").order("created_dt DESC").first
-  end
-
-  delorean_fn :find_match, sig: 1 do
-    |dt|
-    id = select(:id).where("created_dt <= ?", dt).order("created_dt DESC").first.id
-
-    # performance hack to use cached version
-    id && lookup_id(id)
+  def self.find_match(dt)
+    order("created_dt DESC").find_by("created_dt <= ?", dt)
   end
 
   # Performance hack for script sets -- FIXME: making find_mtach
   # cached breaks Gemini tests.  Need to look into it.
-  cached_delorean_fn :cached_find_match, sig: 1 do
-    |dt|
-
-    find_match dt
+  def self.cached_find_match(dt)
+    @@CACHE_FIND_BY_DT ||= {}
+    @@CACHE_FIND_BY_DT[dt] ||= find_match(dt)
   end
 end

data/lib/marty/data_change.rb

@@ -21,7 +21,7 @@ class Marty::DataChange
 
     changes.each_with_object({}) do |(group_id, ol), h|
       h[group_id] = ol.each_with_index.map do |o, i|
-        profile = {"obj" => o}
+        profile = {"obj" => o.attributes}
 
         # Create a profile hash for each object in the group.
         # "status" tells us if the object is old/new/mod.  If
@@ -128,7 +128,7 @@ class Marty::DataChange
     klass = k.constantize
     next (klass.is_a? Marty::PgEnum) ? klass.get_all : []
   end
-  
+
   delorean_fn :export_changes, sig: 3 do
     |t0, t1, class_name|
 

data/lib/marty/mcfly_model.rb

@@ -27,7 +27,6 @@ module Mcfly::Model
         cache_key = [name, ts] + args.map{ |a|
           a.is_a?(ActiveRecord::Base) ? a.id : a
         } unless Mcfly.is_infinity(ts)
-
         next @LOOKUP_CACHE[cache_key] if
           cache_key && @LOOKUP_CACHE.has_key?(cache_key)
 
@@ -53,19 +52,54 @@ module Mcfly::Model
       end
     end
 
-    # FIXME: duplicate code from Mcfly's mcfly_lookup.
-    def cached_mcfly_lookup(name, options = {}, &block)
-      cached_delorean_fn(name, options) do |ts, *args|
-        raise "nil timestamp" if ts.nil?
+    def base_mcfly_lookup(meth, name, options = {}, &block)
+
+      sig = options[:sig]
+      newsig = sig.is_a?(Array) ? [sig[0], sig[1]+1] :
+                 sig == -1 ? sig : [sig, sig+1]
+      options[:sig] = newsig
+      asig = options[:asig] || newsig[1]-1
+
+      send(meth, name, options) do |ts, *pargs|
+        raise "time cannot be nil" if ts.nil?
+
+        args, opts = pargs.last.is_a?(Hash) && pargs.length == asig ?
+                       [pargs[0..-2], pargs.last] :
+                       [pargs, {}]
 
         ts = Mcfly.normalize_infinity(ts)
 
-        self.mcfly_pt(ts).scoping do
+        q = self.where("#{table_name}.obsoleted_dt >= ? AND " +
+                   "#{table_name}.created_dt < ?", ts, ts).scoping do
           block.call(ts, *args)
         end
+        fa = get_final_attrs(opts)
+        opts += {"fa"=>fa}
+
+        q = q.select(*fa) if fa.present? &&
+                             q.respond_to?(:select) && !q.is_a?(Array) &&
+                             !q.is_a?(Hash)
+
+        case
+        when opts["no_convert"] == true
+          q
+        when q.is_a?(ActiveRecord::Relation)
+          q.map{|ar| make_openstruct(ar, opts)}
+        when q.is_a?(ActiveRecord::Base)
+          make_openstruct(q, opts)
+        else
+          q
+        end
       end
     end
 
+    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={})
@@ -99,14 +133,11 @@ module Mcfly::Model
         raise "bad attrs" unless Array === attrs
       end
 
-      fn = cache ? :cached_mcfly_lookup : :mcfly_lookup
-
-      # hacky: if private, set sig to bad value -- i.e. can't be
-      # called from delorean.  Ideally, we should have a 'private'
-      # option for delorean_fn.
-      sig = options[:private] ? -1 : attrs.length+1
+      actual_sig = attrs.length + 1
+      fn = cache ? :cached_delorean_fn : :delorean_fn
+      sig = options[:private] ? -1 : actual_sig
 
-      send(fn, name, sig: sig) do
+      base_mcfly_lookup(fn, name, {sig: sig, asig: actual_sig}) do
         |t, *attr_list|
 
         attr_list_ids = attr_list.each_with_index.map {|x, i|

data/lib/marty/monkey.rb

@@ -264,6 +264,7 @@ args_hack = [[ActiveRecord::Relation, ActiveRecord::QueryMethods::WhereChain]] +
 Delorean::RUBY_WHITELIST.merge!(
   count:    [ActiveRecord::Relation],
   distinct: args_hack,
+  find_by:  args_hack,
   group:    args_hack,
   joins:    args_hack,
   limit:    [ActiveRecord::Relation, Integer],
@@ -275,6 +276,9 @@ Delorean::RUBY_WHITELIST.merge!(
   mcfly_pt: [ActiveRecord::Relation,
              [Date, Time, ActiveSupport::TimeWithZone, String],
              [nil, Class]],
+  lookup_grid_distinct_entry: [OpenStruct,
+                               [Date, Time, ActiveSupport::TimeWithZone, String],
+                               Hash],
 )
 
 ######################################################################
@@ -285,3 +289,24 @@ module Mcfly::Controller
     find_current_user rescue nil
   end
 end
+
+######################################################################
+
+class OpenStruct
+  def save
+    loc = %r([^/]+:[0-9]+).match(caller.first)[0]
+    raise "save called from #{loc} on #{self}"
+  end
+  def save!
+    loc = %r([^/]+:[0-9]+).match(caller.first)[0]
+    raise "save! called from #{loc} on #{self}"
+  end
+  def reload
+    loc = %r([^/]+:[0-9]+).match(caller.first)[0]
+    raise "reload called from #{loc} on #{self}"
+  end
+  #def method_missing(meth, *args)
+  #  puts caller[0..8]
+  #  super
+  #end
+end

data/lib/marty/promise_job.rb

@@ -23,7 +23,6 @@ class Delorean::BaseModule::NodeCall
     end
     script, tag = engine.module_name, engine.sset.tag
     nn = node.is_a?(Class) ? node.name : node.to_s
-
     begin
       # make sure params is serialzable before starting a Job
       Marshal.dump(params)

data/lib/marty/version.rb

@@ -1,3 +1,3 @@
 module Marty
-  VERSION = "2.0.0"
+  VERSION = "2.0.1"
 end

data/marty.gemspec

@@ -32,8 +32,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'axlsx', '3.0.0pre'
 
-
-  s.add_dependency 'delorean_lang', '~> 0.3.33'
+  s.add_dependency 'delorean_lang', '~> 0.3.37'
   s.add_dependency 'mcfly', '0.0.20'
 
   s.add_dependency 'coderay'

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")
+    s = Marty::Script.lookup('infinity', "A", {"no_convert"=>true})
     s.body = "A:\n    a = 3\n"
     s.save!
   }

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

@@ -21,18 +21,20 @@ class Gemini::Helper
 
   # Just for testing
   delorean_fn :import_data, sig: [2, 3] do
-    |import_type, data, col_sep|
+    |import_type_name, data, col_sep|
 
     col_sep ||= "\t"
 
+    imp_t = Marty::ImportType.find_by_name(import_type_name)
+
     raise "Insufficient permissions to run the data import" unless
-      import_type.allow_import?
+      imp_t.allow_import?
 
-    Marty::DataImporter.do_import_summary(import_type.get_model_class,
+    Marty::DataImporter.do_import_summary(imp_t.get_model_class,
                                           data,
                                           'infinity',
-                                          import_type.cleaner_function,
-                                          import_type.validation_function,
+                                          imp_t.cleaner_function,
+                                          imp_t.validation_function,
                                           col_sep,
                                           false)
   end

data/spec/dummy/delorean/blame_report.dl

@@ -2,7 +2,9 @@ import Fields
 import Styles
 
 PostingField2: Fields::PostingField2
-    store = ["NOW"] + [lp.name for lp in Marty::Posting.get_latest(10, nil)]
+    store = ["NOW"] + Marty::Posting.
+                   where("created_dt <> 'infinity'").
+                   order("created_dt DESC").limit(10).pluck("name")
 
 StyleRow:
     profile     =?

data/spec/dummy/delorean/data_report.dl

@@ -70,7 +70,7 @@ ImportTypeField:
     field_label = "Import Type"
     name        = "import_type"
     xtype       = ":combo"
-    store       = [imp.name for imp in Marty::ImportType.get_all].sort
+    store       = Marty::ImportType.pluck("name").sort
     value       = store[0]
 
 CommaSepField:
@@ -92,11 +92,8 @@ DataImportReport:
 
     data_import_field =?
 
-    import_type_rec = Marty::ImportType.lookup(import_type) ||
-        ERR("NULL ImportType", import_type)
-
     result = Gemini::Helper.import_data(
-        import_type_rec,
+        import_type,
         data_import_field,
         if comma_sep then "," else nil
         )

data/spec/dummy/delorean/fields.dl

@@ -2,7 +2,9 @@ PostingField:
     field_label = "Posting"
     xtype       = ":combo"
     name        = "pt_name"
-    store       = [lp.name for lp in Marty::Posting.get_latest(10)]
+    store       =  Marty::Posting.
+                   where("created_dt <> 'infinity'").
+                   order("created_dt DESC").limit(10).pluck("name")
     value       = store[0]
 
 ######################################################################

data/spec/features/data_import_spec.rb

@@ -83,7 +83,9 @@ feature 'under Applications menu, Reports using  Data Import', js: true do
           import_type_combo = netzke_find('Import Type', 'combobox')
           import_type_combo.select_values('FB')
           bud_id = Gemini::BudCategory.first.id
-          paste("bud_category_id\tnote_rate\tsettlement_mm\tsettlement_yy\tbuy_up\tbuy_down\n#{bud_id}\t9.500\t9\t2014\t0\t0\n#{bud_id}\t9.750\t9\t2014\t0\t0\n",
+          paste("bud_category_id\tnote_rate\tsettlement_mm\tsettlement_yy\t"\
+                "buy_up\tbuy_down\n#{bud_id}\t9.500\t9\t2014\t0\t0\n"\
+                "#{bud_id}\t9.750\t9\t2014\t0\t0\n",
                 'data_import_field')
         end
       end

data/spec/features/reporting_spec.rb

@@ -37,7 +37,9 @@ PostingField:
     field_label = "Posting"
     xtype       = ":combo"
     name        = "pt_name"
-    store       = [lp.name for lp in Marty::Posting.get_latest(10)]
+    store       =  Marty::Posting.
+                   where("created_dt <> 'infinity'").
+                   order("created_dt DESC").limit(10).pluck("name")
 
 RateField:
     field_label = "Note Rate"

data/spec/features/rule_spec.rb

@@ -117,8 +117,8 @@ feature 'rule view', js: true do
                                             "results"=>"",
                                            })
 
-    r = Gemini::MyRule.lookup('infinity','abc')
-    expect(r.as_json).to include({"user_id"=>1,
+    r = Gemini::MyRule.lookup('infinity','abc', {"no_convert"=>true})
+    expect(r.attributes).to include({"user_id"=>1,
                                   "o_user_id"=>nil,
                                   "name"=>"abc",
                                   "engine"=>"Gemini::MyRuleScriptSet",
@@ -172,7 +172,7 @@ feature 'rule view', js: true do
            "results"=>"",
           }
     r = Gemini::MyRule.lookup('infinity','abc')
-    expect(r.as_json["simple_guards"]["g_nullbool"]).to eq(false)
+    expect(r["simple_guards"]["g_nullbool"]).to eq(false)
     expect(mrv.get_row_vals(1)).to include(exp)
     # grid edits
     press("Edit")
@@ -189,7 +189,7 @@ feature 'rule view', js: true do
                                                 "grids"=>
                                                 "{\"grid1\":\"DataGrid1\"}"})
     r = Gemini::MyRule.lookup('infinity','abc')
-    expect(r.as_json["simple_guards"]).not_to include('g_nullbool')
+    expect(r["simple_guards"]).not_to include('g_nullbool')
     # computed fields
     press("Edit")
     fill_in(:computed_guards, with: 'sadf asdf ljsf')
@@ -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})
-
+                                                     "g_range2"=> 35},
+                                    {"no_convert"=>true})
     expect(r.to_a.count).to eq(1)
     exp = {"user_id"=>1,
            "o_user_id"=>nil,

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")
+      s = Marty::Script.lookup('infinity', "M1", {"no_convert"=>true})
       s.body = sample_script.gsub(/A/, "AA") + '    e =? "hello"'
       s.save!
     }

data/spec/lib/delorean_query_spec.rb

@@ -37,6 +37,12 @@ A:
       select("note_rate").
       first.note_rate
 
+    oo = Gemini::FannieBup.
+      order("note_rate", "buy_down ASC").
+      select("note_rate").
+      find_by("obsoleted_dt = 'infinity'").
+      note_rate
+
     g = Gemini::FannieBup.
       select("settlement_yy*settlement_mm AS x, count(*) AS c").
       group("settlement_mm", "settlement_yy").
@@ -124,6 +130,16 @@ EOF
                           first.note_rate
     end
 
+    it "perfroms order+find_by" do
+      res = @engine.evaluate("A", "oo", {})
+
+      expect(res).to eq Gemini::FannieBup.
+                          order("note_rate", "buy_down ASC").
+                          select("note_rate").
+                          find_by("obsoleted_dt = 'infinity'").
+                          note_rate
+    end
+
     it "perfroms group+count" do
       res = @engine.evaluate("A", "gg", {})
 

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')
+        s = Marty::Script.lookup('infinity', 'Script1', {"no_convert"=>true})
         s.body = "A:\n    a = 3\n"
         s.save!
 

data/spec/models/data_grid_spec.rb

@@ -204,9 +204,10 @@ EOS
         dg_from_import("G8", G8)
         dg_from_import("Ga", Ga)
 
-        expect(Marty::DataGrid.lookup('infinity', "G1").name).to eq "G1"
-        expect(Marty::DataGrid.lookup('infinity', "G2").name).to eq "G2"
-        expect(Marty::DataGrid.lookup('infinity', "G3").name).to eq "G3"
+        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
@@ -415,7 +416,7 @@ EOS
           expect(res).to eq [5.6,"G2"]
         }
 
-        dg = Marty::DataGrid.lookup('infinity', "G1")
+        dg = Marty::DataGrid.lookup('infinity', "G1", {"no_convert"=>true})
 
         h = {
           "fico" => 600,
@@ -562,7 +563,6 @@ EOS
       it "should handle multi DataGrid lookups" do
         expect(Marty::DataGrid.lookup('infinity', "G8").data_type).
           to eq "Marty::DataGrid"
-        g1 = Marty::DataGrid.lookup('infinity', "G1")
 
         h = {
           "fico" => 600,
@@ -581,7 +581,7 @@ EOS
       end
 
       it "should handle DataGrid typed data grids" do
-        g1 = Marty::DataGrid.lookup('infinity', "G1")
+        g1 = Marty::DataGrid.lookup('infinity', "G1", {"no_convert"=>true})
 
         res = lookup_grid_helper('infinity',
                                  "Ga",
@@ -824,8 +824,9 @@ EOS
 
         expect(sum).to eq({create: 1})
 
-        g1 = Marty::DataGrid.lookup('infinity', "G1")
-        g11 = Marty::DataGrid.lookup('infinity', "G11")
+        nc = {"no_convert"=>true}
+        g1 = Marty::DataGrid.lookup('infinity', "G1", nc)
+        g11 = Marty::DataGrid.lookup('infinity', "G11", nc)
 
         expect(g1.export).to eq g11.export
       end

data/spec/models/posting_spec.rb

@@ -69,31 +69,38 @@ module Marty
             # First param is just the limit (max) to return
             res = Posting.get_latest_by_type(10, ['BASE'])
             expect(res.count).to eq 1
-            expect(res[0].comment).to eq 'base posting'
+            r0 = Posting.find_by_name(res[0]['name'])
+            expect(r0.comment).to eq 'base posting'
           end
 
           it "filters on multiple posting types" do
             res = Posting.get_latest_by_type(10, ['BASE', 'SNAPSHOT'])
             expect(res.count).to eq 4
             # snapshot3 is most recent with this filter
-            expect(res[0].comment).to eq 'snapshot3 posting'
-            expect(res[3].comment).to eq 'base posting'
+            r0 = Posting.find_by_name(res[0]['name'])
+            r3 = Posting.find_by_name(res[3]['name'])
+            expect(r0.comment).to eq 'snapshot3 posting'
+            expect(r3.comment).to eq 'base posting'
           end
 
           it "filters on posting types that are single or double quoted" do
             res = Posting.get_latest_by_type(10, ['SNAPSHOT', "OTHER"])
             expect(res.count).to eq 5
             # other2 is most recent with this filter
-            expect(res[0].comment).to eq 'other2 posting'
-            expect(res[4].comment).to eq 'snapshot1 posting'
+            r0 = Posting.find_by_name(res[0]['name'])
+            r4 = Posting.find_by_name(res[4]['name'])
+            expect(r0.comment).to eq 'other2 posting'
+            expect(r4.comment).to eq 'snapshot1 posting'
           end
 
           it "filters and limits on multiple posting types" do
             res = Posting.get_latest_by_type(3, ['SNAPSHOT', 'OTHER'])
             expect(res.count).to eq 3
             # other2 is most recent with this filter
-            expect(res[0].comment).to eq 'other2 posting'
-            expect(res[2].comment).to eq 'other1 posting'
+            r0 = Posting.find_by_name(res[0]['name'])
+            r2 = Posting.find_by_name(res[2]['name'])
+            expect(r0.comment).to eq 'other2 posting'
+            expect(r2.comment).to eq 'other1 posting'
           end
 
           it "returns nothing with an empty posting type list" do

data/spec/models/rule_spec.rb

@@ -170,66 +170,68 @@ 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'})
+                                            {'g_array'=>'G1V3'}, nc)
         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})
+                                            {'g_bool'=>false}, nc)
         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'})
+                                            {'g_string'=>'def'}, nc)
         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'})
+                                            {'g_string'=>'abc'}, nc)
         expect(lookup).to eq([])
         lookup = Gemini::MyRule.get_matches('infinity',
                                             {'rule_type'=>'SimpleRule'},
                                             {'g_bool'=>true, "g_range"=>25,
-                                             'g_integer'=>99})
+                                             'g_integer'=>99}, nc)
         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})
+                                            {'g_bool'=>true, "g_range"=>75}, nc)
         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})
+                                             'g_integer'=>11}, nc)
         expect(lookup).to eq([])
         lookup = Gemini::MyRule.get_matches('infinity',
                                             {'rule_type'=>'SimpleRule'},
                                             {'g_bool'=>true, "g_range"=>75,
-                                             'g_integer'=>10})
+                                             'g_integer'=>10}, nc)
         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})
+                                             'g_integer'=>10}, nc)
         expect(lookup.to_a.count).to eq(1)
         expect(lookup.first.name).to eq("Rule2c")
         lookup = Gemini::MyRule.get_matches('infinity',
@@ -237,13 +239,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',
@@ -254,38 +256,40 @@ module Marty::RuleSpec
         expect(lookup.to_a).to eq([])
         lookup = Gemini::MyRule.get_matches('infinity', {},
                                             {"g_bool_def"=>false,
-                                             "g_nbool_def"=>true})
+                                             "g_nbool_def"=>true}, nc)
         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'}).first }
+                                            {'g_string'=>'def'}, nc).first }
       let(:xyz) { Gemini::XyzRule.get_matches('infinity',
                                               {'rule_type'=>'ZRule'},
-                                              {'g_integer'=> 2}).first }
+                                              {'g_integer'=> 2}, nc).first }
       let(:simple) {
         Gemini::MyRule.get_matches('infinity',
                                    {'rule_type'=>'SimpleRule'},
-                                   {'g_bool'=>true, "g_range"=>25}).first }
+                                   {'g_bool'=>true, "g_range"=>25}, nc).first }
       let(:simple2a) {
         Gemini::MyRule.get_matches('infinity',
                                    {'rule_type'=>'SimpleRule'},
-                                   {'g_bool'=>true, "g_integer"=>99}).first }
+                                   {'g_bool'=>true, "g_integer"=>99}, nc).first }
       let(:simple2b) {
         Gemini::MyRule.get_matches('infinity',
                                    {'rule_type'=>'SimpleRule'},
-                                   {'g_bool'=>true, "g_integer"=>999}).first }
+                                   {'g_bool'=>true, "g_integer"=>999}, nc).first }
       let(:altgridmethod) {
         Gemini::MyRule.get_matches('infinity',
                                    {'rule_type'=>'ComplexRule'},
-                                   {"g_integer"=>3757}).first }
+                                   {"g_integer"=>3757}, nc).first }
       let(:gridcomputedname) {
         Gemini::MyRule.get_matches('infinity',
                                    {'rule_type'=>'ComplexRule'},
-                                   {"g_string"=>"Hi Mom", "g_integer"=>11}).first }
+                                   {"g_string"=>"Hi Mom",
+                                    "g_integer"=>11}, nc).first }
       it "computed guards work" do
         c = complex.compute({"pt"=>Time.zone.now,
                              'param2'=>'def'})

data/spec/models/script_spec.rb

@@ -17,7 +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').created_dt.to_s).
+      expect(Marty::Script.lookup('infinity', 'TestNew', {"no_convert"=>true}).
+              created_dt.to_s).
         to eq(now.to_s)
     end
 
@@ -39,8 +40,8 @@ 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').
-             created_dt.to_s).to eq(now.to_s)
+      expect(Marty::Script.lookup('infinity', 'TestExistsAndDifferent2',
+                         {"no_convert"=>true}).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.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Arman Bostani
@@ -14,7 +14,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-30 00:00:00.000000000 Z
+date: 2018-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -64,14 +64,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.33
+        version: 0.3.37
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.33
+        version: 0.3.37
 - !ruby/object:Gem::Dependency
   name: mcfly
   requirement: !ruby/object:Gem::Requirement
@@ -508,7 +508,6 @@ files:
 - other/marty/diagnostic/request.rb
 - other/marty/diagnostic/version.rb
 - script/rails
-- script_id,
 - spec/controllers/application_controller_spec.rb
 - spec/controllers/diagnostic/controller_spec.rb
 - spec/controllers/job_controller_spec.rb