dkastner-capybara-wheel 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 48f3c56080572f38abc650588314ebc0335646c9
+  data.tar.gz: 86b2298ebc7e77c2970c0c0d7c4d7d9ab91aa2e4
+SHA512:
+  metadata.gz: a090305573a3ae190140824d8596274db2c9fe94d71c253cbaff6ab22062ff002624d561a189b939ceb49bf73ecc770941e36ed3c6653795fed4391a5e4bf507
+  data.tar.gz: daf6887577eb28636cd9afc594bb2ed8057c7710d4e036b351a8e39a607e852ad455548dfd5df8afb6f17c3b49541546868b32c4cc306874557febc514d97c35

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in capybara-wheel.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Gabriel Rotbart
+
+MIT License
+
+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,260 @@
+# Capybara::Wheel
+> Keeping the rodent on track
+
+Capybara wheel is a page model framework which natively and (hopefully) easily enforces stability coventions:
+
+- No memoization. Every action or query relating to the page should make a new find callback to the actual page.
+ - Enforces native Capybara wait time when interacting with the page if the element is not there (yet) or changed.
+
+- No access to capybara directly from the specs.
+  - Enforces single point of reference to selectors / elements.
+  - Also helps reducing memoizations.
+
+- Element hierarchy structure to scope finds to a specific section of the page.
+  - Reduces ambiguity.
+
+*A special thank you to @woollyams for the initial concept*
+
+## Why Wheel?
+
+Browser driven acceptance tests are notorious for being unstable and hard to maintain. The main culprits are:
+
+1. Timing issues which result in unstable waits and "is the page loaded?" queries accross the specs.
+
+2. Memoizing the state of the page (e.g. `search_result = Capybara.find('li')` ) at a certain time. Each spec run might memoize a different state, leading to unstable tests.
+
+3. No convention around page interactions (e.g. sometimes calling a page model, sometimes a native find with a selector).
+
+Wheel solves all these by forcing the spec to always act or query the currect state of the page.
+If the page is not in a state that the spec expects, the native Capybara wait will be used until it is; removing the need to `sleep` or build mechanics to test for page loads.
+
+Specs are always written in one uniform, clean, way - always calling the same model when dealing with the same page / element. No more hunting multiple specs to change a selector.
+
+The Element model DSL is still eaily customisable just like "normal" page model classes so domain specfic applications are just as easy, resulting in descriptive, easy to read specs.
+
+## Example spec:
+
+    feature "Supervillan Console" do
+
+     let(:supervillan_console) { SuperVillanConsole.new }
+
+     it 'can destroy the world with the push of a button' do
+        supervillan_console.visit do |page|
+          page.button_of_doom.should be_present
+          page.button_of_doom.click
+
+          # assert that world was destroyed
+        end
+     end
+
+    end
+
+More spec goodness below.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'capybara-wheel'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install capybara-wheel
+
+## Usage
+
+In spec_helper.rb:
+
+    $ require 'capybara/wheel'
+
+**Important: Capybara Wheel overrides Capybara native `feature` method to inject new behavior. This means it should be required instead or Capybara**
+
+## Modeling
+
+### Page Model
+
+
+To model a new page:
+
+    class NewPage < Capybara::Wheel::Page
+
+A page needs to implement two methods:
+
+    def path
+      # implament to support visiting the page directly
+      # Rails apps can include Rails.application.routes.url_helpers to access the url helpers
+      # Other applications should implament a relative url
+    end
+
+  and
+
+    def on_page?
+      # Capybara Wheel calls this method before excuting the page block (see Specs section below below)
+      # Recommended: Use Wheel native Page method has_title?('Title')
+      # e.g. has_title?('Login')
+
+      # Or: Use Capybara.find(any selector you expect would be on a loaded page)
+      # e.g. Capybara.find('h1', text: 'Login Page')
+    end
+
+**_Example:_**
+
+     class SuperVillanConsole << Capybara::Wheel::Page
+
+       def path
+         super_villan_console_path
+       end
+
+       def on_page?
+         has_title?('Destroy all humans')
+       end
+     end
+
+***
+
+### Element model
+
+#### Element
+
+Once inside a Page model, it has access to the `element` method.
+
+    element 'ElementName', 'selector' *optional block*
+
+    # Wheel recommends using a name that follows the class constant name convention (i.e CamelCase)
+    # as an object will be created and assigned this name (see below)
+
+The `element` method does several important things:
+
+1. It defines a Page method element_name which allows access and initializes...
+2. an Element model
+
+Out of the box, Element accepts all the old familar Capybara Element actions / queries (e.g. click, set, text, visible?). Once an action or query is sent to a Wheel element it then finds the native Capybara element and passes it on. This ensures that each method call is executed on the newset version of the element.
+
+Passing a block to element gives access to the Element object for the purpose of implamenting a subelement (see below) or rolling your own customised methods:
+
+**The following messages are delegated to the native Capybara element callback.**
+
+```
+  #find, #click, #has_content?, #checked?, #text, #visible?, #present?, #selected?, #disabled?, #tag_name, #value, #set, #select_option, #unselect_option, #hover
+```
+
+**_Example:_**
+
+     element 'ButtonOfDoom', '#doom-button' do
+
+        def armed?
+          capybara_element.text == 'Armed'
+        end
+
+      end
+
+     element 'MissleTracker', '.missle-tracker'
+
+
+     #=> SuperVillanConsole.new.button_of_doom.armed?
+
+     #=> SuperVillanConsole.new.missle_tracker.visible?
+
+
+
+#### (Sub)Element
+
+An element block also accepts the `element` method.
+
+    element 'SubElementName', 'selector' *optional block*
+
+When called inside an element block, the element behaves like an Element but is now scoped to the containing (or parent) element, which reduces ambiguity.
+
+**_Example:_**
+
+ Two buttons have an `li` element with the `.key` class. We want to be able to find one and turn it without accidently causing world peace:
+
+     element 'ButtonOfDoom', '#doom-button' do
+
+        # reference to this key is scoped inside the #doom-button element
+        element 'ArmingKey', 'li.key' do
+
+          def turn
+            click
+          end
+
+        end
+     end
+
+     element 'ButtonOfWorldPeace', '#peace-button' do
+
+       # reference to this key is scoped inside the #peace-button element
+       element 'ArmingKey', 'li.key' do
+
+         def turn
+           click
+         end
+
+       end
+     end
+
+     #=> SuperVillanConsole.new.button_of_world_peace.arming_key.turn
+     #=> SuperVillanConsole.new.button_of_doom.arming_key.turn
+
+## Specs
+
+Wheel specs are written to always refer to the models and to never refer to Capybara directly. The page methods we implemented above allows us the do:
+
+    let(:some_page) { SomePageModel.new }
+
+    it 'can visit a page' do
+      some_page.visit
+    end
+
+The visit page would use the `on_page?` method to determine if we are indeed on the page. It will use Capyara's internal wait to poll the page until it is ready. We can then even excute within the scope of the page:
+
+    it 'can visit a page and pass a block to execute' do
+      some_page.visit do | page |
+        page.some_element.should be_visible
+      end
+    end
+
+    it 'can also just check if we're on the page without visiting it'
+      some_page.on do | page |
+        page.some_element.should be_visible
+      end
+    end
+
+
+**_Example:_**
+
+    feature "Supervillan Console" do
+
+      let(:supervillan_console) { SuperVillanConsole.new }
+
+      before :each do
+        supervillan_console.visit
+      end
+
+      scenario 'can arm doom button' do
+        supervillan_console.on do | con |
+          con.button_of_doom.arming_key.turn
+          con.button_of_doom.armed?.should be_true
+        end
+      end
+
+
+    end
+
+***
+***
+***
+
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/capybara-wheel.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'capybara/wheel/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "dkastner-capybara-wheel"
+  spec.version       = Capybara::Wheel::VERSION
+  spec.authors       = ["@gabrielrotbart"]
+  spec.email         = ["gabe@hooroo.com"]
+  spec.description   = %q{Keeping the rodent on track}
+  spec.summary       = %q{Creating (yet another) page model gem based around making capybara tests more stable with no need for waits}
+  spec.homepage      = "http://github.com/hooroo/capybara-wheel"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "capybara", "~> 2.1"
+  spec.add_dependency "rspec"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "selenium-webdriver", "~> 2.0"
+  spec.add_development_dependency "sinatra", "~> 1.0"
+  spec.add_development_dependency "pry"
+end

data/lib/capybara/wheel.rb

@@ -0,0 +1,34 @@
+Dir.glob(File.join(File.dirname(__FILE__), 'wheel', '*.rb')).each {|file| require file}
+require 'capybara'
+require 'capybara/dsl'
+require 'rspec'
+
+module Capybara
+  module Wheel
+    # main mixin to access wheel
+
+    def self.included(base)
+      base.instance_eval do
+        alias :background :before
+        alias :scenario :it
+        alias :given :let
+        alias :given! :let!
+      end
+    end
+
+    module FeatureOverride
+      def feature(*args, &block)
+        options = {
+          type: :wheel_feature,
+          caller: caller
+        }
+        options.merge!(args.pop) if args.last.is_a?(Hash)
+        describe(*args, options, &block)
+      end
+    end
+
+  end
+end
+
+extend Capybara::Wheel::FeatureOverride
+RSpec.configuration.include Capybara::Wheel, wheel_feature: true

data/lib/capybara/wheel/element.rb

@@ -0,0 +1,96 @@
+require 'capybara/wheel/includes'
+require 'forwardable'
+
+module Capybara
+  module Wheel
+    class Element
+
+        extend Forwardable
+        include Capybara::Wheel::Includes
+        extend Capybara::Wheel::Includes::ClassIncludes
+
+        attr_reader :scope
+
+        def initialize(selector = nil, scope = nil)
+          @selector = selector if selector
+          @scope    = scope
+        end
+
+        def_delegators  :capybara_element,
+                        :find,
+                        :click,
+                        :has_content?,
+                        :checked?,
+                        :text,
+                        :visible?,
+                        :present?,
+                        :selected?,
+                        :disabled?,
+                        :tag_name,
+                        :value,
+                        :set,
+                        :select_option,
+                        :unselect_option,
+                        :hover,
+                        :[]
+
+
+
+        def present?
+          capybara_element.visible?
+        rescue Capybara::ElementNotFound => e
+          puts "#{e} on #{Time.now.strftime("%H:%I:%S:%L")}"
+          false
+        end
+
+        def visible?
+          capybara_element.visible?
+        rescue Capybara::ElementNotFound => e
+          puts "#{e} on #{Time.now.strftime("%H:%I:%S:%L")}"
+          false
+        end
+
+        def self.element(name, selector, block = nil)
+          subelement_factory = lambda do |parent_element|
+            Capybara::Wheel::ElementFactory.create_element(selector, parent_element, block)
+          end
+
+          define_method(underscore(name).to_sym) { subelement_factory.call(self) }
+          self
+        end
+
+        def element(name, selector, &block)
+          self.class.element(name, selector, block)
+        end
+
+        #TODO: deprecated in 0.0.5
+        def subelement(name, selector, &block)
+          puts "subelement will be deprecated in future versions."
+          puts "Calling element inside an element block will scope it to the parent element"
+          element(name, selector, block)
+        end
+
+        def self.subelement(name, selector, &block)
+          puts "subelement will be deprecated in future versions."
+          puts "Calling element inside an element block will scope it to the parent element"
+          element(name, selector, &block)
+        end
+
+        def selector
+          @selector
+        end
+
+        private
+
+        # Finds a capybara element representing this thing
+        def capybara_element
+          scope_capybara.find(selector, options)
+        end
+
+        def scope_capybara
+          scope.nil? ? capybara : scope.send(:capybara_element)
+        end
+
+    end
+  end
+end

data/lib/capybara/wheel/element_factory.rb

@@ -0,0 +1,33 @@
+require 'capybara/wheel'
+
+module Capybara
+  module Wheel
+    class ElementFactory
+
+      def self.create_element_klass(selector, options = {}, block = nil)
+        subclass = Class.new(Capybara::Wheel::Element)
+
+        _selector = selector
+        _options = options
+
+        subclass.class_exec do
+          define_method(:selector) { @selector = _selector }
+          define_method(:options) { @options = _options }
+        end
+
+        subclass.class_eval(&block) if block
+
+        subclass
+      end
+
+      #TODO: Pass object not an instance
+      def self.create_element(selector, parent_element, block = nil)
+        subelement = Capybara::Wheel::Element.new(selector, parent_element)
+        subelement.instance_eval(&block) if block
+
+        subelement
+      end
+
+    end
+  end
+end

data/lib/capybara/wheel/includes.rb

@@ -0,0 +1,32 @@
+require 'capybara/wheel'
+require 'capybara'
+require 'capybara/dsl'
+require 'rspec'
+
+module Capybara
+  module Wheel
+    module Includes
+
+      include Capybara::DSL
+
+      def capybara
+        Capybara.current_session
+      end
+
+      module ClassIncludes
+        def underscore(string)
+          string.gsub(/::/, '/').
+                  gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+                  gsub(/([a-z\d])([A-Z])/,'\1_\2').
+                  tr("-", "_").
+                  downcase
+        end
+
+        def make_const(string)
+
+        end
+      end
+
+    end
+  end
+end

data/lib/capybara/wheel/page.rb

@@ -0,0 +1,59 @@
+require 'capybara/wheel/includes'
+
+module Capybara
+  module Wheel
+    class Page
+
+      include Capybara::Wheel::Includes
+      extend Capybara::Wheel::Includes::ClassIncludes
+
+      # actively visits page and executes block in context
+      def visit(&block)
+        capybara.visit(path)
+        if block_given?
+          on(&block)
+        else
+          on_page?
+        end
+        return self
+      end
+
+      # execute a block in the context of this page
+      def on
+        unless on_page?
+          raise "We don't appear to be on the #{self.class}"
+        end
+        yield self if block_given?
+        self
+      end
+
+      # Returns the path (relative URI) of this page
+      def path
+        raise NotImplementedError, "implement to support page.visit"
+      end
+
+      # Return true if the browser is on this page
+      def on_page?
+        raise NotImplementedError, "implement me, e.g. using #has_title?"
+      end
+
+      def has_title?(expected_title)
+        capybara.has_css?("head title", text: expected_title)
+      end
+
+      def self.element(name, selector, options = {}, &block)
+        begin
+          element_klass = const_set("#{name}", Capybara::Wheel::ElementFactory.create_element_klass(selector, options, block))
+        rescue NameError
+          puts "We recommend using capitalized element and subelement names"
+          name = name.capitalize!
+          retry
+        end
+
+        define_method(underscore(name).to_sym) { element_klass.new(selector) }
+        self
+      end
+
+    end
+  end
+end

data/lib/capybara/wheel/version.rb

@@ -0,0 +1,5 @@
+module Capybara
+  module Wheel
+    VERSION = "0.1.0"
+  end
+end

data/spec/element_factory_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+feature 'ElementFactory' do
+  let(:subject)               { Capybara::Wheel::ElementFactory }
+  let(:selector)              { '#rad-selector'}
+  let(:created_element_klass) { subject.create_element_klass(selector) }
+
+
+  it 'creates an element' do
+    created_element_klass.superclass.should == Capybara::Wheel::Element
+  end
+
+  it 'allows access to the selector' do
+    created_element_klass.new.selector.should == selector
+  end
+
+  it 'generated instance evalutes block' do
+    test_block = Proc.new do
+      def evaled_method
+      end
+    end
+
+    subject.create_element_klass(selector, test_block).new.should respond_to(:evaled_method)
+  end
+end

data/spec/element_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+feature 'Element' do
+  let(:element_selector)  { '#some-selector' }
+  let(:element)           { Capybara::Wheel::Element }
+  let(:element_instance)  {  element.new(element_selector) }
+
+  it 'has access to capybara' do
+    element_instance.methods.include?(:capybara).should be_true
+  end
+
+  it 'has delegators for Capybara actions' do
+    pending 'grab all the actions from Capybara and ensure delegators are implemented'
+  end
+
+  context 'self.element' do
+    let(:element_selector)    { '#rad-parent-selector' }
+
+    let(:subelement_name)     { 'RadSubElement' }
+    let(:subelement_selector) { '#rad-sub-selector' }
+
+    before do
+      element_instance.instance_eval do
+        element('RadSubElement', '#rad-sub-selector')
+      end
+    end
+
+    it 'created a method for calling the element' do
+      element_instance.should respond_to(:rad_sub_element)
+    end
+
+    it 'create a (sub)element with parent element context' do
+      element_instance.send(:rad_sub_element).scope.should == element_instance
+    end
+
+    it 'the find would be scoped to parent' do
+      subelement             = element_instance.send(:rad_sub_element)
+      mock_capybara_session  = mock(Capybara::Session)
+      mock_capybara_element  = mock('Capybara::Element')
+      Capybara.stub!(:current_session).and_return(mock_capybara_session)
+      mock_capybara_session.stub(:find).with(element_selector).and_return(mock_capybara_element)
+      mock_capybara_element.stub(:find).with(subelement_selector).and_return(mock_capybara_element)
+
+      element_instance.should_receive(:capybara_element).once.and_return(mock_capybara_element)
+
+      subelement.send(:capybara_element)
+    end
+  end
+
+end

data/spec/feature_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+RSpec.configure do |config|
+  config.before(:each, :some_hook) do
+    @hook_passed_on = true
+  end
+end
+
+feature 'runs as a wheel feature', :some_hook do
+
+  it 'should pass' do
+  end
+
+  it 'should be set as a wheel feature' do
+    example.metadata[:type].should == :wheel_feature
+  end
+
+  it 'should pass the right hook' do
+    @hook_passed_on.should be_true
+  end
+end

data/spec/page_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+feature 'Page' do
+  let(:page) { Capybara::Wheel::Page }
+
+  subject { page.new }
+  it { is_expected.to respond_to(:capybara) }
+
+  describe '.element' do
+
+    context 'element with no options' do
+      subject { page.element('RadElement', '#rad-selector').new }
+
+      it { is_expected.to respond_to(:rad_element) }
+    end
+
+    context 'element with extra options' do
+      subject { page.element('OptionalElement', '#opt-selector', visible: false).new }
+
+      it { is_expected.to respond_to(:optional_element) }
+      
+      it 'has options' do
+        expect(subject.optional_element.options).to eq(visible: false)
+      end
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'capybara/wheel'
+require 'rspec'
+require 'pry'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+end

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification
+name: dkastner-capybara-wheel
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- "@gabrielrotbart"
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: capybara
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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: selenium-webdriver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.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'
+description: Keeping the rodent on track
+email:
+- gabe@hooroo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- capybara-wheel.gemspec
+- lib/capybara/wheel.rb
+- lib/capybara/wheel/element.rb
+- lib/capybara/wheel/element_factory.rb
+- lib/capybara/wheel/includes.rb
+- lib/capybara/wheel/page.rb
+- lib/capybara/wheel/version.rb
+- spec/element_factory_spec.rb
+- spec/element_spec.rb
+- spec/feature_spec.rb
+- spec/page_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/hooroo/capybara-wheel
+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: Creating (yet another) page model gem based around making capybara tests
+  more stable with no need for waits
+test_files:
+- spec/element_factory_spec.rb
+- spec/element_spec.rb
+- spec/feature_spec.rb
+- spec/page_spec.rb
+- spec/spec_helper.rb