automation_object 0.6.0 → 0.7.5

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

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-require_relative 'hook'
-
-module AutomationObject
-  module State
-    module Composite
-      # Helper module for Element composite classes
-      module CommonElement
-        attr_accessor :cache
-
-        def reset
-          self.cache = nil
-        end
-
-        def method_hook?(name)
-          blue_prints.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
-
-          @method_hooks = {}
-          blue_prints.method_hooks.each do |key, blue_prints|
-            @method_hooks[key] = Hook.new(session,
-                                          driver,
-                                          blue_prints,
-                                          key,
-                                          self,
-                                          location + "[#{key}]")
-          end
-
-          @method_hooks
-        end
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-# 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
-          return cache if cache
-
-          element = driver.find_element(*blue_prints.selector_params)
-          self.cache = ElementProxy.new(self, element)
-        end
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-# 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
-          return cache if cache
-
-          elements = driver.find_elements(*blue_prints.selector_params)
-
-          self.cache = elements.map do |element|
-            ElementProxy.new(self, element)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-# 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
-          return cache if cache
-
-          elements = driver.find_elements(*blue_prints.selector_params)
-          self.cache = {}
-
-          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
-
-            cache[hash_key] = wrapped_element
-          end
-
-          cache
-        end
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-# 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

data/lib/automation_object/state/composite/helpers/window.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-require_relative '../../error'
-
-module AutomationObject
-  module State
-    module Composite
-      # Window class
-      class Window
-        # @param window_manager [AutomationObject::State::Composite::WindowManager]
-        # @param driver [AutomationObject::Driver::Driver]
-        # @param handle [String]
-        # @param screen [Symbol]
-        def initialize(window_manager, driver, handle, screen)
-          @window_manager = window_manager
-          @driver = driver
-          @handle = handle
-
-          # Use to control history
-          @position = 0
-          @history = [screen]
-        end
-
-        # @return [Symbol,nil] previous screen name
-        def previous
-          return nil if @position < 1
-          @history[@position - 1]
-        end
-
-        # @param name [Symbol] screen name
-        # @return [void]
-        def update(name)
-          # Reset current screen
-          @window_manager.screens[self.name].reset
-
-          @position += 1
-          @history << name
-        end
-
-        # @return [Symbol] current screen
-        def name
-          @history[@position]
-        end
-
-        # @return [void]
-        def use
-          return if @driver.window_handle == @handle
-          @driver.window_handle = @handle
-        end
-
-        # @return [void]
-        def back
-          raise CannotNavigateBack if @position.zero?
-
-          @driver.back
-          @position -= 1
-        end
-
-        # @return [void]
-        def forward
-          raise CannotNavigateForward if @position >= @history.length
-
-          @driver.forward
-          @position += 1
-        end
-
-        # @return [Boolean]
-        def closed?
-          !@driver.window_handles.include?(window_handle)
-        end
-
-        # Close the window
-        # @return [void]
-        def close
-          @driver.close
-        end
-      end
-    end
-  end
-end

data/lib/automation_object/state/composite/helpers/window_manager.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-require_relative 'window'
-require_relative '../../error'
-
-module AutomationObject
-  module State
-    module Composite
-      # Collection to manage Window objects
-      module WindowManager
-        # @param name [Symbol] name of window to use
-        # @return [void]
-        def use(name)
-          raise AutomationObject::State::ScreenNotActiveError, name unless live_screens.include?(name)
-
-          windows.each do |window|
-            next if window.name != name
-            return if window == self.window
-
-            @window = window
-            @window.use
-          end
-        end
-
-        # @return [AutomationObject::State::Composite::Window]
-        def window
-          raise AutomationObject::State::Error::NoActiveWindows unless @window
-          @window
-        end
-
-        # @return [Array<Window>]
-        def windows
-          @windows ||= []
-        end
-
-        # @return [Array<String>] list of stored window handles
-        def window_handles
-          windows.map(&:handle)
-        end
-
-        # @return [Array<String>] list of stored screen names
-        def live_screens
-          windows.map(&:name)
-        end
-
-        # @return [void]
-        def new_window(name)
-          driver_handles = driver.window_handles
-          diff_handles = driver_handles - window_handles
-
-          # Should only have one extra window
-          raise UnexpectedExtraWindowError if diff_handles.length > 1
-
-          @window = Window.new(self, driver, diff_handles.first, name)
-          windows << @window
-        end
-      end
-    end
-  end
-end

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

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-require_relative '_base'
-
-require_relative 'hook_action'
-require_relative 'hook_actions/element_requirement'
-
-module AutomationObject
-  module State
-    module Composite
-      # Hook composite for managing state
-      class Hook < Base
-        # @return [Boolean, nil] return nil if no live? check, otherwise boolean
-        def live?
-          before
-
-          return nil if blue_prints.live?.empty?
-
-          blue_prints.live?.each do |element_requirement_blueprints|
-            hook_element_requirement = ElementRequirement.new(self, driver, element_requirement_blueprints, 1)
-            return false unless hook_element_requirement.run
-          end
-
-          after
-
-          true
-        end
-
-        # Runs the before hook
-        # @return [Boolean, nil] return nil unless there is a hook, otherwise boolean depending on success of hook
-        def before
-          return nil if blue_prints.before.empty?
-
-          hook_action = HookAction.new(session,
-                                       driver,
-                                       blue_prints.before,
-                                       :hook_action, self, location + '[hook_action]')
-
-          hook_action.run
-        end
-
-        # Runs the after hook
-        # @return [Boolean, nil] return nil unless there is a hook, otherwise boolean depending on success of hook
-        def after
-          return nil if blue_prints.after.empty?
-
-          hook_action = HookAction.new(session,
-                                       driver,
-                                       blue_prints.after,
-                                       :hook_action, self, location + '[hook_action]')
-          hook_action.run
-        end
-      end
-    end
-  end
-end

data/lib/automation_object/state/composite/hook_actions/action_loop.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-module AutomationObject
-  module State
-    module Composite
-      # Composite action loop base class
-      class ActionLoop
-        # @return [AutomationObject::State::Composite::Base]
-        attr_accessor :composite
-        # @return [AutomationObject::Driver::Driver]
-        attr_accessor :driver
-        # @return [AutomationObject::BluePrint::Composite::Base]
-        attr_accessor :blue_prints
-        # @return [Integer]
-        attr_accessor :loops
-
-        # @param composite [AutomationObject::State::Composite::Base]
-        # @param driver [AutomationObject::Driver::Driver]
-        # @param blue_prints [AutomationObject::BluePrint::Composite::Base]
-        # @param loops [Integer]
-        def initialize(composite, driver, blue_prints, loops = 30)
-          self.composite = composite
-          self.driver = driver
-          self.blue_prints = blue_prints
-          self.loops = loops
-        end
-
-        # @return [Boolean] run success or not
-        def run
-          loops.times do
-            # Sub classes implement single run
-            return true if single_run
-          end
-
-          false
-        end
-
-        # Abstract method, override
-        # @return [Boolean] success or not
-        def single_run
-          raise NotImplementedError
-        end
-      end
-    end
-  end
-end

data/lib/automation_object/state/composite/hook_actions/change_screen.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-require_relative 'action_loop'
-
-module AutomationObject
-  module State
-    module Composite
-      # Change screen hook loop
-      class ChangeScreen < ActionLoop
-        def single_run
-          return false unless driver.document_complete?
-
-          new_screen = composite.top.screens[blue_prints]
-          if new_screen.load.live? != false # Need strict
-            composite.top.window.update(blue_prints)
-            return true
-          else
-            return false
-          end
-        end
-      end
-    end
-  end
-end

data/lib/automation_object/state/composite/hook_actions/change_to_previous_screen.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-require_relative 'action_loop'
-
-module AutomationObject
-  module State
-    module Composite
-      # Change to previous screen hook loop
-      class ChangeToPreviousScreen < ActionLoop
-        def single_run
-          return false unless driver.document_complete?
-
-          new_screen = composite.top.window.previous
-          if new_screen.load.live? != false
-            composite.top.window.update(new_screen)
-            return true
-          else
-            return false
-          end
-        end
-      end
-    end
-  end
-end