capybara-rc 0.5.1

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,5 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.2.3
+before_install: gem install bundler -v 1.10.6

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+* 0.5.1
+
+* Add homepage to gemspec (rubygems.org won't let you publish without it)
+
+# 0.5.0
+
+* Initial version

data/DIFFERENCES.md

@@ -0,0 +1,34 @@
+# Behavior differences between Selenium-RC and Capybara
+
+* Selenium-RC can locate elements which are not visible. Capybara only returns
+  visible elements. Among other things, this means that `is_element_present` and
+  `is_visible` behave differently in this adapter than in Selenium-RC.
+* Capybara always waits for conditions to become true, so
+  `wait_for_page_to_load` is a no-op. Capybara does not expose a way to do what
+  Selenium-RC's `wait_for_page_to_load` does (wait until the next time a page
+  is loaded for any reason). The Capybara way to do this is to specify a
+  condition that will be satisfied once the new page is loaded. Capybara will
+  wait for that to become true. See also `Capybara.use_wait_time` if Capybara's
+  default wait time is too short for the page load you are waiting on.
+* The Capybara-backed implementation of `is_visible` waits for an element to
+  show up even if what you're trying to test is that the element is _not_
+  present. The adapter provides a method `capybara_has_no_locator?` which allows
+  you to hook into Capybara's negated matchers and avoid this delay.
+* Support for `mouse_out` is not available, but a workaround is calling
+  `mouse_over` on another element.
+* Methods which take JavaScript snippets as arguments (such as `get_eval`,
+  `run_script`, and `wait_for_condition`) behave differently. Because Capybara
+  uses Selenium-Webdriver and not RC, the JavaScript environment is different:
+  the execution context is the active window, not the `selenium` object and the
+  Selenium-RC API is not present (`browserbot`, etc.). Details for specific
+  adapted methods:
+  * `get_eval` is translated to Capybara's `execute_script`. While `get_eval`
+    returns the value of the last expression automatically, `execute_script`
+    only returns a value if the script snippet has an explicit return.
+  * `run_script` is also translated to Capybara's `execute_script`. Unlike
+    Selenium-RC, this will not necessarily be implemented by creating a script
+    tag with the provided JavaScript source.
+  * `wait_for_condition`'s condition is evaluated using `evaluate_script`. The
+    script must only contain a single expression.
+* Capybara-RC does not support switching to a window based on a handle
+  referenced as a local variable in the current page.

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Collaborative Drug Discovery.
+
+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,81 @@
+# Capybara::Rc
+
+This gem provides an adapter that allows Selenium-RC-based code to execute using
+[Capybara](http://jnicklas.github.io/capybara/) instead. This is useful because:
+
+* Selenium-RC has been deprecated for a while
+* Capybara allows your tests to run against different backends (not just selenium)
+* Porting an existing test suite to a new library is dangerous — you can wind up
+  modifying your tests in such a way that they still pass but are no longer
+  actually testing what you want.
+
+### Caveats
+
+* This is not a full adapter yet — it only adapts the methods that we are using
+  at CDD.
+* Some things that were possible with Selenium-RC are not possible in Capybara.
+  See DIFFERENCES.md for a list of some of these.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'capybara-rc'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install capybara-rc
+
+## Usage
+
+* Configure Capybara as is appropriate for your application
+* Replace your Selenium-RC initialization with something like this:
+
+```ruby
+require 'capybara/rc'
+# If @browser was your Selenium-RC browser before …
+@browser = Capybara::Rc::Adapter.new(Capybara.current_session)
+```
+
+### Additions
+
+The ideal with this adapter is that you'd be able to drop it in and run your
+existing test suite with no changes. The reality is that you probably use some
+features of Selenium-RC that can't be adapted to Capybara (`get_eval` and the
+Selenium-RC in-browser JavaScript API are likely sources of this).
+
+In order to limit the changes you need to make to your test suite, the `Adapter`
+class provides some lower-level translation methods:
+
+* `capybara_find_by_locator(locator)`: returns a Capybara element corresponding
+  to the given Selenium-RC locator. You can use the Capybara API to do further
+  querying/testing on the returned element.
+* `capybara_has_no_locator?(locator)`: allows you to bypass Capybara's wait
+  when you are trying to test that something isn't present. Maps from a
+  Selenium-RC locator to the appropriate Capybara `has_no_*` method
+  (`has_no_css`, `has_no_xpath`, etc.).
+* `capybara_has_locator?(locator)`: The positive version of the previous method.
+  Similarly maps to the appropriate Capybara `has_*` method.
+
+## Development
+
+### Project infrastructure
+
+* [Source on GitHub](https://github.com/cdd/capybara-rc)
+* [![Build Status](https://travis-ci.org/cdd/capybara-rc.svg?branch=master)](https://travis-ci.org/cdd/capybara-rc)
+  [Continuous Integration on Travis-CI](https://travis-ci.org/cdd/capybara-rc)
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/cdd/capybara-rc.
+
+
+## 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/rspec

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('rspec-core', 'rspec')

data/capybara-rc.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'capybara/rc/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "capybara-rc"
+  spec.version       = Capybara::Rc::VERSION
+  spec.authors       = ["Rhett Sutphin"]
+  spec.email         = ["rhett@collaborativedrug.com"]
+
+  spec.summary       = %q{Provides the Selenium-RC API on top of Capybara}
+  spec.description   = %q{
+    Provides a wrapper for a Capybara session which exposes the ancient Selenium-RC API.
+    Allows gradually porting a legacy Selenium suite to newer technologies.
+  }
+  spec.homepage      = "https://github.com/cdd/capybara-rc"
+  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_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", '~> 3.3'
+  spec.add_development_dependency "capybara"
+  spec.add_development_dependency "mime-types", "2.99" # 3.0+ requires Ruby 2.0+, which we currently do not support
+end

data/lib/capybara/rc.rb

@@ -0,0 +1,7 @@
+require "capybara/rc/version"
+require "capybara/rc/adapter"
+
+module Capybara
+  module Rc
+  end
+end

data/lib/capybara/rc/accessors.rb

@@ -0,0 +1,159 @@
+require 'timeout'
+
+module Capybara
+  module Rc
+    ##
+    # Contributes Selenium-RC reader methods to the adapter.
+    #
+    # Expects a `session` accessor to be provided where it is mixed in.
+    module Accessors
+      WAIT_FOR_CONDITION_DELAY_SECONDS = 0.2
+
+      def is_checked(locator)
+        element = capybara_find_by_locator(locator)
+        if capybara_element_is_radio_or_checkbox?(element)
+          element.checked?
+        else
+          fail "#{locator.inspect} is not a checkable element"
+        end
+      end
+
+      ##
+      # Note that Capybara does not allow access to invisible elements, so this
+      # is equivalent to `is_visible`.
+      #
+      # @return [Boolean]
+      def is_element_present(locator)
+        capybara_has_locator?(locator)
+      end
+
+      ##
+      # Returns true if the locator matches an element. Capybara does not make
+      # invisible elements available at all, so there is no distinction between
+      # an invisible element and one that is not present. (This method returns
+      # false for both.)
+      #
+      # @return [Boolean]
+      def is_visible(locator)
+        capybara_has_locator?(locator)
+      end
+
+      def is_text_present(pattern)
+        page_text = session.text
+        parsed = parse_selenium_rc_string_pattern(pattern)
+        case parsed[:type]
+        when :glob
+          page_text.include?(parsed[:string])
+        else
+          fail "Don't know how to search a string using a #{parsed[:type].inspect} Selenium pattern"
+        end
+      end
+
+      def is_editable(locator)
+        !capybara_find_by_locator(locator).disabled?
+      end
+
+      def get_title
+        session.title
+      end
+
+      def get_html_source
+        session.source
+      end
+
+      def get_location
+        session.current_url
+      end
+
+      def get_text(locator)
+        capybara_find_by_locator(locator).text
+      end
+
+      def get_value(locator)
+        c_element = capybara_find_by_locator(locator)
+        if (capybara_element_is_radio_or_checkbox?(c_element))
+          c_element.checked? ? 'on' : 'off'
+        else
+          c_element.value.strip
+        end
+      end
+
+      def get_attribute(attribute_locator)
+        match = (attribute_locator.match(/\A(.*)@(\w+)\Z/))
+        if match
+          element_locator = match[1]
+          attribute_name = match[2]
+          capybara_find_by_locator(element_locator)[attribute_name]
+        else
+          fail "Unable to parse attribute_locator #{attribute_locator.inspect}"
+        end
+      end
+
+      def get_select_options(locator)
+        capybara_find_select_by_locator(locator).
+          all('option').map { |opt_elt| opt_elt.text.strip }
+      end
+
+      def get_selected_label(locator)
+        capybara_get_selected_option_elements_by_locator(locator).first.text
+      end
+
+      def get_selected_value(locator)
+        capybara_get_selected_option_elements_by_locator(locator).first.value
+      end
+
+      def get_xpath_count(xpath)
+        session.all(:xpath, xpath).size
+      end
+
+      def get_table(table_cell_address)
+        address_parts = table_cell_address.split(".")
+        locator = address_parts[0..-3].join(".")
+        row = address_parts[-2].to_i
+        column = address_parts[-1].to_i
+
+        table = capybara_find_by_locator(locator)
+        row = table.all("tr")[row]
+        cell = (row.all('th').to_a + row.all('td').to_a)[column]
+
+        if cell
+          cell.text
+        else
+          fail Capybara::ElementNotFound
+        end
+      end
+
+      def wait_for_condition(script, timeout_milliseconds)
+        begin
+          Timeout.timeout(timeout_milliseconds / 1000.0) do
+            until session.evaluate_script(script)
+              sleep(WAIT_FOR_CONDITION_DELAY_SECONDS)
+            end
+          end
+        rescue Timeout::Error
+          fail "Condition did not become true within #{timeout_milliseconds}ms"
+        end
+      end
+
+      private
+
+      def capybara_element_is_radio_or_checkbox?(element)
+        element.tag_name == 'input' && %w(checkbox radio).include?(element['type'])
+      end
+
+      def capybara_find_select_by_locator(locator)
+        element = capybara_find_by_locator(locator)
+        if element.tag_name == 'select'
+          element
+        else
+          fail "#{locator.inspect} does not point to a select element"
+        end
+      end
+
+      def capybara_get_selected_option_elements_by_locator(locator)
+        capybara_find_select_by_locator(locator).all('option').
+          select { |opt_elt| opt_elt.selected? }
+      end
+    end
+  end
+end

data/lib/capybara/rc/actions.rb

@@ -0,0 +1,103 @@
+require 'capybara/rc/selenium_rc_locators'
+require 'capybara/rc/extensions'
+
+module Capybara
+  module Rc
+    ##
+    # Contributes Selenium-RC action methods to the adapter.
+    #
+    # Expects a `session` accessor to be provided where it is mixed in.
+    module Actions
+      include SeleniumRcLocators
+      include Extensions
+
+      def open(url)
+        session.visit(url)
+      end
+
+      def get_eval(js)
+        session.execute_script(js)
+      end
+
+      def run_script(js)
+        session.execute_script(js); nil
+      end
+
+      def click(locator)
+        capybara_find_by_locator(locator).click
+      end
+
+      def check(locator)
+        capybara_find_by_locator(locator).set(true)
+      end
+
+      def uncheck(locator)
+        capybara_find_by_locator(locator).set(false)
+      end
+
+      def select(select_locator, option_locator)
+        select_element = capybara_find_by_locator(select_locator)
+        parsed = parse_selenium_rc_select_option_locator(option_locator)
+        if parsed[:type] == :text
+          select_element.select(parsed[:string])
+          return
+        end
+        options = select_element.all('option')
+        option_to_select = nil
+        case parsed[:type]
+        when :value
+          option_to_select = options.detect { |o| o['value'] == parsed[:string] }
+        else
+          fail "Don't know how to find a #{parsed[:type].inspect} Selenium option locator with Capybara"
+        end
+        if option_to_select
+          option_to_select.select_option
+        else
+          fail Capybara::ElementNotFound, "No option matching #{option_locator.inspect} for select element #{select_locator}"
+        end
+      end
+
+      def type(locator, value)
+        element = capybara_find_by_locator(locator)
+        element.set(value)
+      end
+
+      def type_keys(locator, value)
+        element = capybara_find_by_locator(locator)
+        element.send_keys(value)
+      end
+
+      def drag_and_drop_to_object(draggable_locator, target_locator)
+        draggable = capybara_find_by_locator(draggable_locator)
+        target = capybara_find_by_locator(target_locator)
+
+        draggable.drag_to(target)
+      end
+
+      def drag_and_drop(draggable_locator, move_by)
+        draggable = capybara_find_by_locator(draggable_locator).native
+        delta_x, delta_y = move_by.split(",").map { |int| Kernel.Integer(int) }
+
+        session.driver.browser.action.drag_and_drop_by(draggable, delta_x, delta_y).perform
+      end
+
+      def attach_file(locator, file_name)
+        capybara_element = capybara_find_by_locator(locator)
+        session.attach_file(capybara_element[:id] || capybara_element[:name], file_name)
+      end
+
+      def go_back
+        session.execute_script("window.history.back()")
+      end
+
+      def refresh
+        session.execute_script("window.location.reload()")
+      end
+
+      def mouse_over(locator)
+        element = capybara_find_by_locator(locator)
+        element.hover
+      end
+    end
+  end
+end

data/lib/capybara/rc/adapter.rb

@@ -0,0 +1,28 @@
+require 'capybara/rc/accessors'
+require 'capybara/rc/actions'
+require 'capybara/rc/extensions'
+require 'capybara/rc/modals'
+require 'capybara/rc/windows'
+
+module Capybara
+  module Rc
+    class Adapter
+      include Accessors
+      include Actions
+      include Extensions
+      include Modals
+      include Windows
+
+      attr_reader :session
+
+      def initialize(session)
+        super
+        @session = session
+      end
+
+      def wait_for_page_to_load(timeout)
+        # Capybara always waits, so nothing to do here.
+      end
+    end
+  end
+end

data/lib/capybara/rc/extensions.rb

@@ -0,0 +1,143 @@
+require 'capybara/rc/selenium_rc_locators'
+require 'xpath'
+
+module Capybara
+  module Rc
+    ##
+    # Contributes methods to the adapter that are not part of Selenium-RC, but
+    # which are useful in a test suite in transition.
+    #
+    # Expects a `session` accessor to be provided where it is mixed in.
+    module Extensions
+      include SeleniumRcLocators
+
+      ##
+      # Parses the locator and finds the corresponding Capybara element.
+      # Raises Capybara::ElementNotFound when the element can't be found, or
+      # a StandardError if the locator is not supported.
+      #
+      # @return [Capybara::Node::Element]
+      def capybara_find_by_locator(locator)
+        parsed = parse_selenium_rc_locator(locator)
+
+        css_selector = locator_to_css_selector(parsed)
+        return session.find(css_selector) if css_selector
+
+        xpath_expression = locator_to_xpath_expression(parsed)
+        return session.find(:xpath, xpath_expression) if xpath_expression
+
+        fail "Don't know how to find a #{parsed[:type].inspect} Selenium locator with Capybara"
+      end
+
+      ##
+      # Parses the locator and queries the session to see if it is present.
+      #
+      # @return [Boolean]
+      def capybara_has_locator?(locator)
+        parsed = parse_selenium_rc_locator(locator)
+
+        css_selector = locator_to_css_selector(parsed)
+        return session.has_css?(css_selector) if css_selector
+
+        xpath_expression = locator_to_xpath_expression(parsed)
+        return session.has_xpath?(xpath_expression) if xpath_expression
+
+        fail "Don't know how to find a #{parsed[:type].inspect} Selenium locator with Capybara"
+      end
+
+      ##
+      # Parses the locator and queries the session to see if it is _not_ present.
+      # This saves time over `!adapter.is_visible(locator)` because Capybara
+      # [pauses]( https://github.com/jnicklas/capybara#asynchronous-javascript-ajax-and-friends)
+      # to wait for an element to show up after you find it. If you want to
+      # check that it isn't there, this pause is a waste of time. As a side
+      # effect of this Capybara behavior, this method will also wait for an
+      # element to disappear.
+      def capybara_has_no_locator?(locator)
+        parsed = parse_selenium_rc_locator(locator)
+
+        css_selector = locator_to_css_selector(parsed)
+        return session.has_no_css?(css_selector) if css_selector
+
+        xpath_expression = locator_to_xpath_expression(parsed)
+        return session.has_no_xpath?(xpath_expression) if xpath_expression
+
+        fail "Don't know how to find a #{parsed[:type].inspect} Selenium locator with Capybara"
+      end
+
+      private
+
+      ##
+      # @return [String, nil] A CSS selector for the given Selenium-RC locator,
+      #   or nil if the locator is of a type which cannot be converted into a
+      #   CSS selector.
+      def locator_to_css_selector(parsedLocator)
+        case parsedLocator[:type]
+        when :class
+          ".#{parsedLocator[:string]}"
+        when :css
+          parsedLocator[:string]
+        when :id
+          "##{parsedLocator[:string]}"
+        when :identifier
+          possibilities = [
+            ("##{parsedLocator[:string]}" if parsedLocator[:string] =~ /\A[a-z][a-z0-9_:\-\.]*\Z/i),
+            "[name=#{parsedLocator[:string].inspect}]"
+          ]
+          possibilities.compact.join(', ')
+        when :name
+          "[name=#{parsedLocator[:string].inspect}]"
+        else
+          nil
+        end
+      end
+
+      ##
+      # @return [String, nil] An XPath selector for the given Selenium-RC
+      #   locator, or nil if the locator is of a type which cannot be converted
+      #   into an XPath selector. N.b. — intended to be used after the CSS
+      #   version, so it doesn't attempt to translate locator types handled
+      #   there.
+      def locator_to_xpath_expression(parsed_locator)
+        case parsed_locator[:type]
+        when :xpath
+          parsed_locator[:string]
+        when :link
+          link_pattern = parse_selenium_rc_string_pattern(parsed_locator[:string])
+          link_pattern_to_xpath_expression(link_pattern)
+        else
+          nil
+        end
+      end
+
+      def link_pattern_to_xpath_expression(parsed_pattern)
+        case parsed_pattern[:type]
+        when :glob
+          link_glob_to_xpath_expression(parsed_pattern[:string])
+        else
+          fail "Don't know how to find a link using a #{parsed[:type].inspect} Selenium pattern"
+        end
+      end
+
+      def link_glob_to_xpath_expression(glob)
+        pos = 0
+        asterisk_locations = glob.split('*', glob.size).map { |part| pos += part.size }
+        asterisk_locations.pop # the last index is the remainder after all the asterisks have been accounted for
+
+        glob_without_asterisks = glob.gsub('*', '')
+        content_expression =
+          if asterisk_locations.empty?
+            XPath.string.n.equals(glob_without_asterisks)
+          elsif asterisk_locations == [glob_without_asterisks.size]
+            XPath.string.n.starts_with(glob_without_asterisks)
+          elsif asterisk_locations == [0, glob_without_asterisks.size]
+            XPath.string.n.is(glob_without_asterisks)
+          else
+            fail "Don't know how to translate the glob #{glob.inspect} into an XPath link-matching expression"
+          end
+
+        XPath.generate { |x| x.descendant(:a)[x.attr(:href)][content_expression] }.to_s
+      end
+    end
+  end
+end

data/lib/capybara/rc/modals.rb

@@ -0,0 +1,27 @@
+module Capybara
+  module Rc
+    ##
+    # Contributes Selenium-RC methods related to modal dialogs to the adapter.
+    #
+    # Expects a `session` accessor to be provided where it is mixed in.
+    module Modals
+      def initialize(*)
+        choose_ok_on_next_confirmation
+      end
+
+      def choose_ok_on_next_confirmation
+        @next_confirmation = :accept_confirm
+      end
+
+      def choose_cancel_on_next_confirmation
+        @next_confirmation = :dismiss_confirm
+      end
+
+      def get_confirmation
+        result = session.send(@next_confirmation)
+        choose_ok_on_next_confirmation
+        result
+      end
+    end
+  end
+end

data/lib/capybara/rc/selenium_rc_locators.rb

@@ -0,0 +1,74 @@
+module Capybara
+  module Rc
+    module SeleniumRcLocators
+      ##
+      # Follows the logic & heuristics in
+      #  https://github.com/SeleniumHQ/selenium/blob/master/javascript/selenium-atoms/se_locators.js
+      #  function core.locators.parseLocator_
+      def parse_selenium_rc_locator(locator)
+        match = locator.match(/\A([A-Za-z]+)=.+\Z/)
+        if match
+          type = match[1]
+          string = locator.split('=', 2)[1]
+          {
+            type: type.to_sym,
+            string: string
+          }
+        elsif locator =~ %r{^//}
+          { type: :xpath, string: locator }
+        elsif locator =~ /^document\./
+          { type: :dom, string: locator }
+        else
+          { type: :identifier, string: locator }
+        end
+      end
+
+      ##
+      # Follows the logic & heuristics in
+      #  https://github.com/SeleniumHQ/selenium/blob/master/javascript/selenium-atoms/select.js
+      #  function core.select.option.getOptionLocator_
+      def parse_selenium_rc_select_option_locator(option_locator)
+        match = option_locator.match(/\A([A-Za-z]+)=.*\Z/)
+        if match
+          type = match[1]
+          type = "text" if type == "label"
+          string = option_locator.split('=', 2)[1]
+          {
+            type: type.to_sym,
+            string: string
+          }
+        else
+          { type: :text, string: option_locator }
+        end
+      end
+
+      def parse_selenium_rc_window_locator(window_locator)
+        if window_locator == nil || window_locator == "null"
+          return { type: :main_window, string: nil }
+        end
+        match = window_locator.match(/\A([A-Za-z]+)=.*\Z/)
+        if match
+          type = match[1]
+          string = window_locator.split('=', 2)[1]
+          { type: type.to_sym, string: string }
+        else
+          { type: :window_id, string: window_locator }
+        end
+      end
+
+      def parse_selenium_rc_string_pattern(pattern)
+        match = pattern.match(/\A([A-Za-z]+):.+\Z/)
+        if match
+          type = match[1]
+          string = pattern.split(':', 2)[1]
+          {
+            type: type.to_sym,
+            string: string
+          }
+        else
+          { type: :glob, string: pattern }
+        end
+      end
+    end
+  end
+end

data/lib/capybara/rc/version.rb

@@ -0,0 +1,5 @@
+module Capybara
+  module Rc
+    VERSION = "0.5.1"
+  end
+end

data/lib/capybara/rc/windows.rb

@@ -0,0 +1,110 @@
+module Capybara
+  module Rc
+    ##
+    # Contributes Selenium-RC methods related to windows to the adapter.
+    #
+    # Expects a `session` accessor to be provided where it is mixed in.
+    # Also requires that the adapter class's initialize method call super.
+    module Windows
+      MAIN_APP_WINDOW_NAME = "selenium_main_app_window"
+
+      def initialize(session)
+        super
+        if session.respond_to?(:current_window)
+          # The result from Capybara.string does not have a current window
+          @main_window = session.current_window
+          session.execute_script("window.name = #{MAIN_APP_WINDOW_NAME.inspect}")
+        end
+      end
+
+      def open_window(url, window_id)
+        session.execute_script("window.open(#{url.inspect}, #{window_id.inspect})")
+      end
+
+      def select_window(window_locator)
+        parsed = parse_selenium_rc_window_locator(window_locator)
+
+        window =
+          case parsed[:type]
+          when :main_window
+            @main_window
+          when :name
+            find_window_by_name(parsed[:string])
+          when :title
+            find_window_by_title(parsed[:string])
+          when :window_id
+            find_window_by_name_or_title(parsed[:string])
+          else
+            fail "Don't know how to find a #{parsed[:type].inspect} Selenium window locator with Capybara"
+          end
+
+        unless window
+          fail "Could not find a window matching #{window_locator.inspect}"
+        end
+        session.switch_to_window(window)
+      end
+
+      def close
+        window = session.current_window
+        window.close
+      end
+
+      def window_maximize
+        session.current_window.maximize
+      end
+
+      def get_all_window_names
+        all_window_names = []
+        in_each_window do |window, page|
+          all_window_names << page.execute_script("return window.name;");
+        end
+        all_window_names
+      end
+
+      private
+
+      def find_window_by_name(name)
+        in_each_window do |window, page|
+          this_name = page.execute_script("return window.name;");
+          break window if name == this_name
+        end
+      end
+
+      def find_window_by_title(title)
+        in_each_window do |window, page|
+          break window if title == page.title
+        end
+      end
+
+      def find_window_by_name_or_title(id)
+        # Check for name matches & return immediately if found. At the same
+        # time collect titles so that we can do that check if necessary without
+        # flipping through the windows again.
+        titles = {}
+        by_name = in_each_window do |window, page|
+          name = page.execute_script("return window.name;");
+          break window if name == id
+          titles[page.title] = window
+        end
+        return by_name if by_name
+
+        # If the other checks didn't find anything, return the window matching
+        # by title or nil if there isn't one.
+        titles[id]
+      end
+
+      def in_each_window(&block)
+        starting_window = session.current_window
+        begin
+          session.windows.each do |window|
+            session.switch_to_window(window)
+            yield window, session
+          end
+          nil
+        ensure
+          session.switch_to_window(starting_window)
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification
+name: capybara-rc
+version: !ruby/object:Gem::Version
+  version: 0.5.1
+  prerelease: 
+platform: ruby
+authors:
+- Rhett Sutphin
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-12-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: capybara
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '2.99'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '2.99'
+description: ! "\n    Provides a wrapper for a Capybara session which exposes the
+  ancient Selenium-RC API.\n    Allows gradually porting a legacy Selenium suite to
+  newer technologies.\n  "
+email:
+- rhett@collaborativedrug.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- CHANGELOG.md
+- DIFFERENCES.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/rspec
+- capybara-rc.gemspec
+- lib/capybara/rc.rb
+- lib/capybara/rc/accessors.rb
+- lib/capybara/rc/actions.rb
+- lib/capybara/rc/adapter.rb
+- lib/capybara/rc/extensions.rb
+- lib/capybara/rc/modals.rb
+- lib/capybara/rc/selenium_rc_locators.rb
+- lib/capybara/rc/version.rb
+- lib/capybara/rc/windows.rb
+homepage: https://github.com/cdd/capybara-rc
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -3019246126874219789
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -3019246126874219789
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Provides the Selenium-RC API on top of Capybara
+test_files: []