marty 2.5.2 → 2.5.4

data/lib/marty/logger.rb

@@ -4,27 +4,24 @@ class Marty::Logger
   def self.method_missing(m, *args, &block)
     return super unless
       [:debug, :info, :warn, :error, :fatal, :unknown].include?(m)
+
     Marty::Util.logger.send(m, args[0]) if Marty::Util.logger.respond_to?(m)
     log(m, *args)
   end
 
-  def self.log(type, message, details=nil)
+  def self.log(type, message, details = nil)
     Marty::Log.write_log(type, message, details)
   end
 
   def self.with_logging(error_message, error_data)
-    begin
       yield
-    rescue => e
-      error(error_message, { "message" => e.message,
-                             "data" => error_data})
+  rescue StandardError => e
+      error(error_message,  'message' => e.message,
+                             'data' => error_data)
       raise "#{error_message}: #{e.message}"
-    end
   end
 
-  delorean_fn :dllog, sig: [2, 20] do
-     |*args|
-
+  delorean_fn :dllog, sig: [2, 20] do |*args|
      info args[0], args[1..-1]
   end
 end

data/lib/marty/mcfly_model.rb

@@ -11,14 +11,13 @@ module Mcfly::Model
     end
 
     def base_mcfly_lookup(meth, name, options = {}, &block)
-
       priv = options[:private]
 
       send(meth, name, options) do |ts, *args|
-        raise "time cannot be nil" if ts.nil?
+        raise 'time cannot be nil' if ts.nil?
 
         ts = Mcfly.normalize_infinity(ts)
-        q = self.where("#{table_name}.obsoleted_dt >= ? AND " +
+        q = where("#{table_name}.obsoleted_dt >= ? AND " +
                    "#{table_name}.created_dt < ?", ts, ts).scoping do
           block.call(ts, *args)
         end
@@ -40,7 +39,7 @@ module Mcfly::Model
       base_mcfly_lookup(:delorean_fn, name, options, &block)
     end
 
-    def gen_mcfly_lookup(name, attrs, options={})
+    def gen_mcfly_lookup(name, attrs, options = {})
       raise "bad options #{options.keys}" unless
         (options.keys - [:mode, :cache, :private]).empty?
 
@@ -52,36 +51,35 @@ module Mcfly::Model
       # the older mode=:all is not supported (it's bogus)
       raise "bad mode #{mode}" unless [nil, :first].member?(mode)
 
-      assoc = Set.new(self.reflect_on_all_associations.map(&:name))
+      assoc = Set.new(reflect_on_all_associations.map(&:name))
 
-      qstr = attrs.map {|k, v|
+      qstr = attrs.map do |k, v|
         k = "#{k}_id" if assoc.member?(k)
 
         v ? "(#{k} = ? OR #{k} IS NULL)" : "(#{k} = ?)"
-      }.join(" AND ")
+      end.join(' AND ')
 
       if Hash === attrs
-        order = attrs.select {|k, v| v}.keys.reverse.map { |k|
+        order = attrs.select { |k, v| v }.keys.reverse.map do |k|
           k = "#{k}_id" if assoc.member?(k)
 
           "#{k} NULLS LAST"
-        }.join(", ")
+        end.join(', ')
         attrs = attrs.keys
       else
-        raise "bad attrs" unless Array === attrs
+        raise 'bad attrs' unless Array === attrs
       end
 
       fn = cache ? :cached_delorean_fn : :delorean_fn
-      base_mcfly_lookup(fn, name, options + {sig:  attrs.length+1,
-                                             mode: mode}) do
-        |t, *attr_list|
+      base_mcfly_lookup(fn, name, options + { sig:  attrs.length + 1,
+                                             mode: mode }) do |t, *attr_list|
 
-        attr_list_ids = attr_list.each_with_index.map {|x, i|
+        attr_list_ids = attr_list.each_with_index.map do |x, i|
           assoc.member?(attrs[i]) ?
             (attr_list[i] && attr_list[i].id) : attr_list[i]
-        }
+        end
 
-        q = self.where(qstr, *attr_list_ids)
+        q = where(qstr, *attr_list_ids)
         q = q.order(order) if order
         q
       end
@@ -109,7 +107,7 @@ module Mcfly::Model
     # pc_name         = :pc_lookup_q
     # pc_attrs        = {entity: true, security_instrument: true, coupon: true}
 
-    def gen_mcfly_lookup_cat(name, catrel, attrs, options={})
+    def gen_mcfly_lookup_cat(name, catrel, attrs, options = {})
       rel_attr, cat_assoc_name, cat_attr = catrel
 
       raise "#{rel_attr} should be mapped in attrs" if attrs[rel_attr].nil?
@@ -118,13 +116,13 @@ module Mcfly::Model
       cat_attr_id = "#{cat_attr}_id"
 
       # replace rel_attr with cat_attr in attrs
-      pc_attrs = attrs.each_with_object({}) {|(k, v), h|
+      pc_attrs = attrs.each_with_object({}) do |(k, v), h|
         h[k == rel_attr ? cat_attr_id : k] = v
-      }
+      end
 
       pc_name = "pc_#{name}".to_sym
 
-      gen_mcfly_lookup(pc_name, pc_attrs, options + {private: true})
+      gen_mcfly_lookup(pc_name, pc_attrs, options + { private: true })
 
       lpi = attrs.keys.index rel_attr
 
@@ -135,9 +133,7 @@ module Mcfly::Model
       fn = options.fetch(:mode, :first) ? :cached_delorean_fn : :delorean_fn
       priv = options[:private]
 
-      send(fn, name, sig: attrs.length+1) do
-        |ts, *args|
-
+      send(fn, name, sig: attrs.length + 1) do |ts, *args|
         # Example: rel is a Gemini::SecurityInstrument instance.
         rel = args[lpi]
         raise "#{rel_attr} can't be nil" unless rel
@@ -148,7 +144,7 @@ module Mcfly::Model
                       find_by(rel_attr => rel).
                       send(cat_attr_id)
 
-        q = self.send(pc_name, ts, *args)
+        q = send(pc_name, ts, *args)
         hash_if_necessary(q, priv)
       end
     end

data/lib/marty/migrations.rb

@@ -1,20 +1,20 @@
 module Marty::Migrations
   def tb_prefix
-    "marty_"
+    'marty_'
   end
 
   def new_enum(klass, prefix_override = nil)
     raise "bad class arg #{klass}" unless
       klass.is_a?(Class) && klass < ActiveRecord::Base
 
-    raise "model class needs VALUES (as Set)" unless
+    raise 'model class needs VALUES (as Set)' unless
       klass.const_defined?(:VALUES)
 
     values = klass::VALUES
     str_values =
-      values.map {|v| ActiveRecord::Base.connection.quote v}.join ','
+      values.map { |v| ActiveRecord::Base.connection.quote v }.join ','
 
-    #hacky way to get name
+    # hacky way to get name
     prefix = prefix_override || tb_prefix
     enum_name = klass.table_name.sub(/^#{prefix}_*/, '')
 
@@ -28,14 +28,14 @@ module Marty::Migrations
     raise "bad class arg #{klass}" unless
       klass.is_a?(Class) && klass < ActiveRecord::Base
 
-    raise "model class needs VALUES (as Set)" unless
+    raise 'model class needs VALUES (as Set)' unless
       klass.const_defined?(:VALUES)
 
-    #hacky way to get name
+    # hacky way to get name
     prefix = prefix_override || tb_prefix
     enum_name = klass.table_name.sub(/^#{prefix}/, '')
 
-    #check values against underlying values
+    # check values against underlying values
     res = execute <<-SQL
       SELECT ENUM_RANGE(null::#{enum_name});
     SQL
@@ -63,7 +63,7 @@ module Marty::Migrations
     # FIXME: so hacky to specifically check for "marty_"
     to_table = "#{tb_prefix}#{to_table}" unless
       to_table.to_s.start_with?(tb_prefix) ||
-      to_table.to_s.start_with?("marty_")
+      to_table.to_s.start_with?('marty_')
 
     add_foreign_key(from_table,
                     to_table,
@@ -86,9 +86,9 @@ module Marty::Migrations
 
     add_mcfly_attrs_index(tb, *attrs)
 
-    MCFLY_INDEX_COLUMNS.each { |a|
+    MCFLY_INDEX_COLUMNS.each do |a|
       add_index tb.to_sym, a, index_opts(tb, a)
-    }
+    end
   end
 
   def add_mcfly_unique_index(klass)
@@ -115,19 +115,19 @@ module Marty::Migrations
 
     remove_index(klass.table_name.to_sym,
                  name: unique_index_name(klass)
-                 ) if index_exists?(klass.table_name.to_sym,
-                                    attrs,
-                                    name: unique_index_name(klass),
-                                    unique: true)
+                ) if index_exists?(klass.table_name.to_sym,
+                                   attrs,
+                                   name: unique_index_name(klass),
+                                   unique: true)
   end
 
   def self.write_view(target_dir, target_view, klass, jsons, excludes, extras)
     colnames = klass.columns_hash.keys
-    excludes += ["user_id", "o_user_id"]
-    joins = ["join marty_users u on main.user_id = u.id",
-             "left join marty_users ou on main.o_user_id = ou.id"]
-    columns = ["u.login AS user_name",
-               "ou.login AS obsoleted_user"]
+    excludes += ['user_id', 'o_user_id']
+    joins = ['join marty_users u on main.user_id = u.id',
+             'left join marty_users ou on main.o_user_id = ou.id']
+    columns = ['u.login AS user_name',
+               'ou.login AS obsoleted_user']
     jointabs = {}
     colnames.each do |c|
       if jsons[c]
@@ -142,14 +142,14 @@ module Marty::Migrations
         end
       elsif !excludes.include?(c)
         assoc = klass.reflections.find { |(n, h)| h.foreign_key == c }
-        if assoc && assoc[1].klass.columns_hash["name"]
+        if assoc && assoc[1].klass.columns_hash['name']
           table_name = assoc[1].table_name
           jointabs[table_name] ||= 0
           jointabs[table_name] += 1
           tn_alias = "#{table_name}#{jointabs[table_name]}"
           joins.push "left join #{table_name} #{tn_alias} on main.#{c} " +
                      "= #{tn_alias}.id"
-          target_name = c.gsub(/_id$/,'_name')
+          target_name = c.gsub(/_id$/, '_name')
           columns.push "#{tn_alias}.name as #{target_name}"
           extras.each do |(table, column, new_colname)|
             columns.push "#{tn_alias}.#{column} as #{new_colname}" if
@@ -160,7 +160,7 @@ module Marty::Migrations
         end
       end
     end
-    File.open(File.join(target_dir, "#{target_view}.sql"), "w") do |f|
+    File.open(File.join(target_dir, "#{target_view}.sql"), 'w') do |f|
       f.puts <<EOSQL
 create or replace function f_fixfalse(s text) returns text as $$
 begin
@@ -205,14 +205,14 @@ EOSQL
     gen_count = 0
 
     sql_files.each do |sql|
-      base = File.basename(sql, ".sql")
+      base = File.basename(sql, '.sql')
       existing = mig_files[base].first rescue nil
       # must ensure CRLF line endings or SQL Server keep asking about line
       # endings whenever you generating script
-      sql_lines = lines_to_crlf(File.open(sql, "r").readlines)
+      sql_lines = lines_to_crlf(File.open(sql, 'r').readlines)
       next if existing && sql_lines == File.open(existing[:raw_sql]).readlines
 
-      timestamp = (time_now + gen_count.seconds).strftime("%Y%m%d%H%M%S")
+      timestamp = (time_now + gen_count.seconds).strftime('%Y%m%d%H%M%S')
       v = existing && existing[:version] + 1 || 1
       klass = "v#{v}_sql_#{base}"
       newbase = "#{timestamp}_#{klass}"
@@ -221,14 +221,14 @@ EOSQL
       sql_snap_call =
         "Rails.root.join('#{migrations_dir}', 'sql', '#{newbase}.sql')"
 
-      File.open(sql_snap_literal, "w") do |f|
+      File.open(sql_snap_literal, 'w') do |f|
         f.print sql_lines.join
       end
       puts "creating #{newbase}.rb"
 
       # only split on "GO" at the start of a line with optional whitespace
       # before EOL.  GO in comments could trigger this and will cause an error
-      File.open(mig_name, "w") do |f|
+      File.open(mig_name, 'w') do |f|
         f.print <<OUT
 class #{klass.camelcase} < ActiveRecord::Migration[4.2]
 
@@ -254,20 +254,21 @@ OUT
   # we have to get it from the database
   def get_old_enum_id(klass, name)
     ActiveRecord::Base.
-               connection.execute(<<-SQL).to_a.first.try{|v| v['id']}
+               connection.execute(<<-SQL).to_a.first.try { |v| v['id'] }
       select id from #{klass.table_name} where name =
          #{ActiveRecord::Base.connection.quote(name)}
     SQL
   end
 
   private
+
   def fk_opts(from, to, column)
     name = "fk_#{from}_#{to}_#{column}"
     if name.length > 63
       s = Digest::MD5.hexdigest("#{to}_#{column}").slice(0..9)
       name = "fk_#{from}_#{s}"
     end
-    {name: name}
+    { name: name }
   end
 
   def index_opts(tb, a)
@@ -278,11 +279,11 @@ OUT
   end
 
   def add_mcfly_attrs_index(tb, *attrs)
-    attrs.each { |a|
+    attrs.each do |a|
       options = index_opts(tb, a)
-      options[:order] = {a.to_sym => "NULLS LAST"}
+      options[:order] = { a.to_sym => 'NULLS LAST' }
       add_index tb.to_sym, a, options
-    }
+    end
   end
 
   def unique_index_name(klass)
@@ -305,15 +306,16 @@ OUT
 
   def self.get_plv8_migration(file)
     fnname = %r(/([^/]+)_v[0-9]+\.js\z).match(file)[1]
-    lines=File.readlines(file)
+    lines = File.readlines(file)
     parts = lines.map do |line|
       next [:param, $1] if %r(\A// PARAM[:] (.*)$).match(line)
       next [:ret, $1]  if %r(\A// RETURN[:] (.*)$).match(line)
+
       [:body, line]
     end.group_by(&:first)
-    args = parts[:param].map{ |(_,l)| l}.join(",\n")
+    args = parts[:param].map { |(_, l)| l }.join(",\n")
     ret =  parts[:ret][0][1]
-    body = parts[:body].map{ |(_,l)| l}.join
+    body = parts[:body].map { |(_, l)| l }.join
     <<EOT
 CREATE OR REPLACE FUNCTION #{fnname} (
 #{args}

data/lib/marty/monkey.rb

@@ -25,14 +25,14 @@ end
 class Hash
   # define addition on hashes -- useful in Delorean code.
   def +(x)
-    self.merge(x)
+    merge(x)
   end
 
   # define hash slice (similar to node slice in Delorean)
   def %(x)
-    x.each_with_object({}) { |k, h|
+    x.each_with_object({}) do |k, h|
       h[k] = self[k]
-    }
+    end
   end
 end
 
@@ -42,7 +42,7 @@ require 'netzke-basepack'
 
 class Netzke::Base
   # get root component session
-  def root_sess(component=nil)
+  def root_sess(component = nil)
     component ||= self
     component.parent ? root_sess(component.parent) : component.component_session
   end
@@ -87,7 +87,6 @@ class String
   def in_time_zone(zone = ::Time.zone)
     self == 'infinity' ? self : old_in_time_zone(zone)
   end
-
 end
 
 ######################################################################
@@ -121,8 +120,8 @@ module Netzke::Basepack::DataAdapters
         arel_table = assoc ? Arel::Table.new(assoc.klass.table_name.to_sym) :
                        @model.arel_table
 
-        value = q["value"]
-        op = q["operator"]
+        value = q['value']
+        op = q['operator']
 
         attr_type = attr_type(attr)
 
@@ -144,11 +143,11 @@ module Netzke::Basepack::DataAdapters
       end
 
       # join them by AND
-      predicates[1..-1].inject(predicates.first){ |r,p| r.and(p)  }
+      predicates[1..-1].inject(predicates.first) { |r, p| r.and(p)  }
     end
 
     def update_predecate_for_enum(table, op, value)
-      col = Arel::Nodes::NamedFunction.new("CAST", [table.as("TEXT")])
+      col = Arel::Nodes::NamedFunction.new('CAST', [table.as('TEXT')])
       col.matches "%#{value}%"
     end
   end
@@ -166,8 +165,9 @@ module ActiveRecord
 
         enum = options.delete(:enum)
 
-        column_names.each { |name|
-          column(name, enum || name.to_s.pluralize, options) }
+        column_names.each do |name|
+          column(name, enum || name.to_s.pluralize, options)
+        end
       end
     end
   end
@@ -176,10 +176,10 @@ end
 ######################################################################
 
 class ActiveRecord::Relation
-  def mcfly_pt(pt, cls=nil)
-    cls ||= self.klass
+  def mcfly_pt(pt, cls = nil)
+    cls ||= klass
     tb = cls.table_name
-    self.where("#{tb}.obsoleted_dt >= ? AND #{tb}.created_dt < ?", pt, pt)
+    where("#{tb}.obsoleted_dt >= ? AND #{tb}.created_dt < ?", pt, pt)
   end
 
   def attributes
@@ -216,9 +216,9 @@ class ActiveRecord::Base
       # when joins args are strings, checks to see if they're
       # associations attrs.  If so, convert them to symbols for joins
       # to work properly.
-      new_args = args.map {|a|
-        self.reflections.has_key?(a) ? a.to_sym : a
-      }
+      new_args = args.map do |a|
+        reflections.key?(a) ? a.to_sym : a
+      end
       old_joins(*new_args)
     end
   end
@@ -226,19 +226,20 @@ end
 
 ar_instances = [ActiveRecord::Relation, ActiveRecord::QueryMethods::WhereChain]
 
-args_hack = [[Object, nil]]*10
-
-[[:distinct, args_hack],
- [:find_by,  args_hack],
- [:group,    args_hack],
- [:joins,    args_hack],
- [:limit,    [Integer]],
- [:not,      args_hack],
- [:order,     args_hack],
- [:pluck,     args_hack],
- [:select,    args_hack],
- [:where,     args_hack],
- [:mcfly_pt, [[Date, Time, ActiveSupport::TimeWithZone, String], [nil, Class]]]
+args_hack = [[Object, nil]] * 10
+
+[
+  [:distinct, args_hack],
+  [:find_by,  args_hack],
+  [:group,    args_hack],
+  [:joins,    args_hack],
+  [:limit,    [Integer]],
+  [:not,      args_hack],
+  [:order,     args_hack],
+  [:pluck,     args_hack],
+  [:select,    args_hack],
+  [:where,     args_hack],
+  [:mcfly_pt, [[Date, Time, ActiveSupport::TimeWithZone, String], [nil, Class]]]
 ].each do |meth, args|
   ::Delorean::Ruby.whitelist.add_method meth do |method|
     ar_instances.each do |ar|
@@ -254,10 +255,9 @@ end
 ::Delorean::Ruby.whitelist.add_method :lookup_grid_distinct_entry do |method|
   method.called_on OpenStruct, with: [[Date, Time,
                                        ActiveSupport::TimeWithZone, String],
-                                        Hash]
+                                      Hash]
 end
 
-
 mcfly_cache_adapter = ::Marty::CacheAdapters::McflyRubyCache.new(
   size_per_class: 1000
 )
@@ -278,7 +278,7 @@ end
 class OpenStruct
   # the default as_json produces {"table"=>h} which is quite goofy
   def as_json(*)
-    self.to_h
+    to_h
   end
 end