automation_object 0.5.0 → 0.5.1

data/lib/automation_object/dsl/top.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+require_relative '_base'
+require_relative '_proxy'
+
+require_relative 'screen'
+
+module AutomationObject
+  module Dsl
+    # Top DSL Class
+    class Top < Base
+      has_many :screens, ScreenProxy
+    end
+
+    # Proxy for Top Composite
+    # Use proxy for methods trying to do a @state call
+    class TopProxy < Proxy
+      # @param [AutomationObject::BluePrint::Composite::Top] blue_prints
+      # @param [AutomationObject::State::Session] state
+      # @param [Symbol] name
+      def initialize(blue_prints, state, name)
+        super Top, blue_prints, state, name
+      end
+    end
+  end
+end

data/lib/automation_object/framework.rb

@@ -1,13 +1,14 @@
-require_relative 'proxies/proxy'
+# frozen_string_literal: true
+require_relative 'proxy/proxy'
 require_relative 'blue_print'
 require_relative 'driver'
 require_relative 'dsl'
 require_relative 'state'
 
 module AutomationObject
-  #Framework class, the core
-  #A Proxy class that will become the DSL Framework
-  class Framework < Proxies::Proxy
+  # Framework class, the core
+  # A Proxy class that will become the DSL Framework
+  class Framework < Proxy::Proxy
     # @return [AutomationObject::BluePrint::Composite::Top]
     attr_accessor :blue_prints
 
@@ -28,60 +29,49 @@ module AutomationObject
       self.driver = driver
       self.blue_prints = blue_prints
 
-      #Create the DSL
-      #Should create all subsequent needed object
-      @subject = self.dsl
+      self.state = State.create(self.driver, self.blue_prints)
+      @subject = Dsl.create(self.blue_prints, state)
 
       AutomationObject::Framework.singleton = self
     end
 
-    # dsl get method
-    # @return [Dsl] workable dsl composite object
-    def dsl
-      @dsl ||= Dsl.new(blue_prints: self.blue_prints, state: self.state)
-    end
-
-    # state get method
-    # @return [State] state object which actively controls the ui state
-    def state
-      @state ||= State.new(self.blue_prints, self.driver)
-    end
-
     # 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
+    undef :blue_prints= if defined? :blue_prints=
     def blue_prints=(value)
       case value
-        when String
-          BluePrint.adapter = :yaml
-        when Hash
-          BluePrint.adapter = :hash
+      when String
+        BluePrint.adapter = :yaml
+      when Hash
+        BluePrint.adapter = :hash
       end
 
-      @blue_prints = BluePrint.new(value)
+      @blue_prints = BluePrint.create(value)
     end
 
     # Driver port provides a formatted interface for interacting with different drivers
     # @return [AutomationObject::Driver::Driver] driver interface object
+    undef :driver= if defined? :driver=
     def driver=(value)
-      case value
-        when Selenium::WebDriver::Driver
-          Driver.adapter = :selenium
-        when Appium::Driver
-          Driver.adapter = :appium
-        else
-          Driver.adapter = :nokogiri
-      end
-
-      @driver = Driver.new(value)
+      Driver.adapter = case value
+                       when Selenium::WebDriver::Driver
+                         :selenium
+                       when Appium::Driver
+                         :appium
+                       else
+                         :nokogiri
+                       end
+
+      @driver = Driver.create(value)
     end
 
     # 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
+      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
 
@@ -91,11 +81,11 @@ module AutomationObject
     class << self
       attr_accessor :singleton
 
-      #Singleton method if using Cucumber
+      # Singleton method if using Cucumber
       # @return [Framework] singleton of self
       def get
-        return self.singleton
+        singleton
       end
     end
   end
-end
+end

data/lib/automation_object/helpers/composite.rb

@@ -1,30 +1,33 @@
-require_relative 'reflection_helper'
+# frozen_string_literal: true
+require_relative 'reflection'
 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
+  # 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
+    include Reflection
 
     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')
+    def initialize(_name = :top, parent = nil, location = 'top')
       self.parent = parent
       self.location = location
 
-      self.before_create_run
+      before_create_run
 
-      self.add_has_one_relationships
-      self.add_has_many_relationships
+      add_has_one_relationships
+      add_has_many_relationships
 
-      self.after_create_run
+      after_create_run
     end
 
+    # Remove getter to solve stupid Ruby warning
+    undef :children if method_defined? :children
     def children
       @children ||= {}
     end
@@ -32,15 +35,15 @@ module AutomationObject
     # 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
+      # Should recursively call top until parent is nil
+      parent.nil? ? 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)
+    def get_child(_name, _options)
       raise 'Abstract method'
     end
 
@@ -48,48 +51,48 @@ module AutomationObject
     # @param name [Symbol] name of child
     # @param options [Hash] options for child
     # @return children [Hash] return children and names
-    def get_children(name, options)
+    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])
-      }
+      self.class.has_one_relationships.each do |name, options|
+        children[name] = get_child(name, options)
+        add_attribute(name, children[name])
+      end
     end
 
     def add_has_many_relationships
-      self.class.has_many_relationships.each { |name, options|
+      self.class.has_many_relationships.each do |name, options|
         composite_children = get_children(name, options)
-        self.children[name] = composite_children
-        self.add_attribute(name, self.children[name])
-      }
+        children[name] = composite_children
+        add_attribute(name, children[name])
+      end
     end
 
     class << self
-      #Has many children relationship for the composite
+      # 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
+        has_many_relationships[children_name] = args
       end
 
       # @return [Hash] relationships for the composite
       def has_many_relationships
-        @has_many_relationships ||= Hash.new
+        @has_many_relationships ||= {}
       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
+        has_one_relationships[child_name] = args
       end
 
       # @return [Hash] hash of relationships
       def has_one_relationships
-        @has_one_relationships ||= Hash.new
+        @has_one_relationships ||= {}
       end
     end
   end
-end
+end

data/lib/automation_object/helpers/composite_hook.rb

@@ -1,16 +1,17 @@
+# frozen_string_literal: true
 module AutomationObject
-  #Hooks for composites
+  # Hooks for composites
   module CompositeHook
     def before_create_run
-      self.class.before_create_hooks.each { |before_create_hook|
-        self.send(before_create_hook)
-      }
+      self.class.before_create_hooks.each do |before_create_hook|
+        send(before_create_hook)
+      end
     end
 
     def after_create_run
-      self.class.after_create_hooks.each { |after_create_hook|
-        self.send(after_create_hook)
-      }
+      self.class.after_create_hooks.each do |after_create_hook|
+        send(after_create_hook)
+      end
     end
 
     # @param base [Class] class to extend when included
@@ -18,29 +19,29 @@ module AutomationObject
       base.extend(ClassMethods)
     end
 
-    #Class level methods
+    # Class level methods
     module ClassMethods
       # @param instance_method [Symbol] method to call
       def after_create(instance_method)
-        self.after_create_hooks.push(instance_method)
+        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
+        @after_create_hooks = [] unless defined? @after_create_hooks
+        @after_create_hooks
       end
 
       # @param instance_method [Symbol] method to call
       def before_create(instance_method)
-        self.before_create_hooks.push(instance_method)
+        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
+        @before_create_hooks = [] unless defined? @before_create_hooks
+        @before_create_hooks
       end
     end
   end
-end
+end

data/lib/automation_object/{blue_print/helpers/file_helper.rb → helpers/file.rb}

@@ -1,16 +1,16 @@
-module AutomationObject::BluePrint
-  #Collect files in directory recursively and return Array
-  module FileHelper
+# frozen_string_literal: true
+# Extend file class
+# Collect files in directory recursively and return Array
+class File
+  class << self
     # @param path [String] specified directory path for getting files underneath
     # @returns [Array] list of file paths that exist recursively underneath a directory
     def collect_files(path)
-      unless File.exists?(path)
-        raise "Expecting path to exist, got #{path}"
-      end
+      raise "Expecting path to exist, got #{path}" unless File.exist?(path)
 
       if File.directory?(path)
-        @file_array = Array.new
-        self.recursive_collection(path)
+        @file_array = []
+        recursive_collection(path)
       else
         @file_array = [path]
       end
@@ -24,15 +24,15 @@ module AutomationObject::BluePrint
     # @param path [String] specified directory path for getting files underneath
     def recursive_collection(path)
       Dir.foreach(path) do |item|
-        next if item == '.' or item == '..'
+        next if item == '.' || item == '..'
 
-        file_path = File.join(path, "#{item}")
+        file_path = File.join(path, item.to_s)
         if File.directory?(file_path)
-          self.recursive_collection(file_path)
+          recursive_collection(file_path)
         else
           @file_array.push(file_path)
         end
       end
     end
   end
-end
+end

data/lib/automation_object/helpers/hash.rb

@@ -1,8 +1,9 @@
-#Hash class method additions
-class ::Hash
+# frozen_string_literal: true
+# 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)
+    merger = proc { |_key, v1, v2| v1.is_a?(Hash) && v2.is_a?(Hash) ? v1.merge(v2, &merger) : v2 }
+    merge(second, &merger)
   end
 
   def symbolize_keys_deep!(h = self)
@@ -12,4 +13,4 @@ class ::Hash
       symbolize_keys_deep! h[ks] if h[ks].is_a?(Hash)
     end
   end
-end
+end

data/lib/automation_object/helpers/kernel.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+# Kernel method additions
+module Kernel
+  def suppress_warnings
+    original_verbosity = $VERBOSE
+    $VERBOSE = nil
+    result = yield
+    $VERBOSE = original_verbosity
+    result
+  end
+end

data/lib/automation_object/helpers/{reflection_helper.rb → reflection.rb}

@@ -1,28 +1,29 @@
+# frozen_string_literal: true
 module AutomationObject
-  #Helper module for adding attributes/alias to classes dynamically
-  #Reflection/MetaProgramming
-  module ReflectionHelper
+  # Helper module for adding attributes/alias to classes dynamically
+  # Reflection/MetaProgramming
+  module Reflection
     # @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)
+      self.class.send(:attr_accessor, name) unless self.class.method_defined? name
       instance_variable_set("@#{name}", value)
 
-      self.add_alias(alias_name, name) if alias_name
+      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;
+      singleton_class = class << self
+        self
       end
       singleton_class.send(:define_method, alias_name) do
         instance_variable_get("@#{attribute_name}")
       end
     end
   end
-end
+end

data/lib/automation_object/helpers/string.rb

@@ -1,27 +1,37 @@
-#String class method additions
-class ::String
+# frozen_string_literal: true
+# String class method additions
+class String
+  # Test whether a string is a valid url or not
+  # @return [Boolean]
   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
+    return true if uri.is_a?(URI::HTTP)
+    return !(self =~ /^(http|https):\/\/[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$/ix).nil?
   rescue URI::InvalidURIError
     return false
   end
 
   def join_url(url)
-    full_url = self.chomp('/') + url.reverse.chomp('/').reverse
-    return full_url
+    full_url = chomp('/') + url.reverse.chomp('/').reverse
+    full_url
   end
 
+  # Convert self to pascal case
   def pascalize
     return self if self !~ /_/ && self =~ /[A-Z]+.*/
-    self.split('_').map { |part| part.capitalize }.join
+    split('_').map(&:capitalize).join
   end
-end
+
+  # Convert string to underscore
+  # @return [String] underscored self string
+  def to_underscore!
+    gsub!(/(.)([A-Z])/, '\1_\2')
+    downcase!
+  end
+
+  # Convert string to underscore
+  # @return [String] underscored string
+  def to_underscore
+    dup.tap(&:to_underscore!)
+  end
+end