insite 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: '094a111c4101a5cb18a2f76c6d46625ba32b255f'
+  data.tar.gz: c850f4e79fb102e8ab477d0de0821b6ed4deeb5e
+SHA512:
+  metadata.gz: 97aa7fa4c708b17b6b9bea7ea4408fa1aa566de7e2b4fa543329a06d55a9bde2ca0c9e73dc461ea2c3dd2c8305849b6b2774972f258a2f97e565104a8c955d41
+  data.tar.gz: a42caf8bf52e5f90a28e6f1909e1d14a6b5938fbe26fcaa427ba8112a3a9cecc6da47bdbe47c5ebd87864cd8632527e6b9935a6fcfed6433983802a9af3e5c49

data/lib/insite.rb

@@ -0,0 +1,29 @@
+require 'watir'
+require 'watir-scroll'
+require 'active_support'
+require 'active_support/core_ext'
+require 'addressable/template'
+require 'nokogiri'
+
+require "insite/constants"
+require "insite/insite"
+require "insite/errors"
+require "insite/version"
+
+# Modules with method definitions used by UI metaclasses.
+require "insite/methods/dom_methods"
+require "insite/methods/common_methods"
+
+# Files for Insite::Widget.
+require "insite/widget/widget"
+require "insite/widget/widget_methods"
+
+# Files for Insite::Feature.
+require "insite/feature/feature"
+
+# Files for ElementContainer.
+require "insite/element_container/element_container"
+
+# Files for pages (defined/undefined.)
+require "insite/page/defined_page"
+require "insite/page/undefined_page"

data/lib/insite/constants.rb

@@ -0,0 +1,32 @@
+# DOM_ELEMENTS
+# DOM_COLLECTIONS
+
+# Watir DOM methods. This data is used to create class-level element accessors
+# for page objects.
+DOM_METHODS = %i(
+  a            br          datalists         elements          forms       hidden   li                meshpatches  params            rect          source     tbody        tspan
+  abbr         brs         datas             ellipse           frame       hiddens  line              meshrow      path              rects         sources    tbodys       tspans
+  abbrs        bs          date_field        ellipses          frames      hr       linear_gradient   meshrows     paths             rp            span       td           u
+  address      button      date_fields       em                frameset    hrs      linear_gradients  meta         pattern           rps           spans      tds          ul
+  addresses    buttons     date_time_field   embed             framesets   htmls    lines             metadata     patterns          rt            ss         template     uls
+  area         canvas      date_time_fields  embeds            g           i        link              metadatas    picture           rtc           stop       templates    us
+  areas        canvases    dd                ems               gs          iframe   links             metas        pictures          rtcs          stops      text_field   use
+  article      caption     dds               extract_selector  h1          iframes  lis               meter        polygon           rts           strong     text_fields  uses
+  articles     captions    defs              field_set         h1s         image    main              meters       polygons          rubies        strongs    text_path    var
+  as           checkbox    defss             field_sets        h2          images   mains             nav          polyline          ruby          style      text_paths   vars
+  aside        checkboxes  del               fieldset          h2s         img      map               navs         polylines         s             styles     textarea     video
+  asides       circle      dels              fieldsets         h3          imgs     maps              noscript     pre               samp          sub        textareas    videos
+  audio        circles     desc              figcaption        h3s         input    mark              noscripts    pres              samps         subs       tfoot        view
+  audios       cite        descs             figcaptions       h4          inputs   marker            object       progress          script        summaries  tfoots       views
+  b            cites       details           figure            h4s         ins      markers           objects      progresses        scripts       summary    th           wbr
+  base         code        detailses         figures           h5          inses    marks             ol           ps                section       sup        thead        wbrs
+  bases        codes       dfn               file_field        h5s         is       menu              ols          q                 sections      sups       theads
+  bdi          col         dfns              file_fields       h6          kbd      menuitem          optgroup     qs                select        svg        ths
+  bdis         colgroup    div               font              h6s         kbds     menuitems         optgroups    radial_gradient   select_list   svgs       time
+  bdo          colgroups   divs              fonts             hatchpath   keygen   menus             option       radial_gradients  select_lists  switch     times
+  bdos         cols        dl                footer            hatchpaths  keygens  mesh              options      radio             selects       switches   titles
+  blockquote   cursor      dls               footers           head        label    meshes            output       radio_set         small         symbol     tr
+  blockquotes  cursors     dt                foreign_object    header      labels   meshgradient      outputs      radios            smalls        symbols    track
+  body         data        dts               foreign_objects   headers     legend   meshgradients     p            rb                solidcolor    table      tracks
+  bodys        datalist    element           form              heads       legends  meshpatch         param        rbs               solidcolors   tables     trs
+).freeze

data/lib/insite/element_container/element_container.rb

@@ -0,0 +1,42 @@
+class ElementContainer
+  attr_reader :target, :site
+
+  include Insite::CommonMethods
+  extend  Forwardable
+
+  class << self
+    include Insite::DOMMethods
+  end # self
+
+  def initialize(site, element)
+    @site    = site
+    @browser = @site.browser
+    @target  = element
+
+    # Temporary replacement for custom wait_until.
+    # TODO: Continue looking at scolling solutions.
+    if @target.present?
+      @target.scroll.to
+      t = Time.now + 2
+      while Time.now <= t do
+        break if @target.present?
+        sleep 0.1
+      end
+    end
+
+    @target
+  end
+
+  # For page widget code.
+  def method_missing(sym, *args, &block)
+    if @target.respond_to? sym
+      if @target.is_a? Watir::ElementCollection
+        @target.map { |x| self.class.new(x) }.send(sym, *args, &block)
+      else
+        @target.send(sym, *args, &block)
+      end
+    else
+      super
+    end
+  end
+end

data/lib/insite/errors.rb

@@ -0,0 +1,16 @@
+module Insite
+  module Errors
+    class Insite::Errors::BrowserClosedError              < StandardError; end
+    class Insite::Errors::BrowserLibraryNotSupportedError < StandardError; end
+    class Insite::Errors::BrowserNotAvailableError        < StandardError; end
+    class Insite::Errors::BrowserNotOpenError             < StandardError; end
+    class Insite::Errors::BrowserNotValidError            < StandardError; end
+    class Insite::Errors::BrowserResponseError            < StandardError; end
+    class Insite::Errors::PageConfigError                 < StandardError; end
+    class Insite::Errors::PageInitError                   < StandardError; end
+    class Insite::Errors::PageNavigationError             < StandardError; end
+    class Insite::Errors::PageNavigationNotAllowedError   < StandardError; end
+    class Insite::Errors::SiteInitError                   < StandardError; end
+    class Insite::Errors::WrongPageError                  < StandardError; end
+  end
+end

data/lib/insite/feature/feature.rb

@@ -0,0 +1,30 @@
+module Insite
+  class Feature
+    attr_reader :args, :page, :page_elements, :browser
+
+    include Insite::CommonMethods
+
+    class << self
+      attr_accessor :alias, :page_elements
+
+      include Insite::DOMMethods
+      include Insite::WidgetMethods
+    end # Self.
+
+    def initialize(site, **args)
+      if self.class.ancestors.include?(Insite::DefinedPage)
+      # if site.is_a? Insite:DefinedPage # TODO: Bandaid.
+        @site  = site.site
+        @page  = site
+      elsif site.class.ancestors.include?(Insite)
+        @site  = site
+        @page  = site.page
+      end
+
+      @args    = args
+      @page    = page
+      @browser = @site.browser
+      @page_elements = @site.page_elements
+    end
+  end
+end

data/lib/insite/insite.rb

@@ -0,0 +1,294 @@
+require 'timeout'
+
+# Usage:
+#  require 'insite'
+#
+#  class MySite
+#    include Insite
+#  end
+module Insite
+  attr_reader :base_url, :unique_methods, :browser_type
+  attr_accessor :pages, :browser, :arguments, :most_recent_page
+
+  # Automatically sets up a Page class when Insite is included. Probably overkill
+  # but it protects against the case where two different sites are used at the
+  # same time: Each site will use its own page objects only.
+  def self.included(base)
+    mod = Module.new
+    base.const_set('WidgetMethods', mod)
+
+    klass = Class.new(DefinedPage)
+    base.const_set('Page', klass)
+    base::send(:extend, WidgetMethods)
+
+    klass = Class.new(UndefinedPage)
+    base.const_set('UndefinedPage', klass)
+  end
+
+  # Returns true if there's an open browser (that's also responding.) False if not.
+  def browser?
+    begin
+      @browser.exists?
+    rescue => e
+      false
+    end
+  end
+
+  # Closes the site object's browser/driver.
+  def close
+    @browser.close
+  end
+
+  def describe
+puts <<-EOF
+Wrapper class for all pages defined for the site.
+Site:\t#{self.class} (#{__FILE__})
+Base URL:\t#{@base_url}
+Browser:\t#{@browser}
+Current Page:\t#{page.class}
+
+Page Accessor Methods (Use '?' with name to check for presence.)
+-----------------------------------------------------------------
+#{
+  tmp = []
+  max = pages.map(&:to_s).max { |x| x.length }
+  if max.length > 40
+    pages.map(&:to_s).sort.map(&:underscore).join("\n")
+  else
+    pages.map(&:to_s).sort.map(&:underscore).each_slice(2) do |arr|
+      tmp << arr[0].to_s.ljust(40) + arr[1].to_s.ljust(40)
+    end
+    tmp.join("\n")
+  end
+}
+EOF
+  end
+
+  # Returns a Selenium driver object.
+  def driver
+    @browser.driver
+  end
+
+  # Returns true if there's an open driver (that's also responding.) False if not.
+  def driver?
+    browser?
+  end
+
+  # Creates a site object, which will have accessor methods for all pages that
+  # you have defined for the site. This object takes a hash argument. There is
+  # only one required value (the base_url for the site.) Example:
+  #
+  #  class MySite
+  #    include Insite
+  #  end
+  #
+  #  # Note: This base URL can be overridden when defining a page.
+  #  site = MySite.new("https://foo.com")
+  #
+  # You can also specify any other arguments that you want for later use:
+  #
+  #  site = MySite.new("http://foo.com", arg1, arg2, key1: val1, key2: val2)
+  #
+  #  site.foo
+  #  => true
+  #  site.bar
+  #  => 1
+  # TODO: Sort args.
+  def initialize(base_url, **hsh)
+    @arguments       = hsh.with_indifferent_access
+    @base_url        = base_url
+    @browser_type    = (@arguments[:browser] ? @arguments[:browser].to_sym : nil)
+    @pages           = self.class::DefinedPage.descendants.reject { |p| p.page_template? }
+
+    # Set up accessor methods for each page and page checking methods..
+    @pages.each do |current_page|
+      unless current_page.page_template?
+        current_page.set_url_template(@base_url)
+
+        if current_page.url_matcher
+          unless current_page.url_matcher.is_a? Regexp
+            raise Insite::Errors::PageConfigError,
+            "A url_matcher was defined for the #{current_page} page but it was not a " \
+            "regular expression. Check the value provided to the set_url_matcher method " \
+            "in the class definition for this page. Object provided was a " \
+            "#{current_page.url_matcher.class.name}"
+          end
+        end
+
+        self.class.class_eval do
+          define_method(current_page.to_s.underscore) do |args = nil, block = nil|
+            current_page.new(self, args)
+          end
+
+          define_method("#{current_page.to_s.underscore}?") do
+            on_page? current_page
+          end
+        end
+      end
+    end
+
+    visited = Set.new
+    tmp = @pages.map {|p| p.instance_methods }.flatten
+    tmp.each do |element|
+      if visited.include?(element)
+       else
+        visited << element
+      end
+    end
+    @unique_methods = visited
+  end
+
+  # Custom inspect method so that console output doesn't get in the way when debugging.
+  def inspect
+    "#<#{self.class.name}:0x#{object_id}\n @base_url=\"#{@base_url}\" " \
+    "@most_recent_page=#{@most_recent_page}>"
+  end
+
+  # In cases where Insite doesn't recognize a method call it will try to do the following:
+  # - Delegate the method call to the most recently accessed page, which is stored in
+  #   Insite#most_recent_page.
+  #
+  # - If the cached page doesn't respond to the method, Insite will update the cache and
+  #   then try to delegate the method again.
+  #
+  # If delegation doesn't work then a NoMethodError will be raised with some details about
+  # what was attempted.
+  def method_missing(sym, *args, &block)
+    original_page = @most_recent_page
+    if original_page.respond_to?(sym)
+      original_page.public_send(sym, *args, &block)
+    else
+      new_page = page
+      if new_page.respond_to?(sym)
+        page.public_send(sym, *args, &block)
+      else
+        raise(
+          NoMethodError,
+          "Unable to apply #{sym}. The site object doesn't support it and the" \
+          "currently displayed page doesn't support it either.\n" \
+          "Page:\t\t#{new_page.class}\n" \
+          "Current URL:\t#{@browser.url}\n\n",
+          caller
+        )
+      end
+    end
+  end
+
+  # Returns true or false depending on whether the specified page is displayed. You can use a page
+  # object or a PageObject class name to identify the page you are looking for. Examples:
+  #
+  #  page = site.account_summary_page
+  #  =>#<AccountSummaryPage:70341126478080 ...>
+  #  site.on_page? page
+  #  =>true
+  #
+  #  site.on_page? AccountSummaryPage
+  #  =>true
+  #
+  # If no arguments are provided, the currently displayed page will be checked. If a
+  # matching page object can be found then true will be returned. if there's no matching
+  # page object, false will be returned.
+  #
+  # Insite caches the most recently accessed page. This method updates that cached value,
+  # which can be accessed by calling Insite#most_recent_page.
+  def on_page?(page_arg = nil)
+    if page_arg
+      if pages.include?(page_arg) # See if the currently displayed page has the same class.
+        if @most_recent_page == page_arg && @most_recent_page.on_page?
+          true
+        else
+          @most_recent_page = page
+          @most_recent_page.class == page_arg
+        end
+      else # See if the currently displayed page is the same type of object.
+        if @most_recent_page == page_arg
+          @most_recent_page.on_page?
+        else
+          @most_recent_page = page
+          @most_recent_page == page_arg
+        end
+      end
+    else # Just see if the currently displayed page has been defined.
+      if @most_recent_page.defined? && @most_recent_page.on_page?
+        true
+      else
+        @most_recent_page = page
+        @most_recent_page.on_page?
+      end
+    end
+  end
+
+  # Opens a browser. The arguments used here get passed down to the browser
+  # constructor. Example:
+  #  s = SomeSite.new("http://foo.com")
+  #  s.open :firefox
+  def open(btype = nil, *args)
+    browser_platform = btype ||= @browser_type
+
+    if browser_platform
+      self.instance_variable_set(
+        :@browser,
+        Watir::Browser.new(browser_platform, *args)
+      )
+    else
+      self.instance_variable_set(
+        :@browser,
+        Watir::Browser.new(*args)
+      )
+    end
+
+    Watir.logger.level = :error
+    self
+  end
+
+  # Looks at the page currently being displayed in the browser and tries to
+  # return a page object for it. Does this by looking at the currently displayed
+  # URL in the browser.
+  #
+  # If a matching page can't be found then Insite will return an "undefined page"
+  # object. See the Un class for more details.
+  def page
+    return @most_recent_page if @most_recent_page && @most_recent_page.on_page?
+    url = @browser.url
+    found_page = nil
+    @pages.each do |pg|
+      if pg.url_matcher && pg.url_matcher =~ url
+        found_page = pg
+      elsif !pg.url_matcher && pg.url_template.match(url)
+        found_page = pg
+      else
+        next
+      end
+
+      break if found_page
+    end
+
+    if found_page && found_page.required_arguments.present?
+      if hsh = found_page.url_template.extract(url)
+        return found_page.new(self, found_page.url_template.extract(url))
+      else
+        return found_page.new(self, found_page.url_template.extract(url.split(/(\?|#)/)[0]))
+      end
+    elsif found_page
+      return found_page.new(self)
+    else
+      return UndefinedPage.new(self)
+    end
+  end
+
+  def text
+    @browser.text
+  end
+
+  # Returns an Addressable::URI object for the current browser URL.
+  def uri
+    Addressable::URI.parse(@browser.url)
+  end
+
+  # Returns the current browser URL.
+  def url
+    @browser.url
+  end
+
+  at_exit { @browser.close if @browser }
+end