automation_object 0.5.0 → 0.5.1

data/lib/automation_object/{proxies → proxy}/mutex_proxy.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
 require_relative 'proxy'
 
 module AutomationObject
-  module Proxies
-    #Proxy class for protecting object with Mutex
+  module Proxy
+    # Proxy class for protecting object with Mutex
     class MutexProxy < Proxy
       def initialize(subject)
         super
@@ -12,52 +13,48 @@ module AutomationObject
       end
 
       def add_mutex(mutex_object)
-        unless mutex_object.is_a?(Mutex)
-          raise ArgumentError, 'Expecting mutex_object argument to be a Mutex object'
-        end
+        raise ArgumentError, 'Expecting mutex_object argument to be a Mutex object' unless mutex_object.is_a?(Mutex)
 
         @mutexes << mutex_object
       end
 
       def delete_mutex(mutex_object)
-        unless mutex_object.is_a?(Mutex)
-          raise ArgumentError, 'Expecting mutex_object argument to be a Mutex object'
-        end
+        raise ArgumentError, 'Expecting mutex_object argument to be a Mutex object' unless mutex_object.is_a?(Mutex)
 
         @mutexes.delete(mutex_object)
       end
 
       def method_missing(method_symbol, *args, &block)
-        exec_procedures = Array.new
-        exec_procedures.push(lambda {
+        exec_procedures = []
+        exec_procedures.push(lambda do
           execution_return = @subject.send(method_symbol, *args, &block)
-          return self.protect_object(execution_return)
-        })
+          return protect_object(execution_return)
+        end)
 
         index = 0
-        @mutexes.each { |mutex|
+        @mutexes.each do |mutex|
           index += 1
-          exec_procedures.push(lambda {
+          exec_procedures.push(lambda do
             mutex.synchronize do
               index -= 1
               exec_procedures[index].call
             end
-          })
-        }
+          end)
+        end
 
-        return exec_procedures.last.call
+        exec_procedures.last.call
       end
 
       def protect_object(object)
         return object if @skip_protection_classes.include?(object.class)
         protected_object = MutexProxy.new(object)
 
-        @mutexes.each { |mutex|
+        @mutexes.each do |mutex|
           protected_object.add_mutex(mutex)
-        }
+        end
 
-        return protected_object
+        protected_object
       end
     end
   end
-end
+end

data/lib/automation_object/proxy/proxy.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+module AutomationObject
+  module Proxy
+    # CompositeBase Proxy class for getting between another
+    class Proxy
+      instance_methods.each do |instance_method|
+        undef_method instance_method unless instance_method =~ /(^__|^send$|^object_id)/
+      end
+
+      # @param [Object] subject
+      def initialize(subject)
+        @subject = subject
+      end
+
+      # @param [Symbol] method
+      # @param [Array, nil] args
+      # @param [Proc] block
+      def method_missing(method, *args, &block)
+        @subject.send(method, *args, &block)
+      end
+    end
+  end
+end

data/lib/automation_object/proxy/throttle_proxy.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+require_relative 'proxy'
+
+module AutomationObject
+  module Proxy
+    # Proxy class to throttle methods on the subject
+    class ThrottleProxy < Proxy
+      def initialize(subject)
+        super
+      end
+
+      def throttle_methods
+        @throttle_methods ||= {}
+      end
+
+      def method_missing(method_symbol, *args, &block)
+        start_time = Time.new.to_f
+        execution_return = @subject.send(method_symbol, *args, &block)
+        throttle_speed(method_symbol, start_time)
+        execution_return
+      end
+
+      def add_method_throttle(method_symbol, time)
+        raise ArgumentError, 'Expecting method_symbol argument to be a Symbol' unless method_symbol.is_a?(Symbol)
+
+        raise ArgumentError, 'Expecting time argument to be Numeric' unless time.is_a?(Numeric)
+
+        raise ArgumentError, "Expecting object to respond_to? #{method_symbol}" unless @subject.respond_to?(method_symbol)
+
+        throttle_methods[method_symbol] = time
+      end
+
+      # Delete throttle that exists
+      # @param method_symbol [Symbol] method symbol to remove throttle from
+      def delete_method_throttle(method_symbol)
+        throttle_methods.delete(method_symbol)
+      end
+
+      # Method to sleep the difference between actual and throttle time
+      # @param method_symbol [Symbol] method that is to be throttled
+      # @param start_time [Float] start time as float
+      # @return [nil]
+      def throttle_speed(method_symbol, start_time)
+        return unless throttle_methods.key?(method_symbol)
+        total_time_taken = Time.new.to_f - start_time
+
+        sleep_time = throttle_methods[method_symbol] - total_time_taken
+        sleep(sleep_time) if sleep_time.positive?
+      end
+    end
+  end
+end

data/lib/automation_object/state.rb

@@ -1,37 +1,19 @@
+# frozen_string_literal: true
 require_relative 'state/session'
 
 module AutomationObject
-  #State Port, following port/adapter pattern
-  #BluePrintAdapter adapts the state to the blueprint
+  # State Port, following port/adapter pattern
+  # Composite adapts the state to the blueprint
   module State
-    extend self
+    module_function
 
-    # @return [AutomationObject::State::BluePrintAdapter::Top]
-    def adapter
-      return @adapter if @adapter
-      self.adapter = :blue_print
-      @adapter
-    end
-
-    # Sets adapter const will append _adapter if needed
-    # @param adapter_name [String] name of adapter wanted for composite creation
-    def adapter=(adapter_name)
-      adapter_name = adapter_name.to_s
-      adapter_name << '_adapter' unless adapter_name.match(/_adapter$/)
-      adapter_const = adapter_name.pascalize
-
-      require_relative "state/#{adapter_name}"
-      @adapter = AutomationObject::State.const_get("#{adapter_const}")
-    end
-
-    # Creates/returns a new session, attaches driver, and composite adapter
-    # Will use a composite to direct the other layers (ie BluePrint)
-    # @param blue_prints [AutomationObject::BluePrint::Composite::Top] Top composite interface
+    # Creates/returns a new session, attaches driver, and composite
+    # Will use a composite to help control the state
     # @param driver [AutomationObject::Driver::Driver] driver interface
-    # @return [AutomationObject::State::Session] Session instance
-    def new(blue_prints, driver)
-      adapter_composite = self.adapter.build(blue_prints, driver)
-      return Session.new(driver: args.fetch(driver), composite: adapter_composite)
+    # @param blue_prints [AutomationObject::BluePrint::Composite::Top] Top composite interface
+    # # @return [AutomationObject::State::Session] Session instance
+    def create(driver, blue_prints)
+      Session.new(driver, blue_prints)
     end
   end
-end
+end

data/lib/automation_object/state/{blue_print_adapter/composite.rb → composite/_base.rb}

@@ -1,22 +1,30 @@
+# frozen_string_literal: true
 require_relative '../../helpers/composite'
-#require_relative 'top'
-#require_relative 'screen'
 
 module AutomationObject
   module State
-    module BluePrintAdapter
-      #Parent composite class
-      class Composite < AutomationObject::Composite
-        attr_accessor :blue_prints, :driver
+    module Composite
+      # Parent composite class
+      class Base < ::AutomationObject::Composite
+        # @return [AutomationObject::State::Session]
+        attr_accessor :session
 
-        # @param blue_prints [AutomationObject::BluePrint::Composite] blue print composite
+        # @return [AutomationObject::BluePrint::Composite::]
+        attr_accessor :blue_prints
+
+        # @return [AutomationObject::Driver::Driver]
+        attr_accessor :driver
+
+        # @param session [AutomationObject::State::Session] session
         # @param driver [AutomationObject::Driver] driver
+        # @param blue_prints [AutomationObject::BluePrint::Composite] blue print composite
         # @param name [Symbol] name of composite element
         # @param parent [Object, nil] parent composite object
         # @param location [String] string location for error/debugging purposes
-        def initialize(blue_prints, driver, name = :top, parent = nil, location = 'top')
-          self.blue_prints = blue_prints
+        def initialize(session, driver, blue_prints, name = :top, parent = nil, location = 'top')
+          self.session = session
           self.driver = driver
+          self.blue_prints = blue_prints
 
           super(name, parent, location)
         end
@@ -25,9 +33,12 @@ module AutomationObject
         # @param name [Symbol] name of child
         # @param args [Hash] args
         def get_child(name, args)
-          child_location = self.location + "[#{name}]"
+          child_location = location + "[#{name}]"
 
-          return args.fetch(:interface).new(self.blue_prints.send(name), self.driver, name, self, child_location)
+          args.fetch(:interface).new(session,
+                                     driver,
+                                     blue_prints.send(name),
+                                     name, self, child_location)
         end
 
         # Overriding base get_children method
@@ -35,31 +46,30 @@ module AutomationObject
         # @param args [Hash] args
         # @return children [Array<Composite>] return children and names
         def get_children(name, args)
-          children_hash = Hash.new
+          children_hash = {}
 
-          self.blue_prints.send(name).each { |child_key, child_blue_prints|
-            child_location = self.location + "[#{child_key}]"
+          blue_prints.send(name).each do |child_key, child_blue_prints|
+            child_location = location + "[#{child_key}]"
 
-            children_hash[child_key] = args.fetch(:interface).new(child_blue_prints,
-                                                                  self.driver,
-                                                                  name,
-                                                                  self,
-                                                                  child_location)
-          }
+            children_hash[child_key] = args.fetch(:interface).new(session,
+                                                                  driver,
+                                                                  child_blue_prints,
+                                                                  name, self, child_location)
+          end
 
-          return children_hash
+          children_hash
         end
 
         # Recursive function to reach parent screen
         # Can return nil if above a screen!
         # @return [AutomationObject::State::BluePrintAdapter::Screen,nil]
         def screen
-          return nil if self.is_a?(Top)
+          return nil if is_a?(Top)
 
-          #Should recursively call top until parent is nil
-          return (self.is_a?(Screen)) ? self : self.parent.screen
+          # Should recursively call top until parent is nil
+          is_a?(Screen) ? self : parent.screen
         end
       end
     end
   end
-end
+end

data/lib/automation_object/state/{blue_print_adapter/helpers/element_helper.rb → composite/_common_element.rb}

@@ -1,12 +1,13 @@
-require_relative '../hook'
+# frozen_string_literal: true
+require_relative 'hook'
 
 module AutomationObject
   module State
-    #Helper module for Element composite classes
-    module BluePrintAdapter
-      module ElementHelper
+    module Composite
+      # Helper module for Element composite classes
+      module CommonElement
         def method_hook?(name)
-          return self.blue_prints.method_hooks.has_key?(name)
+          blue_prints.method_hooks.key?(name)
         end
 
         # @return [Hash<Hook>] array of Hook that are defined under the element
@@ -14,18 +15,17 @@ module AutomationObject
           return @method_hooks if @method_hooks
 
           @method_hooks = {}
-          self.blue_prints.method_hooks.each { |key, blue_prints|
+          blue_prints.method_hooks.each do |key, blue_prints|
             @method_hooks[key] = Hook.new(blue_prints,
-                                          self.driver,
+                                          driver,
                                           key,
                                           self,
-                                          self.location + "[#{key}]")
-          }
+                                          location + "[#{key}]")
+          end
 
-          return @method_hooks
+          @method_hooks
         end
       end
     end
   end
 end
-

data/lib/automation_object/state/composite/element.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+require_relative '_base'
+require_relative '_common_element'
+
+require_relative 'element_proxy'
+
+module AutomationObject
+  module State
+    module Composite
+      # Element composite for managing state
+      class Element < Base
+        include CommonElement
+
+        # @return [AutomationObject::State::Composite::ElementProxy] Selenium proxy
+        def load
+          element = driver.find_element(*blue_prints.selector_params)
+          ElementProxy.new(self, element)
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/state/composite/element_array.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+require_relative '_base'
+require_relative '_common_element'
+
+require_relative 'element_proxy'
+
+module AutomationObject
+  module State
+    module Composite
+      # Element array composite for managing state
+      class ElementArray < Base
+        include CommonElement
+
+        # @return [Array<AutomationObject::State::Composite::ElementProxy>] Selenium proxy
+        def load
+          elements = driver.find_elements(*blue_prints.selector_params)
+
+          wrapped_elements = elements.map do |element|
+            ElementProxy.new(self, element)
+          end
+
+          wrapped_elements
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/state/composite/element_hash.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+require_relative '_base'
+require_relative '_common_element'
+
+require_relative 'element_proxy'
+
+module AutomationObject
+  module State
+    module Composite
+      # Element hash composite for managing state
+      class ElementHash < Base
+        include CommonElement
+
+        # @return [Hash<String, AutomationObject::State::Composite::ElementProxy>] Selenium proxy
+        def load
+          elements = driver.find_elements(*blue_prints.selector_params)
+          elements_hash = {}
+
+          elements.each do |element|
+            # Want to wrap element, before sending for method!
+            # That will help us include custom methods, etc...
+            wrapped_element = ElementProxy.new(self, element)
+            hash_key = wrapped_element.send(blue_prints.define_elements_by) # Send to wrapped state proxy
+
+            elements_hash[hash_key] = wrapped_element
+          end
+
+          elements_hash
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/state/composite/element_proxy.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+require_relative '../../proxy/proxy'
+
+module AutomationObject
+  module State
+    module Composite
+      # Proxy class to allow for usage of hooks
+      class ElementProxy < ::AutomationObject::Proxy::Proxy
+        def initialize(composite, element)
+          @composite = composite
+          @subject = element
+        end
+
+        # Overiding base method to run possible hooks
+        def method_missing(method_symbol, *args, &block)
+          # Run before hook if needed
+          @composite.method_hooks[method_symbol].before if @composite.method_hook?(method_symbol)
+
+          subject_return = @subject.send(method_symbol, *args, &block)
+
+          # Run after hook if needed
+          @composite.method_hooks[method_symbol].after if @composite.method_hook?(method_symbol)
+
+          subject_return
+        end
+
+        def respond_to_missing?(method, include_private = false)
+          @subject.respond_to_missing?(method, include_private)
+        end
+      end
+    end
+  end
+end