automation_object 0.5.0 → 0.5.1

data/lib/automation_object/blue_print/hash_adapter/helpers/validators/validate.rb

@@ -1,23 +1,26 @@
+# frozen_string_literal: true
 module AutomationObject
   module BluePrint
     module HashAdapter
       module Validators
-        #Super-class for validators, contains base functionality
-        #Sub-classes must implement validate for the composite
+        # Super-class for validators, contains base functionality
+        # Sub-classes must implement validate for the composite
         class Validate
           attr_accessor :error_messages
 
+          # Remove getter to solve stupid Ruby warning
+          undef :error_messages if method_defined? :error_messages
           # @return [Array<String>] array of error messages, default empty array
           def error_messages
-            @error_messages ||= Array.new
+            @error_messages ||= []
           end
 
           # @return [Boolean] whether or not validation passed or failed
           def valid?
-            return (self.error_messages.length == 0) ? true : false
+            error_messages.length.zero? ? true : false
           end
         end
       end
     end
   end
-end
+end

data/lib/automation_object/blue_print/hash_adapter/helpers/validators/validate_allowed_keys.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
 require_relative 'validate'
 
 module AutomationObject
   module BluePrint
     module HashAdapter
       module Validators
-        #Validator that tests the composite hash for bad keys
+        # Validator that tests the composite hash for bad keys
         class ValidateAllowedKeys < Validate
           # @param args [Hash] arguments for the validation class
           def initialize(args)
@@ -15,17 +16,15 @@ module AutomationObject
           # @param composite_object [Object] Composite object to be tested.
           # @return [nil] no return on exceptions on failure
           def validate(composite_object)
-            #Get the hash from the composite object
+            # Get the hash from the composite object
             target_hash = composite_object.hash
 
-            target_hash.each_key { |key|
-              unless @allowed_keys.include?(key)
-                self.error_messages.push("Invalid Key: #{key}, at: #{composite_object.location}. Allowed keys: #{@allowed_keys}.")
-              end
-            }
+            target_hash.each_key do |key|
+              error_messages.push("Invalid Key: #{key}, at: #{composite_object.location}. Allowed keys: #{@allowed_keys}.") unless @allowed_keys.include?(key)
+            end
           end
         end
       end
     end
   end
-end
+end

data/lib/automation_object/blue_print/hash_adapter/helpers/validators/validate_element_presence_of.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
 require_relative 'validate'
 
 module AutomationObject
   module BluePrint
     module HashAdapter
       module Validators
-        #Validator that tests that a element is defined when it is called elsewhere through a hook
+        # Validator that tests that a element is defined when it is called elsewhere through a hook
         class ValidateElementPresenceOf < Validate
           # @param args [Hash] arguments for the validation class
           def initialize(args)
@@ -15,41 +16,45 @@ module AutomationObject
           # @param composite_object [Object] Composite object to be tested.
           # @return [nil] no return on exceptions on failure
           def validate(composite_object)
-            #Get the hash value from the composite object
+            # Get the hash value from the composite object
             target_value = composite_object.hash[@key]
 
             return unless target_value
 
-            target_values = (target_value.is_a?(Array)) ? target_value : [target_value]
+            target_values = target_value.is_a?(Array) ? target_value : [target_value]
+            valid_elements = find_elements(composite_object)
 
-            valid_elements = self.find_elements(composite_object)
-
-            target_values.each { |element|
-              element = element.to_sym
-              next if valid_elements.include?(element)
-
-              error_message = "Invalid Element: #{element}, at: #{composite_object.location}[#{@key}]."
-              error_message << " Valid Elements(s): #{valid_elements}"
-              self.error_messages.push(error_message)
-            }
+            populate_errors(target_values, valid_elements, composite_object)
           end
 
-          #Traverses up a composite tree to find :elements in a hash
+          private
+
+          # Traverses up a composite tree to find :elements in a hash
           # @param composite_object [Object] composite object to traverse up
           # @return [Array<Symbol>] array of element names
           def find_elements(composite_object)
-            #Using the hash instead of the method because lower nodes will get validated
-            #before composite is finished building
-            if composite_object.hash[:elements].is_a?(Hash)
-              return composite_object.hash[:elements].keys #Should be Hash with element names as the keys
-            elsif composite_object.parent
-              return self.find_elements(composite_object.parent)
-            end
+            # Using the hash instead of the method because lower nodes will get validated
+            # before composite is finished building
+            return composite_object.hash[:elements].keys if composite_object.hash[:elements].is_a?(Hash)
+
+            # Should be Hash with element names as the keys
+            return find_elements(composite_object.parent) if composite_object.parent
 
-            return []
+            []
+          end
+
+          def populate_errors(target_values, valid_elements, composite_object)
+            target_values.each do |element|
+              element = element.to_sym
+              next if valid_elements.include?(element)
+
+              error_message = "Invalid Element: #{element}, at: #{composite_object.location}[#{@key}]."
+              error_message += " Valid Elements(s): #{valid_elements}"
+              error_messages.push(error_message)
+            end
           end
         end
       end
     end
   end
-end
+end

data/lib/automation_object/blue_print/hash_adapter/helpers/validators/validate_instance_of.rb

@@ -1,39 +1,38 @@
+# frozen_string_literal: true
 require_relative 'validate'
 
 module AutomationObject
   module BluePrint
     module HashAdapter
       module Validators
-        #Validator that tests that a element is defined when it is called elsewhere through a hook
+        # Validator that tests that a element is defined when it is called elsewhere through a hook
         class ValidateInstanceOf < Validate
           # @param args [Hash] arguments for the validation class
           def initialize(args)
             @key = args.fetch :key
-            #Convert to array of instances for consistency
-            @should_be_instances_of = (args.fetch(:args).is_a?(Array)) ? args.fetch(:args) : [args.fetch(:args)]
+            # Convert to array of instances for consistency
+            @should_be_instances_of = args.fetch(:args).is_a?(Array) ? args.fetch(:args) : [args.fetch(:args)]
           end
 
-          # Validates the composite object and throws errors on failure
-          # @param composite_object [Object] Composite object to be tested.
+          # Validates the composite object and adds errors on failure
+          # @param composite_object [AutomationObject::BluePrint::HashAdapter::Composite] composite
           # @return [nil] no return on exceptions on failure
           def validate(composite_object)
-            #Get the hash value from the composite object
+            # Get the hash value from the composite object
             target_value = composite_object.hash[@key]
 
-            #Skip empty or non-existent
+            # Skip empty or non-existent
             return unless target_value
 
-            @should_be_instances_of.each { |should_be_instance_of|
-              return if target_value.is_a?(should_be_instance_of)
-            }
+            return if @should_be_instances_of.any? { |should_instance| target_value.is_a?(should_instance) }
 
             error_message = "Invalid Type: #{target_value.class}, at: #{composite_object.location}[#{@key}]."
-            error_message << " Allowed Type(s): #{@should_be_instances_of}"
+            error_message += " Allowed Type(s): #{@should_be_instances_of}"
 
-            self.error_messages.push(error_message)
+            error_messages.push(error_message)
           end
         end
       end
     end
   end
-end
+end

data/lib/automation_object/blue_print/hash_adapter/helpers/validators/validate_modal_presence_of.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
 require_relative 'validate'
 
 module AutomationObject
   module BluePrint
     module HashAdapter
       module Validators
-        #Validator that tests that a modal is defined when it is called elsewhere through a hook
+        # Validator that tests that a modal is defined when it is called elsewhere through a hook
         class ValidateModalPresenceOf < Validate
           # @param args [Hash] arguments for the validation class
           def initialize(args)
@@ -15,40 +16,43 @@ module AutomationObject
           # @param composite_object [Object] Composite object to be tested.
           # @return [nil] no return on exceptions on failure
           def validate(composite_object)
-            #Get the hash value from the composite object
+            # Get the hash value from the composite object
             target_value = composite_object.hash[@key]
-            target_values = (target_value.is_a?(Array)) ? target_value : [target_value]
+            target_values = target_value.is_a?(Array) ? target_value : [target_value]
 
             return unless target_value
 
-            valid_modals = self.find_modals(composite_object)
-
-            target_values.each { |modal|
-              modal = modal.to_sym
-              next if valid_modals.include?(modal)
-
-              error_message = "Invalid Modal: #{modal}, at: #{composite_object.location}[#{@key}]."
-              error_message << " Valid Modal(s): #{valid_modals}"
-              self.error_messages.push(error_message)
-            }
+            valid_modals = find_modals(composite_object)
+            populate_errors(target_values, valid_modals, composite_object)
           end
 
-          #Traverses up a composite tree to find :modals in a hash
+          private
+
+          # Traverses up a composite tree to find :modals in a hash
           # @param composite_object [Object] composite object to traverse up
           # @return [Array<Symbol>] array of modal names
           def find_modals(composite_object)
-            #Using the hash instead of the method because lower nodes will get validated
-            #before composite is finished building
-            if composite_object.hash[:modals].is_a?(Hash)
-              return composite_object.hash[:modals].keys #Should be Hash with modal names as the keys
-            elsif composite_object.parent
-              return self.find_modals(composite_object.parent)
-            end
+            # Using the hash instead of the method because lower nodes will get validated
+            # before composite is finished building
+            return composite_object.hash[:modals].keys if composite_object.hash[:modals].is_a?(Hash)
+
+            return find_modals(composite_object.parent) if composite_object.parent
 
-            return []
+            []
+          end
+
+          def populate_errors(target_values, valid_modals, composite_object)
+            target_values.each do |modal|
+              modal = modal.to_sym
+              next if valid_modals.include?(modal)
+
+              error_message = "Invalid Modal: #{modal}, at: #{composite_object.location}[#{@key}]."
+              error_message += " Valid Modal(s): #{valid_modals}"
+              error_messages.push(error_message)
+            end
           end
         end
       end
     end
   end
-end
+end

data/lib/automation_object/blue_print/hash_adapter/helpers/validators/validate_presence_of.rb

@@ -1,17 +1,18 @@
+# frozen_string_literal: true
 require_relative 'validate'
 
 module AutomationObject
   module BluePrint
     module HashAdapter
       module Validators
-        #Validates tests the a key exists on a composite hash
+        # Validates tests the a key exists on a composite hash
         class ValidatePresenceOf < Validate
           # @param args [Hash] arguments for the validation class
           def initialize(args)
             @key = args.fetch :key
 
             options = args.fetch :args, {}
-            options = (options.is_a?(Hash)) ? options : {}
+            options = options.is_a?(Hash) ? options : {}
             @unless_presence_of = options.fetch :unless_presence_of, nil
           end
 
@@ -19,18 +20,18 @@ module AutomationObject
           # @param composite_object [Object] Composite object to be tested.
           # @return [nil] no return on exceptions on failure
           def validate(composite_object)
-            #Get the hash value from the composite object
-            return if composite_object.hash.has_key?(@key)
+            # Get the hash value from the composite object
+            return if composite_object.hash.key?(@key)
 
-            #Do unless_presence_of check
+            # Do unless_presence_of check
             if @unless_presence_of
-              return if composite_object.hash.has_key?(@unless_presence_of)
+              return if composite_object.hash.key?(@unless_presence_of)
             end
 
-            self.error_messages.push("Required Key Missing: #{@key}, at: #{composite_object.location}.")
+            error_messages.push("Required Key Missing: #{@key}, at: #{composite_object.location}.")
           end
         end
       end
     end
   end
-end
+end

data/lib/automation_object/blue_print/hash_adapter/helpers/validators/validate_screen_presence_of.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
 require_relative 'validate'
 
 module AutomationObject
   module BluePrint
     module HashAdapter
       module Validators
-        #Validator that tests that a screen is defined when it is called elsewhere through a hook
+        # Validator that tests that a screen is defined when it is called elsewhere through a hook
         class ValidateScreenPresenceOf < Validate
           # @param args [Hash] arguments for the validation class
           def initialize(args)
@@ -15,41 +16,44 @@ module AutomationObject
           # @param composite_object [Object] Composite object to be tested.
           # @return [nil] no return on exceptions on failure
           def validate(composite_object)
-            #Get the hash value from the composite object
+            # Get the hash value from the composite object
             target_value = composite_object.hash[@key]
 
             return unless target_value
 
-            target_values = (target_value.is_a?(Array)) ? target_value : [target_value]
+            target_values = target_value.is_a?(Array) ? target_value : [target_value]
 
-            valid_screens = self.find_screens(composite_object)
-
-            target_values.each { |screen|
-              screen = screen.to_sym
-              next if valid_screens.include?(screen)
-
-              error_message = "Invalid Screen: #{screen}, at: #{composite_object.location}[#{@key}]."
-              error_message << " Valid Screen(s): #{valid_screens}"
-              self.error_messages.push(error_message)
-            }
+            valid_screens = find_screens(composite_object)
+            populate_errors(target_values, valid_screens, composite_object)
           end
 
-          #Traverses up a composite tree to find :screens in a hash
+          private
+
+          # Traverses up a composite tree to find :screens in a hash
           # @param composite_object [Object] composite object to traverse up
           # @return [Array<Symbol>] array of screen names
           def find_screens(composite_object)
-            #Using the hash instead of the method because lower nodes will get validated
-            #before composite is finished building
-            if composite_object.hash[:screens].is_a?(Hash)
-              return composite_object.hash[:screens].keys #Should be Hash with screen names as the keys
-            elsif composite_object.parent
-              return self.find_screens(composite_object.parent)
-            end
+            # Using the hash instead of the method because lower nodes will get validated
+            # before composite is finished building
+            return composite_object.hash[:screens].keys if composite_object.hash[:screens].is_a?(Hash)
+
+            return find_screens(composite_object.parent) if composite_object.parent
 
-            return []
+            []
+          end
+
+          def populate_errors(target_values, valid_screens, composite_object)
+            target_values.each do |screen|
+              screen = screen.to_sym
+              next if valid_screens.include?(screen)
+
+              error_message = "Invalid Screen: #{screen}, at: #{composite_object.location}[#{@key}]."
+              error_message += " Valid Screen(s): #{valid_screens}"
+              error_messages.push(error_message)
+            end
           end
         end
       end
     end
   end
-end
+end

data/lib/automation_object/blue_print/hash_adapter/helpers/validators/validate_view_presence_of.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
 require_relative 'validate'
 
 module AutomationObject
   module BluePrint
     module HashAdapter
       module Validators
-        #Validator that tests that a view is defined when it is called elsewhere through a hook
+        # Validator that tests that a view is defined when it is called elsewhere through a hook
         class ValidateViewPresenceOf < Validate
           # @param args [Hash] arguments for the validation class
           def initialize(args)
@@ -15,38 +16,41 @@ module AutomationObject
           # @param composite_object [Object] Composite object to be tested.
           # @return [nil] no return on exceptions on failure
           def validate(composite_object)
-            #Get the hash value from the composite object
+            # Get the hash value from the composite object
             target_value = composite_object.hash[@key]
-            target_values = (target_value.is_a?(Array)) ? target_value : [target_value]
+            target_values = target_value.is_a?(Array) ? target_value : [target_value]
 
             return unless target_value
 
-            valid_views = self.find_views(composite_object)
+            valid_views = find_views(composite_object)
+            populate_errors(target_values, valid_views, composite_object)
+          end
+
+          private
+
+          # Need to traverse up the composite tree and find views
+          def find_views(composite_object)
+            # Using the hash instead of the method because lower nodes will get validated
+            # before composite is finished building
+            return composite_object.hash[:views].keys if composite_object.hash[:views].is_a?(Hash)
+
+            return find_views(composite_object.parent) if composite_object.parent
 
-            target_values.each { |view|
+            []
+          end
+
+          def populate_errors(target_values, valid_views, composite_object)
+            target_values.each do |view|
               view = view.to_sym
               next if valid_views.include?(view)
 
               error_message = "Invalid View: #{view}, at: #{composite_object.location}[#{@key}]."
-              error_message << " Valid Views(s): #{valid_views}"
-              self.error_messages.push(error_message)
-            }
-          end
-
-          #Need to traverse up the composite tree and find views
-          def find_views(composite_object)
-            #Using the hash instead of the method because lower nodes will get validated
-            #before composite is finished building
-            if composite_object.hash[:views].is_a?(Hash)
-              return composite_object.hash[:views].keys #Should be Hash with view names as the keys
-            elsif composite_object.parent
-              return self.find_views(composite_object.parent)
+              error_message += " Valid Views(s): #{valid_views}"
+              error_messages.push(error_message)
             end
-
-            return []
           end
         end
       end
     end
   end
-end
+end