marty 0.5.12

data/lib/marty/monkey.rb~

@@ -0,0 +1,160 @@
+# 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

data/lib/marty/permissions.rb

@@ -0,0 +1,64 @@
+module Marty
+  module Permissions
+    # Make sure there are admin and user_manager roles,
+    # even if hosting app doesn't define them
+    REQ_ROLES = [:admin, :user_manager]
+    ALL_ROLES = Rails.configuration.marty.roles.to_set.merge(REQ_ROLES)
+
+    # Call using following format
+    #   has_marty_permissions   create: [:dev, :admin],
+    #                           read: :any,
+    #                           update: :admin,
+    #                           delete: []
+    #
+    # :any gives permission to the action if user belongs to at least 1 role
+    def has_marty_permissions(attrs)
+      raise "bad attrs" unless attrs.is_a?(Hash)
+      raise "unknown role" unless
+        attrs.values.flatten.to_set.subset? (ALL_ROLES << :any)
+
+      self.define_singleton_method(:marty_permissions) { attrs }
+    end
+
+    def current_user_roles
+      roles = Mcfly.whodunnit.roles rescue []
+      roles.map {|r| r.name.to_sym}.to_set
+    end
+
+    def can_perform_action?(action)
+      return false unless self.respond_to?(:marty_permissions)
+
+      roles = self.current_user_roles
+      roles = roles << :any if self.has_any_perm?
+
+      aroles = self.marty_permissions[action.to_sym] || []
+      # TODO: Use code below when switching to Ruby 2.1
+      # Set[ *aroles].intersect? roles.to_set
+      (Set[ *aroles] & roles.to_set).length > 0
+    end
+
+    def can_perform_actions
+      return [] unless self.respond_to?(:marty_permissions)
+
+      roles = self.current_user_roles
+      roles = roles << :any if self.has_any_perm?
+
+      self.marty_permissions.map { |action, aroles|
+        # TODO: Use code below when switching to Ruby 2.1
+        #action if Set[ *aroles].intersect? roles.to_set
+        action if (Set[ *aroles] & roles.to_set).length > 0
+      }.compact
+    end
+
+    # generate has_xxx_perm? methods for all permissions.
+    Rails.configuration.marty.roles.each { |role|
+      define_method("has_#{role}_perm?") do
+        current_user_roles.member? role
+      end
+    }
+
+    def has_any_perm?
+      !(current_user_roles & ALL_ROLES).empty?
+    end
+  end
+end

data/lib/marty/permissions.rb~

@@ -0,0 +1,69 @@
+module Marty
+  module Permissions
+    # Make sure there are admin and user_manager roles,
+    # even if hosting app doesn't define them
+    REQ_ROLES = [:admin, :user_manager]
+    ALL_ROLES = (Set.new Rails.configuration.marty.roles.clone).merge(REQ_ROLES)
+    ACTIONS = Set.new [:create, :read, :update, :delete] # CRUD
+
+    # Call using following format
+    #   has_marty_permissions	create: [:dev, :admin],
+    #				read: :any,
+    #				update: :admin,
+    #				delete: :none
+    #
+    # Allowed actions are only :create, :read, :update, :delete
+    # Roles can be passed in as a symbol or array of symbols
+    #
+    # :any gives permission to the action if user belongs to at least 1 role
+    # :none overrides any other roles
+    #    e.g. delete: [:none, :admin] would return false when calling
+    #    can_allow_action? even if the user belong to the admin role
+    def has_marty_permissions(attrs)
+      raise "bad attrs" unless attrs.is_a?(Hash)
+      raise "unknown action - only create/read/update/delete allowed" unless
+        attrs.keys.to_set.subset? ACTIONS
+      raise "unknown role" unless
+        attrs.values.flatten.to_set.subset? (ALL_ROLES << :any << :none)
+
+      #klass = self.to_s
+      #return "#{klass} with #{attrs.inspect}"
+      self.define_singleton_method(:marty_permissions) { attrs }
+    end
+
+    def current_user_roles
+      roles = Mcfly.whodunnit.roles rescue []
+      Set.new(roles.map {|r| r.name.to_sym})
+    end
+
+    def can_perform_action?(action)
+      roles = self.current_user_roles
+      roles << :any if self.has_any_perm?
+
+      allow = false
+
+      if self.respond_to?(:marty_permissions)
+        perms = self.marty_permissions
+        result = []
+        result = (result << perms.fetch(action.to_sym)).flatten if
+          perms.include?(action.to_sym)
+
+        result.each {|r| allow ||= roles.include? r} unless
+          result.include?(:none)
+        #puts "#{self.to_s} #{action} - #{allow}"
+      end
+      allow
+    end
+
+    # generate has_xxx_perm? methods for all permissions.
+    Rails.configuration.marty.roles.each { |role|
+      define_method("has_#{role}_perm?") do
+        current_user_roles.member? role
+      end
+    }
+
+    def has_any_perm?
+      !(current_user_roles & ALL_ROLES).empty?
+    end
+  end
+end

data/lib/marty/promise.rb~

@@ -0,0 +1,41 @@
+class Marty::Promise < Struct.new(:arg1)
+  def log(msg)
+    open('/tmp/dj.out', 'a') { |f|
+      f.puts msg
+    }
+  end
+
+  def perform
+    log "hello there #{Process.pid} #{arg1}"
+    
+    raise "oops #{Process.pid}" if arg1 == 5
+
+    sleep 0.2
+  end
+
+  def error(job, exc)
+    log "Error #{Process.pid} #{job} #{exc}"
+  end
+
+  def failure(job)
+    log "failure #{Process.pid}, #{job}"
+  end
+
+  def before(job)
+    log "before #{Process.pid}, #{job}"
+  end
+
+  def after(job)
+    log "after #{Process.pid}, #{job}"
+  end
+
+  def success(job)
+    log "success #{Process.pid}, #{job}"
+  end
+
+  def max_attempts
+    return 1
+  end
+end
+
+

data/lib/marty/promise_job.rb

@@ -0,0 +1,123 @@
+require 'delorean_lang'
+
+class Delorean::BaseModule::NodeCall
+  def initialize(_e, engine, node, params)
+    super
+
+    # If call has a promise_id (i.e. is from a promise) then that's
+    # our parent.  Otherwise, we use its parent as our parent.
+    params[:_parent_id] = _e[:_promise_id] || _e[:_parent_id]
+    params[:_user_id]   = _e[:_user_id]    || Mcfly.whodunnit.try(:id)
+  end
+
+  # Monkey-patch '|' method for Delorean NodeCall to create promise
+  # jobs and return promise proxy objects.
+  def |(args)
+    if args.is_a?(String)
+      attr = args
+      args = [attr]
+    else
+      raise "bad arg to %" unless args.is_a?(Array)
+      attr = nil
+    end
+
+    script, tag = engine.module_name, engine.sset.tag
+    nn = node.is_a?(Class) ? node.name : node.to_s
+
+    begin
+      # make sure params is serialzable before starting a Job
+      Marshal.dump(params)
+    rescue => exc
+      raise "non-serializable parameters"
+    end
+
+    title   = params["p_title"]   || "#{script}::#{nn.demodulize}"
+    timeout = params["p_timeout"] || Marty::Promise::DEFAULT_PROMISE_TIMEOUT
+    hook    = params["p_hook"]
+    promise = Marty::Promise.
+      create(title:     title,
+             user_id:   params[:_user_id],
+             parent_id: params[:_parent_id],
+             )
+    params[:_promise_id] = promise.id
+
+    begin
+      job = Delayed::Job.enqueue Marty::PromiseJob.
+        new(promise, title, script, tag, nn, params, args, hook)
+    rescue => exc
+      # log "CALLERR #{exc}"
+      res = Delorean::Engine.grok_runtime_exception(exc)
+      promise.set_start
+      promise.set_result(res)
+      # log "CALLERRSET #{res}"
+      raise
+    end
+
+    # keep a reference to the job.  This is needed in case we want to
+    # work off a promise job that we're waiting for and which hasn't
+    # been reserved yet.
+    promise.job_id = job.id
+    promise.save!
+
+    Marty::PromiseProxy.new(promise.id, timeout, attr)
+  end
+end
+
+class Delorean::Engine
+  def background_eval(node, params, attrs)
+    raise "background_eval bad params" unless params.is_a?(Hash)
+
+    nc = Delorean::BaseModule::NodeCall.new({}, self, node, params)
+    # start the background promise
+    nc | attrs
+  end
+end
+
+class Marty::PromiseJob < Struct.new(:promise,
+                                     :title,
+                                     :sname,
+                                     :tag,
+                                     :node,
+                                     :params,
+                                     :attrs,
+                                     :hook,
+                                     )
+  # def log(msg)
+  #   open('/tmp/dj.out', 'a') { |f| f.puts msg }
+  # end
+
+  def perform
+    # log "PERF #{Process.pid} #{title}"
+
+    promise.set_start
+
+    begin
+      # in case the job writes to the the database
+      Mcfly.whodunnit = promise.user
+
+      engine = Marty::ScriptSet.new(tag).get_engine(sname)
+
+      engine.evaluate_attrs(node, attrs, params)
+
+      res = attrs.each_with_object({}) { |attr, h|
+        h[attr] = engine.evaluate(node, attr, params)
+      }
+
+      # log "DONE #{Process.pid} #{promise.id} #{Time.now.to_f} #{res}"
+    rescue => exc
+      res = Delorean::Engine.grok_runtime_exception(exc)
+      # log "ERR- #{Process.pid} #{promise.id} #{Time.now.to_f} #{exc}"
+    end
+    promise.set_result(res)
+
+    begin
+      hook.run(res) if hook
+    rescue => exc
+      Marty::Util.logger.error "promise hook failed: #{exc}"
+    end
+  end
+
+  def max_attempts
+    1
+  end
+end