marty 2.5.2 → 2.5.4

data/app/models/marty/helper.rb

@@ -1,21 +1,53 @@
 class Marty::Helper
   include Delorean::Model
 
-  delorean_fn :sleep, sig: 1 do
-    |seconds|
+  delorean_fn :sleep, sig: 1 do |seconds|
     Kernel.sleep seconds
   end
 
-  delorean_fn :range_step, sig: 3 do
-    |rstart, rend, step|
+  delorean_fn :range_step, sig: 3 do |rstart, rend, step|
     (rstart..rend).step(step).to_a
   end
 
-  delorean_fn :my_ip, sig:0 do
+  delorean_fn :my_ip, sig: 0 do
     Marty::Diagnostic::Node.my_ip
   end
 
-  delorean_fn :git, sig:0 do
+  delorean_fn :git, sig: 0 do
     [my_ip, ENV['DELAYED_VER']]
   end
+
+  delorean_fn :infinity_dt, sig: 1 do |pt|
+    Mcfly.is_infinity pt
+  end
+
+  delorean_fn :constantize, sig: 1 do |class_name|
+    raise 'bad class_name' unless class_name.is_a?(String)
+
+    class_name.constantize
+  end
+
+  delorean_fn :get_column_types, sig: 1 do |klass|
+    Marty::DataConversion.col_types(klass)
+  end
+
+  delorean_fn :parse_csv_to_hash, sig: 3 do |txt, comma_sep, types|
+    txt ||= ''
+    headers, *rows = CSV.parse(txt.strip,
+                               headers: true,
+                               col_sep: (comma_sep ? ',' : "\t")).to_a
+    rows.map do |row|
+      headers.zip(row).each_with_object({}) do |(h, v), res|
+        res[h] = v.blank? ? nil :
+                   Marty::DataConversion.convert(v, (types[h] || 'text').to_sym)
+      end
+    end
+  end
+
+  delorean_fn :to_csv, sig: [1, 2] do |*args|
+    # NOTE: can't use |data, config| due to delorean_fn weirdness.
+    data, config = args
+
+    Marty::DataExporter.to_csv(data, config)
+  end
 end

data/app/models/marty/import_type.rb

@@ -4,7 +4,7 @@ class Marty::ImportType < Marty::Base
       klass = entry.get_model_class
 
       unless klass.is_a?(Class) && klass < ActiveRecord::Base
-        entry.errors.add :base, "bad model name"
+        entry.errors.add :base, 'bad model name'
         return
       end
 
@@ -12,19 +12,19 @@ class Marty::ImportType < Marty::Base
         entry.cleaner_function,
         entry.validation_function,
         entry.preprocess_function,
-      ].each { |func|
+      ].each do |func|
         entry.errors.add(:base, "unknown class method #{func}") if
         func && !klass.respond_to?(func.to_sym)
-      }
+      end
     end
   end
 
   before_validation do
     # Fix issue with blank strings in popup edit form or grid
     # being interpreted as a function
-    self.cleaner_function = nil if self.cleaner_function.blank?
-    self.validation_function = nil if self.validation_function.blank?
-    self.preprocess_function = nil if self.preprocess_function.blank?
+    self.cleaner_function = nil if cleaner_function.blank?
+    self.validation_function = nil if validation_function.blank?
+    self.preprocess_function = nil if preprocess_function.blank?
   end
 
   belongs_to :role

data/app/models/marty/log.rb

@@ -9,7 +9,7 @@ class Marty::Log < Marty::Base
               message: message,
               details: details,
               timestamp: Time.zone.now)
-    rescue => e
+    rescue StandardError => e
       Marty::Util.logger.error("Marty::Logger failure: #{e.message}")
     end
     true
@@ -18,6 +18,7 @@ class Marty::Log < Marty::Base
   def self.cleanup(days_to_keep)
     raise "Must give numeric value. (Got '#{days_to_keep}')" unless
       (Float(days_to_keep) rescue false)
-    where("timestamp <= ?", Time.zone.now - days_to_keep.to_i.days).delete_all
+
+    where('timestamp <= ?', Time.zone.now - days_to_keep.to_i.days).delete_all
   end
 end

data/app/models/marty/name_validator.rb

@@ -1,6 +1,7 @@
 class Marty::NameValidator < ActiveModel::Validator
   def validate(entry)
-    raise "need field option" unless options[:field]
+    raise 'need field option' unless options[:field]
+
     field = options[:field].to_sym
     value = entry.send(field)
 
@@ -9,7 +10,7 @@ class Marty::NameValidator < ActiveModel::Validator
     # disallow leading, trailing, >1 internal spaces, special chars (|)
     if value =~ /\A\s|\s\z|\A.*\s\s.*\z|.*\|.*/
       entry.errors[field] <<
-        I18n.t("activerecord.errors.messages.extraneous_spaces")
+        I18n.t('activerecord.errors.messages.extraneous_spaces')
     end
   end
 end

data/app/models/marty/pg_enum.rb

@@ -1,16 +1,15 @@
 module Marty::PgEnum
-
-  def [](i0, i1=nil)
+  def [](i0, i1 = nil)
     # if i1 is provided, then i0 is a pt and we ignore it.
     index = (i1 || i0).to_s
 
-    raise "no such #{self.name}: '#{index}'" unless
+    raise "no such #{name}: '#{index}'" unless
       self::VALUES.include?(index)
 
     index
   end
 
-  def get_all(pt=nil)
+  def get_all(pt = nil)
     self::VALUES.map(&:to_s)
   end
 

data/app/models/marty/posting.rb

@@ -4,7 +4,7 @@ class Marty::Posting < Marty::Base
   mcfly_validates_uniqueness_of :name
   validates_presence_of :name, :posting_type_id, :comment
 
-  belongs_to :user, class_name: "Marty::User"
+  belongs_to :user, class_name: 'Marty::User'
   belongs_to :posting_type
 
   def self.make_name(posting_type, dt)
@@ -22,8 +22,8 @@ class Marty::Posting < Marty::Base
 
   before_validation :set_posting_name
   def set_posting_name
-    posting_type = Marty::PostingType.find_by_id(self.posting_type_id)
-    self.name = self.class.make_name(posting_type, self.created_dt)
+    posting_type = Marty::PostingType.find_by_id(posting_type_id)
+    self.name = self.class.make_name(posting_type, created_dt)
     true
   end
 
@@ -41,7 +41,7 @@ class Marty::Posting < Marty::Base
   end
 
   def self.get_struct_attrs
-    self.struct_attrs ||= super + ["created_dt", "name"]
+    self.struct_attrs ||= super + ['created_dt', 'name']
   end
 
   # Not using mcfly_lookup since we don't want these time-warp markers
@@ -49,43 +49,39 @@ 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 do
-    |name|
+  delorean_fn :lookup, sig: 1 do |name|
     p = select(get_struct_attrs).find_by_name(name)
     make_openstruct(p)
   end
 
-  delorean_fn :lookup_dt, sig: 1 do
-    |name|
+  delorean_fn :lookup_dt, sig: 1 do |name|
     find_by_name(name).try(:created_dt)
   end
 
-  delorean_fn :first_match, sig: [1, 2] do
-    |dt, posting_type=nil|
-    raise "bad posting type" if
+  delorean_fn :first_match, sig: [1, 2] do |dt, posting_type = nil|
+    raise 'bad posting type' if
       posting_type && !posting_type.is_a?(Marty::PostingType)
 
-    q = where("created_dt <= ?", dt)
+    q = where('created_dt <= ?', dt)
     q = q.where(posting_type_id: posting_type.id) if posting_type
-    q.order("created_dt DESC").first.attributes
+    q.order('created_dt DESC').first.attributes
   end
 
-  def self.get_latest(limit, is_test=nil)
+  def self.get_latest(limit, is_test = nil)
     # IMPORTANT: is_test arg is ignored (KEEP for backward compat.)
 
-    q=where("created_dt <> 'infinity'").
-       order("created_dt DESC").limit(limit)
+    q = where("created_dt <> 'infinity'").
+       order('created_dt DESC').limit(limit)
   end
 
-  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)
+  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)
 
-    q=joins(:posting_type).where("created_dt <> 'infinity'").
-       where(marty_posting_types: { name: posting_types } ).
+    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}
+       order('created_dt DESC').limit(limit || 1)
+    q.map(&:attributes)
   end
 end

data/app/models/marty/promise.rb

@@ -1,28 +1,27 @@
 class Marty::Promise < Marty::Base
-
   # default timeout (seconds) to wait for promise values
   DEFAULT_PROMISE_TIMEOUT = Rails.configuration.marty.promise_timeout || 30
 
   # default timeout (seconds) to wait for jobs to start
   DEFAULT_JOB_TIMEOUT = Rails.configuration.marty.job_timeout || 10
 
-  def result(force=false)
+  def result(force = false)
     res = super()
     Marty::Promise.load_result(res, force)
   end
 
-  def self.load_result(obj, force=false)
+  def self.load_result(obj, force = false)
     if force && obj.respond_to?(:__force__)
       obj = obj.__force__
     end
 
     case obj
     when Array
-      obj.map {|x| load_result(x, force)}
+      obj.map { |x| load_result(x, force) }
     when Hash
       p = obj['__promise__']
 
-      if p && obj.length==1
+      if p && obj.length == 1
         load_result(Marty::PromiseProxy.new(*p), force)
       else
         obj.each_with_object({}) { |(k, v), h| h[k] = load_result(v, force) }
@@ -34,21 +33,19 @@ class Marty::Promise < Marty::Base
 
   has_many :children,
            foreign_key: 'parent_id',
-           class_name: "Marty::Promise",
+           class_name: 'Marty::Promise',
            dependent: :destroy
 
   validates_presence_of :title
 
-  belongs_to :parent, class_name: "Marty::Promise"
-  belongs_to :user, class_name: "Marty::User"
+  belongs_to :parent, class_name: 'Marty::Promise'
+  belongs_to :user, class_name: 'Marty::User'
 
-  def self.cleanup(all=false)
-    begin
+  def self.cleanup(all = false)
       where('start_dt < ? AND parent_id IS NULL',
             DateTime.now - (all ? 0.hours : 4.hours)).destroy_all
-    rescue => exc
+  rescue StandardError => exc
       Marty::Util.logger.error("promise GC error: #{exc}")
-    end
   end
 
   def raw_conn
@@ -60,38 +57,38 @@ class Marty::Promise < Marty::Base
   end
 
   def set_start
-    if self.start_dt || self.result != {}
+    if start_dt || result != {}
       Marty::Util.logger.error("promise already started: #{self}")
       return
     end
 
     # mark promise as started
     self.start_dt = DateTime.now
-    self.save!
+    save!
   end
 
   def set_result(res)
     # log "SETRES #{Process.pid} #{self}"
 
     # promise must have been started and not yet ended
-    if !self.start_dt || self.end_dt || self.result != {}
+    if !start_dt || end_dt || result != {}
       # log "SETERR #{Process.pid} #{self}"
       Marty::Util.logger.error("unexpected promise state: #{self}")
       return
     end
 
-    raise "bad result" unless res.is_a?(Hash)
+    raise 'bad result' unless res.is_a?(Hash)
 
-    self.status = res["error"].nil?
+    self.status = res['error'].nil?
     self.result = res
 
     # update title/format from result hash (somewhat hacky)
-    self.title   = res["title"].to_s  if res["title"]
-    self.cformat = res["format"].to_s if res["format"]
+    self.title   = res['title'].to_s  if res['title']
+    self.cformat = res['format'].to_s if res['format']
 
     # mark promise as ended
     self.end_dt = DateTime.now
-    self.save!
+    save!
 
     # log "NOTIFY #{Process.pid}"
     pg_notify
@@ -106,11 +103,11 @@ class Marty::Promise < Marty::Base
   # end
 
   def wait_for_my_notify(timeout)
-    while true do
+    while true
       # FIXME: we keep using the same timeout.  The timeout should be
       # reduced by total time spent here.
       n = raw_conn.wait_for_notify(timeout)
-      return n if !n || n=="promise_#{id}"
+      return n if !n || n == "promise_#{id}"
     end
   end
 
@@ -120,17 +117,17 @@ class Marty::Promise < Marty::Base
     # seems to work.
 
     # get latest uncached version
-    Marty::Promise.uncached {Marty::Promise.find(id)}
+    Marty::Promise.uncached { Marty::Promise.find(id) }
   end
 
   def self.job_by_id(job_id)
-    Delayed::Job.uncached {Delayed::Job.find_by_id(job_id)}
+    Delayed::Job.uncached { Delayed::Job.find_by_id(job_id) }
   end
 
   def work_off_job(job)
     # Create a temporary worker to work off the job
     Delayed::Job.where(id: job.id).
-      update_all(locked_at: Delayed::Job.db_time_now, locked_by: "Temp")
+      update_all(locked_at: Delayed::Job.db_time_now, locked_by: 'Temp')
     w = Delayed::Worker.new
     w.run(job)
   end
@@ -138,7 +135,7 @@ class Marty::Promise < Marty::Base
   def wait_for_result(timeout)
     # FIXME: Not sure that comparing result with empty hash if a good idea
     # perhaps it's better to use .present? or .blank?
-    return self.result if self.result != {}
+    return result if result != {}
 
     begin
       # start listening on promise's notification
@@ -150,7 +147,8 @@ class Marty::Promise < Marty::Base
       if !last.start_dt
         job = Marty::Promise.job_by_id(last.job_id)
 
-        # FIXME: this block is needed since a lot of specs rely on delayed job being runned in the same thread as promise
+        # FIXME: this block is needed since a lot of specs rely on
+        # delayed job being runned in the same thread as promise
         # Can be deleted later and replaces with simple timeout below
         if !job || job.locked_at
           # job has been locked, so it looks like it started already
@@ -162,7 +160,7 @@ class Marty::Promise < Marty::Base
           # log "OFF0 #{Process.pid} #{last}"
           begin
             work_off_job(job)
-          rescue => exc
+          rescue StandardError => exc
             # log "OFFERR #{exc}"
             res = Delorean::Engine.grok_runtime_exception(exc)
             last.set_result(res)
@@ -179,7 +177,7 @@ class Marty::Promise < Marty::Base
         # timeout error.
         if !last.start_dt
           # log "TO11 #{Process.pid} #{last}"
-          return {"error" => "promise #{last.id} timed out (never started)"}
+          return { 'error' => "promise #{last.id} timed out (never started)" }
         end
       end
 
@@ -192,7 +190,7 @@ class Marty::Promise < Marty::Base
         last = latest
 
         if !last.end_dt
-          return {"error" => "promise #{last.id} timed out (didn't end)"}
+          return { 'error' => "promise #{last.id} timed out (didn't end)" }
         end
       end
 

data/app/models/marty/script.rb

@@ -3,24 +3,23 @@ class Marty::Script < Marty::Base
 
   validates_presence_of :name, :body
   mcfly_validates_uniqueness_of :name
-  validates_format_of :name, {
-    with: /\A[A-Z][a-zA-Z0-9]*\z/,
-    message: I18n.t('script.save_error'),
-  }
+  validates_format_of :name,
+                      with: /\A[A-Z][a-zA-Z0-9]*\z/,
+                      message: I18n.t('script.save_error')
 
-  belongs_to :user, class_name: "Marty::User"
+  belongs_to :user, class_name: 'Marty::User'
 
   gen_mcfly_lookup :lookup, [:name], cache: true
 
   # find script by name/tag (not cached)
-  def self.find_script(sname, tag=nil)
+  def self.find_script(sname, tag = nil)
     tag = Marty::Tag.map_to_tag(tag)
     Marty::Script.mcfly_pt(tag.created_dt).find_by(name: sname)
   end
 
   def find_tag
     # find the first tag created after this script.
-    Marty::Tag.where("created_dt >= ?", created_dt).order(:created_dt).first
+    Marty::Tag.where('created_dt >= ?', created_dt).order(:created_dt).first
   end
 
   def self.create_script(name, body)
@@ -31,7 +30,7 @@ class Marty::Script < Marty::Base
     script
   end
 
-  def self.load_a_script(sname, body, dt=nil)
+  def self.load_a_script(sname, body, dt = nil)
     s = Marty::Script.find_by(obsoleted_dt: 'infinity', name: sname)
 
     if !s
@@ -47,28 +46,27 @@ class Marty::Script < Marty::Base
     end
   end
 
-  def self.load_script_bodies(bodies, dt=nil)
-    bodies.each {
-      |sname, body|
+  def self.load_script_bodies(bodies, dt = nil)
+    bodies.each do |sname, body|
       load_a_script(sname, body, dt)
-    }
+    end
 
     # Create a new tag if scripts were modified after the last tag
     tag = Marty::Tag.get_latest1
-    latest = Marty::Script.order("created_dt DESC").first
+    latest = Marty::Script.order('created_dt DESC').first
 
     tag_time = (dt || [latest.try(:created_dt), Time.now].compact.max) +
       1.second
 
     # If no tag_time is provided, the tag created_dt will be the same
     # as the scripts.
-    tag = Marty::Tag.do_create(tag_time, "tagged from load scripts") if
+    tag = Marty::Tag.do_create(tag_time, 'tagged from load scripts') if
       !(tag && latest) || tag.created_dt <= latest.created_dt
 
     tag
   end
 
-  def self.load_scripts(path=nil, dt=nil)
+  def self.load_scripts(path = nil, dt = nil)
     files = get_script_filenames(path)
 
     bodies = read_script_files(files)
@@ -77,10 +75,10 @@ class Marty::Script < Marty::Base
   end
 
   def self.read_script_files(files)
-    files.collect { |fpath|
+    files.collect do |fpath|
       fname = File.basename(fpath)[0..-4].camelize
       [fname, File.read(fpath)]
-    }
+    end
   end
 
   def self.get_script_filenames(paths = nil)
@@ -90,7 +88,7 @@ class Marty::Script < Marty::Base
     paths.each do |path|
       Dir.glob("#{path}/*.dl").each do |filename|
         basename = File.basename(filename)
-        filenames[basename] = filename unless filenames.has_key?(basename)
+        filenames[basename] = filename unless filenames.key?(basename)
       end
     end
 
@@ -114,15 +112,15 @@ class Marty::Script < Marty::Base
 
   def self.delete_scripts
     ActiveRecord::Base.connection.
-      execute("ALTER TABLE marty_scripts DISABLE TRIGGER USER;")
+      execute('ALTER TABLE marty_scripts DISABLE TRIGGER USER;')
     Marty::Script.delete_all
     ActiveRecord::Base.connection.
-      execute("ALTER TABLE marty_scripts ENABLE TRIGGER USER;")
+      execute('ALTER TABLE marty_scripts ENABLE TRIGGER USER;')
   end
 
-  delorean_fn :eval_to_hash, sig: 5 do
-    |dt, script, node, attrs, params|
-    tag = Marty::Tag.find_match(dt) || raise("no tag found for #{dt}")
+  delorean_fn :eval_to_hash, sig: 5 do |dt, script, node, attrs, params|
+    tag = Marty::Tag.find_match(dt) if dt.present?
+    raise("no tag for #{dt}") if tag.nil? && dt.present?
 
     engine = Marty::ScriptSet.new(tag).get_engine(script)
     # IMPORTANT: engine evals (e.g. eval_to_hash) modify the
@@ -134,11 +132,16 @@ class Marty::Script < Marty::Base
     # current tag can caused problems.
   end
 
-  delorean_fn :evaluate, sig: 5 do
-    |dt, script, node, attr, params|
-    tag = Marty::Tag.find_match(dt) || raise("no tag found for #{dt}")
+  # evaluate script's node attribute (attr) with the given params.  dt
+  # is used to determine which script tag to use.  The latest tag is
+  # used if dt is nil.
+  delorean_fn :evaluate, sig: 5 do |dt, script, node, attr, params|
+    tag = Marty::Tag.find_match(dt) if dt.present?
+    raise("no tag for #{dt}") if tag.nil? && dt.present?
 
+    # nil tag, uses the latest one
     engine = Marty::ScriptSet.new(tag).get_engine(script)
+
     # IMPORTANT: engine evals (e.g. eval_to_hash) modify the
     # params, but it is possible that we may be passing in
     # a frozen hash. To avoid performance impacts, we should first check if
@@ -146,8 +149,7 @@ class Marty::Script < Marty::Base
     engine.evaluate(node, attr, params.frozen? ? params.dup : params.clone)
   end
 
-  delorean_fn :pretty_print, sig: 1 do
-    |id|
+  delorean_fn :pretty_print, sig: 1 do |id|
     script = find_by_id id
 
     next "unknown script #{id}" unless script