marty 2.5.2 → 2.5.4

data/app/models/marty/delorean_rule.rb

@@ -5,43 +5,46 @@ class Marty::DeloreanRule < Marty::BaseRule
 
   def validate
     super
-    return errors[:base] << "Start date must be before end date" if
+    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_as_hash)
-      rescue => e
-        return errors[:computed] << "- " + e.message
+      rescue StandardError => e
+        return errors[:computed] << '- ' + e.message
       end
     end
   end
 
   def self_as_hash
-    self.attributes + {"classname"=>self.class.name}
+    attributes + { 'classname' => self.class.name }
   end
+
   def self.find_fixed(results)
     results.each_with_object({}) do |(k, v), h|
-      v_wo_comment = /\A([^#]+)/.match(v)[1] if v.include?("#")
+      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)
+    self.fixed_results = self.class.find_fixed(results)
   end
 
   def self.results_cfg_var
-    "NOT DEFINED"
+    'NOT DEFINED'
   end
 
   def self.compg_keys(computed_guards)
@@ -51,11 +54,12 @@ class Marty::DeloreanRule < Marty::BaseRule
   def self.comp_res_keys(results, grids, ecl, pcfg)
     # FIXME in May 2019: remove this check (use as passed)
     defkeys = pcfg.is_a?(Hash) ? pcfg.keys : pcfg
-    results.keys.map {|k| k.ends_with?("_grid") ? ecl.grid_final_name(k) : k}.
-       select{|k| defkeys.include?(k)} + grid_keys(grids, ecl)
+    results.keys.map { |k| k.ends_with?('_grid') ? ecl.grid_final_name(k) : k }.
+       select { |k| defkeys.include?(k) } + grid_keys(grids, ecl)
   end
+
   def self.grid_keys(grids, eclass)
-      grids.keys.map{|k| eclass.grid_final_name(k) }
+      grids.keys.map { |k| eclass.grid_final_name(k) }
   end
 
   class ComputeError < StandardError
@@ -69,14 +73,14 @@ class Marty::DeloreanRule < Marty::BaseRule
     end
   end
 
-  def self.base_compute2(ruleh, metadata_opts, params, dgparams=params)
-    begin
+  def self.base_compute2(ruleh, metadata_opts, params, dgparams = params)
       id, name, eclassname, computed_guards, grids, results, fixed_results =
-          ruleh.values_at("id", "name", "engine", "computed_guards", "grids",
-                          "results", "fixed_results")
+        ruleh.values_at('id', 'name', 'engine', 'computed_guards', 'grids',
+                        'results', 'fixed_results')
       raise "Error in rule '#{id}:#{name}': bad metadata_opts" if !metadata_opts
+
       eclass = eclassname && eclassname.constantize || Marty::RuleScriptSet
-      engine = eclass.new(params["pt"]).get_engine(ruleh) if
+      engine = eclass.new(params['pt']).get_engine(ruleh) if
         computed_guards.present? || results.present?
 
       result = OpenStruct.new(cg_keys: compg_keys(computed_guards))
@@ -85,18 +89,18 @@ class Marty::DeloreanRule < Marty::BaseRule
         begin
           result.cg_vals = engine.evaluate(eclass.node_name, result.cg_keys,
                                            params.clone)
-        rescue => e
+        rescue StandardError => e
           result.err_message = e.message
           result.err_stack   = e.backtrace
           result.err_section = 'computed_guards'
           raise ComputeError.new(
-                  "Error (guard) in rule '#{id}:#{name}': #{result.err_message}",
-                  result.err_stack,
-                  params.clone,
-                  result.err_section)
+            "Error (guard) in rule '#{id}:#{name}': #{result.err_message}",
+            result.err_stack,
+            params.clone,
+            result.err_section)
         end
         result.cg_hash = Hash[result.cg_keys.zip(result.cg_vals)]
-        fails = result.cg_hash.select{|k,v| ![v].flatten.first}
+        fails = result.cg_hash.select { |k, v| ![v].flatten.first }
         return fails if fails.present?
       end
 
@@ -109,20 +113,20 @@ class Marty::DeloreanRule < Marty::BaseRule
             eclass.node_name,
             result.res_keys,
             params + {
-              "dgparams__" => dgparams,
+              'dgparams__' => dgparams,
             })
           grids_computed = true
-        rescue => e
+        rescue StandardError => e
           result.err_message = e.message
           result.err_stack   = e.backtrace
           result.err_section = 'results'
           raise ComputeError.new(
-                  "Error (results) in rule '#{id}:#{name}': #{result.err_message}",
-                  result.err_stack,
-                  params + {
-                    "dgparams__" => dgparams,
-                  },
-                  result.err_section)
+            "Error (results) in rule '#{id}:#{name}': #{result.err_message}",
+            result.err_stack,
+            params + {
+              'dgparams__' => dgparams,
+            },
+            result.err_section)
         end
         result.res_hash = Hash[result.res_keys.zip(result.res_vals)]
       else
@@ -135,76 +139,73 @@ class Marty::DeloreanRule < Marty::BaseRule
         result.gr_hash = grids.each_with_object({}) do |(gvar, gname), h|
           usename = eclass.grid_final_name(gvar)
           next h[usename] = gres[gname] if gres[gname]
-          dg = Marty::DataGrid.lookup_h(pt,gname)
+
+          dg = Marty::DataGrid.lookup_h(pt, gname)
           dgr = dg && Marty::DataGrid.lookup_grid_distinct_entry_h(pt, dgparams,
                                                                    dg)
-          h[usename] = gres[gname] = dgr["result"] if dgr
+          h[usename] = gres[gname] = dgr['result'] if dgr
         end
       end
-      (result.res_hash||{}) + (result.gr_hash||{})
-    ensure
+      (result.res_hash || {}) + (result.gr_hash || {})
+  ensure
       if ruleh['fixed_results']['log__']
         resh = result.to_h
-        [:res_keys, :res_vals].each {|k|resh.delete(k)} if
+        [:res_keys, :res_vals].each { |k| resh.delete(k) } if
           result.res_hash.present? || result.res_keys.blank?
-        [:cg_keys, :cg_vals].each {|k|resh.delete(k)} if
+        [:cg_keys, :cg_vals].each { |k| resh.delete(k) } if
           result.cg_hash.present? ||  result.cg_keys.blank?
         resh.delete(:gr_keys) if result.gr_hash.present? || result.gr_keys.blank?
         estack_full = resh.delete(:err_stack)
         estack = estack_full && {
-          err_stack: estack_full.select{ |l| l.starts_with?('DELOREAN')}} || {}
-        detail = { input: params, dgparams: dgparams} + resh + estack
+          err_stack: estack_full.select { |l| l.starts_with?('DELOREAN') } } || {}
+        detail = { input: params, dgparams: dgparams } + resh + estack
         Marty::Logger.info("Rule Log #{ruleh['name']}",
                            Marty::Util.scrub_obj(detail))
       end
-    end
   end
 
-  delorean_fn :route_compute, sig: 4 do
-    |ruleh, pt, params, grid_names_p|
-    kl = ruleh["classname"].constantize
+  delorean_fn :route_compute, sig: 4 do |ruleh, pt, params, grid_names_p|
+    kl = ruleh['classname'].constantize
     kl.compute(ruleh, nil, pt, params, grid_names_p)
   end
-  delorean_fn :route_compute2, sig: 5 do
-    |ruleh, metadata_opts, pt, params, grid_names_p|
-    kl = ruleh["classname"].constantize
+  delorean_fn :route_compute2, sig: 5 do |ruleh, metadata_opts, pt, params, grid_names_p|
+    kl = ruleh['classname'].constantize
     kl.compute(ruleh, metadata_opts, pt, params, grid_names_p)
   end
-  delorean_fn :route_compute_rs, sig: 3 do
-    |ruleh, pt, features|
-    kl = ruleh["classname"].constantize
+  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
+  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
+  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_compute2(metadata_opts, params, dgparams=params)
+  def base_compute2(metadata_opts, params, dgparams = params)
     self.class.base_compute2(self_as_hash, metadata_opts, params, dgparams)
   end
 
   def self.get_matches_(pt, attrs, params)
-    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 = 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
 
   def self.get_grid_rename_handler(klass)
-    Proc.new do |old, new|
+    proc do |old, new|
       klass.where(obsoleted_dt: 'infinity').each do |r|
         r.grids.each { |k, v| r.grids[k] = new if v == old }
-        r.results.each { |k, v| r.results[k] = %Q("#{new}") if
-                         k.ends_with?("_grid") && r.fixed_results[k] == old }
+        r.results.each do |k, v|
+          r.results[k] = %Q("#{new}") if
+                         k.ends_with?('_grid') && r.fixed_results[k] == old
+        end
         r.save! if r.changed?
       end
     end

data/app/models/marty/enum.rb

@@ -6,7 +6,7 @@ module Marty::Enum
 
     res = @LOOKUP_CACHE[index] ||= find_by_name(index)
 
-    raise "no such #{self.name}: '#{index}'" unless res
+    raise "no such #{name}: '#{index}'" unless res
 
     res
   end

data/app/models/marty/event.rb

@@ -1,8 +1,7 @@
 class Marty::Event < Marty::Base
-
   class EventValidator < ActiveModel::Validator
     def validate(event)
-      event.errors[:base] << "Must have promise_id or start_dt" unless
+      event.errors[:base] << 'Must have promise_id or start_dt' unless
         event.promise_id || event.start_dt
     end
   end
@@ -14,10 +13,10 @@ class Marty::Event < Marty::Base
   validates_with EventValidator
 
   after_validation(on: [:create, :update]) do
-    self.comment = self.comment.truncate(255) if self.comment
+    self.comment = comment.truncate(255) if comment
   end
 
-  UPDATE_SQL =<<SQL
+  UPDATE_SQL = <<SQL
   UPDATE marty_events as me
   SET start_dt = p.start_dt,
       end_dt = p.end_dt
@@ -31,7 +30,7 @@ class Marty::Event < Marty::Base
             )
         )
 SQL
-  BASE_QUERY =<<SQL
+  BASE_QUERY = <<SQL
 SELECT id,
             klass,
             subject_id,
@@ -54,8 +53,8 @@ SQL
 
   def self.op_is_running?(klass, subject_id, operation)
     all_running.detect do |pm|
-      pm["klass"] == klass && pm["subject_id"].to_i == subject_id.to_i &&
-        pm["enum_event_operation"] == operation
+      pm['klass'] == klass && pm['subject_id'].to_i == subject_id.to_i &&
+        pm['enum_event_operation'] == operation
     end
   end
 
@@ -64,27 +63,27 @@ SQL
                         operation,
                         start_dt,
                         expire_secs,
-                        comment=nil)
+                        comment = nil)
 
     # use lookup_event instead of all_running which is throttled
-    evs = self.lookup_event(klass, subject_id, operation)
-    running = evs.detect do
-      |ev|
-      next if ev["end_dt"]
-      next true unless ev["expire_secs"]
-      (Time.zone.now - ev["start_dt"]).truncate < ev["expire_secs"]
+    evs = lookup_event(klass, subject_id, operation)
+    running = evs.detect do |ev|
+      next if ev['end_dt']
+      next true unless ev['expire_secs']
+
+      (Time.zone.now - ev['start_dt']).truncate < ev['expire_secs']
     end
 
     raise "#{operation} is already running for #{klass}/#{subject_id}" if
       running
 
-    self.create!(klass:                klass,
+    create!(klass:                klass,
                  subject_id:           subject_id,
                  enum_event_operation: operation,
                  start_dt:             start_dt,
                  expire_secs:          expire_secs,
                  comment:              comment,
-                )
+           )
   end
 
   def self.lookup_event(klass, subject_id, operation)
@@ -94,33 +93,35 @@ SQL
               AND subject_id = #{subject_id}
               AND enum_event_operation = '#{operation}'")
 
-    #For now we return a bare hash
-    #Marty::Event.find_by_id(hash["id"])
+    # For now we return a bare hash
+    # Marty::Event.find_by_id(hash["id"])
   end
 
-  def self.finish_event(klass, subject_id, operation, error=false, comment=nil)
-    raise "error must be true or false" unless [true, false].include?(error)
+  def self.finish_event(klass, subject_id, operation, error = false, comment = nil)
+    raise 'error must be true or false' unless [true, false].include?(error)
+
     time_now_s = Time.zone.now.strftime('%Y-%m-%d %H:%M:%S.%6N')
 
     event = get_data(running_query(time_now_s)).detect do |ev|
-      ev["klass"] == klass && ev["subject_id"] == subject_id.to_i &&
-        ev["enum_event_operation"] == operation
+      ev['klass'] == klass && ev['subject_id'] == subject_id.to_i &&
+        ev['enum_event_operation'] == operation
     end
     raise "event #{klass}/#{subject_id}/#{operation} not found" unless
       event
 
-    ev = Marty::Event.find_by_id(event["id"])
+    ev = Marty::Event.find_by_id(event['id'])
     raise "can't explicitly finish a promise event" if ev.promise_id
+
     ev.end_dt = Time.zone.now
     ev.error = error
     ev.comment = comment if comment
     ev.save!
   end
 
-  def self.last_event(klass, subject_id, operation=nil)
+  def self.last_event(klass, subject_id, operation = nil)
     hash = all_running.select do |pm|
-      pm["klass"] == klass && pm["subject_id"] == subject_id.to_i &&
-        (operation.nil? || pm["enum_event_operation"] == operation)
+      pm['klass'] == klass && pm['subject_id'] == subject_id.to_i &&
+        (operation.nil? || pm['enum_event_operation'] == operation)
     end.last
 
     return hash if hash
@@ -134,14 +135,13 @@ SQL
               ORDER BY end_dt desc").first
   end
 
-  def self.last_event_multi(klass, subject_ids_arg, operation=nil)
+  def self.last_event_multi(klass, subject_ids_arg, operation = nil)
     subject_ids = subject_ids_arg.map(&:to_i)
     events = all_running.select do |pm|
-      pm["klass"] == klass && subject_ids.include?(pm["subject_id"]) &&
-        (operation.nil? || pm["enum_event_operation"] == operation)
-    end.group_by { |ev| ev["subject_id"] }.each_with_object({}) do
-      |(id, evs), h|
-      h[id] = evs.sort { |a, b| a["start_dt"] <=> b["start_dt"] }.first
+      pm['klass'] == klass && subject_ids.include?(pm['subject_id']) &&
+        (operation.nil? || pm['enum_event_operation'] == operation)
+    end.group_by { |ev| ev['subject_id'] }.each_with_object({}) do |(id, evs), h|
+      h[id] = evs.sort { |a, b| a['start_dt'] <=> b['start_dt'] }.first
     end
 
     running_ids = events.keys
@@ -149,7 +149,7 @@ SQL
 
     if check_fin.present?
       op_filt = "AND enum_event_operation = '#{operation}'" if operation
-      op_col = ", enum_event_operation" if operation
+      op_col = ', enum_event_operation' if operation
 
       fins = get_data("SELECT klass,
                               subject_id,
@@ -179,7 +179,7 @@ SQL
                        WHERE rnum = 1")
 
       fins.each do |fin|
-        events[fin["subject_id"]] = fin
+        events[fin['subject_id']] = fin
       end
     end
     events
@@ -187,16 +187,16 @@ SQL
 
   def self.currently_running(klass, subject_id)
     all_running.select do |pm|
-      pm["klass"] == klass && pm["subject_id"] == subject_id.to_i
-    end.map { |e| e["enum_event_operation"] }
+      pm['klass'] == klass && pm['subject_id'] == subject_id.to_i
+    end.map { |e| e['enum_event_operation'] }
   end
 
   def self.currently_running_multi(klass, subject_id_raw)
     subject_ids = [subject_id_raw].flatten.map(&:to_i)
     all_running.select do |pm|
-      pm["klass"] == klass && subject_ids.include?(pm["subject_id"])
+      pm['klass'] == klass && subject_ids.include?(pm['subject_id'])
     end.each_with_object({}) do |e, h|
-      (h[e["subject_id"]] ||= []) <<  e["enum_event_operation"]
+      (h[e['subject_id']] ||= []) << e['enum_event_operation']
     end
   end
 
@@ -210,12 +210,12 @@ SQL
   def self.pretty_op(hash)
     d = hash['enum_event_operation'].downcase.capitalize
 
-    #&& !(hash['comment'] =~ /^ERROR/)
+    # && !(hash['comment'] =~ /^ERROR/)
     hash['end_dt'] ? d.sub(/ing/, 'ed') : d
   end
 
   def self.compact_end_dt(hash)
-    hash['end_dt'] ? hash['end_dt'].strftime("%H:%M") : '---'
+    hash['end_dt'] ? hash['end_dt'].strftime('%H:%M') : '---'
   end
 
   def self.update_start_and_end
@@ -224,13 +224,13 @@ SQL
 
   def self.get_data(sql)
     ActiveRecord::Base.connection.execute(sql).to_a.map do |h|
-      h["id"]          = h["id"].to_i
-      h["subject_id"]  = h["subject_id"].to_i
-      h["start_dt"]    = Time.zone.parse(h["start_dt"]) if h["start_dt"]
-      h["end_dt"]      = Time.zone.parse(h["end_dt"]) if h["end_dt"]
-      h["expire_secs"] = h["expire_secs"].to_i if h["expire_secs"]
-      h["comment"]     = h["comment"]
-      h["error"]       = h["error"]
+      h['id']          = h['id'].to_i
+      h['subject_id']  = h['subject_id'].to_i
+      h['start_dt']    = Time.zone.parse(h['start_dt']) if h['start_dt']
+      h['end_dt']      = Time.zone.parse(h['end_dt']) if h['end_dt']
+      h['expire_secs'] = h['expire_secs'].to_i if h['expire_secs']
+      h['comment']     = h['comment']
+      h['error']       = h['error']
       h
     end
   end
@@ -289,17 +289,17 @@ SQL
         WHERE row_num = 1")
       @all_finished[:timestamp] = time_now_i
       raw.each_with_object(@all_finished[:data]) do |ev, hash|
-        if ev["end_dt"] && ev["error"].nil?
-          real_ev = Marty::Event.where(id: ev["id"]).first
-          promise = Marty::Promise.where(id: real_ev["promise_id"]).first
-          maybe_error = promise.result["error"]
-          ev["error"] = real_ev.error = !!maybe_error
+        if ev['end_dt'] && ev['error'].nil?
+          real_ev = Marty::Event.where(id: ev['id']).first
+          promise = Marty::Promise.where(id: real_ev['promise_id']).first
+          maybe_error = promise.result['error']
+          ev['error'] = real_ev.error = !!maybe_error
           real_ev.comment = maybe_error
           real_ev.save!
         end
-        subhash = hash[[ev["klass"], ev["subject_id"]]] ||= {}
-        subhash[ev["enum_event_operation"]] =
-          ev["end_dt"].strftime("%Y-%m-%d %H:%M:%S")
+        subhash = hash[[ev['klass'], ev['subject_id']]] ||= {}
+        subhash[ev['enum_event_operation']] =
+          ev['end_dt'].strftime('%Y-%m-%d %H:%M:%S')
       end
     end
     @all_finished[:data]
@@ -310,11 +310,8 @@ SQL
   end
 
   def self.cleanup
-    begin
       where('start_dt < ?', Time.zone.now - 48.hours).delete_all
-    rescue => exc
+  rescue StandardError => exc
       Marty::Util.logger.error("event GC error: #{exc}")
-    end
   end
-
 end