presets_factory.rb in eco-helpers-2.0.17

- old
+ new

@@ -1,10 +1,12 @@
 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)
@@ -22,48 +24,40 @@
             @abilities ||= abilities_model.keys
           end
 
         end
 
-        ABILITIES = File.join(__dir__, 'presets_values.json')
-        INTEGRITY = File.join(__dir__, 'presets_integrity.json')
-        DEFAULT_CUSTOM = 'presets_custom.json'
-        DEFAULT_MAP    = 'presets_map.json'
-
-        def initialize(presets_custom: DEFAULT_CUSTOM, presets_map: DEFAULT_MAP, enviro: nil, policy_groups: nil)
+        def initialize(enviro: nil, policy_groups: nil)
           fatal("Expecting Environment object. Given: #{enviro}") if enviro && !enviro.is_a?(Eco::API::Common::Session::Environment)
           @enviro        = enviro
+          @policy_groups = policy_groups
+        end
 
-          @policy_groups       = policy_groups
-          @presets_custom_file = presets_custom || DEFAULT_CUSTOM
-          @presets_map_file    = presets_map    || DEFAULT_MAP
+        # @return [Array<String>] all the abilities
+        def keys
+          self.class.abilities
         end
 
-        def new(*policy_group_ids_or_names)
+        def valid?(preset)
+          validate(perset).length == 0
+        end
 
-          names = policy_group_ids_or_names.map do |id_name|
-            policy_groups.to_name(id_name)&.downcase
-          end.compact
-
-          if presets_map
-            preset_names = names.map { |name| presets_map.fetch(name, nil) }
-          else # option to do not use preset mapping (so just the policy group name)
-            preset_names = names
+        def validate(preset)
+          [].tap do |errors|
+            if err = preset_errors(preset)
+              errors << "{ '#{key}' preset -> #{err}}"
+            end
+            if err = preset_integrity(preset)
+              errors << "{ '#{key}' preset -> #{err}}"
+            end
           end
-          compile(*preset_names)
         end
 
-        # @return [Array<String>] all the abilities
-        def keys
-          abilities_model.keys
-        end
-
         private
 
-        def compile(*preset_names)
-          fatal("You need to specify an existing file for the custom presets.") if !@presets_custom
-          @presets_custom.values_at(*preset_names).compact.reduce({}) do |p1, p2|
+        def compile(*presets)
+          presets.compact.reduce({}) do |p1, p2|
             merge(p1, p2)
           end
         end
 
         def merge(preset1, preset2)
@@ -77,15 +71,10 @@
             ].compact.max
             result[key] = idx && values[idx]
           end
         end
 
-        # unsused: only play with the given abilities
-        def empty_model
-          JSON.parse(abilities_model.to_json).transform_values {|v| nil }
-        end
-
         def preset_errors(preset)
           return "No preset given" if !preset
           errors = preset.map do |k, v|
             value_exists?(k, v) ? nil : "#{k}:#{v}"
           end.compact
@@ -144,11 +133,11 @@
             out[key] = values.each_with_object({}) {|v, h| h[v] = true }
           end
         end
 
         def ability_value_idx(ability, value)
-          abilities_model[ability].index(value)
+          abilities_model[ability].index(value) || -1
         end
 
         def abilities_model
           self.class.abilities_model
         end
@@ -159,59 +148,9 @@
 
           unless @policy_groups.is_a?(Eco::API::Organization::PolicyGroups)
             @policy_groups = Eco::API::Organization::PolicyGroups.new(@policy_groups)
           end
           @policy_groups
-        end
-
-        def presets_custom
-          return @presets_custom if instance_variable_defined?(:@presets_custom)
-          @presets_custom = nil
-          if @presets_custom_file
-            if (file = File.expand_path(@presets_custom_file)) && File.exists?(file)
-              @presets_custom = JSON.load(File.open(file)).tap do |custom_presets|
-                errors = custom_presets.each_with_object([]) do |(key, preset), errors|
-                  if err = preset_errors(preset)
-                    errors << "{ '#{key}' preset -> #{err}}"
-                  end
-                  if err = preset_integrity(preset)
-                    errors << "{ '#{key}' preset -> #{err}}"
-                  end
-                end
-
-                fatal("File '#{file}' contains invalid presets:\n  #{errors.join("\n  ")}") if errors.length > 0
-              end
-            end
-          end
-        end
-
-        def presets_map
-          return @presets_map if instance_variable_defined?(:@presets_map)
-          @presets_map = nil
-          if @presets_map_file
-            if (file = File.expand_path(@presets_map_file)) && File.exists?(file)
-              fatal("Maps file specified without 'presets_custom.json' file. Aborting!") if !presets_custom
-              @presets_map = JSON.load(File.open(file)).tap do |map_presets|
-
-                errors = []
-                if policy_groups.length > 0
-                  errors = policy_groups.map do |pg|
-                    exists = map_presets[pg.name.downcase] || presets_custom[pg.name.downcase]
-                    exists ? nil : "'#{pg.name}'"
-                  end.compact
-
-                  warn("No maps or no preset for policy group(s): #{errors.join(", ")}") if errors.length > 0
-                end
-
-                errors = map_presets.map do |source, dest|
-                  presets_custom[dest] ? nil : "'#{dest}'"
-                end.compact
-
-                warn("Unexisting mapped preset(s): #{errors.uniq.join(", ")}") if errors.length > 0
-
-              end
-            end
-          end
         end
 
         def fatal(msg)
           raise msg if !@enviro
           @enviro.logger.fatal(msg)