marty 0.5.15 → 0.5.16

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

@@ -1,10 +0,0 @@
-class Marty::Role < Marty::Base
-  extend Marty::Enum
-
-<<<<<<< HEAD
-  # attr_accessible :name
-=======
->>>>>>> master
-  validates_uniqueness_of :name
-  # FIXME: should have before_destroy
-end

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

@@ -1,62 +0,0 @@
-require 'mcfly'
-
-class Marty::Script < Marty::Base
-  has_mcfly
-
-<<<<<<< HEAD
-  # attr_accessible :name, :body
-=======
->>>>>>> master
-  validates_presence_of :name, :body
-  mcfly_validates_uniqueness_of :name
-  validates_format_of :name, {
-    with: /\A[A-Z][a-zA-Z0-9]*\z/,
-    message: I18n.t('script.save_error'),
-  }
-
-  belongs_to :user, class_name: "Marty::User"
-
-  gen_mcfly_lookup :lookup, {
-    name: false,
-  }
-
-  gen_mcfly_lookup :get_all, {}, mode: :all
-
-  # find script by name/tag
-  def self.find_script(sname, tag=nil)
-    tag = Marty::Tag.map_to_tag(tag)
-    Marty::Script.lookup(tag.created_dt, sname)
-  end
-
-  def find_tag
-    # find the first tag created after this script.
-    Marty::Tag.where("created_dt >= ?", created_dt).order(:created_dt).first
-  end
-
-  def self.create_script(name, body)
-    script      = new
-    script.name = name
-    script.body = body
-    script.save
-    script
-  end
-
-  delorean_fn :eval_to_hash, sig: 5 do
-    |dt, script, node, attrs, params|
-    tag = Marty::Tag.find_match(dt)
-
-    # IMPORTANT: engine evals (e.g. eval_to_hash) modify the
-    # params. So, need to clone it.
-    params = params.clone
-
-    raise "no tag found for #{dt}" unless tag
-
-    engine = Marty::ScriptSet.new(tag).get_engine(script)
-    res = engine.eval_to_hash(node, attrs, params)
-
-    # FIXME: should sanitize res to make sure that no nodes are being
-    # passed back.  It's likely that nodes which are not from the
-    # current tag can caused problems.
-    res
-  end
-end

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

@@ -1,91 +0,0 @@
-class Marty::Tag < Marty::Base
-  has_mcfly append_only: true
-
-<<<<<<< HEAD
-  # attr_accessible :created_dt, :name, :comment
-=======
->>>>>>> master
-  mcfly_validates_uniqueness_of :name
-  validates_presence_of :name, :comment
-
-  belongs_to :user, class_name: "Marty::User"
-
-  def self.make_name(dt)
-    return 'DEV' if Mcfly.is_infinity(dt)
-
-    # If no dt is provided (which is the usual non-testing case), we
-    # use Time.now.strftime to name the posting.  This has the effect
-    # of using the host's timezone. i.e. since we're in PST8PDT, names
-    # will be based off of the Pacific TZ.
-    dt ||= Time.now
-    dt.strftime('%Y%m%d-%H%M')
-  end
-
-  before_validation :set_tag_name
-  def set_tag_name
-    self.name = self.class.make_name(self.created_dt)
-    true
-  end
-
-  def self.do_create(dt, comment)
-    o            = new
-    o.comment    = comment
-    o.created_dt = dt
-    o.save!
-    o
-  end
-
-  def isdev?
-    Mcfly.is_infinity(created_dt)
-  end
-
-  def self.map_to_tag(tag_id)
-    case tag_id
-    when String
-      tag = find_by_name(tag_id)
-      # if tag name wasn't found, look for a matching
-      # posting, then find the tag whose created_dt <= posting dt.
-      if !tag
-        posting = Marty::Posting.lookup(tag_id)
-        tag = find_match(Mcfly.normalize_infinity(posting.created_dt)) if
-          posting
-      end
-    when Fixnum
-      tag = find_by_id(tag_id)
-    when nil
-      tag = get_latest1
-    else
-      tag = tag_id
-    end
-
-    raise "bad tag identifier #{tag_id}" unless tag.is_a? Marty::Tag
-    tag
-  end
-
-  cached_delorean_fn :lookup, sig: 1 do
-    |name|
-    self.find_by_name(name)
-  end
-
-  # Performance hack to cache Rule AR object
-  cached_delorean_fn :lookup_id, sig: 1 do
-    |id|
-    find_by_id(id)
-  end
-
-  delorean_fn :lookup_dt, sig: 1 do
-    |name|
-    lookup(name).try(:created_dt)
-  end
-
-  delorean_fn :get_latest1, sig: 0 do
-    where("created_dt <> 'infinity'").order("created_dt DESC").first
-  end
-
-  delorean_fn :find_match, sig: 1 do
-    |dt|
-    id = where("created_dt <= ?", dt).order("created_dt DESC").pluck(:id).first
-    # performance hack
-    id && lookup_id(id)
-  end
-end

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

@@ -1,148 +0,0 @@
-require 'mcfly'
-require 'net/ldap'
-
-class Marty::User < Marty::Base
-  has_paper_trail
-
-  validates_presence_of :login, :firstname, :lastname
-  validates_uniqueness_of :login
-
-  validates_format_of :login, :with => /\A[a-z0-9_\-@\.]*\z/i
-  validates_length_of :login, :firstname, :lastname, maximum: 100
-
-  has_many :user_roles, dependent: :destroy
-  has_many :roles, through: :user_roles
-
-  scope :active, -> { where("#{self.table_name}.active = ?", true) }
-
-  validate :verify_changes
-  before_destroy :destroy_user
-
-  def name
-    "#{firstname} #{lastname}"
-  end
-
-  def to_s
-    name
-  end
-
-  # Returns the user who matches the given autologin +key+ or nil
-  def self.try_to_autologin(key)
-    tokens = Marty::Token.find_all_by_action_and_value('autologin', key.to_s)
-    # Make sure there's only 1 token that matches the key
-    if tokens.size == 1
-      token = tokens.first
-      autologin = Rails.configuration.marty.autologin || 0
-
-      if (token.created_on > autologin.to_i.day.ago) &&
-          token.user && token.user.active?
-        token.user
-      end
-    end
-  end
-
-  # Returns the user that matches provided login and password, or nil
-  def self.try_to_login(login, password)
-    login = login.to_s
-    password = password.to_s
-
-    # Make sure no one can sign in with an empty password
-    return nil if password.empty?
-
-    user = find_by_login(login)
-
-    return nil if !user || !user.active?
-
-    authenticate_with?(login, password) || nil
-  end
-
-  def self.authenticate_with?(login, password)
-    cf = Rails.configuration.marty
-
-    auth_source = cf.auth_source.to_s
-
-    if auth_source == "local"
-      ok = password == cf.local_password
-    elsif auth_source == "ldap"
-      # IMPORTANT NOTE: if server allows anonymous LDAP access, empty
-      # passwords will succeed!  i.e. if a valid user with empty
-      # password is sent in, ldap.bind will return OK.
-      cf = Rails.configuration.marty.ldap
-      ldap = Net::LDAP.new(host: cf.host,
-                           port: cf.port,
-                           base: cf.base_dn,
-                           auth: {
-                             method: :simple,
-                             username: cf.domain + "\\" + login,
-                             password: password,
-                           })
-      ok = ldap.bind
-    else
-      raise "bad auth_source: #{auth_source.inspect}"
-    end
-
-    find_by_login(login) if ok
-  end
-
-  def self.current=(user)
-    Mcfly.whodunnit = user
-  end
-
-  def self.current
-    Mcfly.whodunnit
-  end
-
- def self.has_role(role)
-    mr = Mcfly.whodunnit.roles rescue []
-    mr.any? {|attr| attr.name == role}
- end
-
-private
-  def verify_changes
-    # If current users role is only user_manager, restrict following
-    # 1 - Do not allow user to edit own record
-    # 2 - Do not allow user to edit the Gemini system record
-    if user_manager_only
-      gemini_user = Marty::User.find_by_login(
-        Rails.configuration.marty.system_account.to_s)
-      gemini_id = gemini_user.id if gemini_user
-
-      if self.id == Mcfly.whodunnit.id
-        roles.each {|r| roles.delete r unless r.name == "user_manager"}
-        errors.add :base, "User Managers cannot edit "\
-          "or add additional roles to their own accounts"
-      elsif self.id == gemini_id
-        errors.add :base,
-        "User Managers cannot edit the Gemini system account"
-      end
-    end
-
-    errors.add :base, "The Gemini system account cannot be deactivated" if
-      self.login == Rails.configuration.marty.system_account.to_s &&
-      !self.active
-
-    errors.blank?
-  end
-
-  delorean_fn :get_roles, sig: 0 do
-     Mcfly.whodunnit.roles
-  end
-
-  def user_manager_only
-    Marty::User.has_role("user_manager") && !Marty::User.has_role("admin")
-  end
-
-  def destroy_user
-    errors.add :base, "You cannot delete your own account" if
-      self.login == Mcfly.whodunnit.login
-
-    errors.add :base, "You cannot delete the system account" if
-      self.login == Rails.configuration.marty.system_account.to_s
-    # Default to disallowing any deletions for now
-
-    errors.add :base,
-    "Users cannot be deleted - set 'Active' to false to disable the account"
-
-    errors.blank?
-  end
-end

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

@@ -1,13 +0,0 @@
-class Marty::UserRole < Marty::Base
-  has_paper_trail
-
-<<<<<<< HEAD
-  # attr_accessible :user_id, :role_id
-=======
->>>>>>> master
-  validates_uniqueness_of :user_id, scope: [:role_id]
-  validates_presence_of :user_id, :role_id
-
-  belongs_to :user
-  belongs_to :role
-end

data/app/views/layouts/marty/application.html.erb~

@@ -1,11 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <title><%= Rails.application.class.parent %></title>
-  <%= load_netzke theme: "classic" %>
-  <%= csrf_meta_tag %>
-</head>
-<body>
-<%= yield %>
-</body>
-</html>

data/config/routes.rb~

@@ -1,10 +0,0 @@
-require 'netzke-core'
-
-Marty::Engine.routes.draw do
-<<<<<<< HEAD
-  match via: [:get, :post], "rpc/:action(.:format)" => "rpc"
-=======
-  match "rpc/:action(.:format)" => "rpc"
-  get "job/:action" => "job"
->>>>>>> master
-end

data/db/migrate/019_create_marty_postings.rb~

@@ -1,19 +0,0 @@
-require 'marty/migrations'
-
-class CreateMartyPostings < McflyAppendOnlyMigration
-  include Marty::Migrations
-
-  def change
-    create_table :marty_postings do |t|
-      t.string :name, null: false
-      t.references :posting_type, null: false
-      t.boolean :is_test, null: false
-      t.string :comment, null: false
-    end
-
-    add_mcfly_index :marty_postings,
-    :name, :posting_type_id, :is_test
-
-    add_fk :postings, :posting_types
-  end
-end

data/db/migrate/095_create_marty_tags.rb~

@@ -1,19 +0,0 @@
-require 'marty/migrations'
-
-class CreateMartyPostings < McflyAppendOnlyMigration
-  include Marty::Migrations
-
-  def change
-    create_table :marty_postings do |t|
-      t.string :name, null: false
-      t.references :posting_type, null: false
-      t.boolean :is_test, null: false
-      t.string :comment, null: false
-    end
-
-    add_mcfly_index :marty_postings,
-    :name, :posting_type_id, :is_test
-
-    add_fk :postings, :posting_types
-  end
-end

data/lib/marty.rb~

@@ -1,13 +0,0 @@
-require 'marty/engine'
-require 'marty/monkey'
-require 'marty/mcfly_query'
-require 'marty/util'
-require 'marty/migrations'
-require 'marty/data_exporter'
-require 'marty/xl.rb'
-require 'marty/data_importer'
-require 'marty/promise_job'
-require 'marty/promise_proxy'
-require 'marty/content_handler'
-require 'marty/lazy_column_loader'
-require 'marty/version'

data/lib/marty/content_handler.rb~

@@ -1,93 +0,0 @@
-module Marty::ContentHandler
-  GEN_FORMATS = {
-    "csv" 	=> ['text/csv',			'download'],
-    "zip" 	=> ['application/zip',		'download'],
-    "xlsx" 	=> ['application/vnd.ms-excel',	'download'],
-    "html" 	=> ['text/html',		'inline'],
-    "txt"	=> ['text/plain',		'inline'],
-    "json"	=> ['application/json',		'download'],
-
-    # hacky: default format is JSON
-    nil		=> ['application/json',		'download'],
-  }
-
-  def self.log_and_raise(err)
-    Marty::Util.logger.error err
-    raise err
-  end
-
-  def self.export(data, format, name)
-    begin
-      case format
-      when "csv"
-        res = Marty::DataExporter.to_csv(data)
-      when "xlsx"
-        res = Marty::Xl.spreadsheet(data).to_stream.read
-      when "zip"
-        res = to_zip(data)
-      when nil, "json"
-        res, format = data.to_json, "json"
-      else
-        res, format = {error: "Unknown format: #{format}"}.to_json, "json"
-      end
-    rescue => exc
-      res, format =
-        {error: "Failed conversion #{format}: #{exc}"}.to_json, "json"
-    end
-
-    type, disposition = GEN_FORMATS[format]
-
-    return [res, type, disposition, "#{name}.#{format}"]
-  end
-
-  private
-
-  def self.sanitize_filename(filename)
-    filename.strip.
-      gsub(/[\\\/]/, '_').
-      gsub(/[^[:print:]]/, '_')
-  end
-
-  def self.uniq_filename(filename, fset)
-    (0..1000).each { |i|
-      post = i==0 ? "" : " (#{i})"
-      fn = filename + post
-      return fn unless fset.member? fn
-    }
-    filename
-  end
-
-  def self.to_zip_stream(stream, path, data)
-    fset = Set.new
-
-    data.each { |r|
-      title, format, result = r["title"], r["format"], r["result"]
-
-      log_and_raise "Result has no title" unless title
-      log_and_raise "Result has no result" unless result
-
-      if format == "zip"
-        to_zip_stream(stream, path + [title], result)
-        next
-      end
-
-      res_data, _type, _disposition, res_name = export(result, format, title)
-
-      filename = uniq_filename(sanitize_filename(res_name), fset)
-      fset.add filename
-
-      stream.put_next_entry((path + [filename]).join('/'))
-      stream.write res_data
-    }
-  end
-
-  def self.to_zip(data)
-    raise "Can't convert non-array data to zip format: #{data.class}" unless
-      data.is_a?(Array)
-
-    res = Zip::OutputStream.write_buffer do |stream|
-      to_zip_stream(stream, [], data)
-    end
-    res.string
-  end
-end