page_magic 1.0.0.alpha13 → 1.0.0.alpha17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3bd5d9cee944d0fe84e178901c4db272f56cab69
-  data.tar.gz: f0a9352162e73a5dbffa7b835043e6da5d77f52b
+  metadata.gz: b6aee6a0833a50dbf849f13b2c7a4c3668feef1d
+  data.tar.gz: b4d0aecfbba7509a3ffb9e2bf08b38cb30f4cb64
 SHA512:
-  metadata.gz: e1721e6c1e3db25d8374e08f0a0f6f17e680c3cc84735a8b02bc9afac1370236da7e14cb61265d90b3643178d6ab221b8ed44bca06cee6f0bdd8bbd5fa88ac0f
-  data.tar.gz: f4bf17178033131e4656a2564a0a752a9638a2e36bd9215e054a63993dcba1ce1708a15f00a26573f7f9b0fad122aa518fef14b5c4038920eef80d54948fa770
+  metadata.gz: 4437e58a2107ffcec212ee3778450b73f5384bc46581c78b53c8f28e2c69d3a5c42731c1a8356ff1c42e2ccdb7ba5b4af0c68c6de62477e34349729b9fbc13fd
+  data.tar.gz: 27e427b3fa2bc153836c545b24ef9ea3cf14e360eba3acc3f7fb932ff2c694a6262746735d60eb4752749f0c9cb335bf55c8ff82d4a4ea0f0fe0517f91e5df2d

data/.rubocop.yml

@@ -1,9 +1,15 @@
 Documentation:
   Enabled: false
 
+Metrics/LineLength:
+  Max: 120
+
 AllCops:
   Exclude:
     - 'pkg/**/*'
     - 'vendor/**/*'
     - 'coverage/**/*'
     - '.idea/**/*'
+
+Metrics/ParameterLists:
+  CountKeywordArgs: false

data/.simplecov

@@ -0,0 +1,3 @@
+SimpleCov.start do
+  add_filter '/spec/'
+end

data/Gemfile

@@ -1,4 +1,4 @@
-source 'http://rubygems.org'
+source 'https://rubygems.org'
 
 gem 'capybara'
 gem 'activesupport'

data/Gemfile.lock

@@ -1,5 +1,5 @@
 GEM
-  remote: http://rubygems.org/
+  remote: https://rubygems.org/
   specs:
     activesupport (4.2.3)
       i18n (~> 0.7)
@@ -21,7 +21,7 @@ GEM
     childprocess (0.3.9)
       ffi (~> 1.0, >= 1.0.11)
     cliver (0.2.2)
-    diff-lcs (1.2.4)
+    diff-lcs (1.2.5)
     faraday (0.8.9)
       multipart-post (~> 1.2.0)
     ffi (1.9.3)
@@ -79,14 +79,19 @@ GEM
     rake (10.2.2)
     rdoc (4.1.1)
       json (~> 1.4)
-    rspec (2.14.1)
-      rspec-core (~> 2.14.0)
-      rspec-expectations (~> 2.14.0)
-      rspec-mocks (~> 2.14.0)
-    rspec-core (2.14.6)
-    rspec-expectations (2.14.3)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.14.4)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.2)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
     rubocop (0.34.0)
       astrolabe (~> 1.3)
       parser (>= 2.2.2.5, < 3.0)

data/VERSION

@@ -1 +1 @@
-1.0.0.alpha13
+1.0.0.alpha17

data/lib/page_magic/drivers.rb

@@ -19,12 +19,12 @@ module PageMagic
       Dir["#{path}/*.rb"].each do |driver_file|
         require driver_file
         driver_name = File.basename(driver_file)[/(.*)\.rb$/, 1]
-        register eval(driver_name.classify)
+        register self.class.const_get(driver_name.classify)
       end
     end
 
     def ==(other)
-      other.is_a?(Drivers) && other.all == other.all
+      other.is_a?(Drivers) && all == other.all
     end
   end
 end

data/lib/page_magic/element/method_observer.rb

@@ -0,0 +1,13 @@
+module PageMagic
+  class Element
+    module MethodObserver
+      def singleton_method_added(arg)
+        @singleton_methods_added = true unless arg == :singleton_method_added
+      end
+
+      def singleton_methods_added?
+        @singleton_methods_added == true
+      end
+    end
+  end
+end

data/lib/page_magic/element/query.rb

@@ -0,0 +1,38 @@
+module PageMagic
+  class Element
+    # class Query - models overall queries for Capybara, queries can include:
+    #  - requirements on element type
+    #  - selection criteria, modeled through the Selector class
+    #  - options
+
+    class Query
+      class << self
+        def find(type)
+          query = constants.find { |constant| constant.to_s.downcase == type.to_s.downcase }
+          return ELEMENT unless query
+          const_get(query)
+        end
+      end
+
+      attr_reader :type
+
+      # @param type -
+      def initialize(type = nil)
+        @type = type
+      end
+
+      def build(locator, options = {})
+        [].tap do |array|
+          selector = Selector.find(locator.keys.first)
+          array << selector.build(type, locator.values.first)
+          array << options unless options.empty?
+        end.flatten
+      end
+
+      ELEMENT = Query.new
+      TEXT_FIELD = CHECKBOX = SELECT_LIST = RADIOS = TEXTAREA = Query.new(:field)
+      LINK = Query.new(:link)
+      BUTTON = Query.new(:button)
+    end
+  end
+end

data/lib/page_magic/element/selector.rb

@@ -0,0 +1,40 @@
+module PageMagic
+  class Element
+    # class Selector - models the selection criteria understood by Capybara
+    class Selector
+      class << self
+        def find(name)
+          selector = constants.find { |constant| constant.to_s.downcase == name.to_s.downcase }
+          fail UnsupportedCriteriaException unless selector
+          const_get(selector)
+        end
+      end
+
+      def build(element_type, locator)
+        [].tap do |array|
+          array << element_type if supports_type
+          array << name if name
+          array << formatter.call(locator)
+        end
+      end
+
+      attr_reader :name, :formatter, :supports_type
+
+      def initialize(selector = nil, supports_type: false, &formatter)
+        @name = selector
+        @formatter = formatter || proc { |arg| arg }
+        @supports_type = supports_type
+      end
+
+      XPATH = Selector.new(:xpath, supports_type: false)
+      ID = Selector.new(:id, supports_type: false)
+      LABEL = Selector.new(:field, supports_type: false)
+
+      CSS = Selector.new(supports_type: false)
+      TEXT = Selector.new(supports_type: true)
+      NAME = Selector.new(supports_type: false) do |arg|
+        "*[name='#{arg}']"
+      end
+    end
+  end
+end

data/lib/page_magic/element/selector_methods.rb

@@ -0,0 +1,10 @@
+module PageMagic
+  class Element
+    module SelectorMethods
+      def selector(selector = nil)
+        return @selector unless selector
+        @selector = selector
+      end
+    end
+  end
+end

data/lib/page_magic/element.rb

@@ -1,53 +1,37 @@
+require 'page_magic/element/method_observer'
+require 'page_magic/element/selector_methods'
+require 'page_magic/element/selector'
+require 'page_magic/element/query'
 module PageMagic
-  module MethodObserver
-    def singleton_method_added(arg)
-      @singleton_methods_added = true unless arg == :singleton_method_added
-    end
-
-    def singleton_methods_added?
-      @singleton_methods_added == true
-    end
-  end
-
   class Element
     EVENT_TYPES = [:set, :select, :select_option, :unselect_option, :click]
-    attr_reader :type, :name, :selector, :browser_element
+    DEFAULT_HOOK = proc {}.freeze
+    attr_reader :type, :name, :parent_page_element, :browser_element
 
-    include Elements
+    include Elements, MethodObserver, SelectorMethods
+    extend SelectorMethods
 
     class << self
       def inherited(clazz)
         clazz.extend(Elements)
-
-        def clazz.selector(selector = nil)
-          return @selector unless selector
-          @selector = selector
-        end
       end
     end
 
-    def initialize(name, parent_page_element, options, &block)
-      options = {type: :element, selector: {}, browser_element: nil}.merge(options)
-      @browser_element = options[:browser_element]
-      @selector = options[:selector]
+    def initialize(name, parent_page_element, type: :element, selector: {}, browser_element: nil, &block)
+      @browser_element = browser_element
+      @selector = selector
 
-      @before_hook = proc {}
-      @after_hook = proc {}
+      @before_hook = DEFAULT_HOOK
+      @after_hook = DEFAULT_HOOK
       @parent_page_element = parent_page_element
-      @type = options[:type]
+      @type = type
       @name = name.to_s.downcase.to_sym
-
-      extend MethodObserver
-      expand &block if block
+      expand(&block) if block
     end
 
     def expand(*args, &block)
-      instance_exec *args, &block
-    end
-
-    def selector(selector = nil)
-      return @selector unless selector
-      @selector = selector
+      instance_exec(*args, &block)
+      self
     end
 
     def section?
@@ -68,19 +52,14 @@ module PageMagic
       @after_hook = block
     end
 
-    def method_missing method, *args, &block
+    def method_missing(method, *args, &block)
+      ElementContext.new(self, browser_element, self, *args).send(method, args.first, &block)
+    rescue ElementMissingException
       begin
-        ElementContext.new(self, browser_element, self, *args).send(method, args.first, &block)
-      rescue ElementMissingException
-        begin
-          if browser_element.respond_to?(method)
-            browser_element.send(method, *args, &block)
-          else
-            @parent_page_element.send(method, *args, &block)
-          end
-        rescue ElementMissingException
-          super
-        end
+        return browser_element.send(method, *args, &block) if browser_element.respond_to?(method)
+        return parent_page_element.send(method, *args, &block)
+      rescue NoMethodError, ElementMissingException
+        super
       end
     end
 
@@ -90,77 +69,59 @@ module PageMagic
 
     def browser_element(*_args)
       return @browser_element if @browser_element
-      fail UndefinedSelectorException, 'Pass a selector/define one on the class' if @selector.empty?
-      if @selector
-        selector_copy = @selector.dup
-        method = selector.keys.first
-        selector = selector_copy.delete(method)
-        options = selector_copy
-
-        finder_method, selector_type, selector_arg = case method
-                                                       when :id
-                                                         [:find, "##{selector}"]
-                                                       when :xpath
-                                                         [:find, :xpath, selector]
-                                                       when :name
-                                                         [:find, "*[name='#{selector}']"]
-                                                       when :css
-                                                         [:find, :css, selector]
-                                                       when :label
-                                                         [:find_field, selector]
-                                                       when :text
-                                                         if @type == :link
-                                                           [:find_link, selector]
-                                                         elsif @type == :button
-                                                           [:find_button, selector]
-                                                         else
-                                                           fail UnsupportedSelectorException
-                                                         end
-
-                                                       else
-                                                         fail UnsupportedSelectorException
-                                                     end
-
-        finder_args = [selector_type, selector_arg].compact
-        finder_args << options unless options.empty?
-        @browser_element = @parent_page_element.browser_element.send(finder_method, *finder_args).tap do |browser_element|
-          EVENT_TYPES.each do |action_method|
-            apply_hooks(page_element: browser_element,
-                        capybara_method: action_method,
-                        before_hook: before,
-                        after_hook: after)
-          end
-        end
 
-      end
-    end
+      fail UndefinedSelectorException, 'Pass a locator/define one on the class' if selector.empty?
 
-    def apply_hooks(options)
-      _self = self
-      page_element = options[:page_element]
-      capybara_method = options[:capybara_method]
-      if page_element.respond_to?(capybara_method)
-        original_method = page_element.method(capybara_method)
+      query = Query.find(type).build(query_selector, query_options)
 
-        page_element.define_singleton_method capybara_method do |*arguments, &block|
-          _self.call_hook &options[:before_hook]
-          original_method.call *arguments, &block
-          _self.call_hook &options[:after_hook]
-        end
+      @browser_element = parent_browser_element.send(:find, *query).tap do |raw_element|
+        wrap_events(raw_element)
       end
     end
 
-    def call_hook(&block)
-      @executing_hooks = true
-      result = instance_exec @browser, &block
-      @executing_hooks = false
-      result
+    def ==(other)
+      return false unless other.is_a?(Element)
+      this = [type, name, selector, before, after]
+      this == [other.type, other.name, other.selector, other.before, other.after]
     end
 
     private
 
+    def query_selector
+      Hash[*selector.first]
+    end
+
+    def query_options
+      selector.dup.delete_if { |key, _value| key == selector.keys.first }
+    end
+
     def element_context(*args)
       ElementContext.new(self, @browser_element, self, *args)
     end
+
+    def wrap_events(raw_element)
+      EVENT_TYPES.each do |action_method|
+        next unless raw_element.respond_to?(action_method)
+        apply_hooks(raw_element: raw_element,
+                    capybara_method: action_method,
+                    before_hook: before,
+                    after_hook: after)
+      end
+    end
+
+    def parent_browser_element
+      parent_page_element.browser_element
+    end
+
+    def apply_hooks(raw_element:, capybara_method:, before_hook:, after_hook:)
+      original_method = raw_element.method(capybara_method)
+      this = self
+
+      raw_element.define_singleton_method(capybara_method) do |*arguments, &block|
+        this.instance_exec(&before_hook)
+        original_method.call(*arguments, &block)
+        this.instance_exec(&after_hook)
+      end
+    end
   end
 end

data/lib/page_magic/element_context.rb

@@ -7,9 +7,8 @@ module PageMagic
 
     attr_reader :caller, :page_element
 
-    def initialize(page_element, browser, caller, *_args)
+    def initialize(page_element, caller, *_args)
       @page_element = page_element
-      @browser = browser
       @caller = caller
     end
 
@@ -18,13 +17,9 @@ module PageMagic
 
       element_locator_factory = page_element.element_definitions[method]
 
-      raise ElementMissingException, "Could not find: #{method}" unless element_locator_factory
+      fail ElementMissingException, "Could not find: #{method}" unless element_locator_factory
 
-      if args.empty?
-        element_locator = element_locator_factory.call(page_element, nil)
-      else
-        element_locator = element_locator_factory.call(page_element, *args)
-      end
+      element_locator = element_locator_factory.call(page_element, *args)
 
       element_locator.section? ? element_locator : element_locator.browser_element
     end

data/lib/page_magic/elements.rb

@@ -1,22 +1,17 @@
-require 'ext/string'
 require 'active_support/inflector'
 module PageMagic
   module Elements
-    class InvalidElementNameException < Exception
-    end
+    INVALID_METHOD_NAME_MSG = 'a method already exists with this method name'
 
-    class InvalidMethodNameException < Exception
+    module InstanceOnlyMethods
+      def element_definitions
+        self.class.element_definitions
+      end
     end
 
     def self.extended(clazz)
       clazz.class_eval do
-        unless instance_methods.include?(:browser_element)
-          attr_reader :browser_element
-        end
-
-        def element_definitions
-          self.class.element_definitions
-        end
+        include InstanceOnlyMethods
       end
     end
 
@@ -28,36 +23,30 @@ module PageMagic
       element_definitions.values.collect { |definition| definition.call(browser_element, *args) }
     end
 
-    TYPES = [:element, :text_field, :button, :link, :checkbox, :select_list, :radios, :textarea, :section]
-
-
-    TYPES.each do |type|
-      define_method type do |*args, &block|
-
-        section_class = remove_argument(args, Class) || Element
-
-        selector = remove_argument(args, Hash)
-        selector ||= section_class.selector if section_class.respond_to?(:selector)
-
-        name = remove_argument(args, Symbol)
-        name ||= section_class.name.demodulize.to_snake_case.to_sym unless section_class.is_a?(Element)
+    def element(*args, &block)
+      block ||= proc {}
 
-        options =  selector ? {selector: selector} : {browser_element: args.delete_at(0)}
+      section_class = remove_argument(args, Class) || Element
+      selector = compute_selector(args, section_class)
+      name = compute_name(args, section_class)
 
-        add_element_definition(name) do |parent_browser_element, *e_args|
-          section_class.new(name, parent_browser_element, options.merge(type: type)).tap do |section|
-            section.expand(*e_args, &(block || proc {}))
-          end
-        end
+      options = { type: __callee__ }
+      selector ? options[:selector] = selector : options[:browser_element] = args.delete_at(0)
 
+      add_element_definition(name) do |parent_browser_element, *e_args|
+        section_class.new(name, parent_browser_element, options).expand(*e_args, &block)
       end
     end
 
+    TYPES = [:text_field, :button, :link, :checkbox, :select_list, :radios, :textarea]
+
+    TYPES.each { |type| alias_method type, :element }
+
     def add_element_definition(name, &block)
       fail InvalidElementNameException, 'duplicate page element defined' if element_definitions[name]
 
       methods = respond_to?(:instance_methods) ? instance_methods : methods()
-      fail InvalidElementNameException, 'a method already exists with this method name' if methods.find { |method| method == name }
+      fail InvalidElementNameException, INVALID_METHOD_NAME_MSG if methods.find { |method| method == name }
 
       element_definitions[name] = block
     end
@@ -67,9 +56,20 @@ module PageMagic
     end
 
     private
+
     def remove_argument(args, clazz)
       argument = args.find { |arg| arg.is_a?(clazz) }
       args.delete(argument)
     end
+
+    def compute_name(args, section_class)
+      name = remove_argument(args, Symbol)
+      name || section_class.name.demodulize.underscore.to_sym unless section_class.is_a?(Element)
+    end
+
+    def compute_selector(args, section_class)
+      selector = remove_argument(args, Hash)
+      selector || section_class.selector if section_class.respond_to?(:selector)
+    end
   end
 end

data/lib/page_magic/exceptions.rb

@@ -6,4 +6,13 @@ module PageMagic
 
   class MissingLocatorOrSelector < Exception
   end
+
+  class InvalidElementNameException < Exception
+  end
+
+  class InvalidMethodNameException < Exception
+  end
+
+  class UnsupportedCriteriaException < Exception
+  end
 end

data/lib/page_magic/page_magic.rb

@@ -1,21 +1,20 @@
 module PageMagic
-  attr_reader :browser, :session
+  attr_reader :browser, :session, :browser_element
 
-  def initialize(session = Session.new(Capybara.current_session), options = {}, &block)
+  def initialize(session = Session.new(Capybara.current_session), &block)
     @browser = session.raw_session
     @session = session
 
-    @browser_element = @browser
-    navigate if options[:navigate_to_page]
-    block.call @browser if block
+    @browser_element = browser
+    block.call browser if block
   end
 
   def title
     browser.title
   end
 
-  def text_on_page?(text)
-    text().downcase.include?(text.downcase)
+  def text_on_page?(string)
+    text.downcase.include?(string.downcase)
   end
 
   def visit
@@ -36,6 +35,6 @@ module PageMagic
   end
 
   def element_context
-    ElementContext.new(self, @browser, self)
+    ElementContext.new(self, self)
   end
 end