locator 0.0.1

data/README.textile

@@ -0,0 +1,5 @@
+h1. Locator
+
+This library aims to extract common html element selection from testing tools such as "Webrat":http://github.com/brynary/webrat/blob/master/lib/webrat/core/locators.rb, "Capybara":http://github.com/jnicklas/capybara/blob/master/lib/capybara/xpath.rb or "Steam":http://github.com/svenfuchs/steam/blob/master/lib/steam/locators.rb.
+
+At its core it constructs "XPath":http://github.com/svenfuchs/locator/blob/master/lib/locator/xpath.rb objects using a simple "boolean expression engine":http://github.com/svenfuchs/locator/blob/master/lib/locator/boolean.rb in order to locate elements in a Nokogiri DOM. It provides a bunch of "Element classes":http://github.com/svenfuchs/locator/blob/master/lib/locator/element.rb that are targeted at implementing a Webrat-style DSL for convenience.

data/Rakefile

@@ -0,0 +1,19 @@
+require 'rake/testtask'
+
+require File.expand_path("../lib/locator/version", __FILE__)
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "locator"
+    s.version = Locator::VERSION
+    s.summary = "Generic html element locators for integration testing"
+    s.email = "svenfuchs@artweb-design.de"
+    s.homepage = "http://github.com/svenfuchs/locator"
+    s.description = "Generic html element locators for integration testing"
+    s.authors = ['Sven Fuchs']
+    s.files =  FileList["[A-Z]*", "{lib,test,vendor}/**/*"]
+  end
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/lib/core_ext/string/underscore.rb

@@ -0,0 +1,5 @@
+class String
+  def underscore
+    self[0, 1].downcase + self[1..-1].gsub(/[A-Z]/) { |c| "_#{c.downcase}" }
+  end
+end unless ''.respond_to?(:underscore)

data/lib/locator/boolean.rb

@@ -0,0 +1,50 @@
+class Locator
+  module Boolean
+    class Terms < Array
+      def and!(other)
+        replace(self.dup.and(other))
+      end
+
+      def and(other)
+        other.empty? ? self : And.new(self, other)
+      end
+      alias & and
+
+      def or!(other)
+        replace(self.dup.or(other))
+      end
+
+      def or(other)
+        other.empty? ? self : Or.new(self, other)
+      end
+      alias | and
+
+      def to_s
+        flatten.join(Or.operator)
+      end
+    end
+
+    module Accessors
+      def operator=(operator); @operator = operator end
+      def operator; @operator end
+    end
+
+    class And < Terms
+      extend Accessors
+      self.operator = ' AND '
+
+      def initialize(lft, rgt)
+        replace(lft.map { |l| rgt.map { |r| "#{l}#{self.class.operator}#{r}" } })
+      end
+    end
+
+    class Or < Terms
+      extend Accessors
+      self.operator = ' OR '
+
+      def initialize(lft, rgt)
+        replace([lft, rgt])
+      end
+    end
+  end
+end

data/lib/locator/dom/nokogiri/element.rb

@@ -0,0 +1,49 @@
+class Locator
+  module Dom
+    module Nokogiri
+      class Element
+        attr_reader :element
+
+        def initialize(element)
+          @element = element
+        end
+        
+        def xpath
+          element.path.to_s
+        end
+        
+        def css_path
+          element.css_path.to_s
+        end
+
+        def inner_html
+          element.inner_html
+        end
+
+        def to_s
+          element.to_s
+        end
+
+        def tag_name
+          element.description.name
+        end
+
+        def ancestor_of?(other)
+          other.element.ancestors.include?(element)
+        end
+
+        def attribute(name)
+          element.attribute(name).to_s
+        end
+
+        def attributes(names)
+          names.map { |name| attribute(name) }
+        end
+        
+        def elements_by_xpath(xpath)
+          element.xpath(xpath).map { |element| Element.new(element) }
+        end
+      end
+    end
+  end
+end

data/lib/locator/dom/nokogiri/page.rb

@@ -0,0 +1,25 @@
+class Locator
+  module Dom
+    module Nokogiri
+      class Page
+        attr_reader :dom
+
+        def initialize(html)
+          @dom = ::Nokogiri::HTML::Document.parse(html)
+        end
+
+        def element_by_id(id)
+          elements_by_xpath("//*[@id='#{id}']").first
+        end
+
+        def elements_by_xpath(xpath)
+          @dom.xpath(xpath).map { |element| Element.new(element) }
+        end
+
+        def to_s
+          @dom.to_s
+        end
+      end
+    end
+  end
+end

data/lib/locator/dom/nokogiri.rb

@@ -0,0 +1,10 @@
+require 'nokogiri'
+
+class Locator
+  module Dom
+    module Nokogiri
+      autoload :Element, 'locator/dom/nokogiri/element'
+      autoload :Page,    'locator/dom/nokogiri/page'
+    end
+  end
+end

data/lib/locator/dom.rb

@@ -0,0 +1,21 @@
+require 'nokogiri'
+
+class Locator
+  module Dom
+    autoload :Nokogiri, 'locator/dom/nokogiri'
+    
+    class << self
+      def adapter
+        @@adapter ||= Nokogiri
+      end
+
+      def adapter=(adapter)
+        @@adapter = adapter
+      end
+
+      def page(html)
+        adapter::Page.new(html)
+      end
+    end
+  end
+end

data/lib/locator/element/area.rb

@@ -0,0 +1,9 @@
+class Locator
+  class Element
+    class Area < Element
+      def initialize
+        super('area', [:id, :alt])
+      end
+    end
+  end
+end

data/lib/locator/element/button.rb

@@ -0,0 +1,11 @@
+class Locator
+  class Element
+    class Button < ElementsList
+      def initialize
+        input  = Element.new('input',  [:id, :name, :value, :alt], :type => %w(submit button image))
+        button = Element.new('button', [:id, :name, :content])
+        super(input, button)
+      end
+    end
+  end
+end

data/lib/locator/element/elements_list.rb

@@ -0,0 +1,15 @@
+class Locator
+  class Element
+    class ElementsList
+      attr_reader :elements
+      
+      def initialize(*elements)
+        @elements = elements
+      end
+      
+      def xpath(*args)
+        elements.map { |element| element.xpath(*args) }.join(' | ')
+      end
+    end
+  end
+end

data/lib/locator/element/field.rb

@@ -0,0 +1,10 @@
+class Locator
+  class Element
+    class Field < ElementsList
+      def initialize
+        types = [:text, :password , :email, :url, :search, :tel, :color]
+        super(LabeledElement.new('input', [:id, :name], :type => types), TextArea.new)
+      end
+    end
+  end
+end

data/lib/locator/element/form.rb

@@ -0,0 +1,9 @@
+class Locator
+  class Element
+    class Form < Element
+      def initialize
+        super('form', [:id, :name])
+      end
+    end
+  end
+end

data/lib/locator/element/label.rb

@@ -0,0 +1,9 @@
+class Locator
+  class Element
+    class Label < Element
+      def initialize
+        super('label', [:id, :content])
+      end
+    end
+  end
+end

data/lib/locator/element/labeled_element.rb

@@ -0,0 +1,17 @@
+class Locator
+  class Element
+    class LabeledElement < Element
+      attr_reader :labeled
+
+      def initialize(name = '*', locatables = [], attributes = {})
+        @labeled = Element.new(name, [], attributes)
+        super
+      end
+
+      def compose(selector, attributes)
+        super
+        replace(self + labeled.and("[@id=//label[contains(.,\"#{selector}\")]/@for]")) if selector
+      end
+    end
+  end
+end

data/lib/locator/element/link.rb

@@ -0,0 +1,9 @@
+class Locator
+  class Element
+    class Link < Element
+      def initialize
+        super('a', [:id, :content], :href => true)
+      end
+    end
+  end
+end

data/lib/locator/element/select.rb

@@ -0,0 +1,9 @@
+class Locator
+  class Element
+    class Select < LabeledElement
+      def initialize
+        super('select', [:id, :name])
+      end
+    end
+  end
+end

data/lib/locator/element/select_option.rb

@@ -0,0 +1,9 @@
+class Locator
+  class Element
+    class SelectOption < Element
+      def initialize
+        super('option', [:id, :value, :content])
+      end
+    end
+  end
+end

data/lib/locator/element/text_area.rb

@@ -0,0 +1,9 @@
+class Locator
+  class Element
+    class TextArea < LabeledElement
+      def initialize
+        super('textarea', [:id, :name])
+      end
+    end
+  end
+end

data/lib/locator/element.rb

@@ -0,0 +1,45 @@
+class Locator
+  class Element < Xpath
+    autoload :Area,           'locator/element/area'
+    autoload :Button,         'locator/element/button'
+    autoload :ElementsList,   'locator/element/elements_list'
+    autoload :Field,          'locator/element/field'
+    autoload :Form,           'locator/element/form'
+    autoload :Label,          'locator/element/label'
+    autoload :LabeledElement, 'locator/element/labeled_element'
+    autoload :Link,           'locator/element/link'
+    autoload :Select,         'locator/element/select'
+    autoload :SelectOption,   'locator/element/select_option'
+    autoload :TextArea,       'locator/element/text_area'
+    
+    attr_reader :locatables
+
+    def initialize(name = '*', locatables = [], attributes = {})
+      super(name)
+      @content = !!locatables.delete(:content)
+      @locatables = locatables
+      @attributes = attributes
+    end
+
+    def xpath(*args)
+      attributes = Hash === args.last ? args.pop : {}
+      compose(args.pop, attributes)
+      to_s
+    end
+
+    protected
+    
+      def content?
+        @content
+      end
+
+      def compose(selector, attributes)
+        attributes = @attributes.merge(attributes)
+        attributes.each { |name, value| and! equals(name, value) }
+        terms = []
+        terms << equals(locatables, selector) if selector
+        terms << contains(selector) if content? && selector
+        and!(terms) unless terms.empty?
+      end
+  end
+end

data/lib/locator/version.rb

@@ -0,0 +1,3 @@
+class Locator
+  VERSION = "0.0.1"
+end

data/lib/locator/xpath.rb

@@ -0,0 +1,38 @@
+class Locator
+  autoload :Boolean, 'locator/boolean'
+
+  Boolean::Or.operator, Boolean::And.operator = ' | ', ''
+
+  class Xpath < Boolean::Terms
+    def initialize(name = nil, attributes = {})
+      names = Array(name || '*').map { |name| xpath?(name) ? name : ".//#{name}" }
+      super(names)
+      attributes.each { |name, value| and!(equals(name, value)) }
+    end
+
+    def equals(names, values)
+      case values
+      when TrueClass
+        "[@#{names}]"
+      else
+        values = Array(values).map { |value| xpath?(value) ? value : "\"#{value}\"" }
+        expr = Array(names).map { |name| values.map { |value| "@#{name}=#{value}" } }
+        expr.empty? ? '' : '[' + expr.flatten.join(' or ') + ']'
+      end
+    end
+
+    def matches(name, value)
+      "[contains(@#{name},\"#{value}\")]"
+    end
+
+    def contains(value)
+      "/descendant-or-self::*[contains(.,\"#{value}\")]"
+    end
+
+    protected
+
+      def xpath?(string)
+        string.to_s[0, 1] == '/'
+      end
+  end
+end

data/lib/locator.rb

@@ -0,0 +1,52 @@
+require 'core_ext/string/underscore'
+
+class Locator
+  autoload :Actions, 'locator/actions'
+  autoload :Dom,     'locator/dom'
+  autoload :Element, 'locator/element'
+  autoload :Xpath,   'locator/xpath'
+
+  class << self
+    def [](type)
+      locators[type.to_sym]
+    end
+
+    def xpath(type, *args)
+      Locator[type].new.xpath(*args)
+    end
+
+    protected
+
+      def locators
+        @locators ||= Hash[*Element.constants.map do |name|
+          [name.underscore.to_sym, Element.const_get(name)]
+        end.flatten]
+      end
+  end
+
+  attr_reader :dom, :scopes
+
+  def initialize(dom)
+    @dom = dom.respond_to?(:elements_by_xpath) ? dom : Dom.page(dom)
+    @scopes = []
+  end
+
+  def locate(type, *args)
+    options = Hash === args.last ? args.last : {}
+    if scope = options.delete(:within)
+      within(scope) { locate(type, *args) }
+    else
+      path = type.is_a?(Symbol) ? Locator.xpath(type, *args) : type
+      scope = scopes.pop || dom
+      scope.elements_by_xpath(path).first
+    end
+  end
+
+  # TODO currently only take an xpath or element
+  def within(scope, &block)
+    scope = scope.is_a?(Hash) ? scope.delete(:xpath) : scope
+    scope = locate(scope) unless scope.respond_to?(:xpath)
+    scopes.push(scope)
+    instance_eval(&block)
+  end
+end

data/test/all.rb

@@ -0,0 +1,3 @@
+Dir[File.dirname(__FILE__) + '/**/*_test.rb'].each do |filename|
+  require filename
+end

data/test/locator/boolean_test.rb

@@ -0,0 +1,40 @@
+require File.expand_path('../../test_helper', __FILE__)
+require 'locator/xpath'
+
+class XpathBooleanTest < Test::Unit::TestCase
+  Or, And = Locator::Boolean::Or, Locator::Boolean::And
+
+  def setup
+    Or.operator, And.operator = ' | ', ' & '
+  end
+
+  test "a | b => a | b" do
+    path = Or.new('a', 'b').to_s
+    assert_equal "a | b", path
+  end
+
+  test "a & b => a & b" do
+    path = And.new('a', 'b').to_s
+    assert_equal "a & b", path
+  end
+
+  test "(a & b) | c => a & b | c" do
+    path = And.new('a', 'b').or('c').to_s
+    assert_equal "a & b | c", path
+  end
+
+  test "(a | b) & c => a & c | b & c" do
+    path = Or.new('a', 'b').and('c').to_s
+    assert_equal "a & c | b & c", path
+  end
+
+  test "(a & b | c) & d => a & b & d | c & d" do
+    path = And.new('a', 'b').or('c').and('d').to_s
+    assert_equal "a & b & d | c & d", path
+  end
+
+  test "(a & b | c) & (d | e) => a & b & d | a & b & e | c & d | c & e" do
+    path = And.new('a', 'b').or('c').and(Or.new('d', 'e')).to_s
+    assert_equal "a & b & d | a & b & e | c & d | c & e", path
+  end
+end

data/test/locator/element/button_test.rb

@@ -0,0 +1,26 @@
+require File.expand_path('../../../test_helper', __FILE__)
+require 'locator/element'
+
+class ElementButtonTest < Test::Unit::TestCase
+  Button = Locator::Element::Button
+
+  test "finds a button" do
+    assert_locate '<button></button>', Button.new.xpath
+  end
+
+  test "finds a submit input" do
+    assert_locate '<input type="submit">', Button.new.xpath
+  end
+
+  test "finds a button input" do
+    assert_locate '<input type="button">', Button.new.xpath
+  end
+
+  test "finds an image input" do
+    assert_locate '<input type="image">', Button.new.xpath
+  end
+
+  test "does not find a checkbox input" do
+    assert_no_locate '<input type="checkbox">', Button.new.xpath
+  end
+end

data/test/locator/element/field_test.rb

@@ -0,0 +1,60 @@
+require File.expand_path('../../../test_helper', __FILE__)
+require 'locator/element'
+
+class ElementFieldTest < Test::Unit::TestCase
+  Field = Locator::Element::Field
+
+  test "finds a textarea" do
+    assert_locate '<textarea></textarea>', Field.new.xpath
+  end
+  
+  test "finds a text input" do
+    assert_locate '<input type="text">', Field.new.xpath
+  end
+  
+  test "finds a password input" do
+    assert_locate '<input type="password">', Field.new.xpath
+  end
+  
+  test "finds an email input" do
+    assert_locate '<input type="email">', Field.new.xpath
+  end
+  
+  test "finds a url input" do
+    assert_locate '<input type="url">', Field.new.xpath
+  end
+  
+  test "finds a search input" do
+    assert_locate '<input type="search">', Field.new.xpath
+  end
+  
+  test "finds a tel input" do
+    assert_locate '<input type="tel">', Field.new.xpath
+  end
+  
+  test "finds a color input" do
+    assert_locate '<input type="color">', Field.new.xpath
+  end
+
+  test "finds a text input by name" do
+    assert_locate '<input type="text" name="foo">', Field.new.xpath('foo')
+  end
+
+  test "finds a text input by class attribute" do
+    assert_locate '<input type="text" class="foo">', Field.new.xpath(:class => 'foo')
+  end
+
+  test "finds an input by label content" do
+    html = '<label for="bar">foo</label><input type="text" id="bar">'
+    assert_locate html, Field.new.xpath('foo'), '<input type="text" id="bar">'
+  end
+
+  test "finds an input by label content and input class" do
+    html = '<label for="bar">foo</label><input type="text" id="bar" class="baz">'
+    assert_locate html, Field.new.xpath('foo', :class => 'baz'), '<input type="text" id="bar" class="baz">'
+  end
+
+  test "does not find a checkbox input" do
+    assert_no_locate '<input type="checkbox">', Field.new.xpath
+  end
+end

data/test/locator/element/form_test.rb

@@ -0,0 +1,30 @@
+require File.expand_path('../../../test_helper', __FILE__)
+require 'locator/element'
+
+class ElementFormTest < Test::Unit::TestCase
+  Form = Locator::Element::Form
+
+  test "finds a form" do
+    assert_locate '<form></form>', Form.new.xpath
+  end
+
+  test "finds a form by id" do
+    assert_locate '<form id="foo"></form>', Form.new.xpath('foo')
+  end
+
+  test "finds a form by name" do
+    assert_locate '<form name="foo"></form>', Form.new.xpath('foo')
+  end
+
+  test "finds a form by class" do
+    assert_locate '<form class="foo"></form>', Form.new.xpath(:class => 'foo')
+  end
+
+  test "does not find a form when id does not match" do
+    assert_no_locate '<form id="bar"></form>', Form.new.xpath(:class => 'foo')
+  end
+
+  test "does not find a form when class does not match" do
+    assert_no_locate '<form class="bar"></form>', Form.new.xpath(:class => 'foo')
+  end
+end

data/test/locator/element/label_test.rb

@@ -0,0 +1,26 @@
+require File.expand_path('../../../test_helper', __FILE__)
+require 'locator/element'
+
+class ElementLabelTest < Test::Unit::TestCase
+  Label = Locator::Element::Label
+
+  test "finds a label" do
+    assert_locate '<label></label>', Label.new.xpath
+  end
+
+  test "finds a label by id" do
+    assert_locate '<label id="foo"></label>', Label.new.xpath('foo')
+  end
+
+  test "finds a label by class" do
+    assert_locate '<label class="foo"></label>', Label.new.xpath(:class => 'foo')
+  end
+
+  test "does not find a label when id does not match" do
+    assert_no_locate '<label id="bar"></label>', Label.new.xpath(:class => 'foo')
+  end
+
+  test "does not find a label when class does not match" do
+    assert_no_locate '<label class="bar"></label>', Label.new.xpath(:class => 'foo')
+  end
+end

data/test/locator/element/link_test.rb

@@ -0,0 +1,34 @@
+require File.expand_path('../../../test_helper', __FILE__)
+require 'locator/element'
+
+class ElementLinkTest < Test::Unit::TestCase
+  Link = Locator::Element::Link
+
+  test "finds a link" do
+    assert_locate '<a href=""></a>', Link.new.xpath
+  end
+
+  test "finds a link by id" do
+    assert_locate '<a href="" id="foo"></a>', Link.new.xpath('foo')
+  end
+
+  test "finds a link by class" do
+    assert_locate '<a href="" class="foo"></a>', Link.new.xpath(:class => 'foo')
+  end
+
+  test "finds an link by content" do
+    assert_locate '<a href="">foo</a>', Link.new.xpath('foo')
+  end
+
+  test "does not find an anchor" do
+    assert_no_locate '<a name=""></a>', Link.new.xpath
+  end
+
+  test "does not find a link when id does not match" do
+    assert_no_locate '<a href="" id="bar"></a>', Link.new.xpath(:class => 'foo')
+  end
+
+  test "does not find a link when class does not match" do
+    assert_no_locate '<a href="" class="bar"></a>', Link.new.xpath(:class => 'foo')
+  end
+end

data/test/locator/element/select_option_test.rb

@@ -0,0 +1,34 @@
+require File.expand_path('../../../test_helper', __FILE__)
+require 'locator/element'
+
+class ElementSelectOptionOptionTest < Test::Unit::TestCase
+  SelectOption = Locator::Element::SelectOption
+
+  test "finds an option" do
+    assert_locate '<option></option>', SelectOption.new.xpath
+  end
+
+  test "finds an option by id" do
+    assert_locate '<option id="foo"></option>', SelectOption.new.xpath('foo')
+  end
+
+  test "finds an option by value" do
+    assert_locate '<option value="foo"></option>', SelectOption.new.xpath('foo')
+  end
+
+  test "finds an option by content" do
+    assert_locate '<option>foo</option>', SelectOption.new.xpath('foo')
+  end
+
+  test "finds an option by class attribute" do
+    assert_locate '<option class="foo"></option>', SelectOption.new.xpath(:class => 'foo')
+  end
+
+  test "does not find an option when id does not match" do
+    assert_no_locate '<option id="bar"></option>', SelectOption.new.xpath(:class => 'foo')
+  end
+
+  test "does not find an option when class does not match" do
+    assert_no_locate '<option class="bar"></option>', SelectOption.new.xpath(:class => 'foo')
+  end
+end

data/test/locator/element/select_test.rb

@@ -0,0 +1,26 @@
+require File.expand_path('../../../test_helper', __FILE__)
+require 'locator/element'
+
+class ElementSelectTest < Test::Unit::TestCase
+  Select = Locator::Element::Select
+
+  test "finds a select" do
+    assert_locate '<select></select>', Select.new.xpath
+  end
+
+  test "finds a select by id" do
+    assert_locate '<select id="foo"></select>', Select.new.xpath('foo')
+  end
+
+  test "finds a select by class" do
+    assert_locate '<select class="foo"></select>', Select.new.xpath(:class => 'foo')
+  end
+
+  test "does not find a select when id does not match" do
+    assert_no_locate '<select id="bar"></select>', Select.new.xpath(:class => 'foo')
+  end
+
+  test "does not find a select when class does not match" do
+    assert_no_locate '<select class="bar"></select>', Select.new.xpath(:class => 'foo')
+  end
+end

data/test/locator/element/text_area_test.rb

@@ -0,0 +1,26 @@
+require File.expand_path('../../../test_helper', __FILE__)
+require 'locator/element'
+
+class ElementTextAreaTest < Test::Unit::TestCase
+  TextArea = Locator::Element::TextArea
+
+  test "finds a textarea" do
+    assert_locate '<textarea></textarea>', TextArea.new.xpath
+  end
+
+  test "finds a textarea by id" do
+    assert_locate '<textarea id="foo"></textarea>', TextArea.new.xpath('foo')
+  end
+
+  test "finds a textarea by class" do
+    assert_locate '<textarea class="foo"></textarea>', TextArea.new.xpath(:class => 'foo')
+  end
+
+  test "does not find a textarea when id does not match" do
+    assert_no_locate '<textarea id="bar"></textarea>', TextArea.new.xpath(:class => 'foo')
+  end
+
+  test "does not find a textarea when class does not match" do
+    assert_no_locate '<textarea class="bar"></textarea>', TextArea.new.xpath(:class => 'foo')
+  end
+end

data/test/locator/element_test.rb

@@ -0,0 +1,40 @@
+require File.expand_path('../../test_helper', __FILE__)
+require 'locator/element'
+
+class ElementTest < Test::Unit::TestCase
+  def xpath(*args)
+    Locator::Element.new('foo', [:id, :content]).xpath(*args)
+  end
+
+  test "no selector given => finds all element" do
+    assert_locate '<foo></foo><foo></foo>', xpath, ['<foo></foo>', '<foo></foo>']
+  end
+  
+  test "given selector equals content => finds the element" do
+    assert_locate '<foo>foo</foo>', xpath('foo')
+  end
+  
+  test "given selector contained in content => finds the element" do
+    assert_locate '<foo>foo!</foo>', xpath('foo')
+  end
+  
+  test "given selector equals id => finds the element" do
+    assert_locate '<foo id="foo"></foo>', xpath('foo')
+  end
+  
+  test "given selector contained in id => does not find the element" do
+    assert_no_locate '<foo id="foobar"></foo>', xpath('foo')
+  end
+  
+  test "given attribute equals attribute => finds the element" do
+    assert_locate '<foo class="foo">a</foo>', xpath(:class => 'foo')
+  end
+  
+  test "given attribute contained in attribute => does not find the element" do
+    assert_no_locate '<foo class="foo-bar">a</foo>', xpath(:class => 'foo')
+  end
+  
+  test "selector + attributes => finds the element" do
+    assert_locate '<foo class="foo" title="bar">bar</foo>', xpath('bar', :class => 'foo', :title => 'bar')
+  end
+end

data/test/locator/xpath_test.rb

@@ -0,0 +1,50 @@
+require File.expand_path('../../test_helper', __FILE__)
+require 'locator/xpath'
+
+class XpathTest < Test::Unit::TestCase
+  Xpath = Locator::Xpath
+
+  def setup
+    Locator::Boolean::Or.operator, Locator::Boolean::And.operator = ' | ', ''
+  end
+
+  test "simple xpath" do
+    path = Xpath.new('input').to_s
+    assert_equal ".//input", path
+  end
+
+  test "xpath with alternate nodenames" do
+    path = Xpath.new(['input', 'button']).to_s
+    assert_equal ".//input | .//button", path
+  end
+
+  test "xpath with attributes" do
+    path = Xpath.new(['input', 'button'], :type => 'text', :id => 'foo').to_s
+    assert_equal %(.//input[@type="text"][@id="foo"] | .//button[@type="text"][@id="foo"]), path
+  end
+
+  test "xpath with alternate nodenames and attributes" do
+    path = Xpath.new(['input', 'button']).to_s
+    assert_equal ".//input | .//button", path
+  end
+
+  test "xpath or xpath" do
+    path = Xpath.new('input', :type => 'text').or!(Xpath.new('textarea')).to_s
+    assert_equal %(.//input[@type="text"] | .//textarea), path
+  end
+  
+  test "attribute equals to one of multiple values" do
+    path = Xpath.new('input', :type => [:text, :password]).to_s
+    assert_equal %(.//input[@type="text" or @type="password"]), path
+  end
+  
+  test "one of multiple attributes equals to value" do
+    path = Xpath.new('input', [:id, :name] => 'foo').to_s
+    assert_equal %(.//input[@id="foo" or @name="foo"]), path
+  end
+  
+  test "one of multiple attributes equals to one of multiple values" do
+    path = Xpath.new('input', [:id, :name] => ['foo', 'bar']).to_s
+    assert_equal %(.//input[@id="foo" or @id="bar" or @name="foo" or @name="bar"]), path
+  end
+end

data/test/locator_test.rb

@@ -0,0 +1,31 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'locator/element'
+
+class LocatorTest < Test::Unit::TestCase
+  test "looks up a locator/element class by type" do
+    assert_equal Locator::Element::Field, Locator[:field]
+  end
+
+  test "generates an xpath for type and given args" do
+    path = Locator.xpath(:form, 'foo', :class => 'bar')
+    assert_equal './/form[@class="bar"][@id="foo" or @name="foo"]', path
+  end
+
+  test "locates an element from html" do
+    html = '<html><body><h1></h1><form class="bar"></form></body></html>'
+    element = Locator.new(html).locate(:form, :class => 'bar')
+    assert_equal '<form class="bar"></form>', element.to_s
+  end
+
+  test "within scopes to an xpath" do
+    html = '<form id="foo"></form><div id="bar"><form></form></div>'
+    element = Locator.new(html).within(:xpath => '//div[@id="bar"]') { locate(:form) }
+    assert_equal '<form></form>', element.to_s
+  end
+
+  test "locates scopes to :within option" do
+    html = '<form id="foo"></form><div id="bar"><form></form></div>'
+    element = Locator.new(html).locate(:form, :within => '//div[@id="bar"]')
+    assert_equal '<form></form>', element.to_s
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,46 @@
+$:.unshift File.expand_path("../lib", File.dirname(__FILE__))
+$:.unshift(File.expand_path(File.dirname(__FILE__)))
+
+require 'test/unit'
+require 'locator'
+
+module TestMethod
+  def self.included(base)
+    base.class_eval do
+      def test(name, &block)
+        test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
+        defined = instance_method(test_name) rescue false
+        raise "#{test_name} is already defined in #{self}" if defined
+        if block_given?
+          define_method(test_name, &block)
+        else
+          define_method(test_name) do
+            flunk "No implementation provided for #{name}"
+          end
+        end
+      end
+    end
+  end
+end
+
+class Module
+  include TestMethod
+end
+
+class Test::Unit::TestCase
+  include TestMethod
+
+  def dom(html)
+    Locator::Dom.page(html)
+  end
+  
+  def assert_locate(html, path, elements = nil)
+    expected = Array(elements || html)
+    result   = dom(html).elements_by_xpath(path).map(&:to_s)
+    assert_equal expected, result
+  end
+  
+  def assert_no_locate(html, path)
+    assert_locate(html, path, [])
+  end
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: locator
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Sven Fuchs
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-04 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Generic html element locators for integration testing
+email: svenfuchs@artweb-design.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.textile
+files: 
+- README.textile
+- Rakefile
+- lib/core_ext/string/underscore.rb
+- lib/locator.rb
+- lib/locator/boolean.rb
+- lib/locator/dom.rb
+- lib/locator/dom/nokogiri.rb
+- lib/locator/dom/nokogiri/element.rb
+- lib/locator/dom/nokogiri/page.rb
+- lib/locator/element.rb
+- lib/locator/element/area.rb
+- lib/locator/element/button.rb
+- lib/locator/element/elements_list.rb
+- lib/locator/element/field.rb
+- lib/locator/element/form.rb
+- lib/locator/element/label.rb
+- lib/locator/element/labeled_element.rb
+- lib/locator/element/link.rb
+- lib/locator/element/select.rb
+- lib/locator/element/select_option.rb
+- lib/locator/element/text_area.rb
+- lib/locator/version.rb
+- lib/locator/xpath.rb
+- test/all.rb
+- test/locator/boolean_test.rb
+- test/locator/element/button_test.rb
+- test/locator/element/field_test.rb
+- test/locator/element/form_test.rb
+- test/locator/element/label_test.rb
+- test/locator/element/link_test.rb
+- test/locator/element/select_option_test.rb
+- test/locator/element/select_test.rb
+- test/locator/element/text_area_test.rb
+- test/locator/element_test.rb
+- test/locator/xpath_test.rb
+- test/locator_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/svenfuchs/locator
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Generic html element locators for integration testing
+test_files: 
+- test/all.rb
+- test/locator/boolean_test.rb
+- test/locator/element/button_test.rb
+- test/locator/element/field_test.rb
+- test/locator/element/form_test.rb
+- test/locator/element/label_test.rb
+- test/locator/element/link_test.rb
+- test/locator/element/select_option_test.rb
+- test/locator/element/select_test.rb
+- test/locator/element/text_area_test.rb
+- test/locator/element_test.rb
+- test/locator/xpath_test.rb
+- test/locator_test.rb
+- test/test_helper.rb