automation_object 0.5.0 → 0.5.1

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

@@ -1,30 +1,31 @@
-#Require parent class
+# frozen_string_literal: true
+# Require parent class
 require_relative 'composite'
 
 module AutomationObject
   module BluePrint
     module HashAdapter
-      #Custom method composite
+      # Custom method composite
       class CustomMethod < Composite
-        #Validations
+        # Validations
         validates :element_method, instance_of: [String, Symbol], presence_of: true
         validates :evaluate, instance_of: [String], presence_of: true
 
         def element_method
-          element_method = self.hash[:element_method]
+          element_method = hash[:element_method]
 
           case element_method
-            when Symbol, String
-              return element_method.to_sym
-            else
-              return nil
+          when Symbol, String
+            return element_method.to_sym
+          else
+            return nil
           end
         end
 
         def evaluate
-          return self.hash[:evaluate] ||= nil
+          hash[:evaluate] ||= nil
         end
       end
     end
   end
-end
+end

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

@@ -1,34 +1,35 @@
-#Require parent class
+# frozen_string_literal: true
+# Require parent class
 require_relative 'composite'
 
-#Require child classes
+# Require child classes
 require_relative 'hook'
 require_relative 'custom_method'
 
-#Require helpers
+# Require helpers
 require_relative 'helpers/element_helper'
 
 module AutomationObject
   module BluePrint
     module HashAdapter
-      #Element composite
+      # Element composite
       class Element < Composite
         include ElementHelper
 
         before_create :method_hooks
 
-        #Relationships
+        # Relationships
         has_one :load, interface: Hook
         has_many :custom_methods, interface: CustomMethod
 
-        #Validations
+        # Validations
         validates :load, instance_of: Hash
         validates :custom_methods, instance_of: Hash
 
         validates :in_iframe, instance_of: String, element_presence_of: true
-        validates :css, instance_of: String, presence_of: {:unless_presence_of => :xpath}
-        validates :xpath, instance_of: String, presence_of: {:unless_presence_of => :css}
+        validates :css, instance_of: String, presence_of: { unless_presence_of: :xpath }
+        validates :xpath, instance_of: String, presence_of: { unless_presence_of: :css }
       end
     end
   end
-end
+end

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

@@ -1,36 +1,37 @@
-#Require parent class
+# frozen_string_literal: true
+# Require parent class
 require_relative 'composite'
 
-#Require child classes
+# Require child classes
 require_relative 'hook'
 require_relative 'custom_method'
 
-#Require helpers
+# Require helpers
 require_relative 'helpers/element_helper'
 require_relative 'helpers/multiple_elements_helper'
 
 module AutomationObject
   module BluePrint
     module HashAdapter
-      #Element array composite
+      # Element array composite
       class ElementArray < Composite
         include ElementHelper
         include MultipleElementsHelper
 
         before_create :method_hooks
 
-        #Relationships
+        # Relationships
         has_one :load, interface: Hook
         has_many :custom_methods, interface: CustomMethod
 
-        #Validations
+        # Validations
         validates :load, instance_of: Hash
         validates :custom_range, instance_of: [Hash, String]
         validates :in_iframe, instance_of: String, element_presence_of: true
         validates :custom_methods, instance_of: Hash
-        validates :css, instance_of: String, presence_of: {:unless_presence_of => :xpath}
-        validates :xpath, instance_of: String, presence_of: {:unless_presence_of => :css}
+        validates :css, instance_of: String, presence_of: { unless_presence_of: :xpath }
+        validates :xpath, instance_of: String, presence_of: { unless_presence_of: :css }
       end
     end
   end
-end
+end

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

@@ -1,43 +1,44 @@
-#Require parent class
+# frozen_string_literal: true
+# Require parent class
 require_relative 'composite'
 
-#Require child classes
+# Require child classes
 require_relative 'hook'
 require_relative 'custom_method'
 
-#Require helpers
+# Require helpers
 require_relative 'helpers/element_helper'
 require_relative 'helpers/multiple_elements_helper'
 
 module AutomationObject
   module BluePrint
     module HashAdapter
-      #Element hash composite
+      # Element hash composite
       class ElementHash < Composite
         include ElementHelper
         include MultipleElementsHelper
 
         before_create :method_hooks
 
-        #Relationships
+        # Relationships
         has_one :load, interface: Hook
         has_many :custom_methods, interface: CustomMethod
 
-        #Validations
+        # Validations
         validates :load, instance_of: Hash
 
         validates :define_elements_by, instance_of: [String, Symbol], presence_of: true
         validates :custom_range, instance_of: [Hash, String]
         validates :in_iframe, instance_of: String, element_presence_of: true
         validates :custom_methods, instance_of: Hash
-        validates :css, instance_of: String, presence_of: {:unless_presence_of => :xpath}
-        validates :xpath, instance_of: String, presence_of: {:unless_presence_of => :css}
+        validates :css, instance_of: String, presence_of: { unless_presence_of: :xpath }
+        validates :xpath, instance_of: String, presence_of: { unless_presence_of: :css }
 
         # @return [Symbol] element method to define element keys by
         def define_elements_by
-          return self.hash[:define_elements_by].to_sym
+          hash[:define_elements_by].to_sym
         end
       end
     end
   end
-end
+end

data/lib/automation_object/blue_print/hash_adapter/helpers/element_helper.rb

@@ -1,59 +1,54 @@
+# frozen_string_literal: true
 module AutomationObject
   module BluePrint
     module HashAdapter
-      #Helper module for Element composite classes
+      # Helper module for Element composite classes
       module ElementHelper
         # @return [Array<Symbol, String>, nil] params as an array for driver find_element args
         def selector_params
-          case
-            when self.hash[:xpath].is_a?(String)
-              [:xpath, self.hash[:xpath]]
-            when self.hash[:css].is_a?(String)
-              [:css, self.hash[:css]]
-            else
-              nil
+          if hash[:xpath].is_a?(String)
+            [:xpath, hash[:xpath]]
+          elsif hash[:css].is_a?(String)
+            [:css, hash[:css]]
           end
         end
 
         # @return [Symbol, nil] element name of iframe element is in or nil if not
         def in_iframe
-          case self.hash[:in_iframe]
-            when Symbol, String
-              self.hash[:in_iframe].to_sym
-            else
-              nil
+          case hash[:in_iframe]
+          when Symbol, String
+            hash[:in_iframe].to_sym
           end
         end
 
         # @return [Boolean] whether or not element is in iframe
         def in_iframe?
-          (self.in_iframe) ? true : false
+          in_iframe ? true : false
         end
 
         def method_hook?(name)
-          return self.method_hooks.has_key?(name)
+          method_hooks.key?(name)
         end
 
         # @return [Hash<Hook>] array of Hook that are defined under the element
         def method_hooks
-          return @method_hooks if @method_hooks
+          return @method_hooks if defined? @method_hooks
 
           children = {}
-          self.hash.each { |key, value|
-            #Skip possible keys that elements can have
-            #Otherwise should be a method hook
+          hash.each do |key, value|
+            # Skip possible keys that elements can have
+            # Otherwise should be a method hook
             next if [:load, :custom_methods, :in_iframe, :css, :xpath, :define_elements_by, :custom_range].include?(key)
             children[key] = value
-          }
+          end
 
-          @method_hooks = self.create_hash_children(children,
-                                                    {interface: Hook,
-                                                     location: self.location + '[hook]'})
+          @method_hooks = create_hash_children(children,
+                                               interface: Hook,
+                                               location: location + '[hook]')
 
-          return @method_hooks
+          @method_hooks
         end
       end
     end
   end
 end
-

data/lib/automation_object/blue_print/hash_adapter/helpers/multiple_elements_helper.rb

@@ -1,35 +1,36 @@
+# frozen_string_literal: true
 module AutomationObject
   module BluePrint
     module HashAdapter
-      #Helper module for multiple element composite classes
+      # Helper module for multiple element composite classes
       module MultipleElementsHelper
         # @return [Range, nil] gives range for limiting multiple elements or nil
         def custom_range
-          custom_range = self.hash[:custom_range]
+          custom_range = hash[:custom_range]
 
           case custom_range
-            when String
-              integer_array = custom_range.split('..').map { |number| Integer(number) }
-              return integer_array[0]..integer_array[1]
-            when Hash
-              return custom_range[:start].to_i..custom_range[:end].to_i
+          when String
+            integer_array = custom_range.split('..').map { |number| Integer(number) }
+            return integer_array[0]..integer_array[1]
+          when Hash
+            return custom_range[:start].to_i..custom_range[:end].to_i
           end
 
-          return nil
+          nil
         end
 
         # @return [Symbol, nil] gives element method to remove duplicates on or nil
         def remove_duplicates
-          remove_duplicates = self.hash[:remove_duplicates]
+          remove_duplicates = hash[:remove_duplicates]
 
           case remove_duplicates
-            when Symbol, String
-              return remove_duplicates.to_sym
-            else
-              return nil
+          when Symbol, String
+            return remove_duplicates.to_sym
+          else
+            return nil
           end
         end
       end
     end
   end
-end
+end

data/lib/automation_object/blue_print/hash_adapter/helpers/validation_error.rb

@@ -1,26 +1,27 @@
+# frozen_string_literal: true
 module AutomationObject
   module BluePrint
     module HashAdapter
-      #ValidatorError exception class
-      #Allows for multiple errors at one time to allow for better debugging
-      class ValidationError < Exception
+      # ValidatorError exception class
+      # Allows for multiple errors at one time to allow for better debugging
+      class ValidationError < RuntimeError
         attr_accessor :errors
 
         # @param errors [Array, String] pass validation error(s) in, class can handle singular or multiple
         def initialize(errors)
-          @errors = (errors.is_a?(Array)) ? errors : [errors]
+          @errors = errors.is_a?(Array) ? errors : [errors]
         end
 
         # @return [String] returns full error message
         def message
           message = "\nBluePrint::HashAdapter composite validation failed for the following errors:\n"
-          @errors.each { |error|
+          @errors.each do |error|
             message << "     - #{error}\n"
-          }
+          end
 
-          return message + "\n"
+          message + "\n"
         end
       end
     end
   end
-end
+end

data/lib/automation_object/blue_print/hash_adapter/helpers/validation_helper.rb

@@ -1,4 +1,5 @@
-#Require all the validators
+# frozen_string_literal: true
+# Require all the validators
 require_relative 'validators/validate_instance_of'
 require_relative 'validators/validate_allowed_keys'
 require_relative 'validators/validate_screen_presence_of'
@@ -12,14 +13,16 @@ require_relative '../../../helpers/string'
 module AutomationObject
   module BluePrint
     module HashAdapter
-      #Validation helper for the composite structure, will allow Rails style validations on the composite
+      # Validation helper for the composite structure, will allow Rails style validations on the composite
       module ValidationHelper
         attr_accessor :errors
 
+        # Remove getter to solve stupid Ruby warning
+        undef :errors if method_defined? :errors
         # Give errors a default empty Array
         # @return [Array<String>] errors messages
         def errors
-          @errors ||= Array.new
+          @errors ||= []
         end
 
         # Give errors a default empty Array
@@ -33,27 +36,25 @@ module AutomationObject
         def valid?
           return true if self.class.skip_validations
 
-         # ap self.class
-          #ap self.class.name
+          # ap self.class
+          # ap self.class.name
           self.class.validations.collect do |validation|
-           # ap validation.class.name
+            # ap validation.class.name
           end
 
           self.class.validations.collect do |validation|
             validation.validate(self)
-            unless validation.valid?
-              self.add_errors(validation.error_messages)
-            end
+            add_errors(validation.error_messages) unless validation.valid?
           end
 
-          return self.errors.empty?
+          self.errors.empty?
         end
 
         def self.included(base)
           base.extend(ClassMethods)
         end
 
-        #Class level methods
+        # Class level methods
         module ClassMethods
           def skip_validations=(boolean)
             @skip_validations = boolean
@@ -67,33 +68,27 @@ module AutomationObject
           # @param args [Hash] arguments for validation
           # @return [nil]
           def validates(key, args = {})
-            # ap self
-            # ap self.class.name
-            # ap key
-            # ap args
-
-
-            args.each { |validator_name, validation_args|
+            args.each do |validator_name, validation_args|
               validator_name = 'Validate' + validator_name.to_s.pascalize
               validator = Validators.const_get(validator_name)
 
-              self.validations.push(validator.new({:key => key, :args => validation_args}))
-            }
+              validations.push(validator.new(key: key, args: validation_args))
+            end
           end
 
           # @param args [Hash] arguments for validation
           # @return [nil]
           def validates_keys(args = {})
-            self.validations.push(Validators::ValidateAllowedKeys.new(args))
+            validations.push(Validators::ValidateAllowedKeys.new(args))
           end
 
           # @return [Array] list of Validators, default to empty list
           def validations
-            @validations = [] unless @validations
-            return @validations
+            @validations = [] unless defined? @validations
+            @validations
           end
         end
       end
     end
   end
-end
+end