marty 0.5.15 → 0.5.16

data/app/controllers/marty/components_controller.rb~

@@ -1,37 +0,0 @@
-class Marty::ComponentsController < Marty::ApplicationController
-  # This is useful for individual component testing.  Note that the
-  # appropriate route needs to be defined.
-  # <base_url>/components/<ComponentCamelCaseName>
-  def index
-    component = params[:component]
-
-    return redirect_to root_path unless component
-
-    format, req_disposition, title =
-      params[:format], params[:disposition], params[:reptitle]
-
-    if format && Marty::ContentHandler::GEN_FORMATS.member?(format)
-      klass = component.constantize
-
-      raise "bad component" unless klass < Netzke::Base
-
-      inst = klass.new
-      return unless inst.respond_to?(:export_content)
-
-      title ||= component
-
-      res, type, disposition, filename =
-        inst.export_content(format, title, params)
-
-      return send_data(res,
-                       type:        type,
-                       filename:    filename,
-                       disposition: req_disposition || disposition,
-                       )
-    end
-
-    cname = component.gsub("::", "_").underscore
-    render layout: true,
-    inline: "<%= netzke :#{cname}, class_name: '#{component}', height: 650 %>"
-  end
-end

data/app/controllers/marty/job_controller.rb~

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

data/app/controllers/marty/rpc_controller.rb~

@@ -1,61 +0,0 @@
-class Marty::RpcController < ActionController::Base
-  respond_to :json, :csv
-
-  def evaluate
-    res = do_eval(params["script"],
-                  params["version"],
-                  params["node"],
-                  params["attrs"] || "[]",
-                  params["params"] || "{}",
-                  )
-
-    respond_to do |format|
-      format.json { send_data res.to_json }
-      format.csv  {
-        # SEMI-HACKY: strip outer list if there's only one element.
-        res = res[0] if res.is_a?(Array) && res.length==1
-        send_data Marty::DataExporter.to_csv(res)
-      }
-    end
-
-  end
-
-  private
-
-  def do_eval(sname, version, node, attrs, params)
-    return {error: "Bad attrs"} if !attrs.is_a?(String)
-
-    begin
-      attrs = ActiveSupport::JSON.decode(attrs)
-    rescue MultiJson::DecodeError
-      return {error: "Malformed attrs"}
-    end
-
-    return {error: "Malformed attrs"} unless
-      attrs.is_a?(Array) && attrs.all? {|x| x.is_a? String}
-
-    return {error: "Bad params"} if !params.is_a?(String)
-
-    begin
-      params = ActiveSupport::JSON.decode(params)
-    rescue MultiJson::DecodeError
-      return {error: "Malformed params"}
-    end
-
-    return {error: "Malformed params"} unless
-      params.is_a?(Hash)
-
-    script = Marty::Script.find_script(sname, version)
-
-    return {error: "Can't find #{sname} version #{version}"} unless script
-
-    engine = Marty::ScriptSet.get_engine(script)
-
-    begin
-      engine.evaluate_attrs(node, attrs, params)
-    rescue => exc
-      Delorean::Engine.grok_runtime_exception(exc)
-    end
-  end
-
-end

data/app/helpers/marty/script_set.rb~

@@ -1,59 +0,0 @@
-class Marty::ScriptSet < Delorean::AbstractContainer
-  # ScriptSet acts as a process-wide cache for Delorean
-  # engines. FIXME: rewrite as Singleton.
-
-  @@engines, @@dengines, @@dengines_dt = {}, {}, nil
-
-  attr_reader :tag
-
-  def self.clear_cache
-    @@engines, @@dengines, @@dengines_dt = {}, {}, nil
-  end
-
-  def initialize(tag=nil)
-    @tag = Marty::Tag.map_to_tag(tag)
-    super()
-  end
-
-  def parse_check(sname, body)
-    engine = Delorean::Engine.new(sname, self)
-    engine.parse(body)
-    engine
-  end
-
-  def get_engine(sname)
-    raise "bad sname #{sname}" unless sname.is_a?(String)
-
-    script = Marty::Script.find_script(sname, tag)
-
-    raise "No such script" unless script
-
-    if tag.isdev?
-      # FIXME: there are race conditions here if a script changes in
-      # the middle of a DEV import sequence. But, DEV imports are
-      # hacky/rare anyway.  So, don't bother for now.
-
-      max_dt = Marty::Script.
-        where("created_dt <> 'infinity'").
-        order("created_dt DESC").limit(1).pluck(:created_dt).first
-
-      @@dengines_dt ||= max_dt
-
-      # reset dengine cache if a script has changed
-      @@dengines = {} if max_dt > @@dengines_dt
-
-      engine = @@dengines[sname]
-
-      return engine if engine
-
-      @@dengines[sname] = engine = parse_check(sname, script.body)
-    else
-      engine = @@engines[[tag.id, sname]]
-
-      return engine if engine
-
-      @@engines[[tag.id, sname]] = engine = parse_check(sname, script.body)
-    end
-    engine
-  end
-end

data/app/models/marty/api_auth.rb~

@@ -1,48 +0,0 @@
-require 'mcfly'
-
-class Marty::ApiAuth < Marty::Base
-  has_mcfly
-
-  KEY_SIZE = 19
-
-  def self.generate_key
-    SecureRandom.hex(KEY_SIZE)
-  end
-
-  class ApiAuthValidator < ActiveModel::Validator
-    def validate(api)
-      api.errors[:base] =
-        "API Key length must be #{KEY_SIZE*2}" if
-        api.api_key && api.api_key.length != KEY_SIZE*2
-
-      api.errors[:base] =
-        "Script Name must reference a valid script" if
-        Marty::Script.find_script(api.script_name, nil).nil?
-    end
-  end
-
-  before_validation do
-    self.api_key = Marty::ApiAuth.generate_key if
-      self.api_key.nil? || self.api_key.length == 0
-  end
-
-<<<<<<< HEAD
-  # attr_accessible :app_name, :api_key, :script_name
-=======
->>>>>>> master
-  validates_presence_of :app_name, :api_key, :script_name
-
-  validates_with ApiAuthValidator
-
-  mcfly_validates_uniqueness_of :api_key, scope: [:script_name]
-  validates_uniqueness_of :app_name, scope: [:script_name,
-                                             :obsoleted_dt]
-
-  def self.authorized?(script_name, api_key)
-    is_secured = where(script_name: script_name,
-                       obsoleted_dt: 'infinity').exists?
-    !is_secured || where(api_key: api_key,
-                         script_name: script_name,
-                         obsoleted_dt: 'infinity').exists?
-  end
-end

data/app/models/marty/data_change.rb~

@@ -1,141 +0,0 @@
-require 'delorean_lang'
-
-class Marty::DataChange
-  include Delorean::Model
-
-  # Some arbitrary limit so we don't allow enormous queries
-  MAX_COUNT = 64000
-
-  delorean_fn :changes, sig: 3 do
-    |t0, t1, class_name|
-
-    klass = class_name.constantize
-
-    t0 = 'infinity' if t0 == Float::INFINITY
-    t1 = 'infinity' if t1 == Float::INFINITY
-
-    info = Marty::DataExporter.class_info(klass)
-    changes = get_changed_data(t0, t1, klass)
-
-    changes.inject({}) { |h, (group_id, ol)|
-      h[group_id] = ol.each_with_index.map { |o, i|
-        profile = {
-          "obj" => o,
-        }
-
-        # Create a profile hash for each object in the group.
-        # "status" tells us if the object is old/new/mod.  If
-        # status=="mod" then "changes" will provide the list of
-        # columns which changed.  If the object was deleted during
-        # t0-t1 then we set the deleted flag in the profile.
-        profile["deleted"] = (group_id == o.id &&
-                              o.obsoleted_dt != Float::INFINITY &&
-                              (t1 == 'infinity' || o.obsoleted_dt < t1)
-                              )
-        if i == 0
-          profile["status"] = o.created_dt < t0 ? "old" : "new"
-          prev = nil
-        else
-          profile["status"], prev = "mod", prev = ol[i-1]
-        end
-
-        profile["attrs"] = info[:cols].map { |c|
-          {
-            # FIXME: using .first on export_attr -- this will not work
-            # if the attr is an association which will requires
-            # multiple keys to identify (e.g. Rule: name & version)
-            "value"     => Marty::DataExporter.export_attr(o, c, info).first,
-            "changed"   => prev && (o.send(c.to_sym) != prev.send(c.to_sym)),
-          }
-        }
-
-        profile
-      }
-      h
-    }
-  end
-
-  delorean_fn :change_summary, sig: 3 do
-    |t0, t1, class_name|
-
-    klass = class_name.constantize
-
-    t0 = 'infinity' if t0 == Float::INFINITY
-    t1 = 'infinity' if t1 == Float::INFINITY
-
-    info = Marty::DataExporter.class_info(klass)
-    changes = get_changed_data(t0, t1, klass)
-
-    created = updated = deleted = 0
-
-    changes.each { |group_id, ol|
-      ol.each_with_index.map { |o, i|
-        deleted +=1 if (group_id == o.id &&
-                        o.obsoleted_dt != Float::INFINITY &&
-                        (t1 == 'infinity' || o.obsoleted_dt < t1)
-                        )
-        if i == 0
-          created +=1 unless o.created_dt < t0
-        else
-          updated += 1
-        end
-      }
-    }
-
-    {'created' => created, 'updated' => updated, 'deleted' => deleted}
-  end
-
-  delorean_fn :class_list, sig: 0 do
-    Rails.configuration.marty.class_list.sort.uniq || []
-  end
-
-  delorean_fn :class_headers, sig: 1 do
-    |class_name|
-
-    klass = class_name.constantize
-    info = Marty::DataExporter.class_info(klass)
-    info[:cols].map { |c|
-      # strip _id if it's an assoc
-      c = c[0..-4] if info[:assoc][c]
-      I18n.t(c, scope: 'attributes')
-    }
-  end
-
-  delorean_fn :user_name, sig: 1 do
-    |user_id|
-
-    Marty::User.find_by_id(user_id).try(:name)
-  end
-
-  delorean_fn :sanitize_classes, sig: 1 do
-    |classes|
-    classes = classes.split(/,\s*/) if classes.is_a? String
-
-    classes.to_set & class_list.to_set
-  end
-
-  delorean_fn :do_export, sig: [2, 3] do
-    |pt, klass, sort_field=nil|
-
-    # allow classes on class_list or any Enum to be exported
-    raise "'#{klass}' not on class_list" unless
-      class_list.member?(klass) || klass.constantize.is_a?(Marty::Enum)
-
-    Marty::DataExporter.do_export(pt, klass.constantize, sort_field)
-  end
-
-  def self.get_changed_data(t0, t1, klass)
-    # The following test fails when t0/t1 are infinity.  ActiveSupport
-    # doesn't know about infinity.
-    # return unless t0 < t1
-
-    change_q = '(obsoleted_dt >= ? AND obsoleted_dt < ?)' +
-      ' OR (created_dt >= ? AND created_dt < ?)'
-
-    raise "Change count exceeds limit #{MAX_COUNT}" if
-      klass.where(change_q, t0, t1, t0, t1).count > MAX_COUNT
-
-    klass.where(change_q, t0, t1, t0, t1).
-      order("group_id, created_dt").group_by(&:group_id)
-  end
-end

data/app/models/marty/enum.rb~

@@ -1,16 +0,0 @@
-module Marty::Enum
-  def method_missing(meth, *args, &block)
-    if meth.to_s =~ /^[A-Z_]+$/ && args.empty?
-      items = self.all
-      items.each { |item|
-        name = item.name.upcase.gsub(/[\/\s-]/, '_')
-        self.define_singleton_method(name) do
-          item
-        end unless self.methods.member?(name.to_sym)
-      }
-
-      return self.send(meth) if self.methods.member?(meth)
-    end
-    super
-  end
-end

data/app/models/marty/import_type.rb~

@@ -1,48 +0,0 @@
-class Marty::ImportType < Marty::Base
-  class ImportTypeValidator < ActiveModel::Validator
-    def validate(entry)
-      klass = entry.get_model_class
-
-      unless klass.is_a?(Class) && klass < ActiveRecord::Base
-        entry.errors[:base] = "bad model name"
-        return
-      end
-
-      [entry.cleaner_function, entry.validation_function].each { |func|
-        entry.errors[:base] = "unknown class method #{func}" if
-        func && !klass.respond_to?(func.to_sym)
-      }
-    end
-  end
-
-<<<<<<< HEAD
-  # attr_accessible :name,
-  # :model_name,
-  # :cleaner_function,
-  # :validation_function
-=======
-  belongs_to :role
->>>>>>> master
-
-  validates_presence_of :name, :model_name, :role_id
-  validates_uniqueness_of :name
-  validates_with ImportTypeValidator
-
-  def get_model_class
-    model_name.constantize
-  end
-
-  def allow_import?()
-    Mcfly.whodunnit.roles.pluck(:id).
-      include?(role_id) if Mcfly.whodunnit
-  end
-
-  delorean_fn :lookup, sig: 1 do
-    |name|
-    self.find_by_name(name)
-  end
-
-  delorean_fn :get_all, sig: 0 do
-    self.all
-  end
-end