automation_object 0.5.0 → 0.5.1

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

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

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

@@ -1,16 +1,17 @@
-#Require parent class
+# frozen_string_literal: true
+# Require parent class
 require_relative 'composite'
 require_relative 'hook_element_requirements'
 
 module AutomationObject
   module BluePrint
     module HashAdapter
-      #Hook action composite
+      # Hook action composite
       class HookAction < Composite
-        #Call the wait_for_elements method to generate the children
+        # Call the wait_for_elements method to generate the children
         before_create :wait_for_elements
 
-        #Validations
+        # 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]
@@ -26,109 +27,106 @@ module AutomationObject
         validates :sleep, instance_of: Numeric
         validates :wait_for_elements, instance_of: Array
 
-        #Get the order to run the hook in
+        # 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
+          hash.keys
         end
 
-        #Get length of hook actions
+        # Get length of hook actions
         # @return [Integer] length of hook actions
         def length
-          return self.hash.keys.length
+          hash.keys.length
         end
 
-        #See if hook actions are empty
+        # See if hook actions are empty
         # @return [Boolean] if hook actions are empty
         def empty?
-          return !(self.hash.keys.length > 0)
+          hash.keys.empty?
         end
 
         # @return [Symbol, nil] screen to change to
         def change_screen
-          change_screen = self.hash[:change_screen]
+          change_screen = hash[:change_screen]
 
           case change_screen
-            when Symbol, String
-              return change_screen.to_sym
-            else
-              return nil
+          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]
+          new_screen = hash[:new_screen]
 
           case new_screen
-            when Symbol, String
-              return new_screen.to_sym
-            else
-              return nil
+          when Symbol, String
+            return new_screen.to_sym
+          else
+            return nil
           end
         end
 
         # @return [Boolean]
         def close_screen
-          return self.hash[:close_screen] ||= false
+          hash[:close_screen] ||= false
         end
 
         # @return [Boolean]
         def close_modal
-          return self.hash[:close_modal] ||= false
+          hash[:close_modal] ||= false
         end
 
         # @return [Boolean]
         def change_to_previous_screen
-          return self.hash[:change_to_previous_screen] ||= false
+          hash[:change_to_previous_screen] ||= false
         end
 
         # @return [Symbol, nil]
         def show_modal
-          show_modal = self.hash[:show_modal]
+          show_modal = hash[:show_modal]
 
           case show_modal
-            when Symbol, String
-              return show_modal.to_sym
-            else
-              return nil
+          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
+          return hash[:possible_screen_changes].map(&:to_sym) if hash[:possible_screen_changes].is_a?(Array)
+
+          []
         end
 
-        #@return [Boolean] reset the screen?
+        # @return [Boolean] reset the screen?
         def reset_screen
-          return self.hash[:reset_screen] ||= false
+          hash[:reset_screen] ||= false
         end
 
-        #@return [Numeric] amount of time to sleep
+        # @return [Numeric] amount of time to sleep
         def sleep
-          return self.hash[:sleep] ||= 0
+          hash[:sleep] ||= 0
         end
 
-        #Custom method for array of children instead of Hash
+        # 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]
+          return @wait_for_elements if defined? @wait_for_elements
+          wait_for_elements = 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]'
-                                                          })
+          children = wait_for_elements.is_a?(Array) ? wait_for_elements : []
+          @wait_for_elements = create_array_children(:wait_for_elements, children,
+                                                     interface: HookElementRequirements,
+                                                     location: location + '[wait_for_elements]')
 
-          return @wait_for_elements
+          @wait_for_elements
         end
       end
     end
   end
-end
+end

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

@@ -1,64 +1,60 @@
-#Require parent class
+# frozen_string_literal: true
+# Require parent class
 require_relative 'composite'
 
 module AutomationObject
   module BluePrint
     module HashAdapter
-      #Hook Element Requirements-level composite
+      # Hook Element Requirements-level composite
       class HookElementRequirements < Composite
-        #Valdiations
+        # 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
+        # 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
+          hook_order = [:exists?] # Always put exists? first
 
-          self.hash.keys.each { |hook_name|
+          hash.each_key do |hook_name|
             hook_order.push(hook_name) unless [:element_name, :exists?].include?(hook_name)
-          }
+          end
 
-          return hook_order
+          hook_order
         end
 
-        #Get element requirement
+        # Get element requirement
         # @param name [Symbol] name of requested requirement
         def requirement(name)
-          return self.hash[name] ||= nil
+          hash[name] ||= nil
         end
 
-        #Get name of the element
+        # Get name of the element
         # @return [Symbol] name of element
         def element_name
-          element_name = self.hash[:element_name]
+          element_name = hash[:element_name]
 
           case element_name
-            when Symbol, String
-              return element_name.to_sym
-            else
-              return nil
+          when Symbol, String
+            return element_name.to_sym
+          else
+            return nil
           end
         end
 
-        #Convience for getting element blueprints
+        # Convience for getting element blueprints
         # @return [AutomationObject::BluePrint::HashAdapter::Element]
         def element_blueprints(composite_object = nil)
-          unless composite_object
-            composite_object = self
-          end
+          composite_object = self unless composite_object
 
-          #Traverse!
-          if composite_object.hash[:elements].is_a?(Hash)
+          # Traverse!
+          return composite_object.elements[element_name] 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 element_blueprints(composite_object.parent) if composite_object.parent
 
-          return nil
+          nil
         end
       end
     end
   end
-end
+end

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

@@ -1,7 +1,8 @@
-#Require parent class
+# frozen_string_literal: true
+# Require parent class
 require_relative 'composite'
 
-#Require child classes
+# Require child classes
 require_relative 'element'
 require_relative 'element_array'
 require_relative 'element_hash'
@@ -10,16 +11,16 @@ require_relative 'hook'
 module AutomationObject
   module BluePrint
     module HashAdapter
-      #Modal-level composite, ActiveRecord style composite implementation inheriting from Composite
+      # Modal-level composite, ActiveRecord style composite implementation inheriting from Composite
       class Modal < Composite
-        #Relationships
+        # Relationships
         has_one :load, interface: Hook
 
         has_many :elements, interface: Element
         has_many :element_arrays, interface: ElementArray
         has_many :element_hashes, interface: ElementHash
 
-        #Validations
+        # Validations
         validates_keys allowed_keys: [:load, :elements, :element_arrays, :element_hashes]
 
         validates :load, instance_of: Hash
@@ -29,24 +30,24 @@ module AutomationObject
 
         # @return [Array<Symbol>] array of views this can has
         def included_views
-          included_views_array = self.hash[:included_views] ||= Array.new
-          included_views_array.map { |view| view.to_sym }
+          included_views_array = hash[:included_views] ||= []
+          included_views_array.map(&:to_sym)
         end
 
-        #Method to take views and merge into this composite
+        # Method to take views and merge into this composite
         def merge_views
-          top_hash = self.top.hash
+          top_hash = top.hash
 
           return unless top_hash.is_a?(Hash)
           return unless top_hash[:views].is_a?(Hash)
           top_view_hash = top_hash[:views]
 
-          self.included_views.each { |included_view|
+          included_views.each do |included_view|
             next unless top_view_hash[included_view].is_a?(Hash)
-            self.hash = self.hash.deep_merge(top_view_hash[included_view])
-          }
+            self.hash = hash.deep_merge(top_view_hash[included_view])
+          end
         end
       end
     end
   end
-end
+end

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

@@ -1,7 +1,8 @@
-#Require parent class
+# frozen_string_literal: true
+# Require parent class
 require_relative 'composite'
 
-#Require child classes
+# Require child classes
 require_relative 'automatic_onload_modal'
 require_relative 'element'
 require_relative 'element_array'
@@ -12,13 +13,13 @@ require_relative 'modal'
 module AutomationObject
   module BluePrint
     module HashAdapter
-      #Screen-level composite, ActiveRecord style composite implementation inheriting from Composite
+      # Screen-level composite, ActiveRecord style composite implementation inheriting from Composite
       class Screen < Composite
-        #Creation hooks
+        # Creation hooks
         before_create :merge_views
         before_create :automatic_onload_modals
 
-        #Relationships
+        # Relationships
         has_one :load, interface: Hook
         has_one :accept, interface: Hook
         has_one :dismiss, interface: Hook
@@ -28,7 +29,7 @@ module AutomationObject
         has_many :element_arrays, interface: ElementArray
         has_many :element_hashes, interface: ElementHash
 
-        #Validations
+        # Validations
         validates_keys allowed_keys: [:automatic_onload_modals, :automatic_screen_changes, :elements,
                                       :element_arrays, :element_hashes, :included_views, :load, :modals]
 
@@ -49,41 +50,41 @@ module AutomationObject
 
         # @return [Array<AutomaticOnloadModal>] array of AutomaticOnloadModal that are defined under the screen
         def automatic_onload_modals
-          return @automatic_onload_modals if @automatic_onload_modals
+          return @automatic_onload_modals if defined? @automatic_onload_modals
 
-          children = self.hash[:automatic_onload_modals]
-          children = (children.is_a?(Array)) ? children : Array.new
-          @automatic_onload_modals = self.create_array_children(:automatic_onload_modals, children,
-                                                                {interface: AutomaticOnloadModal,
-                                                                 location: self.location + '[automatic_onload_modals]'})
+          children = hash[:automatic_onload_modals]
+          children = children.is_a?(Array) ? children : []
+          @automatic_onload_modals = create_array_children(:automatic_onload_modals, children,
+                                                           interface: AutomaticOnloadModal,
+                                                           location: location + '[automatic_onload_modals]')
 
-          return @automatic_onload_modals
+          @automatic_onload_modals
         end
 
         # @return [Array<Symbol>] array of screens where screen can automatically change to
         def automatic_screen_changes
-          screen_array = self.hash[:automatic_screen_changes] ||= Array.new
-          screen_array.map { |screen| screen.to_sym }
+          screen_array = hash[:automatic_screen_changes] ||= []
+          screen_array.map(&:to_sym)
         end
 
         # @return [Array<Symbol>] array of views this can has
         def included_views
-          included_views_array = self.hash[:included_views] ||= Array.new
-          included_views_array.map { |view| view.to_sym }
+          included_views_array = hash[:included_views] ||= []
+          included_views_array.map(&:to_sym)
         end
 
-        #Method to take views and merge into this composite
+        # Method to take views and merge into this composite
         def merge_views
-          top_hash = self.top.hash
+          top_hash = top.hash
 
           return unless top_hash.is_a?(Hash)
           return unless top_hash[:views].is_a?(Hash)
           top_view_hash = top_hash[:views]
 
-          self.included_views.each { |included_view|
+          included_views.each do |included_view|
             next unless top_view_hash[included_view].is_a?(Hash)
-            self.hash = self.hash.deep_merge(top_view_hash[included_view])
-          }
+            self.hash = hash.deep_merge(top_view_hash[included_view])
+          end
         end
       end
     end