capybara_page_object 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1b46c4f3b30e45f161b40fdba0269df229bc881f
+  data.tar.gz: d83d6348573ee3ec0476f6377f511a54dbdfa1f5
+SHA512:
+  metadata.gz: 72c2e7c49d8e4dd1012210284dddbfb5ade11dc92e8ce39ebacd573258f5ed0ad2735f592b39c0c7ae1edf66e9c30e4ff5d532ad6f10032066c51e1143039d80
+  data.tar.gz: bb15be36933ebf78cd04ad19584e2cd1e953806b544de8a828032224aae35c93e57b1d70f41062fe367eb8f7cf5e1129405906acc0504d78b358f37bb7560ce8

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.1.5
+before_install: gem install bundler -v 1.10.6

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in capybara_page_object.gemspec
+gemspec
+
+
+gem 'capybara'
+gem 'cucumber'
+gem 'selenium-webdriver'
+gem 'pry'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Ryan Stawarz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,40 @@
+# CapybaraPageObject
+
+This is a partial port of the [`page_object` gem](https://github.com/cheezy/page-object) to use Capybara
+instead of directly relying upon the Selenium or Waitr drivers.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'capybara_page_object'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install capybara_page_object
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/capybara_page_object. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "capybara/page_object"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/capybara_page_object.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'capybara_page_object/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "capybara_page_object"
+  spec.version       = CapybaraPageObject::VERSION
+  spec.authors       = ["Ryan Stawarz"]
+  spec.email         = ["ryan@stawarz.com"]
+
+  spec.summary       = %q{A Page Object Model to be used with capybara}
+  spec.description   = %q{A simple library to abstract out page details from cucumber and browser tests}
+  spec.homepage      = "http://github.com/rstawarz/capybara_page_object"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "capybara"
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+end

data/cucumber.yml

@@ -0,0 +1,10 @@
+<%
+std_opts = "--no-source --color --format pretty" # Cucumber::Formatter::Fuubar"
+%>
+
+default: DRIVER=WATIR <%= std_opts %> --tags ~@selenium_only
+watir_webdriver: DRIVER=WATIR <%= std_opts %> --tags ~@selenium_only
+selenium_webdriver: DRIVER=SELENIUM <%= std_opts %> --tags ~@watir_only
+focus: DRIVER=WATIR <%= std_opts %> --tags ~@selenium_only --tags @focus
+#focus:  DRIVER=SELENIUM <%= std_opts %> --tags ~@watir_only --tags @focus
+

data/lib/capybara_page_object/class_methods.rb

@@ -0,0 +1,252 @@
+module CapybaraPageObject
+  module ClassMethods
+    #
+    # Set some values that can be used within the class.  This is
+    # typically used to provide values that help build dynamic urls in
+    # the page_url method
+    #
+    # @param [Hash] the value to set the params
+    #
+    def params=(the_params)
+      @params = the_params
+    end
+
+    #
+    # Return the params that exist on this page class
+    #
+    def params
+      @params ||= {}
+    end
+
+    #
+    # Specify the url for the page.  A call to this method will generate a
+    # 'goto' method to take you to the page.
+    #
+    # @param [String] the url for the page.
+    # @param [Symbol] a method name to call to get the url
+    #
+    def page_url(url)
+      define_method("goto") do
+        visit self.page_url_value
+      end
+
+      define_method('page_url_value') do
+        url
+      end
+    end
+
+    #
+    # Creates a method that compares the expected_title of a page against the actual.
+    # @param [String] expected_title the literal expected title for the page
+    # @param [Regexp] expected_title the expected title pattern for the page
+    # @return [boolean]
+    # @raise An exception if expected_title does not match actual title
+    #
+    # @example Specify 'Google' as the expected title of a page
+    #   expected_title "Google"
+    #   page.has_expected_title?
+    #
+    def expected_title(expected_title)
+      define_method("has_expected_title?") do
+        page.has_title?(expected_title)
+      end
+    end
+
+    #
+    # Creates a method that provides a way to initialize a page based upon an expected element.
+    # This is useful for pages that load dynamic content.
+    # @param [Symbol] the name given to the element in the declaration
+    # @param [optional, Integer] timeout default value is 5 seconds
+    # @return [boolean]
+    #
+    # @example Specify a text box named :address expected on the page within 10 seconds
+    #   expected_element(:address, 10)
+    #   page.has_expected_element?
+    #
+    def expected_element(element_name)
+      define_method("has_expected_element?") do
+        args = self.send("#{element_name}_selector")
+        page.assert_selector(*args)
+        true
+      end
+    end
+
+    #
+    # Creates a method that provides a way to initialize a page based upon an expected element to become visible.
+    # This is useful for pages that load dynamic content and might have hidden elements that are not shown.
+    # @param [Symbol] the name given to the element in the declaration
+    # @param [optional, Integer] timeout default value is 5 seconds
+    # @param [optional, boolean] also check that element to be visible if set to true
+    # @return [boolean]
+    #
+    # @example Specify a text box named :address expected on the page within 10 seconds
+    #   expected_element_visible(:address, 10)
+    #   page.has_expected_element_visible?
+    #
+    def expected_element_visible(element_name, timeout=Capybara.default_wait_time)
+      define_method("has_expected_element_visible?") do
+        expect(self.send("#{element_name}_element")).to be_visible
+      end
+    end
+
+    #
+    # adds a method to return a collection of generic Element objects
+    # for a specific tag.
+    #
+    #def elements(name, tag=:element, identifier={:index => 0}, &block)
+      ## default tag to :element
+      ##
+      ## elements 'button', css: 'some css'
+      ##
+      ## is the same as
+      ##
+      ## elements 'button', :element, css: 'some css'
+      ##
+      #if tag.is_a?(Hash)
+        #identifier = tag
+        #tag        = :element
+      #end
+
+      #define_method("#{name}_elements") do
+        #return call_block(&block) if block_given?
+        #platform.elements_for(tag, identifier.clone)
+      #end
+    #end
+
+    #
+    # adds a method to return a page object rooted at an element
+    #
+    # @example
+    #   page_section(:navigation_bar, NavigationBar, :id => 'nav-bar')
+    #   # will generate 'navigation_bar' and 'navigation_bar?'
+    #
+    #def page_section(name, section_class, identifier)
+      #define_method(name) do
+        #platform.page_for(identifier, section_class)
+      #end
+    #end
+
+    #
+    # adds a method to return a collection of page objects rooted at elements
+    #
+    # @example
+    #   page_sections(:articles, Article, :class => 'article')
+    #   # will generate 'articles'
+    #
+    #def page_sections(name, section_class, identifier)
+      #define_method(name) do
+        #platform.pages_for(identifier, section_class)
+      #end
+    #end
+
+    #
+    # adds a method that will return an indexed property.  The property will respond to
+    # the [] method with an object that has a set of normal page_object properties that
+    # correspond to the definitions included in the identifier_list parameter, with the
+    # "what" of the "how and what" substituted based on the index provided to the []
+    # method.
+    #
+    # @example
+    #   indexed_property(:title, [
+    #     [:text_field,  :field_1,   :id => 'table[%s].field_1'],
+    #     [:button,      :button_1,  :id => 'table[%s].button_1'],
+    #     [:text_field,  :field_2,   :name => 'table[%s].field_2']
+    #   ])
+    #   # will generate a title method that responds to [].  title['foo'] will return an object
+    #   # that responds to the normal methods expected for two text_fields and a button with the
+    #   # given names, using the given how and what with 'foo' substituted for the %s.  title[123]
+    #   # will do the same, using the integer 123 instead.
+    #
+    #
+    #def indexed_property (name, identifier_list)
+      #define_method("#{name}") do
+        #IndexedProperties::TableOfElements.new(@browser, identifier_list)
+      #end
+    #end
+
+    def add_element_accessor_method(name, element_klass, finder_options)
+      finder_options = finder_options.dup
+      finder_args = extract_finder_args(finder_options)
+      element_klass ||= CapybaraPageObject::Element
+      define_method("#{name}_element") do
+        e = find(*finder_args)
+        element_klass.new(e, self)
+      end
+      define_method("#{name}_selector") do |options={}|
+        [finder_args.first,
+         finder_args[1],
+         finder_args[2].merge(options)]
+      end
+    end
+
+    def add_element_query_method(name, finder_options)
+      finder_options = finder_options.dup
+      finder_args = extract_finder_args(finder_options)
+      define_method("has_#{name}?") do |options = {}|
+        args = self.send("#{name}_selector", options)
+        has_selector?(*args)
+      end
+      define_method("has_no_#{name}?") do |options = {}|
+        args = self.send("#{name}_selector", options)
+        has_no_selector?(*args)
+      end
+      define_method("assert_has_#{name}") do |options = {}|
+        args = self.send("#{name}_selector", options)
+        assert_selector(*args)
+      end
+      define_method("assert_has_no_#{name}") do |options = {}|
+        args = self.send("#{name}_selector", options)
+        assert_no_selector(*args)
+      end
+    end
+
+    def add_value_accessor_method(name)
+      define_method(name) do
+        self.send("#{name}_element").value
+      end
+    end
+
+    def add_text_accessor_method(name)
+      define_method(name) do
+        self.send("#{name}_element").text
+      end
+    end
+
+    def add_value_mutator_method(name)
+      define_method("#{name}=") do |value|
+        self.send("#{name}_element").set(value)
+      end
+    end
+
+    def add_click_method(name)
+      define_method(name) do
+        self.send("#{name}_element").click
+      end
+    end
+
+    def extract_finder_args(finder_options={})
+      finder_type, finder_param = extract_finder_type!(finder_options, :class, :css, :id, :xpath)
+      finder_options.delete(finder_type)
+      case finder_type
+        when :class
+          [:css, ".{finder_param}", finder_options]
+        when :id
+          [:css, "##{finder_param}", finder_options]
+        when :css
+          [finder_type, finder_param, finder_options]
+        when :xpath
+          [finder_type, finder_param, finder_options]
+        else
+          raise "oops"
+      end
+    end
+
+    def extract_finder_type!(options, *types)
+      found_keys = options.select{|k,v| types.include?(k)}
+      unless found_keys.length == 1
+        raise "Incorrect finder type specified '#{found_keys.keys.join(', ')}' - only one of #{types.join(', ')} can be specified at a time."
+      end
+      found_keys.to_a.first
+    end
+  end
+end

data/lib/capybara_page_object/element_class_methods.rb

@@ -0,0 +1,255 @@
+module CapybaraPageObject
+  module ElementClassMethods
+
+    def self.define_element_methods(element_name, options = {})
+      aliases = options.delete(:aliases) || []
+      aliases.each {|name| define_element_methods(name, options) }
+      element_klass = options.fetch(:element_class, CapybaraPageObject::Element)
+      define_method(element_name) do |name, finder_options|
+        add_element_accessor_method(name, element_klass, finder_options)
+        add_element_query_method(name, finder_options)
+        case options[:default]
+        when :text
+          add_text_accessor_method(name)
+        when :value
+          add_value_accessor_method(name)
+        when :click
+          add_click_method(name)
+        end
+      end
+    end
+
+    define_element_methods(:a, default: :click)
+    define_element_methods(:area,  default: :click)
+    define_element_methods(:audio, element_class: CapybaraPageObject::MediaElement)
+    define_element_methods(:b, default: :text)
+    define_element_methods(:button, element_class: CapybaraPageObject::ButtonElement,
+                                    default: :click)
+    define_element_methods(:canvas)
+    define_element_methods(:div, default: :text)
+    define_element_methods(:element, default: :text)
+    define_element_methods(:form, element_class: CapybaraPageObject::FormElement)
+    define_element_methods(:h1, default: :text)
+    define_element_methods(:h2, default: :text)
+    define_element_methods(:h3, default: :text)
+    define_element_methods(:h4, default: :text)
+    define_element_methods(:h5, default: :text)
+    define_element_methods(:h6, default: :text)
+    define_element_methods(:hidden, default: :value,
+                                    aliases: [:hidden_field])
+    define_element_methods(:image, aliases: [:img])
+    define_element_methods(:label, default: :text)
+    define_element_methods(:link, default: :click)
+    define_element_methods(:list_item, default: :text)
+    define_element_methods(:list_item, default: :text, aliases: [:li])
+    define_element_methods(:ordered_list, default: :text,
+                                          element_class: ListElement,
+                                          aliases: [:ol])
+    define_element_methods(:paragraph, default: :text,
+                                       aliases: [:p])
+    define_element_methods(:span, default: :text)
+    define_element_methods(:svg, default: :text)
+    define_element_methods(:table, element_class: CapybaraPageObject::TableElement,
+                                   default: :text)
+    define_element_methods(:td, default: :text, aliases: [:cell])
+    define_element_methods(:row, element_class: CapybaraPageObject::TableRowElement,
+                                 default: :text)
+    define_element_methods(:video, element_class: CapybaraPageObject::MediaElement)
+    define_element_methods(:ul, default: :text,
+                                element_class: CapybaraPageObject::ListElement,
+                                aliases: [:unordered_list])
+
+    #
+    # adds five methods - one to check, another to uncheck, another
+    # to return the state of a checkbox, another to return
+    # an element representing the checkbox, and
+    # a final method to check the checkbox's existence.
+    #
+    # @example
+    #   checkbox(:active, :name => "is_active")
+    #   # will generate
+    #   # * 'check_active',
+    #   # * 'uncheck_active',
+    #   # * 'active_checked?',
+    #   # * 'active_element',
+    #   # * 'active?'
+    #
+    def checkbox(name, finder_options)
+      add_element_accessor_method(name, CapybaraPageObject::Element, finder_options)
+      add_element_query_method(name, finder_options)
+      element_name = "#{name}_element"
+      define_method("check_#{name}") do
+        self.send(element_name).set(true)
+      end
+      define_method("uncheck_#{name}") do
+        self.send(element_name).set(false)
+      end
+      define_method("#{name}_checked?") do
+        self.send(element_name).checked? == true ||
+        self.send(element_name).checked? == 'checked'
+      end
+    end
+
+    #
+    # adds three methods - one to set the file for a file field, another to retrieve
+    # the file field element, and another to check it's existence.
+    #
+    # @example
+    #   file_field(:the_file, :css, '#file_to_upload')
+    #   # will generate
+    #   # * 'the_file=',
+    #   # * 'the_file_element',
+    #   # * 'the_file?'
+    #
+    def file_field(name, finder_options)
+      add_element_accessor_method(name, CapybaraPageObject::Element, finder_options)
+      add_element_query_method(name, finder_options)
+      define_method("#{name}=") do |value|
+        self.send("#{name}_element").set(value)
+      end
+      define_method("#{name}") do
+        self.send("#{name}_element").value
+      end
+    end
+
+    #
+    # adds four methods - one to select, another to return if a radio button
+    # is selected, another method to return a PageObject::Elements::RadioButton
+    # object representing the radio button element, and another to check
+    # the radio button's existence.
+    #
+    # @example
+    #   radio_button(:north, :css, "#north")
+    #   # * will generate
+    #   # * 'select_north',
+    #   # * 'north_selected?',
+    #   # * 'north_element',
+    #   # * 'north?' methods
+    #
+    def radio_button(name, finder_options)
+      add_element_accessor_method(name, CapybaraPageObject::Element, finder_options)
+      add_element_query_method(name, finder_options)
+      define_method("select_#{name}") do
+        self.send("#{name}_element").set(true)
+      end
+      define_method("#{name}_selected?") do
+        self.send("#{name}_element").selected?
+      end
+    end
+    alias_method :radio, :radio_button
+
+    #
+    # adds five methods to help interact with a radio button group -
+    # a method to select a radio button in the group by given value/text,
+    # a method to return the values of all radio buttons in the group, a method
+    # to return if a radio button in the group is selected (will return
+    # the text of the selected radio button, if true), a method to return
+    # an array of PageObject::Elements::RadioButton objects representing
+    # the radio button group, and finally a method to check the existence
+    # of the radio button group.
+    #
+    # @example
+    # radio_button_group(:color, :css, "input[name='color']")
+    # will generate
+    # * 'select_color',
+    # * 'color_values',
+    # * 'color_selected?',
+    # * 'color_elements',
+    # * 'color?' methods
+    #
+    def radio_button_group(name, finder_options)
+      finder_options = finder_options.dup
+      finder_args = extract_finder_args(finder_options)
+
+      define_method("select_#{name}") do |value|
+        elements = self.send("#{name}_elements")
+        elements.find {|e| e.value == value }.set(true)
+      end
+      define_method("#{name}_values") do
+        self.send("#{name}_elements").map(&:value)
+      end
+      define_method("#{name}_selected?") do
+        elements = self.send("#{name}_elements")
+        selected = elements.select {|e| e.checked? }
+        selected.first ? selected.first.value : false
+      end
+      define_method("#{name}_elements") do
+        all(*finder_args)
+      end
+      define_method("#{name}?") do
+        assert_selector(*finder_args)
+      end
+    end
+    alias_method :radio_group, :radio_button_group
+
+
+    #
+    # adds five methods - one to select an item in a drop-down,
+    # another to fetch the currently selected item text, another
+    # to retrieve the select list element, another to check the
+    # drop down's existence and another to get all the available options
+    # to select from.
+    #
+    # @example
+    #   select_list(:state, :css, "#state")
+    #   # will generate 'state', 'state=', 'state_element', 'state?', "state_options" methods
+    #
+    def select_list(name, finder_options)
+      add_element_accessor_method(name, CapybaraPageObject::SelectListElement, finder_options)
+      add_element_query_method(name, finder_options)
+
+      element_name = "#{name}_element"
+      define_method(name) do
+        self.send(element_name).value
+      end
+      define_method("selected_#{name}") do
+        within(self.send(element_name)) do
+          find('option[selected]')
+        end
+      end
+      define_method("#{name}=") do |value|
+        element = self.send(element_name)
+        within(element) do
+          find(:option, value).select_option
+        end
+      end
+      define_method("#{name}_options") do
+        element = self.send(element_name)
+        within(element) do
+          all(:css, 'option')
+        end
+      end
+    end
+    alias_method :select, :select_list
+
+    # adds four methods to the page object - one to set text in a text area,
+    # another to retrieve text from a text area, another to return the text
+    # area element, and another to check the text area's existence.
+    #
+    # @example
+    #   text_area(:address, :css, "#address")
+    #   # will generate
+    #   # * 'address',
+    #   # * 'address=',
+    #   # * 'address_element',
+    #   # * 'address?'
+    #
+    #
+    def text_area(name, finder_options)
+      add_element_accessor_method(name, CapybaraPageObject::TextAreaElement, finder_options)
+      add_element_query_method(name, finder_options)
+      add_value_accessor_method(name)
+      add_value_mutator_method(name)
+    end
+    alias_method :textarea, :text_area
+
+    def text_field(name, finder_options)
+      add_element_accessor_method(name, CapybaraPageObject::TextFieldElement, finder_options)
+      add_element_query_method(name, finder_options)
+      add_value_accessor_method(name)
+      add_value_mutator_method(name)
+    end
+
+  end
+end
+

data/lib/capybara_page_object/elements/button_element.rb

@@ -0,0 +1,13 @@
+module CapybaraPageObject
+  class ButtonElement < Element
+
+    def text
+      if element.tag_name == 'button'
+        element.text
+      else
+        element.value
+      end
+    end
+
+  end
+end

data/lib/capybara_page_object/elements/element.rb

@@ -0,0 +1,85 @@
+module CapybaraPageObject
+  class Element
+    attr_accessor :element,
+                  :page
+
+    def initialize(element, page)
+      @element = element
+      @page = page
+    end
+
+    def attribute(name)
+      element[name.to_s]
+    end
+
+    def enabled?
+      !element.disabled?
+    end
+
+    def class
+      attribute('class')
+    end
+    alias_method :class_name, :class
+
+    def focus
+      bridge.executeScript("return arguments[0].focus()", native)
+    end
+
+    def parent
+      raise Capybara::NotSupportedByDriverError unless javascript_enabled?
+      element.parent
+    end
+
+    def html
+      case native.class.to_s
+      when /Nokogiri/
+        native.to_html
+      when /Selenium/
+        native['outerHTML']
+      else
+        raise "This driver is not supported for retrieving the html of an element"
+      end
+    end
+
+    def native
+      element.native
+    end
+
+    def scroll_into_view
+      unless element.native.respond_to?(:location_once_scrolled_into_view)
+          raise "Selenium javascript driver required to use 'scroll_into_view'"
+      end
+      element.native.location_once_scrolled_into_view
+    end
+
+    def method_missing(method_name, *arguments, &block)
+      if element.respond_to?(method_name, true)
+        element.send(method_name, *arguments, &block)
+      elsif value = element[method_name.to_s]
+        value
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      element.respond_to?(method_name, include_private) ||
+        element[method_name.to_s] != nil ||
+        super
+    end
+
+    def within(&block)
+      page.within(element, &block)
+    end
+
+    private
+
+    def bridge
+      native.instance_variable_get(:@bridge)
+    end
+
+    def javascript_enabled?
+      Capybara.current_driver == Capybara.javascript_driver
+    end
+  end
+end

data/lib/capybara_page_object/elements/form_element.rb

@@ -0,0 +1,11 @@
+module CapybaraPageObject
+  class FormElement < Element
+
+    def submit
+      Capybara.current_session.within(element) do
+        first(:css, "input[type='submit']").click
+      end
+    end
+
+  end
+end

data/lib/capybara_page_object/elements/list_element.rb

@@ -0,0 +1,14 @@
+module CapybaraPageObject
+  class ListElement < Element
+
+    def items
+      @page.within(element) { all('li') }
+    end
+
+    def [](item_index)
+      items[item_index]
+    end
+
+  end
+end
+

data/lib/capybara_page_object/elements/media_element.rb

@@ -0,0 +1,47 @@
+module CapybaraPageObject
+  class MediaElement < Element
+
+    def autoplay?
+        true?(attribute(:autoplay))
+      end
+
+      def has_controls?
+        true?(attribute(:controls))
+      end
+
+      def paused?
+        true?(attribute(:paused))
+      end
+
+      def duration
+        duration = attribute(:duration)
+        return duration.to_f if duration
+      end
+
+      def volume
+        volume = attribute(:volume)
+        return volume.to_i if volume
+      end
+
+      def ended?
+        true?(attribute(:ended))
+      end
+
+      def seeking?
+        true?(attribute(:seeking))
+      end
+
+      def loop?
+        true?(attribute(:loop))
+      end
+
+      def muted?
+        true?(attribute(:muted))
+      end
+
+      def true?(value)
+        value == true || value == 'true'
+      end
+
+  end
+end

data/lib/capybara_page_object/elements/select_list_element.rb

@@ -0,0 +1,38 @@
+module CapybaraPageObject
+  class SelectListElement < Element
+
+    def selected?(value_or_text)
+      option = selected_option
+      option.value == value_or_text ||
+        option.text == value_or_text
+    end
+
+    def selected_option
+      within do
+        first('option[selected]')
+      end
+    end
+
+    def clear
+      selected_options.each(&:unselect_option)
+    end
+
+    def selected_options
+      within do
+        all('option[selected]')
+      end
+    end
+
+    def select_value(value)
+      within do
+        all(:css, "option[@value=#{value}]").each(&:select_option)
+      end
+    end
+
+    def selected_values
+      selected_options.map(&:value)
+    end
+
+  end
+end
+

data/lib/capybara_page_object/elements/table_element.rb

@@ -0,0 +1,50 @@
+module CapybaraPageObject
+  class TableElement < Element
+    include Enumerable
+
+    def each
+      for index in 1..self.rows.length do
+        yield self[index-1]
+      end
+    end
+
+    def [](row_index)
+      if row_index.kind_of?(String)
+        rows.find do |row|
+          row.columns.any? {|col| col.text.include?(row_index) }
+        end
+      else
+        rows[row_index]
+      end
+    end
+
+    def as_hashes
+      rows[1..-1].map do |row|
+        Hash[headers.zip(row.map(&:text))]
+      end
+    end
+
+
+    def rows
+      within do
+        all(:xpath, ".//child::tr").map do |row|
+          TableRowElement.new(row, page, self)
+        end
+      end
+    end
+
+    def last_row
+      the_rows = rows
+      the_rows[the_rows.length - 1]
+    end
+
+    def first_row
+      rows[0]
+    end
+
+    def headers
+      rows[0].columns.map(&:text)
+    end
+
+  end
+end

data/lib/capybara_page_object/elements/table_row_element.rb

@@ -0,0 +1,66 @@
+module CapybaraPageObject
+  class TableRowElement < Element
+    include Enumerable
+
+    attr_reader :parent_table
+
+    def initialize(element, page, parent_table = nil)
+      super(element, page)
+      @parent_table = parent_table || find_parent_table
+    end
+
+    def each
+      for index in 1..self.columns.length do
+        yield self[index-1]
+      end
+    end
+
+    def [](column_index)
+      if column_index.kind_of?(String)
+        column_index = lookup_index_by_name(column_index)
+      end
+
+      return nil if column_index == nil
+      columns[column_index]
+    end
+
+    def columns
+      within do
+        all(:xpath, ".//child::td|th")
+      end
+    end
+
+    private
+
+    def lookup_index_by_name(column_name)
+      parent_table.headers.find_index{|header_name| header_name.include?(column_name) }
+    end
+
+    # Find the parent table based on the current nodes xpath expression
+    # e.g.
+    #  irb > path = "/html/body/table[1]/tbody/tr[1]"
+    #  irb> paths = path.split("/")
+    #       => ["", "html", "body", "table[1]", "tbody", "tr[1]"]
+    #  irb>       paths.reverse!
+    #       => ["tr[1]", "tbody", "table[1]", "body", "html", ""]
+    #  irb>       index = paths.find_index{|s| s.include?('table') }
+    #       => 2
+    #  irb>       paths = paths[index..-1]
+    #       => ["table[1]", "body", "html", ""]
+    #  irb>       paths.reverse!
+    #       => ["", "html", "body", "table[1]"]
+    #  irb> paths.join("/")
+    #       => "/html/body/table[1]"
+    #
+    def find_parent_table
+      path = element.path
+      paths = path.split("/")
+      paths.reverse!
+      index = paths.find_index{|s| s.include?('table') }
+      paths = paths[index..-1]
+      paths.reverse!
+      page.first(:xpath, paths.join("/"))
+    end
+  end
+end
+

data/lib/capybara_page_object/elements/text_area_element.rb

@@ -0,0 +1,10 @@
+module CapybaraPageObject
+  class TextAreaElement < Element
+
+    def clear
+      element.set('')
+    end
+
+  end
+end
+

data/lib/capybara_page_object/elements/text_field_element.rb

@@ -0,0 +1,14 @@
+module CapybaraPageObject
+  class TextFieldElement < Element
+
+    def clear
+      element.set('')
+    end
+
+    #def value
+      #element.text
+    #end
+
+  end
+end
+

data/lib/capybara_page_object/page_factory.rb

@@ -0,0 +1,54 @@
+module CapybaraPageObject
+  #
+  # @example Making the PageFactory available to your step definitions
+  #   World(CapybaraPageObject::PageFactory)
+  #
+  # @example Visiting a page for the first time in a Scenario
+  #   goto_page MyPage do |page|
+  #      ...
+  #   end
+  #
+  # @example using a page that has already been visited in a Scenario
+  #   on_page MyPage do |page|
+  #     ....
+  #   end
+  #
+  #
+  module PageFactory
+    #
+    # Create and navigate to a page object.  The navigation will only work if the
+    # 'page_url' method was set on the page object.
+    #
+    # @param [PageObject, String] a class that has included the
+    # PageObject module or a string containing the name of the class
+    # @param Hash values that is pass through to page class a
+    # available in the @params instance variable.
+    # @param an optional block to be called
+    # @return [PageObject] the newly created page object
+    #
+    def goto_page(page_class, params={:using_params => {}}, &block)
+      new_page(page_class, params, true, &block)
+    end
+
+    #
+    # Create a page object.
+    #
+    def new_page(page_class, params={:using_params => {}}, visit=false, &block)
+      page_class = class_from_string(page_class) if page_class.is_a? String
+      merged = page_class.params.merge(params[:using_params])
+      page_class.instance_variable_set("@merged_params", merged) unless merged.empty?
+      @current_page = page_class.new(visit)
+      block.call @current_page if block
+      @current_page
+    end
+
+    private
+
+    def class_from_string(str)
+      str.split('::').inject(Object) do |mod, class_name|
+        mod.const_get(class_name)
+      end
+    end
+  end
+end
+

data/lib/capybara_page_object/page_object.rb

@@ -0,0 +1,72 @@
+module CapybaraPageObject
+  # Module that when included adds functionality to a page object.  This module
+  # will add numerous class and instance methods that you use to define and
+  # interact with web pages.
+  #
+  # If we have a login page with a username and password textfield and a login
+  # button we might define our page like the one below.  We can then interact with
+  # the object using the generated methods.
+  #
+  # @example Login page example
+  #   class LoginPage
+  #     include PageObject
+  #
+  #     text_field(:username, :id => 'user')
+  #     text_field(:password, :id => 'pass')
+  #     button(:login, :value => 'Login')
+  #   end
+  #
+  #   login_page = LoginPage.new
+  #   login_page.username = 'ryan'
+  #   login_page.password = 'starwars'
+  #   login_page.login
+  #
+  # @see PageObject::ClassMethods to see what class level methods are added to this module at runtime.
+  #
+  module PageObject
+    include Capybara::DSL
+
+    alias_method :navigate_to, :visit
+    #
+    # Construct a new page object.  Prior to browser initialization it will call
+    # a method named initialize_accessors if it exists. Upon initialization of
+    # the page it will call a method named initialize_page if it exists.
+    #
+    #
+    def initialize(visit=false)
+      initialize_accessors if respond_to?(:initialize_accessors)
+      if visit
+        raise "Page must specify `page_url` to use visit functionality" unless respond_to?(:goto)
+        goto
+      end
+      initialize_page if respond_to?(:initialize_page)
+    end
+
+    def self.included(base)
+      base.extend(CapybaraPageObject::ClassMethods)
+      base.extend(CapybaraPageObject::ElementClassMethods)
+    end
+
+    def within(element, &block)
+      if element.kind_of?(CapybaraPageObject::Element)
+        super(element.element, &block)
+      else
+        super(element, &block)
+      end
+    end
+
+    def go_back
+      page.evaluate_script('window.history.back()')
+    end
+
+    def go_forward
+      page.evaluate_script('window.history.forward()')
+    end
+
+    def reload_page
+      url = [ current_path, page.driver.request.env['QUERY_STRING'] ].reject{|s| s.nil? || s == '' }.join('?')
+      page.visit url
+    end
+
+  end
+end

data/lib/capybara_page_object/version.rb

@@ -0,0 +1,3 @@
+module CapybaraPageObject
+  VERSION = "0.0.1"
+end

data/lib/capybara_page_object.rb

@@ -0,0 +1,11 @@
+require 'capybara'
+require "capybara_page_object/version"
+
+base = File.join(File.dirname(__FILE__), 'capybara_page_object')
+require File.join(base, 'elements', 'element.rb')
+Dir.glob(File.join(base, 'elements', '**', '*.rb'), &method(:require))
+
+require 'capybara_page_object/class_methods'
+require 'capybara_page_object/element_class_methods'
+require 'capybara_page_object/page_object'
+require 'capybara_page_object/page_factory'

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: capybara_page_object
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ryan Stawarz
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-10-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: capybara
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.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: A simple library to abstract out page details from cucumber and browser
+  tests
+email:
+- ryan@stawarz.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- capybara_page_object.gemspec
+- cucumber.yml
+- lib/capybara_page_object.rb
+- lib/capybara_page_object/class_methods.rb
+- lib/capybara_page_object/element_class_methods.rb
+- lib/capybara_page_object/elements/button_element.rb
+- lib/capybara_page_object/elements/element.rb
+- lib/capybara_page_object/elements/form_element.rb
+- lib/capybara_page_object/elements/list_element.rb
+- lib/capybara_page_object/elements/media_element.rb
+- lib/capybara_page_object/elements/select_list_element.rb
+- lib/capybara_page_object/elements/table_element.rb
+- lib/capybara_page_object/elements/table_row_element.rb
+- lib/capybara_page_object/elements/text_area_element.rb
+- lib/capybara_page_object/elements/text_field_element.rb
+- lib/capybara_page_object/page_factory.rb
+- lib/capybara_page_object/page_object.rb
+- lib/capybara_page_object/version.rb
+homepage: http://github.com/rstawarz/capybara_page_object
+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.2.2
+signing_key: 
+specification_version: 4
+summary: A Page Object Model to be used with capybara
+test_files: []