marty 0.5.15 → 0.5.16

data/lib/marty/drop_folder_hook.rb~

@@ -1,17 +0,0 @@
-class Marty::DropFolderHook
-  def initialize(login)
-    @login = login
-  end
-
-  def run(res)
-    p 'H.'*10, res
-    drop_path = "/tmp/#{@login}"
-
-    begin
-      Dir.mkdir(drop_path) unless File.directory?(drop_path)
-    rescue => exc
-      Marty::Util.logger.error "Can't create 
-
-
-  end
-end

data/lib/marty/folder_hook.rb~

@@ -1,9 +0,0 @@
-class Marty::FolderHook
-  def initialize
-  end
-
-  def run(res)
-    p 'H.'*10, res
-  end
-
-end

data/lib/marty/lazy_column_loader.rb~

@@ -1,47 +0,0 @@
-module Marty
-  module LazyColumnLoader
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def lazy_load(*columns)
-        return unless table_exists?
-        columns = columns.collect(&:to_s)
-        exclude_columns_from_default_scope columns
-        define_lazy_accessors_for columns
-      end
-
-    private
-      def exclude_columns_from_default_scope(columns)
-        default_scope select((
-                              column_names - columns).map {
-                               |column_name|
-                               "#{table_name}.#{column_name}"
-                             })
-      end
-
-      def define_lazy_accessors_for(columns)
-        columns.each { |column| define_lazy_accessor_for column }
-      end
-
-      def define_lazy_accessor_for(column)
-        define_method column do
-          unless has_attribute?(column)
-            changes_before_reload = self.changes.clone
-            self.reload
-            changes_before_reload.each{|attribute_name, values|
-              self.send("#{attribute_name}=", values[1])}
-          end
-          read_attribute column
-        end
-      end
-    end
-  end
-end
-
-if ActiveRecord::Base.respond_to?(:lazy_load)
-  $stderr.puts "ERROR: Method `.lazy_load` already defined in " +
-    "`ActiveRecord::Base`. This is incompatible with LazyColumnLoader " +
-    "and the module will be disabled."
-else
-  ActiveRecord::Base.send :include, Marty::LazyColumnLoader
-end

data/lib/marty/mcfly_query.rb~

@@ -1,188 +0,0 @@
-require 'mcfly'
-
-module Mcfly
-  module Model
-
-    def self.included(base)
-      base.send :extend, ClassMethods
-    end
-
-    module ClassMethods
-      def clear_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 ? q.send(mode) : q
-        end
-      end
-
-      ######################################################################
-
-      # Generates Gemini 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

data/lib/marty/migrations.rb~

@@ -1,65 +0,0 @@
-require 'digest/md5'
-
-module Marty::Migrations
-  def tb_prefix
-    "marty_"
-  end
-
-  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}
-  end
-
-  def add_fk(from_table, to_table, options = {})
-    options[:column] ||= "#{to_table.to_s.singularize}_id"
-
-    from_table = "#{tb_prefix}#{from_table}" unless
-      from_table.to_s.start_with?(tb_prefix)
-
-    # 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_")
-
-    add_foreign_key(from_table,
-                    to_table,
-                    fk_opts(from_table,
-                            to_table,
-                            options[:column]).update(options),
-                    )
-  end
-
-  def index_opts(tb, a)
-    name = "index_#{tb}_on_#{a}"
-    name.length > 63 ? {
-      name: "index_#{tb}_#{Digest::MD5.hexdigest(a.to_s).slice(0..9)}",
-    } : {}
-  end
-
-  # created_dt/obsoleted_dt need to be indexed since they appear in
-  # almost all queries.
-  MCFLY_INDEX_COLUMNS = [
-                         :created_dt,
-                         :obsoleted_dt,
-                        ]
-
-  def add_mcfly_index(tb, *attrs)
-    tb = "#{tb_prefix}#{tb}" unless
-      tb.to_s.start_with?(tb_prefix)
-
-    attrs.each { |a|
-      options = index_opts(tb, a)
-      options[:order] = {a.to_sym => "NULLS LAST"}
-      add_index tb.to_sym, a, options
-    }
-
-    MCFLY_INDEX_COLUMNS.each { |a|
-      add_index tb.to_sym, a, index_opts(tb, a)
-    }
-  end
-
-end

data/lib/marty/monkey.rb~

@@ -1,160 +0,0 @@
-# Various monkey patches go here
-
-######################################################################
-
-require 'delorean_lang'
-
-# Very hacky to overwrite delorean's whitelist.  But, there's no
-# better way now.
-
-Delorean::RUBY_WHITELIST.
-  merge!({
-         })
-
-######################################################################
-
-# Be able to access Enums from Delorean
-class Delorean::BaseModule::BaseClass
-  class << self
-    alias_method :old_get_attr, :_get_attr
-
-    def _get_attr(obj, attr, _e)
-      Marty::Enum === obj ? obj[attr] : old_get_attr(obj, attr, _e)
-    end
-  end
-end
-
-######################################################################
-# FIXME: not sure why the following is needed.  Otherwise, the monkey
-# patch doesn't work.
-ActiveSupport::JSON.encode([Date.today])
-
-class Date
-  # Very Hacky: The date JSON encoding format doesn't include TZ info.
-  # Therefore, the ExtJS client interprets it as GMT.  This causes
-  # dates to be displayed as previous day on Pacific TZ clients.  So,
-  # we just tack on 12:00 time to force the client to use the correct
-  # date (at least in the US).
-  def as_json(options = nil)
-    strftime("%Y-%m-%dT12:00:00-00:00")
-  end
-end
-
-######################################################################
-
-class Hash
-  # define addition on hashes -- useful in Delorean code.
-  def +(x)
-    self.merge(x)
-  end
-
-  # define hash slice (similar to node slice in Delorean)
-  def %(x)
-    x.each_with_object({}) { |k, h|
-      h[k] = self[k]
-    }
-  end
-end
-
-######################################################################
-
-require 'netzke-basepack'
-
-class Netzke::Base
-  # get root component session
-  def root_sess(component=nil)
-    component ||= self
-    component.parent ? root_sess(component.parent) : component.component_session
-  end
-end
-
-######################################################################
-
-# The following is a hack to get around postgres_ext's broken handling
-# of PostgreSQL ranges.  Essentially, postgres_ext doesn't allow
-# numranges to exlude the range start e.g. anything like: "(1.1,2.2]".
-# This hack turns off the casting of PostgreSQL ranges to ruby
-# ranges. i.e. we keep them as strings.  Note that this hack would be
-# quite different for Rails 4.0.
-
-require 'active_record/connection_adapters/postgresql_adapter'
-
-
-[:numrange,:int4range,:int8range,:daterange,:tsrange,:tstzrange].each {|t|
-  ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::OID.
-  alias_type t.to_s, 'text'
-}
-
-# The following is a hack to work around a bug in Rails4 array
-# handling which doesn't currently support multidimensional arrays.
-module ActiveRecord::ConnectionAdapters::PostgreSQLColumn::Cast
-  def string_to_array(string, oid)
-    type_cast_array parse_pg_array(string), oid
-  end
-
-  private
-  def type_cast_array(value, oid)
-    Array === value ?
-    value.map {|val| type_cast_array val, oid} : oid.type_cast(value)
-  end
-end
-
-######################################################################
-
-def pg_range_to_human(r)
-  m = /\A(?<open>\[|\()(?<start>.*?),(?<end>.*?)(?<close>\]|\))\z/.match(r)
-
-  raise "bad pg range #{r}" unless m
-
-  if m[:start] == ""
-    res = ""
-  else
-    op = m[:open] == "(" ? ">" : ">="
-    res = "#{op}#{m[:start]}"
-  end
-
-  if m[:end] != ""
-    op = m[:close] == ")" ? "<" : "<="
-    res += "#{op}#{m[:end]}"
-  end
-
-  res
-end
-
-def human_to_pg_range(r)
-  m = /\A
-    ((?<op0>\>|\>=)(?<start>[^\<\>\=]*?))?
-    ((?<op1>\<|\<=)(?<end>[^\<\>\=]*?))?
-    \z/x.match(r)
-
-  raise "bad range '#{r}'" unless m
-
-  if m[:op0]
-    open = m[:op0] == ">" ? "(" : "["
-    start = "#{open}#{m[:start]}"
-  else
-    start = "["
-  end
-
-  if m[:op1]
-    close = m[:op1] == "<" ? ")" : "]"
-    ends = "#{m[:end]}#{close}"
-  else
-    ends = "]"
-  end
-
-  "#{start},#{ends}"
-end
-
-######################################################################
-
-# Rails 4 doesn't handle 'infinity' datetime correctly properly due to
-# in_time_zone conversion. Ergo this hack.
-
-class String
-  alias_method :old_in_time_zone, :in_time_zone
-
-  def in_time_zone(zone = ::Time.zone)
-    self == 'infinity' ? self : old_in_time_zone(zone)
-  end
-end