marty 2.5.2 → 2.5.4

data/lib/marty/permissions.rb

@@ -12,49 +12,49 @@ module Marty::Permissions
   #
   # :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
+    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 }
+    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
+    roles.map { |r| r.name.to_sym }.to_set
   end
 
   def can_perform_action?(action)
-    return false unless self.respond_to?(:marty_permissions)
+    return false unless respond_to?(:marty_permissions)
 
-    roles = self.current_user_roles
-    roles = roles << :any if self.has_any_perm?
+    roles = current_user_roles
+    roles = roles << :any if has_any_perm?
 
-    aroles = self.marty_permissions[action.to_sym] || []
+    aroles = 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
+    !(Set[*aroles] & roles.to_set).empty?
   end
 
   def can_perform_actions
-    return [] unless self.respond_to?(:marty_permissions)
+    return [] unless respond_to?(:marty_permissions)
 
-    roles = self.current_user_roles
-    roles = roles << :any if self.has_any_perm?
+    roles = current_user_roles
+    roles = roles << :any if has_any_perm?
 
-    self.marty_permissions.map { |action, aroles|
+    marty_permissions.map do |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
+      # action if Set[ *aroles].intersect? roles.to_set
+      action unless (Set[*aroles] & roles.to_set).empty?
+    end.compact
   end
 
   # generate has_xxx_perm? methods for all permissions.
-  Rails.configuration.marty.roles.each { |role|
+  Rails.configuration.marty.roles.each do |role|
     define_method("has_#{role}_perm?") do
       current_user_roles.member? role
     end
-  }
+  end
 
   def has_any_perm?
     !(current_user_roles & ALL_ROLES).empty?

data/lib/marty/promise_job.rb

@@ -17,12 +17,12 @@ class Delorean::BaseModule::NodeCall
   # 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)
+      raise 'bad arg to %' unless args.is_a?(Array)
+
       attr = nil
     end
     script, tag = engine.module_name, engine.sset.tag
@@ -30,25 +30,25 @@ class Delorean::BaseModule::NodeCall
     begin
       # make sure params is serialzable before starting a Job
       JSON.dump(params)
-    rescue => exc
+    rescue StandardError => exc
       raise "non-serializable parameters: #{params} #{exc}"
     end
 
     # log "||||| #{args.inspect} #{params.inspect}"
 
-    title   = params["p_title"]   || "#{script}::#{nn.demodulize}"
-    timeout = params["p_timeout"] || Marty::Promise::DEFAULT_PROMISE_TIMEOUT
-    hook    = params["p_hook"]
+    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
+    rescue StandardError => exc
       # log "CALLERR #{exc}"
       res = Delorean::Engine.grok_runtime_exception(exc)
       promise.set_start
@@ -63,10 +63,10 @@ class Delorean::BaseModule::NodeCall
     promise.job_id = job.id
     promise.save!
 
-    evh = params["p_event"]
+    evh = params['p_event']
     if evh
-      event, klass, subject_id, operation = evh.values_at("event", "klass",
-                                                          "id", "operation")
+      event, klass, subject_id, operation = evh.values_at('event', 'klass',
+                                                          'id', 'operation')
       if event
         event.promise_id = promise.id
         event.save!
@@ -82,11 +82,11 @@ class Delorean::BaseModule::NodeCall
   end
 end
 
-
 class Delorean::Engine
   def background_eval(node, params, attrs, event = {})
-    raise "background_eval bad params" unless params.is_a?(Hash)
-    params["p_event"] = event.each_with_object({}) do |(k, v), h|
+    raise 'background_eval bad params' unless params.is_a?(Hash)
+
+    params['p_event'] = event.each_with_object({}) do |(k, v), h|
       h[k.to_s] = v
     end unless event.empty?
     nc = Delorean::BaseModule::NodeCall.new({}, self, node, params)
@@ -103,7 +103,7 @@ class Marty::PromiseJob < Struct.new(:promise,
                                      :params,
                                      :attrs,
                                      :hook,
-                                     )
+                                    )
   # def log(msg)
   #   open('/tmp/dj.out', 'a') { |f| f.puts msg }
   # end
@@ -136,7 +136,7 @@ class Marty::PromiseJob < Struct.new(:promise,
       end
 
       # log "DONE #{Process.pid} #{promise.id} #{Time.now.to_f} #{res}"
-    rescue => exc
+    rescue StandardError => exc
       res = Delorean::Engine.grok_runtime_exception(exc)
       # log "ERR- #{Process.pid} #{promise.id} #{Time.now.to_f} #{exc}"
     end
@@ -144,7 +144,7 @@ class Marty::PromiseJob < Struct.new(:promise,
 
     begin
       hook.run(res) if hook
-    rescue => exc
+    rescue StandardError => exc
       Marty::Util.logger.error "promise hook failed: #{exc}"
     end
   end

data/lib/marty/promise_proxy.rb

@@ -14,9 +14,9 @@ class Marty::PromiseProxy < BasicObject
                    :as_json,
                   ]
 
-  instance_methods.each {|m| undef_method m unless m =~ /^(__.*|object_id)$/}
+  instance_methods.each { |m| undef_method m unless m =~ /^(__.*|object_id)$/ }
 
-  def initialize(promise_id, timeout, attr=nil)
+  def initialize(promise_id, timeout, attr = nil)
     promise_id, @timeout, @attr = promise_id, timeout, attr
     @promise = ::Marty::Promise.find(promise_id)
     @mutex   = ::Mutex.new
@@ -24,7 +24,7 @@ class Marty::PromiseProxy < BasicObject
   end
 
   def as_json(*)
-    {'__promise__' => [@promise.id, @timeout, @attr]}
+    { '__promise__' => [@promise.id, @timeout, @attr] }
   end
 
   def __promise__
@@ -54,7 +54,7 @@ class Marty::PromiseProxy < BasicObject
         if @result.equal?(NOT_SET)
           begin
             @result = @promise.wait_for_result(@timeout)
-            @result = @result[@attr] if @attr && !@result["error"]
+            @result = @result[@attr] if @attr && !@result['error']
           rescue ::Exception => exc
             @result = ::Delorean::Engine.grok_runtime_exception(exc)
           end
@@ -65,7 +65,7 @@ class Marty::PromiseProxy < BasicObject
     # FIXME: the logic for shape of exceptions from Delorean is spread
     # all over the place.
     @result.is_a?(::Hash) &&
-      @result["error"] ? ::Kernel.raise(@result["error"]) : @result
+      @result['error'] ? ::Kernel.raise(@result['error']) : @result
   end
 
   alias_method :force, :__force__
@@ -75,7 +75,7 @@ class Marty::PromiseProxy < BasicObject
   #
   # @param  [Symbol]
   # @return [Boolean]
-  def respond_to?(method, include_all=false)
+  def respond_to?(method, include_all = false)
     METH_SET.member?(method) || __force__.respond_to?(method, include_all)
   end
 

data/lib/marty/relation.rb

@@ -2,13 +2,13 @@ class Marty::Relation
   # Given a Mcfly class (klass) and a list of classes which can
   # reference klass, returns instaces of klass which have no references.
   def self.not_referenced(klass, ref_classes)
-    col = (klass.name.split('::').last.snakecase + "_id").to_sym
+    col = (klass.name.split('::').last.snakecase + '_id').to_sym
 
     ids = klass.where(obsoleted_dt: 'infinity').pluck(:group_id)
 
-    ref_ids = ref_classes.map { |rclass|
+    ref_ids = ref_classes.map do |rclass|
       rclass.where(obsoleted_dt: 'infinity', col => ids).pluck(col)
-    }.flatten.uniq
+    end.flatten.uniq
 
     klass.where(id: ids - ref_ids).to_a
   end
@@ -18,17 +18,16 @@ class Marty::Relation
   # mcfly_belongs_to reference from klass.
   def self.obsoleted_references(klass)
     assoc_h = Marty::DataConversion.associations(klass)
-    assoc_h.each_with_object({}) do
-      |(a, ah), h|
+    assoc_h.each_with_object({}) do |(a, ah), h|
       assoc_class = ah[:assoc_class]
       foreign_key = ah[:foreign_key]
 
       next unless Mcfly.has_mcfly? assoc_class
 
-      h[a] = klass.where(obsoleted_dt: 'infinity').map do
-        |obj|
+      h[a] = klass.where(obsoleted_dt: 'infinity').map do |obj|
         ref_key = obj.send(foreign_key)
         next unless ref_key
+
         ref = assoc_class.find(ref_key)
         obj unless Mcfly.is_infinity(ref.obsoleted_dt)
       end.compact

data/lib/marty/rpc_call.rb

@@ -1,30 +1,31 @@
 class Marty::RpcCall
   # POST to a remote marty
-  def self.marty_post(host, port, path, script, node, attrs, params, options={},
-                      ssl=false)
+  def self.marty_post(host, port, path, script, node, attrs, params, options = {},
+                      ssl = false)
     http = Net::HTTP.new(host, port)
     http.use_ssl = ssl
     request = Net::HTTP::Post.new(path)
     request.add_field('Content-Type', 'application/json')
     request.body = (options + {
-                      "script" => script,
-                      "node"   => node,
-                      "attrs"  => attrs.to_json,
-                      "params" => params.to_json,
+                      'script' => script,
+                      'node'   => node,
+                      'attrs'  => attrs.to_json,
+                      'params' => params.to_json,
                     }).to_json
     begin
       response = http.request(request)
-    rescue => e
+    rescue StandardError => e
       raise "#{e.message} during RPC call to #{host}:#{port}"
     end
 
     res = JSON.parse(response.body)
-    raise res["error"] if res.is_a?(Hash) && !res["error"].blank?
+    raise res['error'] if res.is_a?(Hash) && !res['error'].blank?
+
     res
   end
 
-  def self.marty_download(host, port, path, job_id, ssl=false)
-    params = {job_id: job_id}
+  def self.marty_download(host, port, path, job_id, ssl = false)
+    params = { job_id: job_id }
     url = path + '?' + URI.encode(URI.encode_www_form(params))
 
     http = Net::HTTP.new(host, port)
@@ -33,7 +34,7 @@ class Marty::RpcCall
 
     begin
       http.request(request)
-    rescue => e
+    rescue StandardError => e
       raise "#{e.message} during download call to #{host}:#{port}"
     end
   end
@@ -49,7 +50,7 @@ class Marty::RpcCall
     begin
       response = http.request(request)
       raise "got #{response} during XML call" if response.class != Net::HTTPOK
-    rescue => e
+    rescue StandardError => e
       raise "#{e.message} during RPC call to #{host}:#{port}#{path}"
     end
 

data/lib/marty/rule_script_set.rb

@@ -8,13 +8,15 @@ class Marty::RuleScriptSet < Delorean::AbstractContainer
   clear_cache
 
   def self.node_name
-    "Node"
+    'Node'
   end
+
   def self.body_start
     "#{node_name}:\n"
   end
+
   def self.body_lines
-    self.body_start.count("\n")
+    body_start.count("\n")
   end
 
   def initialize(pt)
@@ -31,27 +33,28 @@ class Marty::RuleScriptSet < Delorean::AbstractContainer
   end
 
   def write_attr(k, v)
-    equals, rhs = v == :parameter ? [" =?", ""] :
-                    [" =", "\n" + v.lines.map{|l| " "*8 + l}.join("\n")]
+    equals, rhs = v == :parameter ? [' =?', ''] :
+                    [' =', "\n" + v.lines.map { |l| ' ' * 8 + l }.join("\n")]
     k + equals + rhs
   end
 
   def paramify_h(h)
-    "{" + h.keys.reject{|k|k.ends_with?("__")}.
-                         map {|k| %Q("#{k}": #{k}) }.join(",\n") + "}"
+    '{' + h.keys.reject { |k| k.ends_with?('__') }.
+                         map { |k| %Q("#{k}": #{k}) }.join(",\n") + '}'
   end
 
   def self.grid_final_name(dgid)
-    dgid.ends_with?("_grid") ?  dgid + "_result" : dgid + "_grid_result"
+    dgid.ends_with?('_grid') ? dgid + '_result' : dgid + '_grid_result'
   end
+
   def expand_grid_code(h, dgid, dgname, cache, extra_params)
     final_name = self.class.grid_final_name(dgid)
     if cache[dgname]
-      h[final_name] = "#{cache[dgname]}"
+      h[final_name] = (cache[dgname]).to_s
     else
       h[dgid] = dgname
       h["#{dgid}_dgp__"] = "dgparams__ + \n" + self.class.indent(paramify_h(h))
-      lgde = "lookup_grid_h"
+      lgde = 'lookup_grid_h'
       h[final_name] = "Marty::DataGrid.#{lgde}(pt,#{dgid},#{dgid}_dgp__,true)"
       cache[dgname] = final_name
     end
@@ -59,8 +62,9 @@ class Marty::RuleScriptSet < Delorean::AbstractContainer
 
   def write_code(attrs)
     return '' if attrs.blank?
+
     newh = attrs.each_with_object({}) do |(k, v), h|
-      if k.ends_with?("_grid")
+      if k.ends_with?('_grid')
         expand_grid_code(h, k, v, {}, h)
       else
         h[k] = v
@@ -72,31 +76,32 @@ class Marty::RuleScriptSet < Delorean::AbstractContainer
   def grid_code(ruleh)
     dgcache = {}
     h = {}
-    ruleh["grids"].each do |k, v|
-      expand_grid_code(h, k.ends_with?('_grid')?k:k+'_grid', %Q("#{v}"),
-                                                dgcache, {})
+    ruleh['grids'].each do |k, v|
+      expand_grid_code(h, k.ends_with?('_grid') ? k : k + '_grid', %Q("#{v}"),
+                       dgcache, {})
     end
     h.map { |k, v| write_attr(k, v) }.join("\n") + "\n"
   end
 
   def guard_code(ruleh)
-    write_code(ruleh["computed_guards"])
+    write_code(ruleh['computed_guards'])
   end
 
   def result_code(ruleh)
-    write_code(ruleh["results"])
+    write_code(ruleh['results'])
   end
 
   def grid_init(ruleh)
-    if ruleh["grids"].present? ||
-       ruleh["results"].keys.any?{|k|k.ends_with?("_grid")}
-      write_code({ "pt" => :parameter,
-                   "dgparams__" => :parameter,
-                 })
+    if ruleh['grids'].present? ||
+       ruleh['results'].keys.any? { |k| k.ends_with?('_grid') }
+      write_code('pt' => :parameter,
+                   'dgparams__' => :parameter,
+                )
     else
       ''
     end
   end
+
   def get_code(ruleh)
     grid_i = grid_init(ruleh)
     grid_c = grid_code(ruleh)
@@ -122,11 +127,12 @@ class Marty::RuleScriptSet < Delorean::AbstractContainer
     errs[:results] = result_code(ruleh).count("\n")
     errs
   end
+
   def get_parse_error_field(ruleh, exc)
     line = exc.line ? exc.line - self.class.body_lines : 0
     errs = code_section_counts(ruleh)
     line_count = 0
-    errs.each do |k,v|
+    errs.each do |k, v|
       line_count += v
       return k if line <= line_count
     end
@@ -134,22 +140,21 @@ class Marty::RuleScriptSet < Delorean::AbstractContainer
   end
 
   def get_engine(ruleh)
-    begin
       # if rule is a str => importing a regular Script (i.e. not rule)
       return sset.get_engine(ruleh) if ruleh.is_a? String
 
       # on create rule doesn't have an id => don't cache
       return sset.parse_check("New RULE #{ruleh['name']}", get_code(ruleh)) unless
-        ruleh["id"]
+        ruleh['id']
 
-      rule_pfx = ruleh["classname"].demodulize
+      rule_pfx = ruleh['classname'].demodulize
 
       # unique name for specific version of rule
       sname = "#{rule_pfx}_#{ruleh['group_id']}_#{ruleh['created_dt'].to_f}"
 
       # is it a dev posting?
       if Mcfly.is_infinity(pt)
-        max_dt = ruleh["classname"].constantize.order("created_dt DESC").
+        max_dt = ruleh['classname'].constantize.order('created_dt DESC').
                  limit(1).pluck(:created_dt).first
 
         @@dengines_dt ||= max_dt
@@ -169,14 +174,13 @@ class Marty::RuleScriptSet < Delorean::AbstractContainer
 
         @@engines[[pt, sname]] = sset.parse_check(sname, get_code(ruleh))
       end
-    rescue Delorean::ParseError => e
+  rescue Delorean::ParseError => e
       f = get_parse_error_field(ruleh, e)
       msg = e.message.capitalize
       raise "Error in rule '#{ruleh['name']}' field '#{f}': #{msg}"
-    end
   end
 
   def self.indent(s)
-    s.gsub(/^/, ' '*4)
+    s.gsub(/^/, ' ' * 4)
   end
 end