insite 0.0.1

data/lib/insite/page/undefined_page.rb

@@ -0,0 +1,74 @@
+module Insite
+  class UndefinedPage
+    attr_reader :arguments, :browser, :has_fragment, :page_attributes, :page_elements, :page_features, :page_url, :query_arguments, :required_arguments, :site, :url_template, :url_matcher
+
+    include Insite::CommonMethods
+
+    # Always returns false.
+    def defined?
+      false
+    end
+
+    def describe
+  puts <<-EOF
+  Page Class:\t#{name} (#{__FILE__})
+  URL Template:\tNA
+  URL Matcher:\tNA
+
+  Page class for any page that hasn't been defined (or that Insite doesn't recognize.)
+
+  Note: If there is a page class that is defined for this page that isn't getting
+  loaded, try the following:
+   - Review the pages URL template for problems. A URL template is *not* an interpolated
+     string -- it just looks like one. See the documentation for more details.
+   - If the URL template seems to be designed correctly for loading the page, but the
+     page's URL changes after the load, you will need to look at adding a URL matcher,
+     which overrides the URL template for purposes of checking whether the page object
+     is matching the currently displayed page after it has been loaded.
+
+  Page Elements:\tNA
+  EOF
+    end
+
+    def initialize(site)
+      @site    = site
+      @browser = process_browser
+      @url     = @site.browser.url
+    end
+
+    # TODO: Do the same cache check that's done for a defined page and reapply the
+    # method if the cache is updated and the new page DOES respond to the method.
+    def method_missing(mth, *args, &block)
+      raise NoMethodError, "Could not apply #{mth}. The current page could not be " \
+      "recognized. Current URL #{@browser.url}"
+    end
+
+    # Returns a Nokogiri object for the page HTML.
+    def nokogiri
+      @site.nokogiri
+    end
+
+    # Similar to the method that you can call on a page object you've defined (but always
+    # returns false since the Undefined page class is only returned when the current page
+    # doesn't match up to any page that you've actually defined.
+    def on_page?
+      false
+    end
+
+    # Returns an empty Array (since the page hasn't been defined.)
+    def page_elements
+      []
+    end
+    alias_method :widget_elements, :page_elements
+
+    # Returns the current URL.
+    def url
+      @browser.url
+    end
+
+    # Returns the page title displayed by the browser.
+    def title
+      @browser.title
+    end
+  end
+end

data/lib/insite/version.rb

@@ -0,0 +1,3 @@
+module Insite
+  VERSION = '0.0.1'
+end

data/lib/insite/widget/widget.rb

@@ -0,0 +1,342 @@
+require_relative 'widget_methods'
+require_relative '../methods/common_methods'
+
+# Allows the page object developer to encapsulate common web application features
+# into a "widget" that can be reused across multiple pages. Let's say that a
+# web application has a search widget that is used in 11 of the application's pages.
+# With a modern web app all of those search widgets will likely be implemented
+# in a common way, with a similar or identical structure in the HTML. The widget
+# would look something like this:
+#
+#  class SearchWidget < Widget
+#    text_field :query, id: 'q'
+#    button :search_button, name: 'Search'
+#
+#    def search(search_query)
+#      query.set search_query
+#      search_button.click
+#    end
+#
+#    def clear
+#      query.set ''
+#      search_button.click
+#    end
+#  end
+#
+# Once the widget has been defined, it can be included in a page object definition
+# like this:
+#
+#  class SomePage < SomeSite::Page
+#    set_url 'some_page'
+#    search_widget :search_for_foo, :div, class: 'search-div'
+#  end
+#
+# The search widget can then be accessed like this when working with the site:
+#  site.some_page.search_for_foo 'some search term'
+#  site.search_for_foo.clear
+#
+# Widgets can be embedded in other widgets, but in that case, the arguments for
+# accessing the child widget need to be RELATIVE to the parent widget. For example:
+#
+#  # Generic link menu, you hover over it and one or more links are displayed.
+#  class LinkMenu < Widget
+#  end
+#
+#  # Card widget that uses the link_menu widget. In this case, link_menu widget
+#  # arguments will be used to find a div a div with class == 'card-action-links'
+#  # WITHIN the card itself. This ensures that, if there are multiple cards
+#  # on the page that have link_menus, the CORRECT link_menu will be accessed
+#  # rather than one for some other card widget.
+#  class Card < Widget
+#    link_menu :card_menu, :div, class: 'card-action-links'
+#  end
+module Insite
+  class Widget
+    attr_reader :site, :browser, :type, :args, :target
+
+    include CommonMethods
+    alias_method :update_widget, :update_object
+
+    class << self
+      attr_reader :widget_elements
+
+      include DOMMethods
+      include WidgetMethods
+
+      # - Don't allow the user to create a widget with a name that matches a DOM
+      #   element.
+      #
+      # - Don't allow the user to create a widget method that references a
+      #   collection (because this will be done automatically.)
+      tmp = name.to_s.underscore.to_sym
+      if DOM_METHODS.include?(name.to_s.underscore.to_sym)
+        raise "#{name} cannot be used as a widget name, as the methodized version of the class name (#{name.to_s.underscore} conflicts with a Watir DOM method.)"
+      elsif Watir::Browser.methods.include?(name.to_s.underscore.to_sym)
+        raise "#{name} cannot be used as a widget name, as the methodized version of the class name (#{name.to_s.underscore} conflicts with a Watir::Browser method.)"
+      end
+
+      if tmp =~ /.*s+/
+        raise "Invalid widget type :#{tmp}. You can create a widget for the DOM object but it must be for :#{tmp.singularize} (:#{tmp} will be created automatically.)"
+      end
+    end # Self.
+
+    extend Forwardable
+
+    def self.inherited(subclass)
+      name_string            = subclass.name.demodulize.underscore
+      pluralized_name_string = name_string.pluralize
+
+      if name_string == pluralized_name_string
+        raise ArgumentError, "When defining a new widget, define the singular version only (Plural case will be handled automatically.)"
+      end
+
+      # Creates an accessor method for a new widget when one gets defined via inheritance.
+      # In this case the method is for a single instance of the widget. The top-level block
+      # defines the widget accessor in the Insite::Widget module. The methods in that module
+      # automatically get included in page classes and are used to define widget accessors.
+      #
+      # In this case an accessor for an individual widget is being defined.
+      WidgetMethods.send(:define_method, name_string) do |method_name, dom_type, *args, &block|
+        unless name_string == 'Widget'
+          @widget_elements ||= []
+          @widget_elements << method_name.to_sym unless @widget_elements.include?(method_name.to_sym)
+
+          define_method(method_name) do
+            if is_a? Widget
+              elem = send(dom_type, *args, &block)
+            else
+              elem = @browser.send(dom_type, *args, &block)
+            end
+
+            # TODO: Bandaid.
+            if dom_type.to_s == dom_type.to_s.pluralize
+              raise ArgumentError, "Individual widget method :#{method_name} cannot initialize a widget using an element collection (#{elem.class}.) Use :#{method_name.pluralize} rather than :#{method_name} if you want to define a widget collection."
+            else
+              subclass.new(self, dom_type, *args, &block)
+            end
+          end
+        end
+      end
+
+      # Creates an accessor method for a new widget when one gets defined via inheritance.
+      # In this case the method is for a single instance of the widget. The top-level block
+      # defines the widget accessor in the Insite::Widget module. The methods in that module
+      # automatically get included in page classes and are used to define widget accessors.
+      #
+      # In this case an accessor is being defined for a widget collection.
+      #
+      # TODO: The current implementation for widget collections isn't ideal and should be
+      # replaced at some point. It'd be much better to use a (lazy) custom collection for this.
+      WidgetMethods.send(:define_method, pluralized_name_string) do |method_name, dom_type, *args, &block|
+        unless name_string == 'Widget'
+          @widget_elements ||= []
+          @widget_elements << method_name.to_sym unless @widget_elements.include?(method_name.to_sym)
+
+          define_method(method_name) do
+            if is_a?(Widget) && present?
+              elem = send(dom_type, *args, &block)
+            elsif is_a?(Widget) && !present?
+              return []
+            else
+              elem = @browser.send(dom_type, *args, &block)
+            end
+
+            # TODO: Bandaid.
+            if dom_type.to_s == dom_type.to_s.singularize
+              raise ArgumentError, "Widget collection method :#{method_name} cannot initialize a widget collection using an individual element (#{elem.class}.) Use :#{method_name.to_s.singularize} rather than :#{method_name} if you want to define a widget for an individual element."
+            else
+              # TODO: Revisit the whole .to_a thing, need a custom collection or
+              # somesuch (don't bypass watir wait logic.)
+              t = Time.now
+              loop do
+                elem = @browser.send(dom_type, *args, &block)
+                break if elem.present? && elem.length > 0
+                break if Time.now > t + 4
+              end
+
+              if elem.present?
+                elem.to_a.map! { |x| subclass.new(self, x, [], &block) }
+              else
+                []
+              end
+            end
+          end
+        end
+      end
+    end # self.
+
+    # This method gets used 2 different ways. Most of the time, dom_type and args
+    # will be a symbol and a set of hash arguments that will be used to locate an
+    # element.
+    #
+    # In some cases, dom_type can be a Watir DOM object, and in this case, the
+    # args are ignored and the widget is initialized using the Watir object.
+    #
+    # TODO: Needs a rewrite, lines between individual and collection are blurred
+    # here and that makes the code more confusing. And there should be a proper
+    # collection class for element collections, with possibly some AR-like accessors.
+    def initialize(parent, dom_type, *args)
+      @parent   = parent
+      @site     = parent.class.ancestors.include?(Insite) ? parent : parent.site
+      @browser  = @site.browser
+      @widget_elements = self.class.widget_elements
+
+      if dom_type.is_a?(Watir::HTMLElement) || dom_type.is_a?(Watir::Element)
+        @dom_type = nil
+        @args     = nil
+        @target   = dom_type
+      elsif [String, Symbol].include? dom_type.class
+        @dom_type = dom_type
+        @args     = args
+
+        if @parent.is_a? Widget
+          @target = @parent.send(dom_type, *args)
+        else
+          @target = @browser.send(dom_type, *args)
+        end
+
+        # New webdriver approach.
+        begin
+          @target.scroll.to
+          sleep 0.1
+        rescue => e
+          t = Time.now + 2
+          while Time.now <= t do
+            break if @target.present?
+            sleep 0.1
+          end
+        end
+      elsif dom_type.is_a? Watir::ElementCollection
+        @dom_type = nil
+        @args     = nil
+        if @parent.is_a? Widget
+          @target = dom_type.map { |x| self.class.new(@parent, x.to_subtype) }
+        else
+          @target = dom_type.map { |x| self.class.new(@site, x.to_subtype) }
+        end
+      else
+        raise "Unhandled exception."
+      end
+    end
+
+    # Delegates method calls down to the widget's wrapped element if the element supports the method.
+    #
+    # Supports dynamic link methods. Examples:
+    #  s.accounts_page account
+    #
+    #  # Nav to linked page only.
+    #  s.account_actions.edit_account_info
+    #
+    #  # Update linked page after nav:
+    #  s.account_actions.edit_account_info username: 'foo'
+    #
+    #  # Link with modal (if the modal requires args they should be passed as hash keys):
+    #  # s.hosted_pages.refresh_urls
+    def method_missing(mth, *args, &block)
+      if @target.respond_to? mth
+        @target.send(mth, *args, &block)
+      else
+        if args[0].is_a? Hash
+          page_arguments = args[0]#.with_indifferent_access
+        elsif args.empty?
+          # Do nothing.
+        elsif args[0].nil?
+          raise ArgumentError, "Optional argument for :#{mth} must be a hash. Got NilClass."
+        else
+          raise ArgumentError, "Optional argument must be a hash (got #{args[0].class}.)"
+        end
+
+        if present?
+          # If it's a widget we want to hover over it to ensure links are visible
+          # before trying to find them.
+          if self.is_a?(Widget)
+            t = Time.now
+            loop do
+              begin
+                scroll.to
+                hover
+                sleep 0.2
+                break
+              rescue => e
+                break if Time.now > t + 10
+                sleep 0.2
+              end
+            end
+          end
+
+          # Dynamic helper method, returns DOM object for link (no validation).
+          if mth.to_s =~ /_link$/
+            return a(text: /^#{mth.to_s.sub(/_link$/, '').gsub('_', '.*')}/i)
+          # Dynamic helper method, returns DOM object for button (no validation).
+          elsif mth.to_s =~ /_button$/
+            return button(value: /^#{mth.to_s.sub(/_button$/, '').gsub('_', '.*')}/i)
+          # Dynamic helper method for links. If a match is found, clicks on the link and performs follow up actions.
+          elsif elem = as.find { |x| x.text =~ /^#{mth.to_s.gsub('_', '.*')}/i } # See if there's a matching button and treat it as a method call if so.
+            elem.click
+            sleep 1
+
+            current_page = @site.page
+
+            if page_arguments.present?
+
+              if current_page.respond_to?(:submit)
+                current_page.submit page_arguments
+              elsif @browser.input(xpath: "//div[starts-with(@class,'Row') and last()]//input[@type='submit' and last()]").present?
+                current_page.update_page page_arguments
+                @browser.input(xpath: "//div[starts-with(@class,'Row') and last()]//input[@type='submit' and last()]").click
+              end
+              current_page = @site.page
+            end
+          # Dynamic helper method for buttons. If a match is found, clicks on the link and performs follow up actions.
+          elsif elem = buttons.find { |x| x.text =~ /^#{mth.to_s.gsub('_', '.*')}/i } # See if there's a matching button and treat it as a method call if so.
+            elem.click
+            sleep 1
+
+            if @site.modal.present?
+              @site.modal.continue(page_arguments)
+            else
+              current_page = @site.page
+
+              if page_arguments.present?
+                if current_page.respond_to?(:submit)
+                  current_page.submit page_arguments
+                elsif @browser.input(xpath: "//div[starts-with(@class,'Row') and last()]//input[@type='submit' and last()]").present?
+                  current_page.update_page page_arguments
+                  @browser.input(xpath: "//div[starts-with(@class,'Row') and last()]//input[@type='submit' and last()]").click
+                end
+                current_page = @site.page
+              end
+            end
+          else
+            raise NoMethodError, "undefined method `#{mth}' for #{self.class}."
+          end
+        else
+          raise NoMethodError, "Unhandled method call `#{mth}' for #{self.class} (The widget was not present in the DOM at the point that the method was called.)"
+        end
+
+        page_arguments.present? ? page_arguments : current_page
+      end
+    end
+
+    def present?
+      sleep 0.1
+      begin
+        if @parent
+          if @parent.present? && @target.present?
+            true
+          else
+            false
+          end
+        else
+          if @target.present?
+            true
+          else
+            false
+          end
+        end
+      rescue => e
+        false
+      end
+    end
+  end
+end

data/lib/insite/widget/widget_methods.rb

@@ -0,0 +1,4 @@
+module Insite
+  module WidgetMethods
+  end
+end

metadata

@@ -0,0 +1,198 @@
+--- !ruby/object:Gem::Specification
+name: insite
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- John Fitisoff
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-04-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: watir
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+- !ruby/object:Gem::Dependency
+  name: watir-scroll
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Page object library.
+email: jfitisoff@yahoo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/insite.rb
+- lib/insite/constants.rb
+- lib/insite/element_container/element_container.rb
+- lib/insite/errors.rb
+- lib/insite/feature/feature.rb
+- lib/insite/insite.rb
+- lib/insite/methods/common_methods.rb
+- lib/insite/methods/dom_methods.rb
+- lib/insite/page/defined_page.rb
+- lib/insite/page/undefined_page.rb
+- lib/insite/version.rb
+- lib/insite/widget/widget.rb
+- lib/insite/widget/widget_methods.rb
+homepage: http://rubygems.org/gems/insite
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.1
+signing_key: 
+specification_version: 4
+summary: Wraps page objects up into a site object, which provides some introspection
+  and navigation capabilities that page objects don't provide. Works with Watir and
+  Selenium.
+test_files: []