automation_object 0.0.4 → 0.5.0

data/lib/automation_object/dsl/blue_print_adapter/element.rb

@@ -0,0 +1,14 @@
+require_relative 'composite'
+require_relative '../proxies/element'
+
+module AutomationObject
+  module Dsl
+    module BluePrintAdapter
+      #Element BluePrint adapter composite
+      class Element < Composite
+        #Which proxy to create for this composite
+        implements_proxy AutomationObject::Dsl::Proxies::Element
+      end
+    end
+  end
+end

data/lib/automation_object/dsl/blue_print_adapter/element_array.rb

@@ -0,0 +1,14 @@
+require_relative 'composite'
+require_relative '../proxies/element_array'
+
+module AutomationObject
+  module Dsl
+    module BluePrintAdapter
+      #ElementArray BluePrint adapter composite
+      class ElementArray < Composite
+        #Which proxy to create for this composite
+        implements_proxy AutomationObject::Dsl::Proxies::ElementArray
+      end
+    end
+  end
+end

data/lib/automation_object/dsl/blue_print_adapter/element_hash.rb

@@ -0,0 +1,14 @@
+require_relative 'composite'
+require_relative '../proxies/element_hash'
+
+module AutomationObject
+  module Dsl
+    module BluePrintAdapter
+      #ElementHash BluePrint adapter composite
+      class ElementHash < Composite
+        #Which proxy to create for this composite
+        implements_proxy AutomationObject::Dsl::Proxies::ElementHash
+      end
+    end
+  end
+end

data/lib/automation_object/dsl/blue_print_adapter/modal.rb

@@ -0,0 +1,23 @@
+require_relative 'composite'
+require_relative '../proxies/modal'
+
+require_relative 'element'
+require_relative 'element_array'
+require_relative 'element_hash'
+
+module AutomationObject
+  module Dsl
+    module BluePrintAdapter
+      #Modal BluePrint adapter composite
+      class Modal < Composite
+        #Which proxy to create for this composite
+        implements_proxy AutomationObject::Dsl::Proxies::Modal
+
+        #Children for this composite
+        has_many :elements, interface: Element
+        has_many :element_arrays, interface: ElementArray
+        has_many :element_hashes, interface: ElementHash
+      end
+    end
+  end
+end

data/lib/automation_object/dsl/blue_print_adapter/screen.rb

@@ -0,0 +1,26 @@
+require_relative 'composite'
+require_relative '../proxies/screen'
+
+require_relative 'modal'
+require_relative 'element'
+require_relative 'element_array'
+require_relative 'element_hash'
+
+module AutomationObject
+  module Dsl
+    module BluePrintAdapter
+      #Screen BluePrint adapter composite
+      class Screen < Composite
+        #Which proxy to create for this composite
+        implements_proxy AutomationObject::Dsl::Proxies::Screen
+
+        #Children for this composite
+        has_many :modals, interface: Modal
+
+        has_many :elements, interface: Element
+        has_many :element_arrays, interface: ElementArray
+        has_many :element_hashes, interface: ElementHash
+      end
+    end
+  end
+end

data/lib/automation_object/dsl/blue_print_adapter/top.rb

@@ -0,0 +1,19 @@
+require_relative 'composite'
+require_relative '../proxies/top'
+
+require_relative 'screen'
+
+module AutomationObject
+  module Dsl
+    module BluePrintAdapter
+      #Top BluePrint adapter composite
+      class Top < Composite
+        #Which proxy to create for this composite
+        implements_proxy AutomationObject::Dsl::Proxies::Top
+
+        #Children for this composite
+        has_many :screens, interface: Screen
+      end
+    end
+  end
+end

data/lib/automation_object/dsl/models.rb

@@ -0,0 +1,18 @@
+module AutomationObject
+  module Dsl
+    module Models
+      class Top < OpenStruct;
+      end
+      class Screen < OpenStruct;
+      end
+      class Modal < OpenStruct;
+      end
+      class Element < OpenStruct;
+      end
+      class ElementHash < OpenStruct;
+      end
+      class ElementArray < OpenStruct;
+      end
+    end
+  end
+end

data/lib/automation_object/dsl/proxies/element.rb

@@ -0,0 +1,16 @@
+require_relative '../../proxies/proxy'
+
+require_relative 'helpers/composite_helper'
+
+module AutomationObject::Dsl
+  module Proxies
+    #Element proxy for model
+    class Element < AutomationObject::Proxies::Proxy
+      include CompositeHelper
+
+      def initialize
+        @subject = nil
+      end
+    end
+  end
+end

data/lib/automation_object/dsl/proxies/element_array.rb

@@ -0,0 +1,16 @@
+require_relative '../../proxies/proxy'
+
+require_relative 'helpers/composite_helper'
+
+module AutomationObject::Dsl
+  module Proxies
+    #ElementArray proxy for model
+    class ElementArray < AutomationObject::Proxies::Proxy
+      include CompositeHelper
+
+      def initialize
+        @subject = nil
+      end
+    end
+  end
+end

data/lib/automation_object/dsl/proxies/element_hash.rb

@@ -0,0 +1,16 @@
+require_relative '../../proxies/proxy'
+
+require_relative 'helpers/composite_helper'
+
+module AutomationObject::Dsl
+  module Proxies
+    #ElementHash proxy for model
+    class ElementHash < AutomationObject::Proxies::Proxy
+      include CompositeHelper
+
+      def initialize
+        @subject = nil
+      end
+    end
+  end
+end

data/lib/automation_object/dsl/proxies/helpers/composite_helper.rb

@@ -0,0 +1,74 @@
+module AutomationObject::Dsl
+  module Proxies
+    #CompositeHelper for DSL Proxies
+    #Proxies will deal with the State and wrap around the models
+    module CompositeHelper
+      attr_accessor :state
+
+      # @param state [AutomationObject::State::Session]
+      def state=(state)
+        @state = state
+        self.children.each { |child|
+          @subject[child].state = @state
+        }
+      end
+
+      # @return [Array] hooks array or empty array
+      def hooks
+        @hooks ||= Array.new
+      end
+
+      # @return [Hash] composite hooks or empty hash
+      def composite_hooks
+        @composite_hooks ||= Hash.new
+      end
+
+      # @return [Array] children array or empty array
+      def children
+        @children ||= Array.new
+      end
+
+      # Use this to add children to the DSL composite
+      # @param args [Hash] arguments for adding a child to this composite
+      def add(args={})
+        name = args.fetch :name
+        @subject[name] = args.fetch :object
+        self.children.push(name)
+
+        type = args.fetch(:type)
+
+        case type
+          when :screen, :modal
+            #Just load
+            self.composite_hooks[name] = lambda { self.request_load(type, name) }
+          when :element, :element_array, :element_hash
+            #Set return to subject
+            self.composite_hooks[name] = lambda { @subject[name] = self.request_load(type, name) }
+        end
+
+        @subject[name].hooks.push(self.composite_hooks[name]) if self.composite_hooks.has_key?(name)
+        return @subject[name]
+      end
+
+      # Request the state to load an object
+      # @param type [Symbol] type of object (:screen, :modal, :element, :etc...)
+      # @param name [Symbol] name of the object
+      def request_load(type, name)
+        @state.load(type, name)
+      end
+
+      #Override to allow for hooks to be run when using the DSL API
+      def method_missing(method_symbol, *args, &block)
+        return super unless self.children.include?(method_symbol)
+
+        self.hooks.each { |hook| hook.call }
+
+        if self.composite_hooks.has_key?(method_symbol)
+          self.composite_hooks[method_symbol].call
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/automation_object/dsl/proxies/modal.rb

@@ -0,0 +1,17 @@
+require_relative '../../proxies/proxy'
+require_relative '../models.rb'
+
+require_relative 'helpers/composite_helper'
+
+module AutomationObject::Dsl
+  module Proxies
+    #Modal proxy for model
+    class Modal < AutomationObject::Proxies::Proxy
+      include CompositeHelper
+
+      def initialize
+        @subject = Models::Modal.new
+      end
+    end
+  end
+end

data/lib/automation_object/dsl/proxies/screen.rb

@@ -0,0 +1,17 @@
+require_relative '../../proxies/proxy'
+require_relative '../models.rb'
+
+require_relative 'helpers/composite_helper'
+
+module AutomationObject::Dsl
+  module Proxies
+    #Screen proxy for model
+    class Screen < AutomationObject::Proxies::Proxy
+      include CompositeHelper
+
+      def initialize
+        @subject = Models::Screen.new
+      end
+    end
+  end
+end

data/lib/automation_object/dsl/proxies/top.rb

@@ -0,0 +1,17 @@
+require_relative '../../proxies/proxy'
+require_relative '../models'
+
+require_relative 'helpers/composite_helper'
+
+module AutomationObject::Dsl
+  module Proxies
+    #Top proxy for model
+    class Top < AutomationObject::Proxies::Proxy
+      include CompositeHelper
+
+      def initialize
+        @subject = Models::Top.new
+      end
+    end
+  end
+end

data/lib/automation_object/framework.rb

@@ -1,407 +1,100 @@
-module AutomationObject
-  class Framework
-    include AutomationObject::FrameworkScreenRouting
-    include AutomationObject::FrameworkHelpers
-    include AutomationObject::FrameworkWindowHelpers
-    include AutomationObject::FrameworkPrintObjects
-    include AutomationObject::FrameworkScreenMonitor
-
-    include EventEmitter
-    include AutomationObject::FrameworkEvents
-
-    attr_accessor :driver_object, :configuration,
-                  :current_screen_class, :previous_screen_class, #Singular
-                  :current_screen_hash, :previous_screen_hash, #Multiple, base screens on window_handle
-                  :screen_history_hash, #keys => window_handles, values => array of screen_class_symbols
-                  :screen_monitor_thread,
-                  :screen_monitor_mutex_object
-
-    def initialize(driver, configuration)
-      self.screen_monitor_mutex_object = Mutex.new #Mutex for screen monitor threads, operate one at a time, multiple window edge case
-
-      #Hash for contained screen monitor threads
-      self.screen_monitor_thread = Hash.new
-
-      self.configuration = configuration
-
-      #Wrap driver object in our Driver for Thread Safe operations
-      self.driver_object = AutomationObject::Driver::Driver.new(driver)
-      if self.configuration['throttle_driver_methods']
-        AutomationObject::Driver::Driver::throttle_methods = self.configuration['throttle_driver_methods']
-      end
-      if self.configuration['throttle_element_methods']
-        AutomationObject::Driver::Element::throttle_methods = self.configuration['throttle_element_methods']
-      end
-
-      #Support multiple windows for Browser
-      if self.is_browser?
-        self.current_screen_hash = Hash.new
-        self.previous_screen_hash = Hash.new
-        self.screen_history_hash = Hash.new
-      end
-
-      #Add Screens
-      self.add_screens(configuration['screens']) if configuration['screens']
-
-      #Set Initial Screen
-      self.set_initial_screen
-    end
-
-    def respond_to?(method_symbol, include_private = false)
-      #Translate method in possible internal storage attribute
-      class_symbol = self.translate_string_to_class(method_symbol)
-      instance_symbol = class_symbol.to_s.gsub(/^@/, '')
-      instance_symbol = "@#{instance_symbol}".to_sym
-
-      self.instance_variables.each { |instance_variable|
-        return true if instance_variable == instance_symbol
-      }
-
-      #If not then do the super on the method_symbol
-      super.respond_to?(method_symbol, include_private)
-    end
-
-    def method_missing(screen_name, *args, &block)
-      unless self.current_screen_class #Don't think this happens, but throwing an exception for checking
-        raise "No current screen defined when calling the screen (#{screen_name})"
-      end
-
-      #Translate screen name to internal class property
-      screen_class_symbol = self.translate_string_to_class(screen_name)
-      unless self.respond_to?(screen_class_symbol)
-        raise ArgumentError, "Screen called (#{screen_name}) has not been defined"
-      end
-
-      #Check for any closed windows and update accordingly
-      #Todo: Important!!!! check if this affects anything negatively
-      #self.check_closed_windows if self.is_browser?
-
-      #Return screen object if it is the current screen
-      return self.send(screen_class_symbol, *args, &block) if self.current_screen_class == screen_class_symbol
-
-      #Check mobile, then just switch_to if the screen is already live
-      if self.is_browser?
-        self.current_screen_hash.each { |window_handle, current_screen_symbol|
-          if current_screen_symbol == screen_class_symbol
-            self.switch_to_window(window_handle) unless window_handle == self.get_current_window_handle
-
-            self.current_screen_class = current_screen_symbol
-            return self.send(screen_class_symbol, *args, &block)
-          end
-        }
-      end
-
-      unless self.is_browser?
-        self.route_to_screen(self.current_screen_class, screen_class_symbol)
-        return self.send(screen_class_symbol, *args, &block)
-      end
-
-      #Screen is not live, then try to route to it
-      routed = false
-
-      self.current_screen_hash.each { |window_handle, current_screen_symbol|
-        self.switch_to_window(window_handle)
-        self.current_screen_class = current_screen_symbol
-
-        begin
-          self.route_to_screen(self.current_screen_class, screen_class_symbol)
-          routed = true
-          break
-        rescue Exception => e
-          puts "Unable to route under #{self.current_screen_class} and #{screen_class_symbol}".colorize(:red)
-          ap e
-          ap e.message
-          ap e.backtrace
-          # ignored
-        end
-      }
-
-      unless routed
-        #Kind of an edge case but can happen
-        if self.current_screen_class != screen_class_symbol
-          requested_screen = self.translate_class_to_string(screen_class_symbol)
-          current_screen = self.translate_class_to_string(self.current_screen_class)
-
-          raise "Unable to route to screen from any of the current screens. Current Screen (#{current_screen}), Requested Screen (#{requested_screen})"
-        end
-      end
-
-      self.send(screen_class_symbol, *args, &block)
-    end
-
-    def set_initial_screen
-      if self.is_browser?
-        unless self.configuration['base_url']
-          raise ArgumentError, 'base_url is required for Browser configurations'
-        end
-
-        begin
-          self.driver_object.navigate.to(self.configuration['base_url'])
-        rescue Net::ReadTimeout
-          sleep(5)
-          self.driver_object.navigate.to(self.configuration['base_url'])
-        end
-      else
-        raise ArgumentError, 'App based configuration should not have base_url in configuration' if self.configuration['base_url']
-      end
-
-      #Skip checking live? configurations if default_screen is set
-      if self.configuration['default_screen']
-        initial_screen_symbol = self.translate_string_to_class(self.configuration['default_screen'])
-
-        unless self.respond_to?(initial_screen_symbol)
-          raise "Default screen #{self.configuration['default_screen']} has not been defined in configuration"
-        end
-      else
-        initial_screen_symbol = self.find_current_screen
-      end
-
-      unless initial_screen_symbol
-        raise 'Unable to find the initial screen via live? configurations or no default screen was specified'
-      end
-
-      AutomationObject::Logger::add("Setting as initial screen #{initial_screen_symbol}")
-
-      self.set_current_screen(initial_screen_symbol)
-    end
-
-    def find_current_screen
-      AutomationObject::Logger::add('Looking for possible current screens through screen live? configurations')
-
-      return nil unless self.configuration['screens'].class == Hash
-
-      self.configuration['screens'].each_key { |screen_name|
-        screen_class_symbol = self.translate_string_to_class(screen_name)
-
-        next unless self.configuration['screens'][screen_name].class == Hash
-        next unless self.configuration['screens'][screen_name]['live?'].class == Hash
-
-        if self.current_screen?(screen_name)
-          AutomationObject::Logger::add("Found current screen #{screen_name}")
-          return screen_class_symbol
-        end
-      }
-
-      nil
-    end
-
-    def current_screen?(screen_name)
-      screen_class_symbol = self.translate_string_to_class(screen_name)
-
-      #Raise error if screen doesn't exist, shouldn't be called in the first place if it doesn't
-      unless self.respond_to?(screen_class_symbol)
-        raise ArgumentError, "Screen has not been defined, #{screen_class_symbol}"
-      end
+require_relative 'proxies/proxy'
+require_relative 'blue_print'
+require_relative 'driver'
+require_relative 'dsl'
+require_relative 'state'
 
-      #Return true if screen doesn't have live configuration, unable to tell if not so just say yeah
-      return true unless self.send(screen_class_symbol).has_live_configuration?
-
-      self.send(self.translate_string_to_class(screen_name)).live?
+module AutomationObject
+  #Framework class, the core
+  #A Proxy class that will become the DSL Framework
+  class Framework < Proxies::Proxy
+    # @return [AutomationObject::BluePrint::Composite::Top]
+    attr_accessor :blue_prints
+
+    # @return [AutomationObject::Driver::Driver]
+    attr_accessor :driver
+
+    # @return [AutomationObject::State::Session]
+    attr_accessor :state
+
+    # @return [Dsl] workable dsl composite object
+    attr_accessor :dsl
+
+    # Will assume nil or :nokogiri is XML based and AutomationObject
+    # can also automate XML
+    # @param driver [Selenium::WebDriver::Driver,Appium::Driver,nil] selenium type driver or nil
+    # @param blue_prints [Hash] arguments for Framework
+    def initialize(driver, blue_prints)
+      self.driver = driver
+      self.blue_prints = blue_prints
+
+      #Create the DSL
+      #Should create all subsequent needed object
+      @subject = self.dsl
+
+      AutomationObject::Framework.singleton = self
     end
 
-    def add_screens(configuration)
-      this = self
-      configuration.each { |screen_name, screen_configuration|
-        #Change name of screen for class storage, allows for method missing
-        screen_class_symbol = self.translate_string_to_class(screen_name)
-
-        #Add screen class to self
-        setter = "#{screen_class_symbol}="
-        self.class.send(:attr_accessor, screen_class_symbol) unless self.respond_to?(setter)
-
-        screen_object_options = {
-            :framework_object => self,
-            :driver_object => self.driver_object,
-            :blue_prints => screen_configuration,
-            :screen_name => screen_name
-        }
-
-        send setter, Screen.new(screen_object_options)
-
-        #Add Listeners
-        self.send(screen_class_symbol).on :change_screen do |args|
-          this.change_screen_listener(args[:screen_class_symbol], args[:created_window_handle])
-        end
-
-        self.send(screen_class_symbol).on :possible_screen_changes do |args|
-          this.possible_change_screen_listener(args[:possible_screens], args[:created_window_handle])
-        end
-
-        self.send(screen_class_symbol).on :close_window do |args|
-          this.close_window(args[:screen_name], args[:skip_close])
-        end
-      }
+    # dsl get method
+    # @return [Dsl] workable dsl composite object
+    def dsl
+      @dsl ||= Dsl.new(blue_prints: self.blue_prints, state: self.state)
     end
 
-    def set_previous_screen
-      self.set_current_screen(self.previous_screen_class)
+    # state get method
+    # @return [State] state object which actively controls the ui state
+    def state
+      @state ||= State.new(self.blue_prints, self.driver)
     end
 
-    def reset_screen(screen_class_symbol)
-      unless screen_class_symbol.class == Symbol
-        raise ArgumentError, 'You need to provide the screen_class_symbol to Framework.reset_screen method'
-      end
-
-      unless self.respond_to?(screen_class_symbol)
-        raise ArgumentError, "Screen class symbol provided (#{screen_class_symbol}) has not been defined"
+    # BluePrints (UI configurations) wrapped in an composite
+    # Composite provides a common interface for all adapters
+    # @param value [String, Hash] String to YAML files or Hash configuration
+    # @return [AutomationObject::BluePrint::Composite::Top] top composite object
+    def blue_prints=(value)
+      case value
+        when String
+          BluePrint.adapter = :yaml
+        when Hash
+          BluePrint.adapter = :hash
       end
 
-      unless self.send(screen_class_symbol).class == Screen
-        raise ArgumentError, "Requested symbol (#{screen_class_symbol}) is not a Screen class"
-      end
-
-      #Remove listeners
-      self.send(screen_class_symbol).reset_screen
+      @blue_prints = BluePrint.new(value)
     end
 
-    def set_current_screen(screen_class_symbol, new_window = false)
-      AutomationObject::Logger::add("Going to set current screen #{screen_class_symbol}")
-
-      #Set current_screen_class to previous_screen_class
-      self.previous_screen_class = self.current_screen_class
-
-      #Reset previous screen if needed
-      self.reset_screen(self.previous_screen_class) if self.previous_screen_class
-
-      #Reset new screen just in case
-      self.reset_screen(screen_class_symbol)
-
-      #Sleep if default sleep
-      if self.configuration['screen_transition_sleep']
-        transition_sleep = self.configuration['screen_transition_sleep'].to_f
-        sleep(transition_sleep)
+    # Driver port provides a formatted interface for interacting with different drivers
+    # @return [AutomationObject::Driver::Driver] driver interface object
+    def driver=(value)
+      case value
+        when Selenium::WebDriver::Driver
+          Driver.adapter = :selenium
+        when Appium::Driver
+          Driver.adapter = :appium
+        else
+          Driver.adapter = :nokogiri
       end
 
-      #Reset any active modals in classes underneath
-      self.send(self.previous_screen_class).active_modal = nil if self.previous_screen_class
-
-      #Do multiple set current screens if multiple screens
-      if self.is_browser?
-        self.set_current_screen_multiple(screen_class_symbol, new_window)
-        self.wait_for_window_load
-        self.wait_for_stable_body_size
-      end
-
-      #Before Load Event
-      self.send(screen_class_symbol).before_load
-
-      #Set current_screen_class
-      self.current_screen_class = screen_class_symbol
-
-      #Emit Screen Change
-      self.emit :change_screen, self.translate_class_to_symbol(screen_class_symbol)
-
-      #Possible Automatic Screen Changes
-      screen_configuration = self.send(screen_class_symbol).configuration
-      return unless screen_configuration.is_a?(Hash)
-      return unless screen_configuration['automatic_screen_changes'].is_a?(Array)
-      return if screen_configuration.length == 0
-
-      AutomationObject::Logger::add("Adding thread listener for screen #{screen_class_symbol}")
-      self.screen_monitor_thread[screen_class_symbol] = Thread.new {
-        self.screen_monitor_thread_method(screen_class_symbol)
-      }
+      @driver = Driver.new(value)
     end
 
-    def change_screen_listener(screen_class_symbol, created_window_handle = false)
-      self.set_current_screen(screen_class_symbol, created_window_handle)
-
-      unless self.current_screen?(screen_class_symbol)
-        screen_name = self.translate_class_to_string(screen_class_symbol)
-        possible_screen_symbol = self.find_current_screen
-
-        message = "Tried to change screen to (#{screen_name}).
-                    (#{screen_name}) did not pass live? configuration test. "
-
-        #If it misses the first time around, no need to error out the screen is should be on anyways
-        return if possible_screen_symbol == screen_class_symbol
-
-        if possible_screen_symbol
-          possible_screen_name = self.translate_class_to_string(possible_screen_symbol)
-          message << "Got (#{possible_screen_name}) screen instead."
-        end
-
-        raise message
-      end
-    end
-
-    def possible_change_screen_listener(possible_screens, created_window_handle = false)
-      AutomationObject::Logger::add("Going to try to change to possible screens #{possible_screens}")
-
-      set_new_screen = false
-
-      possible_screens.each { |possible_screen_name|
-        possible_screen_symbol = self.translate_string_to_class(possible_screen_name)
-
-        begin
-          self.set_current_screen(possible_screen_symbol, created_window_handle)
-
-          if self.current_screen?(possible_screen_name)
-            set_new_screen = true
-            break #It worked, screen changed
-          end
-        rescue
-          #Unable to set current screen, don't do much
-        end
-      }
-
-      return if set_new_screen
-
-      #Raise message since unable to change to any of the screens
-      raise "Unable to change to any of the possible screens #{possible_screens}"
+    # Reset the entire state, remove any values
+    # Leave the driver alone here, can be done elsewhere
+    # @return [void]
+    def quit
+      self.state.quit #Quit the state.  That way it knows to kill threads if operational
+      self.dsl, self.state, self.blue_prints, self.driver = nil
     end
 
-    def set_current_screen_multiple(screen_class_symbol, new_window = false)
-      unless self.current_screen_class
-        current_window_handle = self.get_current_window_handle
-
-        self.current_screen_hash[current_window_handle] = screen_class_symbol
-        self.screen_history_hash[current_window_handle] = Array.new
-        self.screen_history_hash[current_window_handle].push(screen_class_symbol)
-        self.send(screen_class_symbol).window_handle = current_window_handle
-
-        return
-      end
-
-      switch_to_window_handle = nil
-
-      if new_window
-        self.current_screen_hash[new_window] = screen_class_symbol
-        self.switch_to_window(new_window)
-        self.screen_history_hash[new_window] = Array.new
-        self.screen_history_hash[new_window].push(screen_class_symbol)
-        self.send(screen_class_symbol).window_handle = new_window
-
-        return
-      end
-
-      #Add previous screen to previous screen hash
-      if self.current_screen_class and not new_window
-        self.current_screen_hash.each { |window_handle, current_screen_symbol|
-          if self.current_screen_class == current_screen_symbol
-            self.previous_screen_hash[window_handle] = current_screen_symbol
-            self.current_screen_hash[window_handle] = screen_class_symbol
-            switch_to_window_handle = window_handle
-
-            unless self.screen_history_hash[window_handle].class == Array
-              self.screen_history_hash[window_handle] = Array.new
-            end
-
-            self.screen_history_hash[window_handle].push(screen_class_symbol)
-            self.send(screen_class_symbol).window_handle = window_handle
-
-            break
-          end
-        }
-      end
-
-      #Switch to window handle if set
-      if switch_to_window_handle
-        return if self.current_screen_hash.keys.length == 1
+    # Static Hack
+    # TODO: figure a multiple instance way of using ao in Cucumber context
+    # Leaving for now to continue testing and building of whole framework
+    class << self
+      attr_accessor :singleton
 
-        if switch_to_window_handle != self.get_current_window_handle
-          self.switch_to_window(switch_to_window_handle)
-        end
+      #Singleton method if using Cucumber
+      # @return [Framework] singleton of self
+      def get
+        return self.singleton
       end
     end
   end