automation_object 0.0.4 → 0.5.0

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

@@ -0,0 +1,39 @@
+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
+        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)]
+          end
+
+          # Validates the composite object and throws errors on failure
+          # @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
+            target_value = composite_object.hash[@key]
+
+            #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)
+            }
+
+            error_message = "Invalid Type: #{target_value.class}, at: #{composite_object.location}[#{@key}]."
+            error_message << " Allowed Type(s): #{@should_be_instances_of}"
+
+            self.error_messages.push(error_message)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+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
+        class ValidateModalPresenceOf < Validate
+          # @param args [Hash] arguments for the validation class
+          def initialize(args)
+            @key = args.fetch :key
+          end
+
+          # Validates the composite object and throws errors on failure
+          # @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
+            target_value = composite_object.hash[@key]
+            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)
+            }
+          end
+
+          #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
+
+            return []
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require_relative 'validate'
+
+module AutomationObject
+  module BluePrint
+    module HashAdapter
+      module Validators
+        #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 : {}
+            @unless_presence_of = options.fetch :unless_presence_of, nil
+          end
+
+          # Validates the composite object and throws errors on failure
+          # @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)
+
+            #Do unless_presence_of check
+            if @unless_presence_of
+              return if composite_object.hash.has_key?(@unless_presence_of)
+            end
+
+            self.error_messages.push("Required Key Missing: #{@key}, at: #{composite_object.location}.")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+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
+        class ValidateScreenPresenceOf < Validate
+          # @param args [Hash] arguments for the validation class
+          def initialize(args)
+            @key = args.fetch :key
+          end
+
+          # Validates the composite object and throws errors on failure
+          # @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
+            target_value = composite_object.hash[@key]
+
+            return unless 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)
+            }
+          end
+
+          #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
+
+            return []
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+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
+        class ValidateViewPresenceOf < Validate
+          # @param args [Hash] arguments for the validation class
+          def initialize(args)
+            @key = args.fetch :key
+          end
+
+          # Validates the composite object and throws errors on failure
+          # @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
+            target_value = composite_object.hash[@key]
+            target_values = (target_value.is_a?(Array)) ? target_value : [target_value]
+
+            return unless target_value
+
+            valid_views = self.find_views(composite_object)
+
+            target_values.each { |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)
+            end
+
+            return []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/blue_print/hash_adapter/hook.rb

@@ -0,0 +1,35 @@
+#Require parent class
+require_relative 'composite'
+
+require_relative 'hook_action'
+require_relative 'hook_element_requirements'
+
+module AutomationObject
+  module BluePrint
+    module HashAdapter
+      #Hook composite
+      class Hook < Composite
+        #Call the live? method so that it creates the needed Array of ElementRequirement interfaces
+        before_create :live?
+
+        #Relationships
+        has_one :before, interface: HookAction
+        has_one :after, interface: HookAction
+
+        #Validations
+        validates_keys allowed_keys: [:before, :live?, :after]
+
+        # @return [Array<HookElementRequirements>] array of element requirements
+        def live?
+          return @live if @live
+
+          children = self.hash[:live?]
+          children = (children.is_a?(Array)) ? children : Array.new
+
+          @live = self.create_array_children(:live, children, {interface: HookElementRequirements, location: self.location + '[live?]'})
+          return @live
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/blue_print/hash_adapter/hook_action.rb

@@ -0,0 +1,134 @@
+#Require parent class
+require_relative 'composite'
+require_relative 'hook_element_requirements'
+
+module AutomationObject
+  module BluePrint
+    module HashAdapter
+      #Hook action composite
+      class HookAction < Composite
+        #Call the wait_for_elements method to generate the children
+        before_create :wait_for_elements
+
+        #Validations
+        validates_keys allowed_keys: [:new_screen, :show_modal, :close_screen, :change_screen,
+                                      :sleep, :wait_for_elements, :change_to_previous_screen, :close_modal, :reset_screen,
+                                      :possible_screen_changes]
+
+        validates :change_screen, instance_of: [String, Symbol], screen_presence_of: true
+        validates :new_screen, instance_of: [String, Symbol], screen_presence_of: true
+        validates :change_to_previous_screen, instance_of: TrueClass
+        validates :close_modal, instance_of: TrueClass
+        validates :close_screen, instance_of: TrueClass
+        validates :possible_screen_changes, instance_of: String, screen_presence_of: true
+        validates :reset_screen, instance_of: TrueClass
+        validates :show_modal, instance_of: String, modal_presence_of: true
+        validates :sleep, instance_of: Numeric
+        validates :wait_for_elements, instance_of: Array
+
+        #Get the order to run the hook in
+        # @return [Array<Symbol>] list of hook methods to run in given order
+        def hook_order
+          return self.hash.keys
+        end
+
+        #Get length of hook actions
+        # @return [Integer] length of hook actions
+        def length
+          return self.hash.keys.length
+        end
+
+        #See if hook actions are empty
+        # @return [Boolean] if hook actions are empty
+        def empty?
+          return !(self.hash.keys.length > 0)
+        end
+
+        # @return [Symbol, nil] screen to change to
+        def change_screen
+          change_screen = self.hash[:change_screen]
+
+          case change_screen
+            when Symbol, String
+              return change_screen.to_sym
+            else
+              return nil
+          end
+        end
+
+        # @return [Symbol, nil] new screen
+        def new_screen
+          new_screen = self.hash[:new_screen]
+
+          case new_screen
+            when Symbol, String
+              return new_screen.to_sym
+            else
+              return nil
+          end
+        end
+
+        # @return [Boolean]
+        def close_screen
+          return self.hash[:close_screen] ||= false
+        end
+
+        # @return [Boolean]
+        def close_modal
+          return self.hash[:close_modal] ||= false
+        end
+
+        # @return [Boolean]
+        def change_to_previous_screen
+          return self.hash[:change_to_previous_screen] ||= false
+        end
+
+        # @return [Symbol, nil]
+        def show_modal
+          show_modal = self.hash[:show_modal]
+
+          case show_modal
+            when Symbol, String
+              return show_modal.to_sym
+            else
+              return nil
+          end
+        end
+
+        # @return [Array]
+        def possible_screen_changes
+          if self.hash[:possible_screen_changes].is_a?(Array)
+            return self.hash[:possible_screen_changes].map { |value| value.to_sym }
+          else
+            return Array.new
+          end
+        end
+
+        #@return [Boolean] reset the screen?
+        def reset_screen
+          return self.hash[:reset_screen] ||= false
+        end
+
+        #@return [Numeric] amount of time to sleep
+        def sleep
+          return self.hash[:sleep] ||= 0
+        end
+
+        #Custom method for array of children instead of Hash
+        # @return [Array<HookElementRequirements>] array of wait for element children
+        def wait_for_elements
+          return @wait_for_elements if @wait_for_elements
+          wait_for_elements = self.hash[:wait_for_elements]
+
+          children = (wait_for_elements.is_a?(Array)) ? wait_for_elements : Array.new
+          @wait_for_elements = self.create_array_children(:wait_for_elements, children,
+                                                          {interface: HookElementRequirements,
+                                                           location: self.location + '[wait_for_elements]'
+                                                          })
+
+          return @wait_for_elements
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/blue_print/hash_adapter/hook_element_requirements.rb

@@ -0,0 +1,64 @@
+#Require parent class
+require_relative 'composite'
+
+module AutomationObject
+  module BluePrint
+    module HashAdapter
+      #Hook Element Requirements-level composite
+      class HookElementRequirements < Composite
+        #Valdiations
+        validates :element_name, presence_of: true, instance_of: [String, Symbol], element_presence_of: true
+        validates :exists?, presence_of: true, instance_of: [FalseClass, TrueClass]
+
+        #Get the order to run the hook in
+        # @return [Array<Symbol>] list of hook methods to run in given order
+        def hook_order
+          hook_order = [:exists?] #Always put exists? first
+
+          self.hash.keys.each { |hook_name|
+            hook_order.push(hook_name) unless [:element_name, :exists?].include?(hook_name)
+          }
+
+          return hook_order
+        end
+
+        #Get element requirement
+        # @param name [Symbol] name of requested requirement
+        def requirement(name)
+          return self.hash[name] ||= nil
+        end
+
+        #Get name of the element
+        # @return [Symbol] name of element
+        def element_name
+          element_name = self.hash[:element_name]
+
+          case element_name
+            when Symbol, String
+              return element_name.to_sym
+            else
+              return nil
+          end
+        end
+
+        #Convience for getting element blueprints
+        # @return [AutomationObject::BluePrint::HashAdapter::Element]
+        def element_blueprints(composite_object = nil)
+          unless composite_object
+            composite_object = self
+          end
+
+          #Traverse!
+          if composite_object.hash[:elements].is_a?(Hash)
+
+            return composite_object.elements[self.element_name]
+          elsif composite_object.parent
+            return self.element_blueprints(composite_object.parent)
+          end
+
+          return nil
+        end
+      end
+    end
+  end
+end