marty 2.5.2 → 2.5.4

data/other/marty/diagnostic/delayed_job_worker_total_count.rb

@@ -4,7 +4,7 @@ module Marty::Diagnostic; class DelayedJobWorkerTotalCount < Base
       [c['application_name'], c['client_addr'] || '127.0.0.1'] if
         c['application_name'].include?('delayed')
     end.compact.uniq.count
-    {'Delayed Workers' => count.zero? ? error(count) : count}
+    { 'Delayed Workers' => count.zero? ? error(count) : count }
   end
 end
 end

data/other/marty/diagnostic/delayed_job_workers.rb

@@ -6,7 +6,7 @@ module Marty::Diagnostic; class DelayedJobWorkers < Base
       name = c['application_name']
       name if name.include?('delayed') && (ip == my_ip || ip == '127.0.0.1')
     end.compact.uniq.count
-    {'Delayed Workers / Node' => workers.zero? ? error(workers) : workers}
+    { 'Delayed Workers / Node' => workers.zero? ? error(workers) : workers }
   end
 end
 end

data/other/marty/diagnostic/environment_variables.rb

@@ -3,37 +3,39 @@ module Marty::Diagnostic; class EnvironmentVariables < Base
     env
   end
 
-  def self.env filter=''
+  def self.env filter = ''
     env = ENV.clone
 
     to_delete = (Marty::Config['DIAG_ENV_BLOCK'] || []).map(&:upcase) + [
-      'SCRIPT_URI', 'SCRIPT_URL']
+      'SCRIPT_URI', 'SCRIPT_URL'
+    ]
 
     to_obfus = (Marty::Config['DIAG_ENV_OBFUSCATE'] || []).map(&:upcase) + [
-      'SECRET_KEY_BASE']
+      'SECRET_KEY_BASE'
+    ]
 
     to_block = (Marty::Config['DIAG_ENV_BLOCK_IF_INCL'] || []).map(&:upcase) + [
-      'ACCESS', 'SECRET', 'PASSWORD', 'DEBUG']
+      'ACCESS', 'SECRET', 'PASSWORD', 'DEBUG'
+    ]
 
-    to_delete.each{|k| env.delete(k)}
+    to_delete.each { |k| env.delete(k) }
 
-    to_obfus.each{|k| env[k] = env[k][0,4] if env[k]}
+    to_obfus.each { |k| env[k] = env[k][0, 4] if env[k] }
 
-    env.sort.each_with_object({}){|(k,v),h|
-      h[k] = v if to_block.all?{|b| !k.include?(b)} && k.include?(filter)}
+    env.sort.each_with_object({}) do |(k, v), h|
+      h[k] = v if to_block.all? { |b| !k.include?(b) } && k.include?(filter)
+    end
   end
 
   # overwritten to only return inconsitent data
   def self.apply_consistency data
     diff = get_difference(data)
-    data.each_with_object({}){
-      |(node, diagnostic), new_data|
-      new_data[node] = diagnostic.each_with_object({}){
-        |(test, info), new_diagnostic|
-        new_diagnostic[test] = info + {'consistent' => false} if
+    data.each_with_object({}) do |(node, diagnostic), new_data|
+      new_data[node] = diagnostic.each_with_object({}) do |(test, info), new_diagnostic|
+        new_diagnostic[test] = info + { 'consistent' => false } if
           diff.include?(test)
-      }
-    }
+      end
+    end
   end
 end
 end

data/other/marty/diagnostic/fatal.rb

@@ -2,7 +2,7 @@ module Marty::Diagnostic; class Fatal < Base
   def self.message msg, opts = {}
     node = opts[:node] || Node.my_ip
     type = opts[:type] || 'RuntimeError'
-    {name.demodulize => {node => {type => error(msg)}}}
+    { name.demodulize => { node => { type => error(msg) } } }
   end
 end
 end

data/other/marty/diagnostic/node.rb

@@ -1,21 +1,17 @@
 module Marty::Diagnostic::Node
   def self.my_ip
-    begin
-      Socket.ip_address_list.detect{|intf| intf.ipv4_private?}.ip_address
-    rescue => e
+      Socket.ip_address_list.detect(&:ipv4_private?).ip_address
+  rescue StandardError => e
       e.message
-    end
   end
 
-
-
   def self.get_target_connections target
-    Marty::Diagnostic::Database.current_connections.select{|conn|
+    Marty::Diagnostic::Database.current_connections.select do |conn|
       conn['application_name'].include?(target)
-    }.map{|conn|
+    end.map do |conn|
       conn['client_addr'] == '127.0.0.1' ? my_ip :
         conn['client_addr'] || '127.0.0.1'
-    }
+    end
   end
 
   def self.get_nodes

data/other/marty/diagnostic/nodes.rb

@@ -4,7 +4,7 @@ module Marty::Diagnostic; class Nodes < Base
   diagnostic_fn aggregatable: false do
     begin
       pg_nodes = Node.get_nodes.sort
-    rescue => e
+    rescue StandardError => e
       next error(e.message)
     end
 
@@ -13,7 +13,7 @@ module Marty::Diagnostic; class Nodes < Base
 
     begin
       instance_data = Marty::Diagnostic::Aws::Ec2Instance.new
-    rescue => e
+    rescue StandardError => e
       next error(pg_nodes.join("\n") +
                  "\nAws Communication Error: #{e.message}")
     end
@@ -25,7 +25,7 @@ module Marty::Diagnostic; class Nodes < Base
       # generate instance information when there is an issue
       # between aws and postgres
       instances = instance_data.instances
-      {'nodes' => error("There is a discrepancy between nodes connected to "\
+      { 'nodes' => error('There is a discrepancy between nodes connected to '\
                         "Postgres and those discovered through AWS EC2.\n"\
                         "Postgres: \n#{pg_nodes.join("\n")}\n"\
                         "AWS: \n#{a_nodes.join("\n")}"),
@@ -35,19 +35,21 @@ module Marty::Diagnostic; class Nodes < Base
        'terminated'    => error_if(instances.terminated),
        'stopping'      => error_if(instances.stopping),
        'stopped'       => error_if(instances.stopped),
-      }.delete_if{|k,v| v.empty?}
-    rescue => e
+      }.delete_if { |k, v| v.empty? }
+    rescue StandardError => e
       error(e.message)
     end
   end
 
   def self.valid_if arr
     return arr.join("\n") unless arr.empty?
+
     error('---')
   end
 
   def self.error_if arr
     return arr if arr.empty?
+
     error(arr.join("\n"))
   end
 end

data/other/marty/diagnostic/packer.rb

@@ -1,21 +1,21 @@
 module Marty::Diagnostic; module Packer
-  def pack include_ip=true
+  def pack include_ip = true
     info = process(yield)
-    include_ip ? {Node.my_ip => info} : info
+    include_ip ? { Node.my_ip => info } : info
   end
 
   def process obj
     obj.is_a?(Hash) ? process_hash(obj) :
-      {name.demodulize => create_info(obj.to_s)}
+      { name.demodulize => create_info(obj.to_s) }
   end
 
   def process_hash data
-    return {name.demodulize => data} if is_valid_info?(data)
+    return { name.demodulize => data } if is_valid_info?(data)
 
-    data.each_with_object({}) do
-      |(k, v), h|
+    data.each_with_object({}) do |(k, v), h|
       if v.is_a?(Hash)
         raise "Invalid Diagnostic Info #{v}" unless is_valid_info?(v)
+
         h[k] = v
       else
         h[k] = create_info(v)
@@ -23,7 +23,7 @@ module Marty::Diagnostic; module Packer
     end
   end
 
-  def create_info description, status=true, consistent=nil
+  def create_info description, status = true, consistent = nil
     {
       'description' => description.to_s,
       'status'      => status,

data/other/marty/diagnostic/reporter.rb

@@ -9,24 +9,26 @@ module Marty::Diagnostic; class Reporter < Request
     self.request = request
 
     ops = op.split(/,\s*/).uniq - [unresolve_diagnostic(self)]
-    reps = ops.select{|o| reports.keys.include?(o)}
+    reps = ops.select { |o| reports.keys.include?(o) }
 
-    self.diagnostics = ((ops - reps) + reps.map{|r| reports[r]}.flatten).uniq.
-                         map{|d| resolve_diagnostic(d)}
+    self.diagnostics = ((ops - reps) + reps.map { |r| reports[r] }.flatten).uniq.
+                         map { |d| resolve_diagnostic(d) }
 
-    self.scope == 'local' ? generate : aggregate
+    scope == 'local' ? generate : aggregate
   end
 
   private
+
   def self.resolve_diagnostic diag_name
     diag_name = diag_name.camelize
     klass = nil
-    self.namespaces.each do |n|
+    namespaces.each do |n|
       klass = (n + '::Diagnostic::' + diag_name).constantize rescue nil
       break if klass
     end
     raise NameError.new("#{diag_name} could not be resolved by #{name}") if
       klass.nil?
+
     klass
   end
 
@@ -35,50 +37,45 @@ module Marty::Diagnostic; class Reporter < Request
   end
 
   def self.generate
-    diagnostics.each_with_object({}){
-      |d, h|
+    diagnostics.each_with_object({}) do |d, h|
       begin
         h[d.name.demodulize] = d.generate
-      rescue => e
+      rescue StandardError => e
         h.deep_merge!(Fatal.message(e.message, type: d.name.demodulize))
       end
-    }
+    end
   end
 
   def self.aggregate
     data = consistency([generate, get_remote_diagnostics].reduce(:deep_merge))
-    {'data' => data, 'errors' => errors(data)}
+    { 'data' => data, 'errors' => errors(data) }
   end
 
   def self.consistency data
-    data.each_with_object({}){
-      |(klass, result), h|
+    data.each_with_object({}) do |(klass, result), h|
       h[klass] = resolve_diagnostic(klass).apply_consistency(result)
-    }
+    end
   end
 
   def self.errors data
-    data.each_with_object({}){
-      |(klass, result), new_data|
-      new_data[klass] = result.each_with_object({}){
-        |(node, diagnostic), new_result|
-        new_result[node] = diagnostic.each_with_object({}){
-          |(test, info), new_diagnostic|
+    data.each_with_object({}) do |(klass, result), new_data|
+      new_data[klass] = result.each_with_object({}) do |(node, diagnostic), new_result|
+        new_result[node] = diagnostic.each_with_object({}) do |(test, info), new_diagnostic|
           new_diagnostic[test] = info unless
             info['status'] && (scope == 'local' || info['consistent'])
-        }
+        end
         new_result.delete(node) if new_result[node].empty?
-      }
+      end
       new_data.delete(klass) if new_data[klass].empty?
-    }
+    end
   end
 
   def self.displays result
-    result.map{|d, r| resolve_diagnostic(d).display(r)}.sum
+    result.map { |d, r| resolve_diagnostic(d).display(r) }.sum
   end
 
   def self.get_remote_diagnostics
-    ops = diagnostics.map{|d| unresolve_diagnostic(d) if d.aggregatable}.compact
+    ops = diagnostics.map { |d| unresolve_diagnostic(d) if d.aggregatable }.compact
     return {} if ops.empty?
 
     nodes = Node.get_nodes - [Node.my_ip]
@@ -97,11 +94,11 @@ module Marty::Diagnostic; class Reporter < Request
         req.verify_mode = OpenSSL::SSL::VERIFY_NONE
 
         begin
-          response = req.start {|http| http.get(uri.to_s)}
-          next JSON.parse(response.body) if response.code == "200"
+          response = req.start { |http| http.get(uri.to_s) }
+          next JSON.parse(response.body) if response.code == '200'
 
           Fatal.message(response.body, type: response.message, node: uri.host)
-        rescue => e
+        rescue StandardError => e
           Fatal.message(e.message, type: e.class, node: uri.host)
         end
       end

data/other/marty/diagnostic/version.rb

@@ -2,8 +2,8 @@ module Marty::Diagnostic; class Version < Base
   diagnostic_fn do
     begin
       message = `cd #{Rails.root.to_s}; git describe --tags --always;`.strip
-    rescue
-      message = error("Failed accessing git")
+    rescue StandardError
+      message = error('Failed accessing git')
     end
     rbv = "#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} (#{RUBY_PLATFORM})"
     {
@@ -22,11 +22,9 @@ module Marty::Diagnostic; class Version < Base
   end
 
   def self.db_schema
-    begin
       Database.db_schema
-    rescue => e
+  rescue StandardError => e
       error(e.message)
-    end
   end
 end
 end

data/script/rails

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
-# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+# This command will automatically be run when you run "rails"
+# with Rails 3 gems installed from the root of your application.
 
 ENGINE_ROOT = File.expand_path('../..', __FILE__)
 ENGINE_PATH = File.expand_path('../../lib/marty/engine', __FILE__)

data/spec/controllers/application_controller_spec.rb

@@ -8,7 +8,7 @@ module Marty
     end
 
     describe 'authentication' do
-      it "should allow a registered user to log in" do
+      it 'should allow a registered user to log in' do
         allow(Rails.configuration.marty).to receive(:auth_source).
           and_return('local')
 
@@ -20,8 +20,8 @@ module Marty
         expect(Marty::User.current).to be_nil
       end
 
-      it "should allow a registered user to log in when the database " +
-        "is in recovery mode" do
+      it 'should allow a registered user to log in when the database ' +
+        'is in recovery mode' do
         allow(Marty::Util).to receive(:db_in_recovery?).and_return(true)
         allow(Rails.configuration.marty).to receive(:auth_source).
           and_return('local')
@@ -34,14 +34,14 @@ module Marty
         expect(Marty::User.current).to be_nil
       end
 
-      it "should prevent a non-registered user from logging in" do
+      it 'should prevent a non-registered user from logging in' do
         user = Marty::User.try_to_login('unknown_marty', 'invalid_password')
         expect(user).to be_nil
         expect(Marty::User.current).to be_nil
       end
 
-      it "should prevent a non-registered user from logging in when the " +
-        "database is in recovery mode" do
+      it 'should prevent a non-registered user from logging in when the ' +
+        'database is in recovery mode' do
         allow(Marty::Util).to receive(:db_in_recovery?).and_return(true)
         user = Marty::User.try_to_login('unknown_marty', 'invalid_password')
         expect(user).to be_nil

data/spec/controllers/delayed_job_controller_spec.rb

@@ -8,25 +8,25 @@ require 'support/empty_job'
 describe Marty::DelayedJobController, slow: false do
   before(:each) { @routes = Marty::Engine.routes }
 
-  describe "#trigger" do
+  describe '#trigger' do
     before do
       @job = ::Delayed::Job.enqueue EmptyJob.new
     end
 
-    it "should be able to execute existing job" do
+    it 'should be able to execute existing job' do
       expect(::Delayed::Job.exists?(@job.id)).to be true
       post :trigger, params: { id: @job.id }
       expect(response).to have_http_status(:ok)
       expect(::Delayed::Job.exists?(@job.id)).to be false
     end
 
-    it "should return ok if triggered job is locked" do
+    it 'should return ok if triggered job is locked' do
       @job.update!(locked_at: Time.zone.now)
       post :trigger, params: { id: @job.id }
       expect(response).to have_http_status(:ok)
     end
 
-    it "should return ok if triggered job is missing" do
+    it 'should return ok if triggered job is missing' do
       @job.destroy!
       post :trigger, params: { id: @job.id }
       expect(response).to have_http_status(:ok)

data/spec/controllers/diagnostic/controller_spec.rb

@@ -16,28 +16,27 @@ module Marty::Diagnostic
 
     def git
       `cd #{Rails.root.to_s}; git describe --tags --always;`.
-        strip rescue "Failed accessing git"
+        strip rescue 'Failed accessing git'
     end
 
     describe 'GET #op' do
       it 'returns http success' do
-        get :op, params: {format: :json, op: 'version'}
+        get :op, params: { format: :json, op: 'version' }
         expect(response).to have_http_status(:success)
       end
 
       it 'a request injects the request object into Diagnostic classes' do
-        get :op, params: {format: :json, op: 'version'}
+        get :op, params: { format: :json, op: 'version' }
         expect(Reporter.request).not_to eq(nil)
       end
 
       it 'returns the current version JSON' do
-        get :op, params: {format: :json, op: 'version', data: 'true'}
+        get :op, params: { format: :json, op: 'version', data: 'true' }
 
         # generate version data and declare all values consistent
-        versions = Version.generate.each_with_object({}){
-          |(n, v),h|
-          h[n] = v.each{|t, r| r['consistent'] = true}
-        }
+        versions = Version.generate.each_with_object({}) do |(n, v), h|
+          h[n] = v.each { |t, r| r['consistent'] = true }
+        end
 
         expected = {
           'data' => {
@@ -50,77 +49,77 @@ module Marty::Diagnostic
 
       it 'returns the expected cummulative diagnostic' do
         expected = {
-          "data" => {
-            "Version" => {
+          'data' => {
+            'Version' => {
               my_ip => {
-                "Marty" => {
-                  "description" => Marty::VERSION,
-                  "status"      => true,
-                  "consistent"  => true
+                'Marty' => {
+                  'description' => Marty::VERSION,
+                  'status'      => true,
+                  'consistent'  => true
                 },
-                "Delorean" => {
-                  "description" => Delorean::VERSION,
-                  "status"      => true,
-                  "consistent"  => true
+                'Delorean' => {
+                  'description' => Delorean::VERSION,
+                  'status'      => true,
+                  'consistent'  => true
                 },
-                "Mcfly" => {
-                  "description" => Mcfly::VERSION,
-                  "status"      => true,
-                  "consistent"  => true
+                'Mcfly' => {
+                  'description' => Mcfly::VERSION,
+                  'status'      => true,
+                  'consistent'  => true
                 },
-                "Git" => {
-                  "description" => git,
-                  "status"      => true,
-                  "consistent"  => true
+                'Git' => {
+                  'description' => git,
+                  'status'      => true,
+                  'consistent'  => true
                 },
-                "Rails" => {
-                  "description" => Rails.version,
-                  "status"      => true,
-                  "consistent"  => true
+                'Rails' => {
+                  'description' => Rails.version,
+                  'status'      => true,
+                  'consistent'  => true
                 },
-                "Netzke Core" => {
-                  "description" => Netzke::Core::VERSION,
-                  "status"      => true,
-                  "consistent"  => true
+                'Netzke Core' => {
+                  'description' => Netzke::Core::VERSION,
+                  'status'      => true,
+                  'consistent'  => true
                 },
-                "Netzke Basepack" => {
-                  "description" => Netzke::Basepack::VERSION,
-                  "status"      => true,
-                  "consistent"  => true
+                'Netzke Basepack' => {
+                  'description' => Netzke::Basepack::VERSION,
+                  'status'      => true,
+                  'consistent'  => true
                 },
-                "Ruby" => {
-                  "description" => "#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} "\
+                'Ruby' => {
+                  'description' => "#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} "\
                                    "(#{RUBY_PLATFORM})",
-                  "status"      => true,
-                  "consistent"  => true
+                  'status'      => true,
+                  'consistent'  => true
                 },
-                "RubyGems" => {
-                  "description" => Gem::VERSION,
-                  "status"      => true,
-                  "consistent"  => true
+                'RubyGems' => {
+                  'description' => Gem::VERSION,
+                  'status'      => true,
+                  'consistent'  => true
                 },
-                "Database Schema Version" => {
-                  "description" => Database.db_schema,
-                  "status"      => true,
-                  "consistent"  => true
+                'Database Schema Version' => {
+                  'description' => Database.db_schema,
+                  'status'      => true,
+                  'consistent'  => true
                 },
-                "Environment" => {
-                  "description" => Rails.env,
-                  "status"      => true,
-                  "consistent"  => true
+                'Environment' => {
+                  'description' => Rails.env,
+                  'status'      => true,
+                  'consistent'  => true
                 }
               }
             },
-            "EnvironmentVariables" => {
+            'EnvironmentVariables' => {
               my_ip => {
               }
             },
-            "Nodes" => {
+            'Nodes' => {
               my_ip => {
-                "Nodes"=> {
-                  "description" => my_ip,
-                  "status"      => true,
-                  "consistent"  => true
+                'Nodes' => {
+                  'description' => my_ip,
+                  'status'      => true,
+                  'consistent'  => true
                 }
               }
             }