marty 2.5.2 → 2.5.4

data/app/controllers/marty/job_controller.rb

@@ -1,6 +1,6 @@
 class Marty::JobController < ActionController::Base
   def download
-    job_id = params["job_id"]
+    job_id = params['job_id']
 
     promise = Marty::Promise.find_by_id(job_id)
 
@@ -12,12 +12,12 @@ class Marty::JobController < ActionController::Base
 
       # somewhat hacky: if result has "result" key, it's used as the
       # content.
-      data = data["result"] || data
+      data = data['result'] || data
       title = promise.title
     else
-      format = "json"
-      data = {error: "Job not found: #{job_id}"}
-      title = "error"
+      format = 'json'
+      data = { error: "Job not found: #{job_id}" }
+      title = 'error'
     end
 
     res, type, disposition, filename =
@@ -27,6 +27,6 @@ class Marty::JobController < ActionController::Base
               type:        type,
               filename:    filename,
               disposition: disposition,
-              )
+             )
   end
 end

data/app/controllers/marty/report_controller.rb

@@ -3,27 +3,27 @@ class Marty::ReportController < Marty::ApplicationController
     format, req_disposition, title =
       params[:format], params[:disposition], params[:reptitle]
 
-    raise "bad format" unless Marty::ContentHandler::GEN_FORMATS.member?(format)
+    raise 'bad format' unless Marty::ContentHandler::GEN_FORMATS.member?(format)
 
     data = Marty::ReportForm.run_eval(params)
 
     # hacky: shouldn't have error parsing logic here
-    format = "json" if data.is_a?(Hash) && (data[:error] || data["error"])
+    format = 'json' if data.is_a?(Hash) && (data[:error] || data['error'])
 
     # hack for testing -- txt -> csv
-    exp_format = format == "txt" ? "csv" : format
+    exp_format = format == 'txt' ? 'csv' : format
 
     res, type, disposition, filename =
-                            Marty::ContentHandler.
-                              export(data, exp_format, title)
+      Marty::ContentHandler.
+        export(data, exp_format, title)
 
     # hack for testing -- set content-type
-    type = "text/plain" if format == "txt" && type =~ /csv/
+    type = 'text/plain' if format == 'txt' && type =~ /csv/
 
-    return send_data(res,
-                     type:        type,
-                     filename:    filename,
-                     disposition: req_disposition || disposition,
-                    )
+    send_data(res,
+              type:        type,
+              filename:    filename,
+              disposition: req_disposition || disposition,
+             )
   end
 end

data/app/controllers/marty/rpc_controller.rb

@@ -1,6 +1,5 @@
 class Marty::RpcController < ActionController::Base
   def evaluate
-    begin
       # set default result and params in case of unexpected errors
       # to ensure logging capabilities
       result          = nil
@@ -13,9 +12,9 @@ class Marty::RpcController < ActionController::Base
 
       # resolve api config in order to determine api class and settings
       api_config = Marty::ApiConfig.lookup(*massaged_params.values_at(
-                                             :script,
-                                             :node,
-                                             :attr)
+        :script,
+        :node,
+        :attr)
                                           ) || {}
 
       # default to base class if no config is present
@@ -26,32 +25,32 @@ class Marty::RpcController < ActionController::Base
 
       api_params = api.process_params(massaged_params)
       auth       = api.is_authorized?(api_params)
-      return result = {error: "Permission denied"} unless auth
+      return result = { error: 'Permission denied' } unless auth
 
       start_time = Time.zone.now
       api.before_evaluate(api_params)
       result = api.evaluate(api_params, request, api_config)
       api.after_evaluate(api_params, result)
-    rescue => e
+  rescue StandardError => e
       # log unexpected failures in rpc controller and respond with
       # generic server error
       Marty::Logger.log('rpc_controller', 'failure', e.message)
-      result = {error: 'internal server error'}
-    ensure
+      result = { error: 'internal server error' }
+  ensure
       # if logging is enabled, always log the result even on error
       if api_config && api_config[:logged] && api
         api.log(result,
-                api_params + {start_time: start_time, auth: auth},
+                api_params + { start_time: start_time, auth: auth },
                 request)
       end
 
       api.respond_to(self) do
-        result || {'error' => 'internal server error'}
+        result || { 'error' => 'internal server error' }
       end
-    end
   end
 
   private
+
   def process_active_params params
     # must permit params before conversion to_h
     # convert hash to json and parse to get expected hash (not indifferent)
@@ -77,7 +76,7 @@ class Marty::RpcController < ActionController::Base
     # FIXME: small patch to allow for single attr array
     attr = ActiveSupport::JSON.decode(attr) rescue attr
 
-    return {error: "Malformed attrs"} unless
+    return { error: 'Malformed attrs' } unless
       attr.is_a?(String) || (attr.is_a?(Array) && attr.count == 1)
 
     # if attr is a single attr array, remember to return as an array
@@ -86,7 +85,7 @@ class Marty::RpcController < ActionController::Base
       ret_arr = true
     end
 
-    return {error: "Malformed attrs"} unless attr =~ /\A[a-z][a-zA-Z0-9_]*\z/
+    return { error: 'Malformed attrs' } unless attr =~ /\A[a-z][a-zA-Z0-9_]*\z/
 
     begin
       case params
@@ -97,13 +96,13 @@ class Marty::RpcController < ActionController::Base
       when ActionController::Parameters
         params = process_active_params(params)
       else
-        return {error: "Bad params"}
+        return { error: 'Bad params' }
       end
     rescue JSON::ParserError => e
-      return {error: "Malformed params"}
+      return { error: 'Malformed params' }
     end
 
-    return {error: "Malformed params"} unless params.is_a?(Hash)
+    return { error: 'Malformed params' } unless params.is_a?(Hash)
 
     # permit request params and convert to hash
     process_active_params(request_params.except(:rpc)).symbolize_keys + {

data/app/helpers/marty/script_set.rb

@@ -10,7 +10,7 @@ class Marty::ScriptSet < Delorean::AbstractContainer
 
   clear_cache
 
-  def initialize(tag=nil)
+  def initialize(tag = nil)
     @tag = Marty::Tag.map_to_tag(tag)
     super()
   end
@@ -30,7 +30,7 @@ class Marty::ScriptSet < Delorean::AbstractContainer
       # hacky/rare anyway.  So, don't bother for now.
 
       max_dt = Marty::Script.
-        order("created_dt DESC").limit(1).pluck(:created_dt).first
+        order('created_dt DESC').limit(1).pluck(:created_dt).first
 
       @@dengines_dt ||= max_dt
 
@@ -41,7 +41,7 @@ class Marty::ScriptSet < Delorean::AbstractContainer
 
       return engine if engine
 
-      script = Marty::Script.find_script(sname, tag) || raise("No such script")
+      script = Marty::Script.find_script(sname, tag) || raise('No such script')
 
       @@dengines[sname] = parse_check(sname, script.body)
     else
@@ -49,7 +49,7 @@ class Marty::ScriptSet < Delorean::AbstractContainer
 
       return engine if engine
 
-      script = Marty::Script.find_script(sname, tag) || raise("No such script")
+      script = Marty::Script.find_script(sname, tag) || raise('No such script')
 
       @@engines[[tag.id, sname]] = parse_check(sname, script.body)
     end

data/app/models/marty/api_auth.rb

@@ -7,10 +7,10 @@ class Marty::ApiAuth < Marty::Base
 
   class ApiAuthValidator < ActiveModel::Validator
     def validate(api)
-      api.errors.add(:base, "API Key length must be #{KEY_SIZE*2}") if
-        api.api_key && api.api_key.length != KEY_SIZE*2
+      api.errors.add(:base, "API Key length must be #{KEY_SIZE * 2}") if
+        api.api_key && api.api_key.length != KEY_SIZE * 2
 
-      api.errors.add(:base, "Script Name must reference a valid script") unless
+      api.errors.add(:base, 'Script Name must reference a valid script') unless
         Marty::Script.find_script(api.script_name, nil)
     end
   end
@@ -21,10 +21,9 @@ class Marty::ApiAuth < Marty::Base
   validates_uniqueness_of :app_name, scope: [:script_name,
                                              :obsoleted_dt]
 
-
   before_validation do
     self.api_key = Marty::ApiAuth.generate_key if
-      self.api_key.blank?
+      api_key.blank?
   end
 
   def self.generate_key

data/app/models/marty/api_config.rb

@@ -17,6 +17,6 @@ class Marty::ApiConfig < Marty::Base
 
   def self.multi_lookup(script, node, attrs)
     (attrs.nil? ? [nil] : attrs).
-      map { |attr| lookup(script, node, attr).try{|x| x.unshift(attr) }}
+      map { |attr| lookup(script, node, attr).try { |x| x.unshift(attr) } }
   end
 end

data/app/models/marty/base.rb

@@ -1,10 +1,10 @@
 class Marty::Base < ActiveRecord::Base
-  self.table_name_prefix = "marty_"
+  self.table_name_prefix = 'marty_'
   self.abstract_class = true
 
   def self.mcfly_pt(pt)
-    tb = self.table_name
-    self.where("#{tb}.obsoleted_dt >= ? AND #{tb}.created_dt < ?", pt, pt)
+    tb = table_name
+    where("#{tb}.obsoleted_dt >= ? AND #{tb}.created_dt < ?", pt, pt)
   end
 
   class << self
@@ -13,9 +13,9 @@ class Marty::Base < ActiveRecord::Base
 
   def self.get_struct_attrs
     self.struct_attrs ||=
-      self.attribute_names - Mcfly::COLUMNS.to_a -
-      (self.const_defined?('MCFLY_UNIQUENESS') &&
-       self.const_get('MCFLY_UNIQUENESS') || []).map(&:to_s)
+      attribute_names - Mcfly::COLUMNS.to_a -
+      (const_defined?('MCFLY_UNIQUENESS') &&
+       const_get('MCFLY_UNIQUENESS') || []).map(&:to_s)
   end
 
   def self.get_final_attrs
@@ -48,12 +48,13 @@ class Marty::Base < ActiveRecord::Base
 
   def self.make_openstruct(inst)
     return nil unless inst
+
     fa = get_final_attrs
     os = OpenStruct.new(inst.attributes.slice(*fa))
     if self == Marty::DataGrid
       def os.lookup_grid_distinct_entry(pt, params)
-        dgh = self.to_h.stringify_keys.slice(
-          "id", "group_id", "created_dt", "metadata", "data_type")
+        dgh = to_h.stringify_keys.slice(
+          'id', 'group_id', 'created_dt', 'metadata', 'data_type')
         Marty::DataGrid.lookup_grid_distinct_entry_h(pt, params, dgh)
       end
     end

data/app/models/marty/base_rule.rb

@@ -9,6 +9,7 @@ class Marty::BaseRule < Marty::Base
   def chkrange(v)
     v.match(/\A(\[|\()([0-9\.-]*),([0-9\.-]*)(\]|\))\z/)
   end
+
   def gettypes(v)
     types = []
     types << :string if v.is_a?(String)
@@ -20,6 +21,7 @@ class Marty::BaseRule < Marty::Base
     types << :boolean if [true, false, 'True', 'False'].include?(v)
     types
   end
+
   def check(name, h)
     multi, type, enum, values, req = h.values_at(:multi, :type, :enum, :values,
                                                  :required)
@@ -31,6 +33,7 @@ class Marty::BaseRule < Marty::Base
     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
@@ -40,22 +43,24 @@ class Marty::BaseRule < Marty::Base
         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~~")
+    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~~")
+    res_err = results.delete('~~ERROR~~')
     errors[:computed] <<
       "- Error in rule '#{name}' field 'results': #{res_err.capitalize}" if res_err
   end
@@ -71,45 +76,45 @@ class Marty::BaseRule < Marty::Base
   end
 
   before_create do
-    self.class.guard_info.each do |k,v|
+    self.class.guard_info.each do |k, v|
       next if !v.include?(:default) || 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 ? "@>" : "="
+              '->' : '->>'
+    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" : ''
+    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)
+    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")
+              (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 ")
+      end.join(' OR ')
       isn = "simple_guards->'#{use_k}' IS NULL OR"
 
       q = q.where("(#{isn} #{filts})")
     end
-    #print q.to_sql
+    # print q.to_sql
     q.order(:name)
   end
-
 end

data/app/models/marty/config.rb

@@ -2,7 +2,7 @@ class Marty::Config < Marty::Base
   class ConfigValidator < ActiveModel::Validator
     def validate(entry)
       v = entry.get_value
-      entry.errors[:base] << "bad JSON value" if v.nil?
+      entry.errors[:base] << 'bad JSON value' if v.nil?
       v
     end
   end
@@ -11,13 +11,12 @@ class Marty::Config < Marty::Base
   validates_uniqueness_of :key
   validates_with ConfigValidator
 
-  delorean_fn :lookup, sig: 1 do
-    |key|
+  delorean_fn :lookup, sig: 1 do |key|
     self[key]
   end
 
   def get_value
-    self.value[0]
+    value[0]
   end
 
   def set_value(v)
@@ -27,7 +26,7 @@ class Marty::Config < Marty::Base
   def self.[]=(key, value)
     entry = find_by_key(key)
     if !entry
-      entry = self.new
+      entry = new
       entry.key = key
     end
     entry.set_value(value)

data/app/models/marty/data_grid.rb

@@ -1,40 +1,37 @@
 class Marty::DataGrid < Marty::Base
   # If data_type is nil, assume float
-  DEFAULT_DATA_TYPE = "float"
+  DEFAULT_DATA_TYPE = 'float'
 
   INDEX_MAP = {
-    "numrange"  => Marty::GridIndexNumrange,
-    "int4range" => Marty::GridIndexInt4range,
-    "integer"   => Marty::GridIndexInteger,
-    "string"    => Marty::GridIndexString,
-    "boolean"   => Marty::GridIndexBoolean,
+    'numrange'  => Marty::GridIndexNumrange,
+    'int4range' => Marty::GridIndexInt4range,
+    'integer'   => Marty::GridIndexInteger,
+    'string'    => Marty::GridIndexString,
+    'boolean'   => Marty::GridIndexBoolean,
   }
 
   ARRSEP = '|'
 
   class DataGridValidator < ActiveModel::Validator
     def validate(dg)
-
       dg.errors.add(:base, "'#{dg.data_type}' not a defined type or class") unless
         Marty::DataGrid.convert_data_type(dg.data_type)
 
-      dg.errors.add(:base, "data must be array of arrays") unless
-        dg.data.is_a?(Array) && dg.data.all? {|a| a.is_a? Array}
-
-      dg.errors.add(:base, "metadata must be an array of hashes") unless
-        dg.metadata.is_a?(Array) && dg.metadata.all? {|a| a.is_a? Hash}
+      dg.errors.add(:base, 'data must be array of arrays') unless
+        dg.data.is_a?(Array) && dg.data.all? { |a| a.is_a? Array }
 
-      dg.errors.add(:base, "metadata must contain only h/v dirs") unless
-        dg.metadata.all? {|h| ["h", "v"].member? h["dir"]}
+      dg.errors.add(:base, 'metadata must be an array of hashes') unless
+        dg.metadata.is_a?(Array) && dg.metadata.all? { |a| a.is_a? Hash }
 
-      dg.errors.add(:base, "metadata item attrs must be unique") unless
-        dg.metadata.map {|h| h["attr"]}.uniq.length == dg.metadata.length
+      dg.errors.add(:base, 'metadata must contain only h/v dirs') unless
+        dg.metadata.all? { |h| ['h', 'v'].member? h['dir'] }
 
-      dg.metadata.each do
-        |inf|
+      dg.errors.add(:base, 'metadata item attrs must be unique') unless
+        dg.metadata.map { |h| h['attr'] }.uniq.length == dg.metadata.length
 
+      dg.metadata.each do |inf|
         attr, type, keys, rs_keep =
-          inf["attr"], inf["type"], inf["keys"], inf["rs_keep"]
+          inf['attr'], inf['type'], inf['keys'], inf['rs_keep']
 
         unless rs_keep.nil? || rs_keep.empty?
           m = /\A *(<|<=|>|>=)? *([a-z][a-z_0-9]+) *\z/.match(rs_keep)
@@ -44,7 +41,7 @@ class Marty::DataGrid < Marty::Base
           end
         end
 
-        dg.errors.add(:base, "metadata elements must have attr/type/keys") unless
+        dg.errors.add(:base, 'metadata elements must have attr/type/keys') unless
           attr && type && keys
 
         # enforce Delorean attr syntax (a bit Draconian)
@@ -54,24 +51,24 @@ class Marty::DataGrid < Marty::Base
         dg.errors.add(:base, "unknown metadata type #{type}") unless
           Marty::DataGrid.type_to_index(type)
 
-        dg.errors.add(:base, "bad metadata keys") unless
-          keys.is_a?(Array) && keys.length>0
+        dg.errors.add(:base, 'bad metadata keys') unless
+          keys.is_a?(Array) && !keys.empty?
       end
 
       # Check key uniqueness of vertical/horizontal key
       # combinations. FIXME: ideally, we should also check for
       # array/range key subsumption.  Those will result in runtime
       # errors anyway when multiple hits are produced.
-      v_keys = dg.dir_infos("v").map {|inf| inf["keys"]}
-      h_keys = dg.dir_infos("h").map {|inf| inf["keys"]}
+      v_keys = dg.dir_infos('v').map { |inf| inf['keys'] }
+      h_keys = dg.dir_infos('h').map { |inf| inf['keys'] }
 
       v_zip_keys = v_keys.empty? ? [] : v_keys[0].zip(*v_keys[1..-1])
       h_zip_keys = h_keys.empty? ? [] : h_keys[0].zip(*h_keys[1..-1])
 
-      dg.errors.add(:base, "duplicate horiz. key combination") unless
+      dg.errors.add(:base, 'duplicate horiz. key combination') unless
         h_zip_keys.uniq.length == h_zip_keys.length
 
-      dg.errors.add(:base, "duplicate vertical key combination") unless
+      dg.errors.add(:base, 'duplicate vertical key combination') unless
         v_zip_keys.uniq.length == v_zip_keys.length
     end
   end
@@ -89,26 +86,23 @@ class Marty::DataGrid < Marty::Base
 
   # FIXME: if the caller requests data as part of fields, there could
   # be memory concerns with caching since some data_grids have massive data
-  cached_delorean_fn :lookup_h, sig: [2, 3] do
-    |pt, name, fields = nil|
+  cached_delorean_fn :lookup_h, sig: [2, 3] do |pt, name, fields = nil|
     fields ||= %w(id group_id created_dt metadata data_type name)
     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|
+  cached_mcfly_lookup :lookup_id, sig: 2 do |pt, group_id|
     find_by_group_id group_id
   end
 
-  cached_delorean_fn :exists, sig: 2 do
-    |pt, name|
+  cached_delorean_fn :exists, sig: 2 do |pt, name|
     Marty::DataGrid.mcfly_pt(pt).where(name: name).exists?
   end
 
   def self.get_struct_attrs
-    self.struct_attrs ||= super + ["id", "group_id", "created_dt", "name"]
+    self.struct_attrs ||= super + ['id', 'group_id', 'created_dt', 'name']
   end
 
   def to_s
@@ -125,6 +119,7 @@ class Marty::DataGrid < Marty::Base
   def self.register_rule_handler(handler)
     (@@rule_handlers ||= []) << handler
   end
+
   def update_rules(old, new)
     @@rule_handlers.each { |rh| rh.call(old, new) }
   end
@@ -133,7 +128,7 @@ class Marty::DataGrid < Marty::Base
   # transaction -- i.e. together with build_index.  before_save would
   # be OK, but then save inside it would cause an infinite loop.
   def save!
-    if self.changed?
+    if changed?
       transaction do
         nc, nw, n = [name_changed?, name_was, name]
         res = super
@@ -147,14 +142,15 @@ class Marty::DataGrid < Marty::Base
 
   # FIXME: hacky -- save is just save!
   def save
-    self.save!
+    save!
   end
 
   def self.type_to_index(type)
     # map given header type to an index class -- uses string index
     # for ruby classes.
     return INDEX_MAP[type] if INDEX_MAP[type]
-    INDEX_MAP["string"] if (type.constantize rescue nil)
+
+    INDEX_MAP['string'] if (type.constantize rescue nil)
   end
 
   def self.convert_data_type(data_type)
@@ -172,29 +168,30 @@ class Marty::DataGrid < Marty::Base
     @@dtcache = {}
   end
 
-  PLV_DT_FMT = "%Y-%m-%d %H:%M:%S.%N6"
+  PLV_DT_FMT = '%Y-%m-%d %H:%M:%S.%N6'
 
-  def self.plv_lookup_grid_distinct(h_passed, dgh, ret_grid_data=false,
-                                    distinct=true)
-    cd = dgh["created_dt"]
+  def self.plv_lookup_grid_distinct(h_passed, dgh, ret_grid_data = false,
+                                    distinct = true)
+    cd = dgh['created_dt']
     @@dtcache ||= {}
     @@dtcache[cd] ||= cd.strftime(PLV_DT_FMT)
     row_info = {
-      "id"         => dgh["id"],
-      "group_id"   => dgh["group_id"],
-      "created_dt" => @@dtcache[cd]
+      'id'         => dgh['id'],
+      'group_id'   => dgh['group_id'],
+      'created_dt' => @@dtcache[cd]
     }
 
-    h = dgh["metadata"].each_with_object({}) do |m, h|
-      attr = m["attr"]
+    h = dgh['metadata'].each_with_object({}) do |m, h|
+      attr = m['attr']
       inc = h_passed.fetch(attr, :__nf__)
       next if inc == :__nf__
+
       val = (defined? inc.name) ? inc.name : inc
       h[attr] = val.is_a?(String) ?
                   ActiveRecord::Base.connection.quote(val)[1..-2] : val
     end
 
-    fn     = "lookup_grid_distinct"
+    fn     = 'lookup_grid_distinct'
     hjson  = "'#{h.to_json}'::JSONB"
     rijson = "'#{row_info.to_json}'::JSONB"
     params = "#{hjson}, #{rijson}, #{ret_grid_data}, #{distinct}"
@@ -202,66 +199,63 @@ class Marty::DataGrid < Marty::Base
     raw    = ActiveRecord::Base.connection.execute(sql)[0][fn]
     res    = JSON.parse(raw)
 
-    if res["error"]
-      msg = res["error"]
-      parms, sqls, ress, dg = res["error_extra"].values_at(
-                           "params", "sql", "results", "dg")
+    if res['error']
+      msg = res['error']
+      parms, sqls, ress, dg = res['error_extra'].values_at(
+        'params', 'sql', 'results', 'dg')
 
       raise "DG #{name}: Error in PLV8 call: #{msg}\n"\
             "params: #{parms}\n"\
             "sqls: #{sqls}\n"\
             "results: #{ress}\n"\
             "dg: #{dg}\n"\
-            "ri: #{row_info}" if res["error"]
+            "ri: #{row_info}" if res['error']
     end
 
     if ret_grid_data
-      dg = find(dgh["id"])
+      dg = find(dgh['id'])
       md, mmd = modify_grid(h_passed, dg.metadata, dg.data)
-      res["data"] = md
-      res["metadata"] = mmd
+      res['data'] = md
+      res['metadata'] = mmd
     end
     res
   end
 
   # deprecated - remove 2018-Oct
-  cached_delorean_fn :lookup_grid, sig: 4 do
-    |pt, dg, h, distinct|
+  cached_delorean_fn :lookup_grid, sig: 4 do |pt, dg, h, distinct|
     dg_is_grid = Marty::DataGrid === dg
-    dg_is_os   =  dg.is_a?(OpenStruct)
+    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_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"]
+    res['result']
   end
 
-  cached_delorean_fn :lookup_grid_h, sig: 4 do
-    |pt, dgn, h, distinct|
-
+  cached_delorean_fn :lookup_grid_h, sig: 4 do |pt, dgn, h, distinct|
     dgh = lookup_h(pt, dgn)
     raise "#{dgn} grid not found" unless dgh
     raise "non-hash arg #{h}" unless Hash === h
 
     res = lookup_grid_distinct_entry_h(pt, h, dgh, nil, true, false, distinct)
-    res["result"]
+    res['result']
   end
 
   # FIXME: using cached_delorean_fn just for the caching -- this is
   # not expected to be called from Delorean.
-  cached_delorean_fn :find_class_instance, sig: 3 do
-    |pt, klass, v|
+  cached_delorean_fn :find_class_instance, sig: 3 do |pt, klass, v|
     if Marty::PgEnum === klass
       klass.find_by_name(v)
     else
       # FIXME: very hacky -- hard-coded name
-      Marty::DataConversion.find_row(klass, {"name" => v}, pt)
+      Marty::DataConversion.find_row(klass, { 'name' => v }, pt)
     end
   end
 
-  def self.lookup_grid_distinct_entry_h(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
@@ -275,15 +269,15 @@ class Marty::DataGrid < Marty::Base
     #   "metadata" => <grid's metadata (array of hashes)>
     vhash = plv_lookup_grid_distinct(h, dgh, return_grid_data, distinct)
 
-    return 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'])
 
     return vhash if String === c_data_type
 
-    res = vhash["result"]
+    res = vhash['result']
 
-    v =  case
+    v = case
              when Marty::PgEnum === res
                c_data_type.find_by_name(res)
              when Marty::DataGrid == c_data_type
@@ -291,10 +285,10 @@ class Marty::DataGrid < Marty::Base
                  Marty::DataGrid.lookup_h(pt, res) :
                  Marty::DataGrid.lookup(pt, res)
              else
-               Marty::DataConversion.find_row(c_data_type, {"name" => res}, pt)
+               Marty::DataConversion.find_row(c_data_type, { 'name' => res }, pt)
          end
 
-    return vhash.merge({"result" => v}) unless (Marty::DataGrid == c_data_type &&
+    return vhash.merge('result' => v) unless (Marty::DataGrid == c_data_type &&
                                               follow)
 
     visited ||= []
@@ -309,24 +303,22 @@ class Marty::DataGrid < Marty::Base
   end
 
   def dir_infos(dir)
-    metadata.select {|inf| inf["dir"] == dir}
+    metadata.select { |inf| inf['dir'] == dir }
   end
 
   def self.export_keys(inf)
     # should unify this with Marty::DataConversion.convert
 
-    type = inf["type"]
+    type = inf['type']
     klass = type.constantize unless INDEX_MAP[type]
 
-    inf["keys"].map do
-      |v|
-
+    inf['keys'].map do |v|
       case type
-      when "numrange", "int4range"
+      when 'numrange', 'int4range'
         Marty::Util.pg_range_to_human(v)
-      when "boolean"
+      when 'boolean'
         v.to_s
-      when "string", "integer"
+      when 'string', 'integer'
         v.map(&:to_s).join(ARRSEP) if v
       else
         # assume it's an AR class
@@ -350,46 +342,45 @@ class Marty::DataGrid < Marty::Base
 
   def export_array
     # add data type metadata row if not default
-    dt_row = lenient ? ["lenient"] : []
+    dt_row = lenient ? ['lenient'] : []
     dt_row << data_type unless [nil, DEFAULT_DATA_TYPE].member?(data_type)
 
     meta_rows = dt_row.empty? ? [] : [[dt_row.join(' ')]]
 
-    meta_rows += metadata.map { |inf|
-      [inf["attr"], inf["type"], inf["dir"], inf["rs_keep"] || ""]
-    }
+    meta_rows += metadata.map do |inf|
+      [inf['attr'], inf['type'], inf['dir'], inf['rs_keep'] || '']
+    end
 
-    v_infos, h_infos = dir_infos("v"), dir_infos("h")
+    v_infos, h_infos = dir_infos('v'), dir_infos('h')
 
-    h_key_rows = h_infos.map { |inf|
-      [nil]*v_infos.count + self.class.export_keys(inf)
-    }
+    h_key_rows = h_infos.map do |inf|
+      [nil] * v_infos.count + self.class.export_keys(inf)
+    end
 
     transposed_v_keys = v_infos.empty? ? [[]] :
-      v_infos.map {|inf| self.class.export_keys(inf)}.transpose
+      v_infos.map { |inf| self.class.export_keys(inf) }.transpose
 
-    data_rows = transposed_v_keys.each_with_index.map { |keys, i|
-      keys + (self.data[i] || [])
-    }
+    data_rows = transposed_v_keys.each_with_index.map do |keys, i|
+      keys + (data[i] || [])
+    end
 
     [meta_rows, h_key_rows, data_rows]
   end
 
   def export
-    # return null string when called from Netzke on add_in_form
-     return "" if metadata.nil? && data.nil?
+     # return null string when called from Netzke on add_in_form
+     return '' if metadata.nil? && data.nil?
 
-    meta_rows, h_key_rows, data_rows = export_array
+     meta_rows, h_key_rows, data_rows = export_array
 
-    Marty::DataExporter.
-      to_csv(meta_rows + [[]] + h_key_rows + data_rows,
-             "col_sep" => "\t",
+     Marty::DataExporter.
+       to_csv(meta_rows + [[]] + h_key_rows + data_rows,
+              'col_sep' => "\t",
              ).
-      gsub(/\"\"/, '') # remove "" to beautify output
+       gsub(/\"\"/, '') # remove "" to beautify output
   end
 
-  delorean_fn :export, sig: 1 do
-    |os|
+  delorean_fn :export, sig: 1 do |os|
     dg = find(os.id)
     dg.export
   end
@@ -398,27 +389,28 @@ class Marty::DataGrid < Marty::Base
     return unless v
 
     case type
-    when "numrange", "int4range"
+    when 'numrange', 'int4range'
       Marty::Util.human_to_pg_range(v)
-    when "integer"
+    when 'integer'
       v.split(ARRSEP).map do |val|
         Integer(val) rescue raise "invalid integer: #{val}"
       end.uniq.sort
-    when "float"
+    when 'float'
       v.split(ARRSEP).map do |val|
         Float(val) rescue raise "invalid float: #{val}"
       end.uniq.sort
-    when "string"
+    when 'string'
       res = v.split(ARRSEP).uniq.sort
-      raise "leading/trailing spaces in elements not allowed" if
-        res.any? {|x| x != x.strip}
-      raise "0-length string not allowed" if res.any?(&:empty?)
+      raise 'leading/trailing spaces in elements not allowed' if
+        res.any? { |x| x != x.strip }
+      raise '0-length string not allowed' if res.any?(&:empty?)
+
       res
-    when "boolean"
+    when 'boolean'
       case v.downcase
-      when "true", "t"
+      when 'true', 't'
         true
-      when "false", "f"
+      when 'false', 'f'
         false
       else
         raise "bad boolean #{v}"
@@ -427,8 +419,7 @@ class Marty::DataGrid < Marty::Base
       # AR class
       # FIXME: won't work if the obj identifier (name) has ARRSEP
       res = v.split(ARRSEP).uniq
-      res.each do
-        |k|
+      res.each do |k|
         begin
           # check to see if class instance actually exists
           Marty::DataGrid.
@@ -442,17 +433,14 @@ class Marty::DataGrid < Marty::Base
   end
 
   def self.maybe_get_klass(type)
-    begin
-      type.constantize unless INDEX_MAP[type] || type == "float"
-    rescue NameError
+      type.constantize unless INDEX_MAP[type] || type == 'float'
+  rescue NameError
       raise "unknown header type/klass: #{type}"
-    end
   end
 
   def self.parse_keys(pt, keys, type)
     klass = maybe_get_klass(type)
-    keys.map do
-      |v|
+    keys.map do |v|
       parse_fvalue(pt, v, type, klass)
     end
   end
@@ -465,9 +453,9 @@ class Marty::DataGrid < Marty::Base
     pt ||= 'infinity'
 
     rows = CSV.new(grid_text, options).to_a
-    blank_index = rows.find_index {|x| x.all?(&:nil?)}
+    blank_index = rows.find_index { |x| x.all?(&:nil?) }
 
-    raise "must have a blank row separating metadata" unless
+    raise 'must have a blank row separating metadata' unless
       blank_index
 
     raise "can't import grid with trailing blank column" if
@@ -483,61 +471,58 @@ class Marty::DataGrid < Marty::Base
       dts = dt.split
       raise "bad data type '#{dt}'" if dts.count > 2
 
-      lenient = dts.delete "lenient"
+      lenient = dts.delete 'lenient'
       data_type = dts.first
     end
 
-    metadata = rows[(data_type || lenient ? 1 : 0)...blank_index].map do
-      |attr, type, dir, rs_keep, key|
-
-      raise "metadata elements must include attr/type/dir" unless
+    rows_for_metadata = rows[(data_type || lenient ? 1 : 0)...blank_index]
+    metadata = rows_for_metadata.map do |attr, type, dir, rs_keep, key|
+      raise 'metadata elements must include attr/type/dir' unless
         attr && type && dir
-      raise "bad dir #{dir}" unless ["h", "v"].member? dir
+      raise "bad dir #{dir}" unless ['h', 'v'].member? dir
       raise "unknown metadata type #{type}" unless
         Marty::DataGrid.type_to_index(type)
 
       res = {
-        "attr" => attr,
-        "type" => type,
-        "dir"  => dir,
-        "keys" => key && parse_keys(pt, [key], type),
+        'attr' => attr,
+        'type' => type,
+        'dir'  => dir,
+        'keys' => key && parse_keys(pt, [key], type),
       }
-      res["rs_keep"] = rs_keep if rs_keep
+      res['rs_keep'] = rs_keep if rs_keep
       res
     end
 
-    v_infos = metadata.select {|inf| inf["dir"] == "v"}
-    h_infos = metadata.select {|inf| inf["dir"] == "h"}
+    v_infos = metadata.select { |inf| inf['dir'] == 'v' }
+    h_infos = metadata.select { |inf| inf['dir'] == 'h' }
 
     # keys+data start right after blank_index
-    data_index = blank_index+1
+    data_index = blank_index + 1
 
     # process horizontal key rows
-    h_infos.each_with_index do
-      |inf, i|
+    h_infos.each_with_index do |inf, i|
+      row = rows[data_index + i]
 
-      row = rows[data_index+i]
-
-      raise "horiz. key row #{data_index+i} must include nil starting cells" if
+      raise "horiz. key row #{data_index + i} must include nil starting cells" if
         row[0, v_infos.count].any?
 
-      inf["keys"] = parse_keys(pt, row[v_infos.count, row.count], inf["type"])
+      inf['keys'] = parse_keys(pt, row[v_infos.count, row.count], inf['type'])
     end
 
-    raise "horiz. info keys length mismatch!" unless
-      h_infos.map {|inf| inf["keys"].length}.uniq.count <= 1
+    raise 'horiz. info keys length mismatch!' unless
+      h_infos.map { |inf| inf['keys'].length }.uniq.count <= 1
 
-    data_rows = rows[data_index+h_infos.count, rows.count]
+    data_rows = rows[data_index + h_infos.count, rows.count]
 
     # process vertical key columns
-    v_key_cols = data_rows.map {|r| r[0, v_infos.count]}.transpose
+    v_key_cols = data_rows.map { |r| r[0, v_infos.count] }.transpose
 
     v_infos.each_with_index do |inf, i|
-      inf["keys"] = parse_keys(pt, v_key_cols[i], inf["type"])
+      inf['keys'] = parse_keys(pt, v_key_cols[i], inf['type'])
     end
 
-    raise "vert. info keys length mismatch!" unless
-      v_infos.map {|inf| inf["keys"].length}.uniq.count <= 1
+    raise 'vert. info keys length mismatch!' unless
+      v_infos.map { |inf| inf['keys'].length }.uniq.count <= 1
 
     c_data_type = Marty::DataGrid.convert_data_type(data_type)
 
@@ -548,18 +533,14 @@ class Marty::DataGrid < Marty::Base
     if String === c_data_type
       tsym = c_data_type.to_sym
 
-      data = data_rows.map do
-        |r|
-        r[v_infos.count, r.count].map do
-          |v|
+      data = data_rows.map do |r|
+        r[v_infos.count, r.count].map do |v|
           Marty::DataConversion.convert(v, tsym) if v
         end
       end
     else
-      data = data_rows.map do
-        |r|
-        r[v_infos.count, r.count].map do
-          |v|
+      data = data_rows.map do |r|
+        r[v_infos.count, r.count].map do |v|
           next v if !v || Marty::DataGrid.
                          find_class_instance(pt, c_data_type, v)
 
@@ -571,9 +552,9 @@ class Marty::DataGrid < Marty::Base
     [metadata, data, data_type, lenient]
   end
 
-  def self.create_from_import(name, import_text, created_dt=nil)
+  def self.create_from_import(name, import_text, created_dt = nil)
     metadata, data, data_type, lenient = parse(created_dt, import_text, {})
-    dg            = self.new
+    dg            = new
     dg.name       = name
     dg.data       = data
     dg.data_type  = data_type
@@ -584,15 +565,16 @@ class Marty::DataGrid < Marty::Base
     dg
   end
 
-  def update_from_import(name, import_text, created_dt=nil)
-    metadata, data, data_type, lenient =
-                               self.class.parse(created_dt, import_text, {})
+  def update_from_import(name, import_text, created_dt = nil)
+    new_metadata, data, data_type, lenient =
+      self.class.parse(created_dt, import_text, {})
 
     self.name       = name
     self.data       = data
     self.data_type  = data_type
     self.lenient    = !!lenient
-    self.metadata   = metadata unless self.metadata == metadata # Otherwise changed will depend on order in hashes
+    # Otherwise changed will depend on order in hashes
+    self.metadata   = new_metadata unless metadata == new_metadata
     self.created_dt = created_dt if created_dt
     save!
   end
@@ -600,17 +582,13 @@ class Marty::DataGrid < Marty::Base
   # FIXME: should be private
   def build_index
     # create indices for the metadata
-    metadata.each do
-      |inf|
-
-      attr, type, keys = inf["attr"], inf["type"], inf["keys"]
+    metadata.each do |inf|
+      attr, type, keys = inf['attr'], inf['type'], inf['keys']
 
       # find index class
       idx_class = Marty::DataGrid.type_to_index(type)
 
-      keys.each_with_index do
-        |k, index|
-
+      keys.each_with_index do |k, index|
         gi              = idx_class.new
         gi.attr         = attr
         gi.key          = k
@@ -623,16 +601,16 @@ class Marty::DataGrid < Marty::Base
   end
 
   def self.modify_grid(params, metadata, data)
-    removes = ["h", "v"].each_with_object({}) {|dir, hash| hash[dir] = Set.new}
+    removes = ['h', 'v'].each_with_object({}) { |dir, hash| hash[dir] = Set.new }
 
     metadata_copy, data_copy = metadata.deep_dup, data.deep_dup
 
     metadata_copy.each do |meta|
       dir, keys, type, rs_keep = meta.values_at(
-                         "dir", "keys", "type", "rs_keep")
+        'dir', 'keys', 'type', 'rs_keep')
       next unless rs_keep
 
-      if type == "numrange" || type == "int4range"
+      if type == 'numrange' || type == 'int4range'
         modop, modvalparm = parse_bounds(rs_keep)
         modval = params[modvalparm]
         if modval
@@ -652,23 +630,23 @@ class Marty::DataGrid < Marty::Base
 
     removes.reject! { |dir, set| set.empty? }
 
-    removes.each do
-      |dir, set|
-      metadata_copy.select { |m| m["dir"] == dir }.each do |meta|
-        meta["keys"] = remove_indices(meta["keys"], removes[dir])
+    removes.each do |dir, set|
+      metadata_copy.select { |m| m['dir'] == dir }.each do |meta|
+        meta['keys'] = remove_indices(meta['keys'], removes[dir])
       end
     end
 
-    data_copy = remove_indices(data_copy, removes["v"]) if removes["v"]
+    data_copy = remove_indices(data_copy, removes['v']) if removes['v']
 
     data_copy.each_index do |index|
-      data_copy[index] = remove_indices(data_copy[index], removes["h"])
-    end if removes["h"]
+      data_copy[index] = remove_indices(data_copy[index], removes['h'])
+    end if removes['h']
 
     [data_copy, metadata_copy]
   end
 
   private
+
   def self.remove_indices(orig_array, inds)
     orig_array.each_with_object([]).with_index do |(item, new_array), index|
       new_array.push(item) unless inds.include?(index)
@@ -731,7 +709,6 @@ class Marty::DataGrid < Marty::Base
           prune_a.push(index)
         end
       end
-
     end
     [prune_a, rewrite_a]
   end
@@ -741,7 +718,6 @@ class Marty::DataGrid < Marty::Base
     prune_a, rewrite_a, value = [], [], Array(val)
 
     keys.each_with_index do |key, index|
-
       # rewrite any nil (wildcard) keys in the dimension
       # to be our 'to-keep' val(s)
       if key.nil?