automation_object 0.5.0 → 0.5.1

data/lib/automation_object/driver/selenium_adapter/element.rb

@@ -1,80 +1,17 @@
-require_relative '../helpers/selenium_element_helper'
+# frozen_string_literal: true
+require_relative '../common_selenium/element'
 
 module AutomationObject
   module Driver
     module SeleniumAdapter
-      #Element proxy for Selenium
-      #Conform Selenium element interface to what's expected of the Driver Port
-      class Element < AutomationObject::Proxies::Proxy
-        include AutomationObject::Driver::SeleniumElementHelper
+      # Element proxy for Selenium
+      # Conform Selenium element interface to what's expected of the Driver Port
+      class Element < AutomationObject::Proxy::Proxy
+        include AutomationObject::Driver::CommonSelenium::Element
 
-        def initialize(args)
-          @driver = args.fetch :driver
-          @subject = args.fetch :element
-        end
-
-        # Set or Get attribute
-        # @param key [String] key of element
-        # @param value [String, nil] set value or leave blank
-        # @return [String, nil]
-        def attribute(key, value = nil)
-          @subject.attribute(key, value)
-        end
-
-        # @return [String] id of element
-        def id
-          @subject.id
-        end
-
-        # @return [String] href of element
-        def href
-          @subject.attribute('href')
-        end
-
-        # Text of element
-        # @return [String, nil]
-        def text
-          @subject.text
-        end
-
-        # Type into an element
-        # @return [void]
-        def send_keys(string)
-          @subject.send_keys(string)
-        end
-
-        # Clear the element field
-        # @return [void]
-        def clear
-          @subject.clear
-        end
-
-        # @return [Boolean]
-        def visible?
-          @subject.displayed?
-        end
-
-        # @return [Boolean]
-        def invisible?
-          !@subject.displayed?
-        end
-
-        # Get the location
-        # @return [Point]
-        def location
-          @subject.location
-        end
-
-        # Get the size of an element
-        # @return [Dimension]
-        def size
-          @subject.size
-        end
-
-        # Perform a submit action on an element
-        # @return [void]
-        def submit
-          @subject.submit
+        def initialize(driver, element)
+          @driver = driver
+          @subject = element
         end
 
         # Scroll the element into view
@@ -82,35 +19,28 @@ module AutomationObject
         def scroll_into_view
           @subject.location_once_scrolled_into_view
 
-          element_location = self.location
+          element_location = location
           scroll_position = @driver.scroll_position
 
-          middle_y_bounds = scroll_position[:y] + @driver.inner_window_height/2
+          middle_y_bounds = scroll_position[:y] + @driver.inner_window_height / 2
 
           if middle_y_bounds > element_location.y
-            #Add
+            # Add
             y_difference = middle_y_bounds - element_location.y
             scroll_y_position = scroll_position[:y] - y_difference
           else
-            #Subtract
+            # Subtract
             y_difference = element_location.y - middle_y_bounds
             scroll_y_position = scroll_position[:y] + y_difference
           end
 
-          #Get the element to halfway
+          # Get the element to halfway
           scroll_x_position = element_location.x.to_f
 
           javascript_string = "return window.scroll(#{scroll_x_position}, #{scroll_y_position});"
           @driver.execute_script(javascript_string)
         end
-
-        # Perform a click action on the element
-        # @return [void]
-        def click
-          self.scroll_into_view
-          @subject.click
-        end
       end
     end
   end
-end
+end

data/lib/automation_object/dsl.rb

@@ -1,33 +1,16 @@
+# frozen_string_literal: true
+require_relative 'dsl/top'
+
 module AutomationObject
-  #Dsl Port
+  # Dsl Port
   module Dsl
-    extend self
-
-    # @return [AutomationObject::Dsl::Module]
-    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 "dsl/#{adapter_name}"
-      @adapter = AutomationObject::Dsl.const_get("#{adapter_const}")
-    end
-
-    # Creates/returns composite and attaches the State to the composite
-    # @return [AutomationObject::Dsl::Models::Top]
-    def new(args={})
-      composite = self.adapter.build(args)
-      composite.state = args.fetch(:state)
+    module_function
 
-      return composite
+    # @param [AutomationObject::BluePrint::Composite::Top] blue_prints
+    # @param [AutomationObject::State::Session] state
+    # @return [AutomationObject::Dsl::Top]
+    def create(blue_prints, state)
+      TopProxy.new(blue_prints, state, :top)
     end
   end
-end
+end

data/lib/automation_object/dsl/_base.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module AutomationObject
+  module Dsl
+    # Base DSL Object
+    class Base < OpenStruct
+      # @param [AutomationObject::BluePrint::Composite::] blue_prints
+      # @param [AutomationObject::State::Session] state
+      def initialize(blue_prints, state)
+        ostruct_hash = {}
+
+        # Add attributes the call super
+        self.class.has_many_relationships.each do |name, composite_class|
+          blue_prints.send(name).each do |child_key, child_blue_prints|
+            ostruct_hash[child_key] = composite_class.new(child_blue_prints, state, child_key)
+          end
+        end
+
+        super ostruct_hash
+      end
+
+      # @param _indent [Integer]
+      # @return [String]
+      def inspect(_indent = 5)
+        string = self.class.to_s
+
+        to_h.each do |key, value|
+          string += formatted_name(key, _indent)
+          string += sub_inspect(value, _indent)
+        end
+
+        string
+      end
+
+      # @param key [String]
+      # @param indent [Integer]
+      # @return [String]
+      def formatted_name(key, indent)
+        # TODO: finish
+        # color = self[key].alive? ? :green : :blue
+        "\n#{' ' * indent} #{key}:".colorize(:green)
+      end
+
+      # @param value [Object]
+      # @param indent [Integer]
+      # @return [String]
+      def sub_inspect(value, indent)
+        if value.is_a?(Base)
+          " #{value.inspect(indent + 10)}"
+        else
+          " #{value.inspect}"
+        end
+      end
+
+      class << self
+        # Has many children relationship for the composite
+        # @param children_name [Symbol] name of the children, should be a BluePrint method
+        # @param composite_class [Class] interface
+        def has_many(children_name, composite_class)
+          has_many_relationships[children_name] = composite_class
+        end
+
+        # @return [Hash] relationships for the composite
+        def has_many_relationships
+          @has_many_relationships ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/dsl/_proxy.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+require_relative '../proxy/proxy'
+
+module AutomationObject
+  module Dsl
+    # Base Proxy Object
+    # Proxies intercept commands and issue calls to the state
+    # Prevents inspection from picking up internal methods
+    class Proxy < AutomationObject::Proxy::Proxy
+      # @param subject_class [AutomationObject::Dsl::CompositeBase, nil]
+      # @param blue_prints [AutomationObject::BluePrint::Composite::CompositeBase]
+      # @param state [AutomationObject::State::Session]
+      # @param name [Symbol]
+      def initialize(subject_class, blue_prints, state, name)
+        @blue_prints = blue_prints
+        @state = state
+        @name = name
+        @subject_class = subject_class
+
+        @subject = @subject_class.new(blue_prints, state)
+      end
+    end
+  end
+end

data/lib/automation_object/dsl/element.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require_relative '_proxy'
+
+module AutomationObject
+  module Dsl
+    # Element DSL Class
+    class Element < Base
+    end
+
+    # Proxy for Element
+    class ElementProxy < Proxy
+      # @param [AutomationObject::BluePrint::Composite::Element] blue_prints
+      # @param [AutomationObject::State::Session] state
+      # @param [Symbol] name
+      def initialize(blue_prints, state, name)
+        super Element, blue_prints, state, name
+      end
+
+      # @param [Symbol] method
+      # @param [Array, nil] args
+      # @param [Proc] block
+      def method_missing(method, *args, &block)
+        return super if Element.methods.include?(method)
+
+        if @subject.is_a?(AutomationObject::Dsl::Element)
+          # puts "@state.load(:element, #{@name})"
+          @subject = @state.load(:element, @name)
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/automation_object/dsl/element_array.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require_relative '_proxy'
+
+module AutomationObject
+  module Dsl
+    # ElementArray DSL Class
+    class ElementArray < Base
+    end
+
+    # Proxy for ElementArray
+    class ElementArrayProxy < Proxy
+      # @param [AutomationObject::BluePrint::Composite::ElementArray] blue_prints
+      # @param [AutomationObject::State::Session] state
+      # @param [Symbol] name
+      def initialize(blue_prints, state, name)
+        super ElementArray, blue_prints, state, name
+      end
+
+      # @param [Symbol] method
+      # @param [Array, nil] args
+      # @param [Proc] block
+      def method_missing(method, *args, &block)
+        return super if ElementArray.methods.include?(method)
+
+        if @subject.is_a?(AutomationObject::Dsl::ElementArray)
+          # puts "@state.load(:element_array, #{@name})"
+          @subject = @state.load(:element_array, @name)
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/automation_object/dsl/element_hash.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require_relative '_proxy'
+
+module AutomationObject
+  module Dsl
+    # ElementHash DSL Class
+    class ElementHash < Base
+    end
+
+    # Proxy for ElementHash
+    class ElementHashProxy < Proxy
+      # @param [AutomationObject::BluePrint::Composite::ElementHash] blue_prints
+      # @param [AutomationObject::State::Session] state
+      # @param [Symbol] name
+      def initialize(blue_prints, state, name)
+        super ElementHash, blue_prints, state, name
+      end
+
+      # @param [Symbol] method
+      # @param [Array, nil] args
+      # @param [Proc] block
+      def method_missing(method, *args, &block)
+        return super if ElementHash.methods.include?(method)
+
+        if @subject.is_a?(AutomationObject::Dsl::ElementHash)
+          # puts "@state.load(:element_hash, #{@name})"
+          @subject = @state.load(:element_hash, @name)
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/automation_object/dsl/modal.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require_relative '_base'
+require_relative '_proxy'
+
+require_relative 'element'
+require_relative 'element_array'
+require_relative 'element_hash'
+
+module AutomationObject
+  module Dsl
+    # Modal DSL Class
+    class Modal < Base
+      has_many :elements, ElementProxy
+      has_many :element_arrays, ElementArrayProxy
+      has_many :element_hashes, ElementHashProxy
+    end
+
+    # Proxy for Modal
+    class ModalProxy < Proxy
+      # @param [AutomationObject::BluePrint::Composite::Modal] blue_prints
+      # @param [AutomationObject::State::Session] state
+      # @param [Symbol] name
+      def initialize(blue_prints, state, name)
+        super Modal, blue_prints, state, name
+      end
+
+      # @param [Symbol] method
+      # @param [Array, nil] args
+      # @param [Proc] block
+      def method_missing(method, *args, &block)
+        return super if Modal.methods.include?(method)
+
+        # Attempt to load screen if composite object contains that child
+        if @subject.methods.include?(method)
+          # puts "@state.load(:modal, #{@name})"
+          @state.load(:modal, @name)
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/automation_object/dsl/screen.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+require_relative '_base'
+require_relative '_proxy'
+
+require_relative 'modal'
+require_relative 'element'
+require_relative 'element_array'
+require_relative 'element_hash'
+
+module AutomationObject
+  module Dsl
+    # Screen DSL Class
+    class Screen < Base
+      has_many :modals, ModalProxy
+      has_many :elements, ElementProxy
+      has_many :element_arrays, ElementArrayProxy
+      has_many :element_hashes, ElementHashProxy
+    end
+
+    # Proxy for Screen
+    class ScreenProxy < Proxy
+      # @param [AutomationObject::BluePrint::Composite::Screen] blue_prints
+      # @param [AutomationObject::State::Session] state
+      # @param [Symbol] name
+      def initialize(blue_prints, state, name)
+        super Screen, blue_prints, state, name
+      end
+
+      # @param [Symbol] method
+      # @param [Array, nil] args
+      # @param [Proc] block
+      def method_missing(method, *args, &block)
+        return super if Screen.methods.include?(method)
+
+        # Attempt to load screen if composite object contains that child
+        if @subject.methods.include?(method)
+          # puts "@state.load(:screen, #{@name})"
+          @state.load(:screen, @name)
+        end
+
+        super
+      end
+    end
+  end
+end