marty 1.2.0 → 1.2.1

data/app/components/marty/mcfly_grid_panel/client/dup_in_form.js

@@ -0,0 +1,20 @@
+{
+    // copied from basepack grid's onEditInForm
+    netzkeOnDupInForm: function(){
+        var selModel = this.getSelectionModel();
+        var recordId = selModel.selected.first().getId();
+        this.netzkeLoadComponent("edit_window", {
+            title: "Duplicate in Form",
+            serverConfig: {record_id: recordId},
+            callback: function(w){
+                w.show();
+                var form = w.items.first();
+                form.baseParams = {dup: true};
+                w.on('close', function(){
+                    if (w.closeRes === "ok") {
+                        this.store.load();
+                    }
+                }, this);
+            }, scope: this});
+    }
+}

data/app/models/marty/base_rule.rb

@@ -0,0 +1,126 @@
+class Marty::BaseRule < Marty::Base
+  self.abstract_class = true
+  has_mcfly
+
+  def self.guard_info
+    {}
+  end
+
+  def chkrange(v)
+    v.match(/\A(\[|\()([0-9\.-]*),([0-9\.-]*)(\]|\))\z/)
+  end
+  def gettypes(v)
+    types = []
+    types << :string if v.is_a?(String)
+    types += [:int, :integer] if Integer(v) rescue nil
+    types << :float if Float(v) rescue nil
+    types << :date if Date.parse(v) rescue nil
+    types << :datetime if DateTime.parse(v) rescue nil
+    types << :range if chkrange(v) rescue nil
+    types << :boolean if [true, false].include?(v)
+    types
+  end
+  def check(name, h)
+    multi, type, enum, values, req = h.values_at(:multi, :type, :enum, :values,
+                                                 :required)
+    ns = "'#{name}'"
+    expmulti = multi ? 'multi' : 'single'
+    errtype = :guards
+    v = simple_guards[name]
+    type ||= :string
+    return errors[errtype] << "- Required field #{ns} is missing" if
+      v.blank? && req
+    return if v.blank?
+    gotmulti = v.is_a?(Array) ? 'multi' : 'single'
+    return errors[errtype] << "- Wrong arity for #{ns} (expected #{expmulti} "\
+                              "got #{gotmulti})" if expmulti != gotmulti
+    vs = [v].flatten.to_set
+    vs.each do |vv|
+      return errors[errtype] << "- Wrong type for #{ns}" unless
+        gettypes(vv).member?(type)
+    end
+    return unless enum || values
+    vals = enum && enum::VALUES || values.to_set
+    bad = (vs - vals)
+    p = bad.count > 1 ? 's' : ''
+    return errors[errtype] <<
+           %Q(- Bad value#{p} '#{bad.to_a.join("', '")}' for #{ns}) if bad.present?
+  end
+  def validate
+    self.class.guard_info.each { |name, h| check(name, h) }
+    grids.each do |vn, gn|
+      return errors[:grids] << "- Bad grid name '#{gn}' for '#{vn}'" unless
+        gn.blank? || Marty::DataGrid.lookup('infinity', gn)
+    end
+    cg_err = computed_guards.delete("~~ERROR~~")
+    errors[:computed] <<
+      "- Error in rule '#{name}' field 'computed_guards': #{cg_err.capitalize}" if cg_err
+    res_err = results.delete("~~ERROR~~")
+    errors[:computed] <<
+      "- Error in rule '#{name}' field 'results': #{res_err.capitalize}" if res_err
+
+    same_name_diff_guards = self.class.
+        where(obsoleted_dt: 'infinity', name: self.name).
+        # id is nil on new rules
+        where.not(id: self.id).
+        where("simple_guards != '#{self.simple_guards.to_json}'")
+
+    errors[:base] =
+      "Can't have rule with same name and different type/guards" +
+      " - #{self.name}" if same_name_diff_guards.exists?
+
+  end
+
+  validates_presence_of :name
+  validate :validate
+
+  before_validation(on: [:create, :update]) do
+    self.simple_guards     ||= {}
+    self.computed_guards   ||= {}
+    self.grids             ||= {}
+    self.results           ||= {}
+  end
+
+  before_create do
+    self.class.guard_info.each do |k,v|
+      next if v[:default].blank? || self.simple_guards.include?(k)
+      self.simple_guards[k] = v[:default]
+    end
+  end
+
+  def self.get_subq(field, subfield, multi, type, vraw)
+    arrow = multi || ![:range, :string, :date, :datetime].include?(type) ?
+              "->" : "->>"
+    op = multi || type == :range ? "@>" : "="
+    value0 = [:string, :date, :datetime].include?(type) ?
+               ActiveRecord::Base.connection.quote(vraw) :
+               type == :range ? vraw.to_f :
+                 "'#{vraw}'::jsonb"
+    value = multi ? %Q('["%s"]') % value0[1..-2] : value0
+    fieldcast = type == :range ? "::numrange" : ''
+    "(#{field}#{arrow}'#{subfield}')#{fieldcast} #{op} #{value}"
+  end
+
+  def self.get_matches_(pt, attrs, params)
+
+    q = select("DISTINCT ON (name) *").where(attrs)
+
+    params.each do |k, vraw|
+      h = guard_info
+      use_k = (h[k] && k) ||
+              (h[k+"_array"] && k+"_array") ||
+              (h[k+"_range"] && k+"_range")
+      next unless use_k
+      multi, type = h[use_k].values_at(:multi, :type)
+      filts = [vraw].flatten.map do |v|
+        qstr = get_subq('simple_guards', use_k, multi, type, v)
+      end.join(" OR ")
+      isn = "simple_guards->'#{use_k}' IS NULL OR"
+
+      q = q.where("(#{isn} #{filts})")
+    end
+   # print q.to_sql
+    q.order(:name)
+  end
+
+end

data/app/models/marty/delorean_rule.rb

@@ -0,0 +1,121 @@
+class Marty::DeloreanRule < Marty::BaseRule
+  self.abstract_class = true
+
+  validates_presence_of :rule_type, :start_dt
+
+  def validate
+    super
+    if self.class.where(obsoleted_dt: 'infinity', name: name).
+        where.not(id: id).
+        where("(start_dt, coalesce(end_dt, 'infinity')) OVERLAPS (?, ?)",
+              start_dt, end_dt || 'infinity').exists?
+      return errors[:base] <<
+             "Can't have rule with same name and overlapping start/end dates"\
+             " - #{name}"
+    end
+
+    return errors[:base] = "Start date must be before end date" if
+      start_dt && end_dt && start_dt >= end_dt
+
+    if computed_guards.present? || results.present?
+      begin
+        eclass = engine && engine.constantize || Marty::RuleScriptSet
+        eng = eclass.new('infinity').get_engine(self)
+      rescue => e
+        return errors[:computed] = "- " + e.message
+      end
+    end
+  end
+
+  def self.find_fixed(results)
+    results.each_with_object({}) do |(k, v), h|
+      v_wo_comment = /\A([^#]+)/.match(v)[1] if v.include?("#")
+      # if v contains a #, try cut it there and attempt parse that way first
+      jp = (v_wo_comment && JSON.parse("[#{v_wo_comment}]") rescue nil) ||
+           (JSON.parse("[#{v}]") rescue nil)
+      next h[k] = jp[0] if jp
+      # json doesn't like single quotes, so handle those manually
+      m = %r{\A'(.*)'\z}.match(v)
+      next unless m
+      h[k] = m[1]
+    end
+  end
+
+  before_validation(on: [:create, :update]) do
+    # identify result values that are fixed, stash them (removing quotes)
+    self.fixed_results = self.class.find_fixed(self.results)
+  end
+
+  def self.results_cfg_var
+    "NOT DEFINED"
+  end
+
+  def compg_keys
+    computed_guards.keys
+  end
+
+  def compres_keys
+    defkeys = (Marty::Config[self.class.results_cfg_var] || {}).keys +
+              ["adjustment", "breakeven"]
+    results.keys.select{|k| defkeys.include?(k)} + grid_keys
+  end
+  def grid_keys
+      grids.keys.map{|k|k.ends_with?("_grid") ? k : k + "_grid"}
+  end
+  def base_compute(params, dgparams=params)
+    eclass = engine && engine.constantize || Marty::RuleScriptSet
+    engine = eclass.new(params["pt"]).get_engine(self) if
+      computed_guards.present? || results.present?
+
+    if computed_guards.present?
+      begin
+        res = engine.evaluate(eclass.node_name,
+                              compg_keys,
+                              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?
+    end
+    grids_computed = false
+    grid_results = {}
+    if (results.keys - fixed_results.keys).present?
+        begin
+          eval_result = engine.evaluate(
+            eclass.node_name,
+            compres_keys,
+            params + {
+              "dgparams__" => dgparams,
+            })
+          grids_computed = true
+        rescue => e
+          raise e, "Error (results) in rule '#{id}:#{name}': #{e}", e.backtrace
+        end
+        result = Hash[compres_keys.zip(eval_result)]
+    elsif fixed_results.keys.sort == results.keys.sort
+      result = fixed_results
+    end
+    if grids.present? && !grids_computed
+      pt = params['pt']
+      gres = {}
+      grid_results = grids.each_with_object({}) do |(gvar, gname), h|
+        usename = gvar.ends_with?("_grid") ? gvar : gvar + "_grid"
+        next h[usename] = gres[gname] if gres[gname]
+        dg = Marty::DataGrid.lookup(pt,gname)
+        dgr = dg && dg.lookup_grid_distinct_entry(pt, dgparams)
+        h[usename] = gres[gname] = dgr["result"] if dgr
+      end
+    end
+    result + grid_results
+  end
+
+  def self.get_matches_(pt, attrs, params)
+    q = super(pt, attrs.except("rule_dt"), params)
+    rule_dt = attrs["rule_dt"]
+    q=q.where("start_dt <= ?", rule_dt).
+       where("end_dt >= ? OR end_dt IS NULL", rule_dt) if rule_dt
+    #puts q.to_sql
+    q
+  end
+
+end

data/lib/marty/data_importer.rb

@@ -85,7 +85,6 @@ module Marty
         end
 
         ids = {}
-
         # raise an error if record referenced more than once.
         res.each_with_index do
           |(op, id), line|

data/lib/marty/rule_script_set.rb

@@ -0,0 +1,176 @@
+class Marty::RuleScriptSet < Delorean::AbstractContainer
+  attr_reader :sset, :pt
+
+  def self.clear_cache
+    @@engines, @@dengines, @@dengines_dt = {}, {}, nil
+  end
+
+  clear_cache
+
+  def self.node_name
+    "Node"
+  end
+  def self.body_start
+    "#{node_name}:\n"
+  end
+  def self.body_lines
+    self.body_start.count("\n")
+  end
+
+  def initialize(pt)
+    @pt = Mcfly.normalize_infinity(pt)
+
+    # if pt is Infinity, we get a DEV Tag
+    tag = Marty::Tag.cached_find_match(pt)
+    @sset = Marty::ScriptSet.new(tag)
+    super()
+  end
+
+  def parse_check(sname, body)
+    sset.parse_check(sname, body)
+  end
+
+  def write_attr(k, v)
+    k + (v == :parameter ? " =?" : " = #{v}")
+  end
+
+  def paramify_h(h)
+    "{" + h.keys.reject{|k|k.ends_with?("__")}.
+                         map {|k| %Q("#{k}": #{k}) }.join(",\n") + "}"
+  end
+
+  def expand_grid_code(h, dgid, dgname, cache, extra_params)
+    final_name = dgid.ends_with?("_grid") ?  dgid : dgid + "_grid"
+    if cache[dgname]
+      h[final_name] = "#{cache[dgname]}"
+    else
+      h["#{dgid}_dg__"] = "Marty::DataGrid.lookup(pt,'#{dgname}')"
+      h["#{dgid}_dgp__"] = "dgparams__ + \n" + self.class.indent(paramify_h(h))
+      lgde = "lookup_grid_distinct_entry"
+      h["#{dgid}_h__"] = "#{dgid}_dg__.#{lgde}(pt,#{dgid}_dgp__)"
+      h[final_name] = "#{dgid}_h__ && #{dgid}_h__.result"
+      cache[dgname] = final_name
+    end
+  end
+
+  def write_code(attrs)
+    return '' if attrs.blank?
+    newh = attrs.each_with_object({}) do |(k, v), h|
+      if k.ends_with?("_grid")
+        expand_grid_code(h, k, v, {}, h)
+      else
+        h[k] = v
+      end
+    end
+    newh.map { |k, v| write_attr(k, v) }.join("\n") + "\n"
+  end
+
+  def grid_code(rule)
+    dgcache = {}
+    h = {}
+    rule.grids.each do |k, v|
+      expand_grid_code(h, k, v, dgcache, {})
+    end
+    h.map { |k, v| write_attr(k, v) }.join("\n") + "\n"
+  end
+
+  def guard_code(rule)
+    write_code(rule.computed_guards)
+  end
+
+  def result_code(rule)
+    write_code(rule.results)
+  end
+
+  def grid_init(rule)
+    if rule.grids.present? || rule.results.keys.any?{|k|k.ends_with?("_grid")}
+      write_code({ "pt" => :parameter,
+                   "dgparams__" => :parameter,
+                 })
+    else
+      ''
+    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)
+
+    code = self.class.body_start + self.class.indent(grid_i +
+                                                     guard_c +
+                                                     grid_c +
+                                                     result_c)
+    #puts '='*40
+    #puts rule.name
+    #puts '-'
+    #puts code
+    #puts '-'*10
+    code
+  end
+
+  def code_section_counts(rule)
+    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
+  end
+  def get_parse_error_field(rule, exc)
+    line = exc.line ? exc.line - self.class.body_lines : 0
+    errs = code_section_counts(rule)
+    line_count = 0
+    errs.each do |k,v|
+      line_count += v
+      return k if line <= line_count
+    end
+    errs.keys.last
+  end
+
+  def get_engine(rule)
+    begin
+      # if rule is a str => importing a regular Script (i.e. not rule)
+      return sset.get_engine(rule) if rule.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
+
+      rule_pfx = rule.class.name.demodulize
+
+      # unique name for specific version of rule
+      sname = "#{rule_pfx}_#{rule.group_id}_#{rule.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
+
+        @@dengines_dt ||= max_dt
+
+        # reset dengine cache if an rule has changed
+        @@dengines = {} if max_dt > @@dengines_dt
+
+        engine = @@dengines[sname]
+
+        return engine if engine
+
+        @@dengines[sname] = sset.parse_check(sname, get_code(rule))
+      else
+        engine = @@engines[[pt, sname]]
+
+        return engine if engine
+
+        @@engines[[pt, sname]] = sset.parse_check(sname, get_code(rule))
+      end
+    rescue Delorean::ParseError => e
+      f = get_parse_error_field(rule, e)
+      raise "Error in rule '#{rule.name}' field '#{f}': #{e}"
+    end
+  end
+
+  def self.indent(s)
+    s.gsub(/^/, ' '*4)
+  end
+end