presets_factory.rb in eco-helpers-3.0.5

- old
+ new

@@ -1,15 +1,13 @@
 module Eco
   module API
     module Organization
-
       class PresetsFactory
         ABILITIES = File.join(__dir__, 'presets_values.json')
         INTEGRITY = File.join(__dir__, 'presets_integrity.json')
 
         class << self
-
           def all_abilities(hash = {})
             Hash[abilities.each_with_object(nil).to_a].merge(hash)
           end
 
           def abilities_model
@@ -21,104 +19,112 @@
           end
 
           def abilities
             @abilities ||= abilities_model.keys
           end
-
         end
 
         def initialize(enviro: nil, policy_groups: nil)
-          fatal("Expecting Environment object. Given: #{enviro}") if enviro && !enviro.is_a?(Eco::API::Common::Session::Environment)
+          msg = "Expecting Environment object. Given: #{enviro.class}"
+          fatal(msg) if enviro && !enviro.is_a?(Eco::API::Common::Session::Environment)
+
           @enviro        = enviro
           @policy_groups = policy_groups
         end
 
         # @return [Array<String>] all the abilities
         def keys
           self.class.abilities
         end
 
         def valid?(preset)
-          validate(perset).length == 0
+          validate(preset).empty?
         end
 
         def validate(preset)
           [].tap do |errors|
-            if err = preset_errors(preset)
+            if (err = preset_errors(preset))
               errors << "{ '#{key}' preset -> #{err}}"
             end
-            if err = preset_integrity(preset)
+
+            if (err = preset_integrity(preset))
               errors << "{ '#{key}' preset -> #{err}}"
             end
           end
         end
 
         private
 
         def compile(*presets)
-          presets.compact.reduce({}) do |p1, p2|
-            merge(p1, p2)
+          presets.compact.reduce({}) do |p_1, p_2|
+            merge(p_1, p_2)
           end
         end
 
-        def merge(preset1, preset2)
-          keys = preset1.keys | preset2.keys
+        def merge(preset_1, preset_2)
+          keys = preset_1.keys | preset_2.keys
 
           abilities_model.each_with_object({}) do |(key, values), result|
             next unless keys.include?(key)
+
             idx = [
-              values.index(preset1[key]),
-              values.index(preset2[key])
+              values.index(preset_1[key]),
+              values.index(preset_2[key])
             ].compact.max
+
             result[key] = idx && values[idx]
           end
         end
 
         def preset_errors(preset)
-          return "No preset given" if !preset
+          return "No preset given" unless preset
+
           errors = preset.map do |k, v|
             value_exists?(k, v) ? nil : "#{k}:#{v}"
           end.compact
-          return " Unknown: {#{errors.join(", ")}}" if errors.length > 0
-          nil
+
+          " Unknown: {#{errors.join(", ")}}" if errors.length.positive?
         end
 
-        def preset_integrity(preset)
+        def preset_integrity(preset) # rubocop:disable Metrics/AbcSize
           preset.each_with_object([]) do |(ability, value), errors|
-            next unless checks = integrity_model[ability]
+            next unless (checks = integrity_model[ability])
 
             suberrors = []
 
             checks.each do |check|
               next unless check["value"] == value
+
               check["conditions"].each do |cond, targets|
                 case cond
                 when "at_least"
                   targets.each do |other, minimum|
-                    unless (ability_value_idx(other, minimum) <= ability_value_idx(other, preset[other]))
-                      suberrors << "'#{other}' should be at least '#{minimum}'"
-                    end
+                    min_idx = ability_value_idx(other, minimum)
+                    oth_idx = ability_value_idx(other, preset[other])
+                    next if min_idx <= oth_idx
+
+                    suberrors << "'#{other}' should be at least '#{minimum}'"
                   end
                 when "one_of"
                   unless targets.any? {|other, expected| preset[other] == expected}
                     suberrors << targets.each_with_object([]) do |(other, expected), out|
                       out << "'#{other}': '#{expected}'"
-                    end.join(", ").yield_self do |msg|
+                    end.join(", ").then do |msg|
                       "there should be at least one of: {#{msg}}"
                     end
                   end
                 else
                   warn("Unsuported integrity condition statement '#{cond}' in '#{ability}' with level '#{value}'")
                 end
               end
             end
 
-            if suberrors.length > 0
+            unless suberrors.empty?
               errors << "Incorrect value '#{value}' for '#{ability}' - reasons: {#{suberrors.join(", ")}}"
             end
-          end.yield_self do |errors|
-            " Integrity errors: { #{errors.join(", ")} }" if errors.length > 0
+          end.then do |errors|
+            " Integrity errors: { #{errors.join(", ")} }" unless errors.empty?
           end
         end
 
         def integrity_model
           self.class.integrity_model
@@ -127,12 +133,12 @@
         def value_exists?(ability, value)
           abilities_model_inverted.dig(ability, value)
         end
 
         def abilities_model_inverted
-          @abilities_model_inverted ||= abilities_model.each_with_object({}) do |(key, values), out|
-            out[key] = values.each_with_object({}) {|v, h| h[v] = true }
+          @abilities_model_inverted ||= abilities_model.transform_values do |values|
+            values.each_with_object({}) {|v, h| h[v] = true }
           end
         end
 
         def ability_value_idx(ability, value)
           abilities_model[ability].index(value) || -1
@@ -151,20 +157,20 @@
           end
           @policy_groups
         end
 
         def fatal(msg)
-          raise msg if !@enviro
+          raise msg unless @enviro
+
           @enviro.logger.fatal(msg)
           raise msg
         end
 
         def warn(msg)
-          raise msg if !@enviro
+          raise msg unless @enviro
+
           @enviro.logger.warn(msg)
         end
-
       end
-
     end
   end
 end