automation_object 0.0.4 → 0.5.0

data/lib/automation_object/helpers/composite.rb

@@ -0,0 +1,95 @@
+require_relative 'reflection_helper'
+require_relative 'composite_hook'
+
+module AutomationObject
+  #Composite is a super class that helps build composite objects based of a Hash
+  #Composite classes should inherit from this class and use the class-level methods to add the components
+  class Composite
+    include CompositeHook
+    include ReflectionHelper
+
+    attr_accessor :name, :parent, :location, :children
+
+    # @param name [Symbol] name of the object
+    # @param parent [Object, nil] parent composite object
+    # @param location [String] string location for error/debugging purposes
+    def initialize(name = :top, parent = nil, location = 'top')
+      self.parent = parent
+      self.location = location
+
+      self.before_create_run
+
+      self.add_has_one_relationships
+      self.add_has_many_relationships
+
+      self.after_create_run
+    end
+
+    def children
+      @children ||= {}
+    end
+
+    # Get top composite Object
+    # @return [AutomationObject::Composite]
+    def top
+      #Should recursively call top until parent is nil
+      return (self.parent == nil) ? self : self.parent.top
+    end
+
+    # Abstract argument, override
+    # @param name [Symbol] name of child
+    # @param options [Hash] options for child
+    # @return child [Object] return child composite object
+    def get_child(name, options)
+      raise 'Abstract method'
+    end
+
+    # Abstract argument, override
+    # @param name [Symbol] name of child
+    # @param options [Hash] options for child
+    # @return children [Hash] return children and names
+    def get_children(name, options)
+      raise 'Abstract method'
+    end
+
+    def add_has_one_relationships
+      self.class.has_one_relationships.each { |name, options|
+        self.children[name] = get_child(name, options)
+        self.add_attribute(name, self.children[name])
+      }
+    end
+
+    def add_has_many_relationships
+      self.class.has_many_relationships.each { |name, options|
+        composite_children = get_children(name, options)
+        self.children[name] = composite_children
+        self.add_attribute(name, self.children[name])
+      }
+    end
+
+    class << self
+      #Has many children relationship for the composite
+      # @param children_name [Symbol] name of the children, should be a BluePrint method
+      # @param args [Hash] additional arguments, expects interface
+      def has_many(children_name, args)
+        self.has_many_relationships[children_name] = args
+      end
+
+      # @return [Hash] relationships for the composite
+      def has_many_relationships
+        @has_many_relationships ||= Hash.new
+      end
+
+      # @param child_name [Symbol] name of key
+      # @param args [Hash] arguments
+      def has_one(child_name, args)
+        self.has_one_relationships[child_name] = args
+      end
+
+      # @return [Hash] hash of relationships
+      def has_one_relationships
+        @has_one_relationships ||= Hash.new
+      end
+    end
+  end
+end

data/lib/automation_object/helpers/composite_hook.rb

@@ -0,0 +1,46 @@
+module AutomationObject
+  #Hooks for composites
+  module CompositeHook
+    def before_create_run
+      self.class.before_create_hooks.each { |before_create_hook|
+        self.send(before_create_hook)
+      }
+    end
+
+    def after_create_run
+      self.class.after_create_hooks.each { |after_create_hook|
+        self.send(after_create_hook)
+      }
+    end
+
+    # @param base [Class] class to extend when included
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    #Class level methods
+    module ClassMethods
+      # @param instance_method [Symbol] method to call
+      def after_create(instance_method)
+        self.after_create_hooks.push(instance_method)
+      end
+
+      # @return [Array<Symbol>] list of methods to call
+      def after_create_hooks
+        @after_create_hooks = [] unless @after_create_hooks
+        return @after_create_hooks
+      end
+
+      # @param instance_method [Symbol] method to call
+      def before_create(instance_method)
+        self.before_create_hooks.push(instance_method)
+      end
+
+      # @return [Array<Symbol>] list of methods to call
+      def before_create_hooks
+        @before_create_hooks = [] unless @before_create_hooks
+        return @before_create_hooks
+      end
+    end
+  end
+end

data/lib/automation_object/helpers/hash.rb

@@ -0,0 +1,15 @@
+#Hash class method additions
+class ::Hash
+  def deep_merge(second)
+    merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
+    self.merge(second, &merger)
+  end
+
+  def symbolize_keys_deep!(h = self)
+    h.keys.each do |k|
+      ks = k.respond_to?(:to_sym) ? k.to_sym : k
+      h[ks] = h.delete k # Preserve order even when k == ks
+      symbolize_keys_deep! h[ks] if h[ks].is_a?(Hash)
+    end
+  end
+end

data/lib/automation_object/helpers/reflection_helper.rb

@@ -0,0 +1,28 @@
+module AutomationObject
+  #Helper module for adding attributes/alias to classes dynamically
+  #Reflection/MetaProgramming
+  module ReflectionHelper
+    # @param name [String, Symbol] name of attribute to add
+    # @param value [Object] value of attribute
+    def add_attribute(name, value)
+      name = name.to_s
+      alias_name = name + '?' if name.gsub!(/\?$/, '')
+
+      self.class.send(:attr_accessor, name)
+      instance_variable_set("@#{name}", value)
+
+      self.add_alias(alias_name, name) if alias_name
+    end
+
+    # @param alias_name [Symbol, String] name of alias to add
+    # @param attribute_name [Symbol, String] attribute to link to
+    def add_alias(alias_name, attribute_name)
+      singleton_class = class << self;
+        self;
+      end
+      singleton_class.send(:define_method, alias_name) do
+        instance_variable_get("@#{attribute_name}")
+      end
+    end
+  end
+end

data/lib/automation_object/helpers/string.rb

@@ -0,0 +1,27 @@
+#String class method additions
+class ::String
+  def valid_url?
+    uri = URI.parse(self)
+    if uri.kind_of?(URI::HTTP)
+      if self.match(/^(http|https):\/\/[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$/ix)
+        return true
+      else
+        return false
+      end
+    else
+      return false
+    end
+  rescue URI::InvalidURIError
+    return false
+  end
+
+  def join_url(url)
+    full_url = self.chomp('/') + url.reverse.chomp('/').reverse
+    return full_url
+  end
+
+  def pascalize
+    return self if self !~ /_/ && self =~ /[A-Z]+.*/
+    self.split('_').map { |part| part.capitalize }.join
+  end
+end

data/lib/automation_object/proxies/mutex_proxy.rb

@@ -0,0 +1,63 @@
+require_relative 'proxy'
+
+module AutomationObject
+  module Proxies
+    #Proxy class for protecting object with Mutex
+    class MutexProxy < Proxy
+      def initialize(subject)
+        super
+
+        @mutexes = [Mutex.new]
+        @skip_protection_classes = [TrueClass, FalseClass, String, Numeric, Array, Hash, Class, NilClass, Symbol]
+      end
+
+      def add_mutex(mutex_object)
+        unless mutex_object.is_a?(Mutex)
+          raise ArgumentError, 'Expecting mutex_object argument to be a Mutex object'
+        end
+
+        @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
+
+        @mutexes.delete(mutex_object)
+      end
+
+      def method_missing(method_symbol, *args, &block)
+        exec_procedures = Array.new
+        exec_procedures.push(lambda {
+          execution_return = @subject.send(method_symbol, *args, &block)
+          return self.protect_object(execution_return)
+        })
+
+        index = 0
+        @mutexes.each { |mutex|
+          index += 1
+          exec_procedures.push(lambda {
+            mutex.synchronize do
+              index -= 1
+              exec_procedures[index].call
+            end
+          })
+        }
+
+        return 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|
+          protected_object.add_mutex(mutex)
+        }
+
+        return protected_object
+      end
+    end
+  end
+end

data/lib/automation_object/proxies/proxy.rb

@@ -0,0 +1,20 @@
+module AutomationObject
+  module Proxies
+    #Base Proxy class for getting between another
+    class Proxy
+      instance_methods.each { |instance_method|
+        unless instance_method =~ /(^__|^send$|^object_id)/
+          undef_method instance_method
+        end
+      }
+
+      def initialize(subject)
+        @subject = subject
+      end
+
+      def method_missing(method_symbol, *args, &block)
+        return @subject.send(method_symbol, *args, &block)
+      end
+    end
+  end
+end

data/lib/automation_object/proxies/throttle_proxy.rb

@@ -0,0 +1,57 @@
+require_relative 'proxy'
+
+module AutomationObject
+  module Proxies
+    #Proxy class to throttle methods on the subject
+    class ThrottleProxy < Proxy
+      def initialize(subject)
+        super
+      end
+
+      def throttle_methods
+        @throttle_methods ||= Hash.new
+      end
+
+      def method_missing(method_symbol, *args, &block)
+        start_time = Time.new.to_f
+        execution_return = @subject.send(method_symbol, *args, &block)
+        self.throttle_speed(method_symbol, start_time)
+        return execution_return
+      end
+
+      def add_method_throttle(method_symbol, time)
+        unless method_symbol.is_a?(Symbol)
+          raise ArgumentError, 'Expecting method_symbol argument to be a Symbol'
+        end
+
+        unless time.is_a?(Numeric)
+          raise ArgumentError, 'Expecting time argument to be Numeric'
+        end
+
+        unless @subject.respond_to?(method_symbol)
+          raise ArgumentError, "Expecting object to respond_to? #{method_symbol}"
+        end
+
+        self.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)
+        self.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 self.throttle_methods.has_key?(method_symbol)
+        total_time_taken = Time.new.to_f - start_time
+
+        sleep_time = self.throttle_methods[method_symbol] - total_time_taken
+        sleep(sleep_time) if sleep_time > 0
+      end
+    end
+  end
+end

data/lib/automation_object/state.rb

@@ -0,0 +1,37 @@
+require_relative 'state/session'
+
+module AutomationObject
+  #State Port, following port/adapter pattern
+  #BluePrintAdapter adapts the state to the blueprint
+  module State
+    extend self
+
+    # @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
+    # @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)
+    end
+  end
+end

data/lib/automation_object/state/blue_print_adapter.rb

@@ -0,0 +1,16 @@
+require_relative 'blue_print_adapter/top'
+
+module AutomationObject
+  module State
+    #State adapter for building DSL framework
+    #Will work with the blueprints and adapter to accomplish the goal of maintaining the state
+    #And give control of operations via the DSL
+    module BluePrintAdapter
+      # @param args [Hash] expects :blue_prints, :driver
+      # @return [AutomationObject::State::BlueAdapter::Top]
+      def self.build(blue_prints, driver)
+        return Top.new(args.fetch(:blue_prints), args.fetch(:driver))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+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
+
+        # @param blue_prints [AutomationObject::BluePrint::Composite] blue print composite
+        # @param driver [AutomationObject::Driver] driver
+        # @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
+          self.driver = driver
+
+          super(name, parent, location)
+        end
+
+        # Overriding base get_child method
+        # @param name [Symbol] name of child
+        # @param args [Hash] args
+        def get_child(name, args)
+          child_location = self.location + "[#{name}]"
+
+          return args.fetch(:interface).new(self.blue_prints.send(name), self.driver, name, self, child_location)
+        end
+
+        # Overriding base get_children method
+        # @param name [Symbol] name of child
+        # @param args [Hash] args
+        # @return children [Array<Composite>] return children and names
+        def get_children(name, args)
+          children_hash = Hash.new
+
+          self.blue_prints.send(name).each { |child_key, child_blue_prints|
+            child_location = self.location + "[#{child_key}]"
+
+            children_hash[child_key] = args.fetch(:interface).new(child_blue_prints,
+                                                                  self.driver,
+                                                                  name,
+                                                                  self,
+                                                                  child_location)
+          }
+
+          return 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)
+
+          #Should recursively call top until parent is nil
+          return (self.is_a?(Screen)) ? self : self.parent.screen
+        end
+      end
+    end
+  end
+end