marty 1.0.54 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b39a9aaf4fd1b9f90bdff0503ea509ae7b4e4232
-  data.tar.gz: 36f9283c373a1e5e1f0ab1c5e5a00efab731238c
+  metadata.gz: 5f65bd901e74662263479f7acb3c2f616e41be2a
+  data.tar.gz: 6ef39fe48e763f6758e93d0f75aae5266bb3ab64
 SHA512:
-  metadata.gz: a0212491f9ac246e2731fc2629d7543f49f0c814b597459cef568be5fc824ce891b56553f083f5de3a831ff8cd6585e118c82379f2512d74f08eff4913f08b40
-  data.tar.gz: abf2e69338e8f90b1f9dac8b15a31896d1ffab3681190adece922db454ac8dada1ecce411cef5c417f3d5d161d0a0e5f250bfa917de03e8ef17fe069163e9b77
+  metadata.gz: bf459ac2132cd88ce789485e564c1885b2433a8bf2fed54239249d660038db911dfec94345e8166ee279c8b1955aa7a93812fed51e16013084679e8235c2fd5d
+  data.tar.gz: 5c89ea1896bfed735b88a6cf3e0d8e507d7ef329d35c53cf1e933d1183826861fa411378f3dbf36dc6de6882a5bfc399b3e12803754b602aa0440b4e3c4c37c5

data/Gemfile

@@ -26,7 +26,9 @@ group :development, :test do
   gem 'netzke-core'
   gem 'netzke-basepack'
   gem 'netzke-testing'
+  gem 'rspec-instafail', require: false
 
   gem 'marty_rspec'
-  gem 'rspec-instafail', require: false
+
+  # gem 'delorean_lang', path: File.expand_path('../../delorean', __FILE__)
 end

data/Gemfile.lock

@@ -1,10 +1,10 @@
 PATH
   remote: .
   specs:
-    marty (1.0.54)
+    marty (1.1.0)
       axlsx (= 2.1.0pre)
       coderay
-      delorean_lang (~> 0.1)
+      delorean_lang (~> 0.3.24)
       json-schema
       mcfly (= 0.0.19)
       net-ldap (~> 0.12.0)

data/app/models/marty/base.rb

@@ -1,4 +1,24 @@
 class Marty::Base < ActiveRecord::Base
   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)
+  end
+  MCFLY_PT_SIG = [1, 1]
+
+  # FIXME: hacky signatures for AR queries
+  COUNT_SIG    = [0, 0]
+  DISTINCT_SIG = [0, 100]
+  FIRST_SIG    = [0, 1]
+  GROUP_SIG    = [1, 100]
+  JOINS_SIG    = [1, 100]
+  LAST_SIG     = [0, 1]
+  LIMIT_SIG    = [1, 1]
+  NOT_SIG      = [1, 100]
+  ORDER_SIG    = [1, 100]
+  PLUCK_SIG    = [1, 100]
+  SELECT_SIG   = [1, 100]
+  WHERE_SIG    = [0, 100]
 end

data/app/models/marty/data_grid.rb

@@ -86,11 +86,8 @@ class Marty::DataGrid < Marty::Base
   validates_with DataGridValidator
   validates_with Marty::NameValidator, field: :name
 
-  gen_mcfly_lookup :lookup, {
-    name: false,
-  }
-
-  gen_mcfly_lookup :get_all, {}, mode: :all
+  gen_mcfly_lookup :lookup, [:name], cache: true
+  gen_mcfly_lookup :get_all, [], mode: nil
 
   cached_mcfly_lookup :lookup_id, sig: 2 do
     |pt, group_id|

data/app/models/marty/script.rb

@@ -10,11 +10,8 @@ class Marty::Script < Marty::Base
 
   belongs_to :user, class_name: "Marty::User"
 
-  gen_mcfly_lookup :lookup, {
-    name: false,
-  }
-
-  gen_mcfly_lookup :get_all, {}, mode: :all
+  gen_mcfly_lookup :lookup, [:name], cache: true
+  gen_mcfly_lookup :get_all, {}, mode: nil
 
   # find script by name/tag
   def self.find_script(sname, tag=nil)

data/lib/marty.rb

@@ -10,7 +10,7 @@
 
 require 'marty/engine'
 require 'marty/railtie'
-require 'marty/mcfly_query'
+require 'marty/mcfly_model'
 require 'marty/monkey'
 require 'marty/promise_job'
 require 'marty/lazy_column_loader'

data/lib/marty/mcfly_model.rb

@@ -0,0 +1,188 @@
+require 'mcfly'
+
+module Mcfly::Model
+  def self.included(base)
+    base.send :extend, ClassMethods
+  end
+
+  module ClassMethods
+    def clear_lookup_cache!
+      @LOOKUP_CACHE.clear if @LOOKUP_CACHE
+    end
+
+    # FIXME IDEA: we just make :cache an argument to delorean_fn.
+    # That way, we don't need the cached_ flavors.  It'll make all
+    # this code a lot simpler.  We should also just add the :private
+    # mechanism here.
+
+    # Implements a VERY HACKY class-based (per process) caching
+    # mechanism for database lookup results.  Issues include: cached
+    # values are ActiveRecord objects.  Query results can be very
+    # large lists which we count as one item in the cache.  Caching
+    # mechanism will result in large processes.
+    def cached_delorean_fn(name, options = {}, &block)
+      @LOOKUP_CACHE ||= {}
+
+      delorean_fn(name, options) do |ts, *args|
+        cache_key = [name, ts] + args.map{ |a|
+          a.is_a?(ActiveRecord::Base) ? a.id : a
+        } unless Mcfly.is_infinity(ts)
+
+        next @LOOKUP_CACHE[cache_key] if
+          cache_key && @LOOKUP_CACHE.has_key?(cache_key)
+
+        res = block.call(ts, *args)
+
+        if cache_key
+          # Cache has >1000 items, clear out the oldest 200.  FIXME:
+          # hard-coded, should be configurable.  Cache
+          # size/invalidation should be per lookup and not class.
+          # We're invalidating cache items simply based on age and
+          # not usage.  This is faster but not as fair.
+          if @LOOKUP_CACHE.count > 1000
+            @LOOKUP_CACHE.keys[0..200].each{|k| @LOOKUP_CACHE.delete(k)}
+          end
+          @LOOKUP_CACHE[cache_key] = res
+
+          # Since we're caching this object and don't want anyone
+          # changing it.  FIXME: ideally should freeze this object
+          # recursively.
+          res.freeze unless res.is_a?(ActiveRecord::Relation)
+        end
+        res
+      end
+    end
+
+    # FIXME: duplicate code from Mcfly's mcfly_lookup.
+    def cached_mcfly_lookup(name, options = {}, &block)
+      cached_delorean_fn(name, options) do |ts, *args|
+        raise "nil timestamp" if ts.nil?
+
+        ts = Mcfly.normalize_infinity(ts)
+
+        self.mcfly_pt(ts).scoping do
+          block.call(ts, *args)
+        end
+      end
+    end
+
+    # FIXME: add private mode.  This should make the function
+    # unavailable to delorean.
+    def gen_mcfly_lookup(name, attrs, options={})
+      raise "bad options #{options.keys}" unless
+        (options.keys - [:mode, :cache, :private]).empty?
+
+      mode = options.fetch(:mode, :first)
+
+      # if mode is nil, don't cache -- i.e. don't cache AR queries
+      cache = mode && options[:cache]
+
+      # 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))
+
+      qstr = attrs.map {|k, v|
+        k = "#{k}_id" if assoc.member?(k)
+
+        v ? "(#{k} = ? OR #{k} IS NULL)" : "(#{k} = ?)"
+      }.join(" AND ")
+
+      if Hash === attrs
+        order = attrs.select {|k, v| v}.keys.reverse.map { |k|
+          k = "#{k}_id" if assoc.member?(k)
+
+          "#{k} NULLS LAST"
+        }.join(", ")
+        attrs = attrs.keys
+      else
+        raise "bad attrs" unless Array === attrs
+      end
+
+      fn = cache ? :cached_mcfly_lookup : :mcfly_lookup
+
+      # hacky: if private, set sig to bad value -- i.e. can't be
+      # called from delorean.  Ideally, we should have a 'private'
+      # option for delorean_fn.
+      sig = options[:private] ? -1 : attrs.length+1
+
+      send(fn, name, sig: sig) do
+        |t, *attr_list|
+
+        attr_list_ids = attr_list.each_with_index.map {|x, i|
+          assoc.member?(attrs[i]) ?
+            (attr_list[i] && attr_list[i].id) : attr_list[i]
+        }
+
+        q = self.where(qstr, *attr_list_ids)
+        q = q.order(order) if order
+        mode ? q.send(mode) : q
+      end
+    end
+
+    ######################################################################
+
+    # Generates categorization lookups, e.g. given class GFee:
+
+    # gen_mcfly_lookup_cat :lookup_q,
+    # [:security_instrument,
+    #  'Gemini::SecurityInstrumentCategorization',
+    #  :g_fee_category],
+    # {
+    #   entity: true,
+    #   security_instrument: true,
+    #   coupon: true,
+    # },
+    # nil
+
+    # rel_attr        = :security_instrument
+    # cat_assoc_klass = Gemini::SecurityInstrumentCategorization
+    # cat_attr        = :g_fee_category
+    # name            = :lookup_q
+    # pc_name         = :pc_lookup_q
+    # pc_attrs        = {entity: true, security_instrument: true, coupon: true}
+
+    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?
+
+      cat_assoc_klass = cat_assoc_name.constantize
+
+      # replace rel_attr with cat_attr in attrs
+      pc_attrs = attrs.each_with_object({}) {|(k, v), h|
+        h[k == rel_attr ? "#{cat_attr}_id" : k] = v
+      }
+
+      pc_name = "pc_#{name}".to_sym
+
+      gen_mcfly_lookup(pc_name, pc_attrs, options + {private: true})
+
+      lpi = attrs.keys.index rel_attr
+
+      raise "should not include #{cat_attr}" if attrs.member?(cat_attr)
+      raise "need #{rel_attr} argument" unless lpi
+
+      # cache if mode is not nil
+      fn = options.fetch(:mode, :first) ? :cached_delorean_fn : :delorean_fn
+
+      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
+
+        args[lpi] = cat_assoc_klass.
+                      mcfly_pt(ts).
+                      # FIXME: XXXX why is this join needed???
+                      # joins(cat_attr).
+                      where(rel_attr => rel).
+                      pluck("#{cat_attr}_id").
+                      first
+
+        self.send(pc_name, ts, *args)
+      end
+    end
+  end
+end

data/lib/marty/monkey.rb

@@ -202,7 +202,7 @@ end
 class StringEnum < String
   include Delorean::Model
   def name
-    self
+    self.to_s
   end
   def id
     self
@@ -224,6 +224,7 @@ class StringEnum < String
     new(v)
   end
 end
+
 YAML::add_domain_type("pennymac.com,2017-06-02", "stringEnum") do
   |type, val|
   StringEnum.new(val)
@@ -252,3 +253,59 @@ module ActiveRecord
     end
   end
 end
+
+######################################################################
+
+class ActiveRecord::Relation
+  def mcfly_pt(pt, cls=nil)
+    cls ||= self.klass
+    tb = cls.table_name
+    self.where("#{tb}.obsoleted_dt >= ? AND #{tb}.created_dt < ?", pt, pt)
+  end
+end
+
+######################################################################
+
+class ActiveRecord::Base
+  class << self
+    alias_method :old_joins, :joins
+
+    def joins(*args)
+      # 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
+      }
+      old_joins(*new_args)
+    end
+  end
+end
+
+args_hack = [[ActiveRecord::Relation, ActiveRecord::QueryMethods::WhereChain]] +
+            [[Object, nil]]*10
+
+Delorean::RUBY_WHITELIST.merge!(
+  count:    [ActiveRecord::Relation],
+  distinct: args_hack,
+  group:    args_hack,
+  joins:    args_hack,
+  limit:    [ActiveRecord::Relation, Integer],
+  not:      args_hack,
+  order:    args_hack,
+  pluck:    args_hack,
+  select:   args_hack,
+  where:    args_hack,
+  mcfly_pt: [ActiveRecord::Relation,
+             [Date, Time, ActiveSupport::TimeWithZone, String],
+             [nil, Class]],
+)
+
+######################################################################
+
+module Mcfly::Controller
+  # define mcfly user to be Flowscape's current_user.
+  def user_for_mcfly
+    find_current_user rescue nil
+  end
+end

data/lib/marty/version.rb

@@ -1,3 +1,3 @@
 module Marty
-  VERSION = "1.0.54"
+  VERSION = "1.1.1"
 end

data/marty.gemspec

@@ -34,7 +34,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'axlsx', '2.1.0pre'
 
-  s.add_dependency 'delorean_lang', '~> 0.1'
+  s.add_dependency 'delorean_lang', '~> 0.3.24'
   s.add_dependency 'mcfly', '0.0.19'
 
   s.add_dependency 'coderay'

data/spec/dummy/app/models/gemini/bud_category.rb

@@ -1,5 +1,5 @@
 module Gemini
-  class BudCategory < ActiveRecord::Base
+  class BudCategory < Marty::Base
     self.table_name = 'gemini_bud_categories'
     has_mcfly append_only: true
     mcfly_validates_uniqueness_of :name

data/spec/dummy/app/models/gemini/fannie_bup.rb

@@ -1,5 +1,5 @@
 module Gemini
-  class FannieBup < ActiveRecord::Base
+  class FannieBup < Marty::Base
     extend Gemini::Extras::DataImport
     extend Gemini::Extras::SettlementImport
 

data/spec/dummy/config/environment.rb

@@ -2,4 +2,4 @@
 require File.expand_path('../application', __FILE__)
 
 # Initialize the rails application
-Dummy::Application.initialize!
+Dummy::Application.initialize! unless Dummy::Application.initialized?

data/spec/lib/delorean_query_spec.rb

@@ -0,0 +1,159 @@
+require "spec_helper"
+
+module Marty
+
+bud_cats =<<EOF
+name
+Conv Fixed 30
+Conv Fixed 20
+EOF
+
+fannie_bup =<<EOF
+bud_category	note_rate	buy_up	buy_down	settlement_mm	settlement_yy
+Conv Fixed 30	2.250	4.42000	7.24000	12	2012
+Conv Fixed 30	2.375	4.42000	7.24000	12	2012
+Conv Fixed 30	2.500	4.41300	7.22800	12	2012
+Conv Fixed 30	2.625	4.37500	7.16200	12	2012
+Conv Fixed 30	2.750	4.32900	7.09300	12	2012
+Conv Fixed 20	2.875	4.24800	6.95900	12	2012
+Conv Fixed 20	2.875	4.24800	6.95900	11	2012
+EOF
+
+script =<<EOF
+A:
+    c = Gemini::FannieBup.
+      joins("bud_category").
+      where("name LIKE '%30'").
+      count
+
+    s = Gemini::FannieBup.
+      joins("bud_category").
+      select("name").
+      distinct("name").
+      pluck("name")
+
+    o = Gemini::FannieBup.
+      order("note_rate DESC", "buy_down ASC").
+      select("note_rate").
+      first.note_rate
+
+    g = Gemini::FannieBup.
+      select("settlement_yy*settlement_mm AS x, count(*) AS c").
+      group("settlement_mm", "settlement_yy").
+      order("settlement_mm").to_a
+
+    gg = [r.attributes for r in g]
+
+    n = Gemini::FannieBup.where.not("settlement_mm < 12").count
+
+    q = Gemini::FannieBup.where("settlement_mm = 12")
+    q1 = q.order("note_rate ASC").pluck("note_rate")
+    q2 = q.order("note_rate DESC").pluck("note_rate")
+
+    settlement_mm =?
+    note_rate     =?
+    pq = Gemini::FannieBup.
+       where({"settlement_mm": settlement_mm}).
+       where("note_rate > ?", note_rate).
+       pluck("note_rate")
+
+    m = Gemini::FannieBup.
+      joins("bud_category").
+      mcfly_pt('infinity').
+      select("name").
+      pluck("name")
+
+    mm = Gemini::FannieBup.
+      mcfly_pt('01-01-2003').count
+EOF
+
+  describe 'DeloreanQuery' do
+    before(:each) do
+      marty_whodunnit
+      Marty::DataImporter.do_import_summary(Gemini::BudCategory, bud_cats)
+      Marty::DataImporter.do_import_summary(Gemini::FannieBup, fannie_bup)
+
+      Marty::Script.load_script_bodies(
+        {
+          "A" => script,
+        }, Date.today)
+
+      @engine = Marty::ScriptSet.new.get_engine("A")
+    end
+
+    it "perfroms join+count" do
+      res = @engine.evaluate("A", "c", {})
+
+      expect(res).to eq Gemini::FannieBup.
+                          joins("bud_category").
+                          where("name LIKE '%30'").
+                          count
+
+    end
+
+    it "perfroms select+distinct" do
+      res = @engine.evaluate("A", "s", {})
+
+      expect(res).to eq Gemini::FannieBup.
+                          joins("bud_category").
+                          select("name").
+                          distinct("name").
+                          pluck("name")
+    end
+
+    it "perfroms mcfly_pt" do
+      res = @engine.evaluate("A", ["m", "mm"], {})
+
+      expect(res).to eq [
+                       Gemini::FannieBup.
+                         joins("bud_category").
+                         mcfly_pt('infinity').
+                         select("name").
+                         pluck("name"),
+                       Gemini::FannieBup.
+                         mcfly_pt('01-01-2003').count,
+                     ]
+    end
+
+    it "perfroms order+first" do
+      res = @engine.evaluate("A", "o", {})
+
+      expect(res).to eq Gemini::FannieBup.
+                          order("note_rate DESC", "buy_down ASC").
+                          select("note_rate").
+                          first.note_rate
+    end
+
+    it "perfroms group+count" do
+      res = @engine.evaluate("A", "gg", {})
+
+      expect(res).
+        to eq Gemini::FannieBup.
+                select("settlement_yy*settlement_mm AS x, count(*) AS c").
+                group("settlement_mm", "settlement_yy").
+                order("settlement_mm").
+                map(&:attributes)
+    end
+
+    it "perfroms where+not" do
+      res = @engine.evaluate("A", "n", {})
+
+      expect(res).to eq Gemini::FannieBup.where.not("settlement_mm < 12").count
+    end
+
+    it "perfroms query+query" do
+      res = @engine.evaluate("A", ["q1", "q2"], {})
+
+      expect(res).to eq [
+                       [2.25, 2.375, 2.5, 2.625, 2.75, 2.875],
+                       [2.875, 2.75, 2.625, 2.5, 2.375, 2.25],
+                     ]
+    end
+
+    it "handle query params" do
+      res = @engine.evaluate("A", "pq",
+                             {"settlement_mm" => 12, "note_rate" => 2.5})
+      expect(res).to eq [2.625, 2.75, 2.875]
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -5,7 +5,7 @@ require 'rspec/rails'
 require 'database_cleaner'
 require 'marty_rspec'
 
-Dummy::Application.initialize!
+Dummy::Application.initialize! unless Dummy::Application.initialized?
 
 ActiveRecord::Migrator.migrate File.expand_path("../../db/migrate/", __FILE__)
 ActiveRecord::Migrator.migrate File.expand_path("../dummy/db/migrate/", __FILE__)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: marty
 version: !ruby/object:Gem::Version
-  version: 1.0.54
+  version: 1.1.1
 platform: ruby
 authors:
 - Arman Bostani
@@ -14,7 +14,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-28 00:00:00.000000000 Z
+date: 2017-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -92,14 +92,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: 0.3.24
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: 0.3.24
 - !ruby/object:Gem::Dependency
   name: mcfly
   requirement: !ruby/object:Gem::Requirement
@@ -496,7 +496,7 @@ files:
 - lib/marty/json_schema.rb
 - lib/marty/lazy_column_loader.rb
 - lib/marty/logger.rb
-- lib/marty/mcfly_query.rb
+- lib/marty/mcfly_model.rb
 - lib/marty/migrations.rb
 - lib/marty/monkey.rb
 - lib/marty/permissions.rb
@@ -1616,6 +1616,7 @@ files:
 - spec/job_helper.rb
 - spec/lib/data_exporter_spec.rb
 - spec/lib/data_importer_spec.rb
+- spec/lib/delorean_query_spec.rb
 - spec/lib/json_schema_spec.rb
 - spec/lib/logger_spec.rb
 - spec/lib/migrations/vw_marty_postings.sql.expected

data/lib/marty/mcfly_query.rb

@@ -1,189 +0,0 @@
-require 'mcfly'
-
-module Mcfly
-  module Model
-
-    def self.included(base)
-      base.send :extend, ClassMethods
-    end
-
-    module ClassMethods
-      def clear_lookup_cache!
-        @LOOKUP_CACHE.clear if @LOOKUP_CACHE
-      end
-
-      # Implements a VERY HACKY class-based caching mechanism for
-      # database lookup results.  Issues include: cached values are
-      # ActiveRecord objects.  Not sure if these should be shared
-      # across connections.  Query results can potentially be very
-      # large lists which we simply count as one item in the cache.
-      # Caching mechanism will result in large processes.  Caches are
-      # not sharable across different Ruby processes.
-      def cached_delorean_fn(name, options = {}, &block)
-        @LOOKUP_CACHE ||= {}
-
-        delorean_fn(name, options) do |ts, *args|
-          cache_key = [name, ts] + args.map{ |a|
-            a.is_a?(ActiveRecord::Base) ? a.id : a
-          } unless Mcfly.is_infinity(ts)
-
-          next @LOOKUP_CACHE[cache_key] if
-            cache_key && @LOOKUP_CACHE.has_key?(cache_key)
-
-          res = block.call(ts, *args)
-
-          if cache_key
-            # Cache has >1000 items, clear out the oldest 200.  FIXME:
-            # hard-coded, should be configurable.  Cache
-            # size/invalidation should be per lookup and not class.
-            # We're invalidating cache items simply based on age and
-            # not usage.  This is faster but not as fair.
-            if @LOOKUP_CACHE.count > 1000
-              @LOOKUP_CACHE.keys[0..200].each{|k| @LOOKUP_CACHE.delete(k)}
-            end
-            @LOOKUP_CACHE[cache_key] = res
-
-            # Since we're caching this object and don't want anyone
-            # changing it.  FIXME: ideally should freeze this object
-            # recursively.
-            res.freeze unless res.is_a?(ActiveRecord::Relation)
-          end
-          res
-        end
-      end
-
-      # FIXME: duplicate code from Mcfly's mcfly_lookup.
-      def cached_mcfly_lookup(name, options = {}, &block)
-        cached_delorean_fn(name, options) do |ts, *args|
-          raise "time cannot be nil" if ts.nil?
-
-          ts = Mcfly.normalize_infinity(ts)
-
-          where("obsoleted_dt >= ? AND created_dt < ?", ts, ts).scoping do
-            block.call(ts, *args)
-          end
-        end
-      end
-
-      # FIXME: for validation purposes, this mechanism should make
-      # sure that the allable attrs are not required.
-      def gen_mcfly_lookup(name, attrs, options={})
-        raise "bad options" unless options.is_a?(Hash)
-
-        # FIXME: mode should be sent later, not as a part of
-        # gen_mcfly_lookup.  i.e. we just generate the search and the
-        # mode is applied at runtime by delorean code.  That would
-        # allow lookups to be used in either mode dynamically.
-        mode = options.fetch(:mode, :first)
-
-        assoc = Set.new(self.reflect_on_all_associations.map(&:name))
-        attr_names = attrs.keys
-
-        allables = attrs.select {|k, v| v}
-
-        order = allables.keys.reverse.map { |k|
-          k = "#{k}_id" if assoc.member?(k)
-          "#{k} NULLS LAST"
-        }.join(", ")
-
-        qstr = attrs.map {|k, v|
-          k = "#{k}_id" if assoc.member?(k)
-          v ? "(#{k} = ? OR #{k} IS NULL)" : "(#{k} = ?)"
-        }.join(" AND ")
-
-        cached_mcfly_lookup(name, sig: attrs.length+1) do
-          |t, *attr_list|
-
-          attr_list_ids = attr_list.each_with_index.map {|x, i|
-            assoc.member?(attr_names[i]) ?
-            (attr_list[i] && attr_list[i].id) : attr_list[i]
-          }
-
-          q = self.where(qstr, *attr_list_ids)
-          q = q.order(order) unless order.empty?
-          mode = :to_a if mode == :all
-          mode ? q.send(mode) : q
-        end
-      end
-
-      ######################################################################
-
-      # Generates categorization lookups.  For instance,
-      # suppose we have the following in class GFee:
-      #
-      # gen_mcfly_lookup_cat :lookup_q,
-      # [:security_instrument,
-      #  'Gemini::SecurityInstrumentCategorization',
-      #  :g_fee_category],
-      # {
-      #   entity: true,
-      #   security_instrument: true,
-      #   coupon: true,
-      # },
-      # nil
-
-      # In the above case,
-      # rel_attr = :security_instrument
-      # cat_assoc_klass = Gemini::SecurityInstrumentCategorization
-      # cat_attr = :g_fee_category
-      # name = :lookup_q
-      # pc_name = :pc_lookup_q
-      # pc_attrs = {entity: true, security_instrument: true,
-      # g_fee_category: true, coupon: true}
-
-      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?
-
-        cat_assoc_klass = cat_assoc_name.constantize
-
-        raise "need lookup method on #{cat_assoc_klass}" unless
-          cat_assoc_klass.respond_to? :lookup
-
-        # replace rel_attr with cat_attr in attrs
-        pc_attrs = attrs.each_with_object({}) {|(k, v), h|
-          h[k == rel_attr ? cat_attr : k] = v
-        }
-
-        pc_name = "pc_#{name}".to_sym
-        gen_mcfly_lookup(pc_name, pc_attrs, options)
-
-        lpi = attrs.keys.index rel_attr
-
-        raise "should not include #{cat_attr}" if
-          attrs.member?(cat_attr)
-
-        raise "need #{rel_attr} argument" unless lpi
-
-        delorean_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
-
-          # Assumes there's a mcfly :lookup function on
-          # cat_assoc_klass.
-          categorizing_obj = cat_assoc_klass.lookup(ts, rel)
-          raise "no categorization #{cat_assoc_klass} for #{rel}" unless
-            categorizing_obj
-
-          pc = categorizing_obj.send(cat_attr)
-          raise ("#{categorizing_obj} must have assoc." +
-                 " #{cat_attr}/#{rel.inspect}") unless pc
-
-          args[lpi] = pc
-          self.send(pc_name, ts, *args)
-        end
-      end
-
-    end
-  end
-end
-
-module Mcfly::Controller
-  # define mcfly user to be Flowscape's current_user.
-  def user_for_mcfly
-    find_current_user rescue nil
-  end
-end