locator 0.0.4 → 0.0.5

data/lib/core_ext/hash/except.rb

@@ -8,4 +8,4 @@ class Hash
   def except(*keys)
     dup.except!(*keys)
   end
-end unless Hash.method_defined?(:slice)
+end unless Hash.method_defined?(:except)

data/lib/locator.rb

@@ -4,9 +4,16 @@ module Locator
   autoload :Boolean, 'locator/boolean'
   autoload :Dom,     'locator/dom'
   autoload :Element, 'locator/element'
+  autoload :Matcher, 'locator/matcher'
   autoload :Result,  'locator/result'
   autoload :Xpath,   'locator/xpath'
 
+  class ElementNotFound < StandardError
+    def initialize(*args)
+      super "could not find element type: #{args.map { |arg| arg.inspect }.join(', ') }"
+    end
+  end
+
   class << self
     def [](type)
       locators[type.to_sym] || raise("unknown locator type: #{type}")
@@ -26,49 +33,67 @@ module Locator
       end
   end
 
+  def scopes
+    @scopes ||= []
+  end
+
   def xpath(*args)
     type = args.shift if args.first.is_a?(Symbol)
     Locator[type].new.xpath(*args)
   end
 
-  def locate(dom, *args, &block)
-    return args.first if args.first.respond_to?(:elements_by_xpath)
-
-    options = Hash === args.last ? args.last : {}
-    result = if scope = options.delete(:within)
-      within(*Array(scope)) { locate(dom, *args) }
-    else
-      type = args.shift if args.first.is_a?(Symbol)
-      Locator.build(type).locate(current_scope(dom), *args)
-    end
+  def all(dom, *args)
+    lookup(:all, dom, *args)
+  end
 
-    result && block_given? ? within(result) { yield(self) } : result
+  def locate(dom, *args, &block)
+    lookup(:locate, dom, *args, &block)
   end
 
-  def within(*scope)
-    scopes.push(scope)
-    yield(self)
+  def within(*args)
+    dom = dom?(args.first) ? args.shift : scopes.pop
+    scopes << resolve_scope(dom, args)
+    yield(scopes.last)
   end
 
   protected
 
-    def current_scope(dom)
-      dom = Locator::Dom.page(dom) unless dom.respond_to?(:elements_by_xpath)
+    def lookup(method, *args, &block)
+      options = Hash === args.last ? args.last : {}
+      dom     = args.shift if dom?(args.first)
+      type    = args.shift if args.first.is_a?(Symbol)
+
+      scope  = resolve_scope(dom, options.delete(:within)) if options[:within]
+      scope  = scope || scopes.pop || dom
+
+      result = Locator.build(type).send(method, scope, *args)
+      result = result && block_given? ? within(result) { yield(result) } : result
+    end
 
-      case (scope = scopes.pop) && scope.first
+    def resolve_scope(dom, scope)
+      dom   = Locator::Dom.page(dom) unless dom.respond_to?(:elements_by_xpath)
+      scope = Array(scope)
+
+      case scope.first
       when NilClass
         dom
       when %r(^\.?//)
-        dom.elements_by_xpath(scope.first).first
+        dom.element_by_xpath(scope.first)
       when String
-        dom.elements_by_css(scope.first).first
+        dom.element_by_css(scope.first)
+      when Dom::Element
+        scope.first.to_s
       else
         locate(dom, *scope)
       end
     end
 
-    def scopes
-      @scopes ||= []
+    def dom?(arg)
+      arg.is_a?(Dom::Element) || html?(arg)
+    end
+
+    def html?(arg)
+      arg.is_a?(String) && arg =~ /<[^>]+>/
     end
 
   extend(self)

data/lib/locator/dom.rb

@@ -4,7 +4,7 @@ module Locator
   module Dom
     autoload :Htmlunit, 'locator/dom/htmlunit'
     autoload :Nokogiri, 'locator/dom/nokogiri'
-    
+
     class << self
       def adapter
         @@adapter ||= Nokogiri
@@ -18,5 +18,7 @@ module Locator
         adapter::Page.new(html)
       end
     end
+
+    class Element ; end
   end
 end

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

@@ -1,7 +1,7 @@
 module Locator
   module Dom
     module Htmlunit
-      class Element
+      class Element < Dom::Element
         attr_reader :element, :matches
 
         def initialize(element)

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

@@ -1,7 +1,7 @@
 module Locator
   module Dom
     module Nokogiri
-      class Element
+      class Element < Dom::Element
         attr_reader :element, :matches
 
         def initialize(element)
@@ -29,6 +29,22 @@ module Locator
           element.content
         end
 
+        def value
+          case name
+          when 'input'
+            element.attribute('value').value
+          when 'select'
+            selected = element.children.select { |option| option.attribute('selected') }
+            values = selected.map { |option| option.attribute('value') || option.content }
+            element.attribute('multiple') ? values.strip : values.first.strip
+          end
+        end
+
+        def checked
+          checked = element.attribute('checked')
+          checked ? checked.value : nil
+        end
+
         def inner_html
           element.inner_html
         end
@@ -48,11 +64,15 @@ module Locator
         def element_by_xpath(xpath)
           elements_by_xpath(xpath).first
         end
-        
+
         def elements_by_xpath(*xpaths)
           element.xpath(*xpaths).map { |element| Element.new(element) }
         end
 
+        def element_by_css(rule)
+          elements_by_css(rule).first
+        end
+
         def elements_by_css(*rules)
           element.css(*rules).map { |element| Element.new(element) }
         end

data/lib/locator/element.rb

@@ -6,6 +6,7 @@ module Locator
     autoload :Area,           'locator/element/area'
     autoload :Button,         'locator/element/button'
     autoload :CheckBox,       'locator/element/check_box'
+    autoload :Content,        'locator/element/content'
     autoload :ElementsList,   'locator/element/elements_list'
     autoload :Field,          'locator/element/field'
     autoload :File,           'locator/element/file'
@@ -24,14 +25,12 @@ module Locator
     attr_reader :name, :css, :locatables, :attributes
 
     def initialize(*args)
-      attributes, name = args.last.is_a?(Hash) ? args.pop : {}, args.pop
-      @name = name
-      @attributes = attributes
-      @locatables = ((attributes.delete(:matches) || [:content]) + [:id]).uniq
+      @attributes, @name = args.last.is_a?(Hash) ? args.pop : {}, args.pop
+      @locatables = (attributes.delete(:matches) || [:content]) << :id
     end
 
     def locate(*args)
-      all(*args).first
+      all(*args).first # || raise(ElementNotFound.new(*args))
     end
 
     def all(scope, *args)
@@ -41,17 +40,23 @@ module Locator
       result
     end
 
-    def xpath(attributes = {})
-      @xpath ||= Xpath.new(name || '*', self.attributes.merge(attributes)).to_s
+    def xpath(*args)
+      options    = args.last.is_a?(Hash) ? args.pop : {}
+      attributes = self.attributes.merge(options.except(:xpath, :css)) # TODO move to Xpath?
+      xpath, css = options.values_at(:xpath, :css)
+
+      xpath ||= css ? ::Nokogiri::CSS.xpath_for(*css).first : args.pop
+      Xpath.new(xpath || name || '*', attributes).to_s
     end
 
     protected
 
       def lookup(scope, selector, attributes = {})
         scope = scope.respond_to?(:elements_by_xpath) ? scope : Locator::Dom.page(scope)
-        xpath, css = attributes.delete(:xpath), attributes.delete(:css)
-        xpath = ::Nokogiri::CSS.xpath_for(*css).first if css
-        elements = scope.elements_by_xpath(xpath || xpath(attributes))
+        xpath = xpath(attributes)
+        xpath = ".#{xpath}" unless xpath[0, 1] == '.'
+
+        elements = scope.elements_by_xpath(xpath)
         Result.new(elements).filter!(selector, locatables)
       end
   end

data/lib/locator/element/content.rb

@@ -0,0 +1,10 @@
+module Locator
+  class Element
+    class Content < Element
+      def initialize(*args)
+        super
+        locatables.delete(:id)
+      end
+    end
+  end
+end

data/lib/locator/element/file.rb

@@ -2,7 +2,7 @@ module Locator
   class Element
     class File < Input
       def initialize
-        super(:input, :type => :file)
+        super(:type => :file)
       end
     end
   end

data/lib/locator/element/form.rb

@@ -2,7 +2,7 @@ module Locator
   class Element
     class Form < Element
       def initialize
-        super(:form)
+        super(:form, :matches => [:name])
       end
     end
   end

data/lib/locator/matcher.rb

@@ -0,0 +1,70 @@
+module Locator
+  module Matcher
+    autoload :HaveTag, 'locator/matcher/have_tag'
+
+    # Matches an HTML document with whatever string is given
+    def contain(*args)
+      HaveTag.new(*args)
+    end
+
+    # Asserts that the response body contains the given string or regexp
+    def assert_contain(*args)
+      matcher = contain(*args)
+      assert matcher.matches?(response.body), matcher.failure_message
+    end
+
+    # Asserts that the response body does not contain the given string or regexp
+    def assert_not_contain(*args)
+      matcher = contain(*args)
+      assert !matcher.matches?(response.body), matcher.negative_failure_message
+    end
+
+    def have_tag(*args, &block)
+      HaveTag.new(*args, &block)
+    end
+
+    def assert_have_tag(html, *args, &block)
+      matcher = have_tag(*args, &block)
+      assert matcher.matches?(response.body), matcher.failure_message
+    end
+
+    def assert_have_no_tag(html, *args, &block)
+      matcher = have_tag(*args, &block)
+      assert !matcher.matches?(response.body), matcher.negative_failure_message
+    end
+
+    # Matches HTML content against an XPath
+    def have_xpath(xpath, options = {}, &block)
+      HaveTag.new(options.delete(:content), options.merge(:xpath => xpath), &block)
+    end
+
+    # Asserts that the response body matches the given XPath
+    def assert_have_xpath(html, *args, &block)
+      matcher = have_xpath(*args, &block)
+      assert matcher.matches?(response.body), matcher.failure_message
+    end
+
+    # Asserts that the response body does not match the given XPath
+    def assert_have_no_xpath(html, *args, &block)
+      matcher = have_xpath(*args, &block)
+      assert !matcher.matches?(response.body), matcher.negative_failure_message
+    end
+
+    # Matches HTML content against a CSS selector.
+    def have_css(css, options = {}, &block)
+      HaveTag.new(options.delete(:content), options.merge(:css => css), &block)
+    end
+
+    # Asserts that the response body matches the given CSS selector
+    def assert_have_css(html, *args, &block)
+      matcher = have_css(*args, &block)
+      assert matcher.matches?(response.body), matcher.failure_message
+    end
+
+    # Asserts that the response body does not match the given CSS selector
+    def assert_have_no_css(html, *args, &block)
+      matcher = have_css(*args, &block)
+      assert !matcher.matches?(response.body), matcher.negative_failure_message
+    end
+  end
+end

data/lib/locator/matcher/have_tag.rb

@@ -0,0 +1,51 @@
+module Locator
+  module Matcher
+    class HaveTag
+      attr_reader :selector, :options, :count, :block, :target
+      
+      def initialize(*args, &block)
+        @options  = args.last.is_a?(Hash) ? args.pop : {}
+        @selector = args.pop
+        @count    = options.delete(:count)
+        @block    = block
+      end
+
+      def matches?(target = nil)
+        @target = target
+        count ? match_count : !!match_element
+      end
+      
+      def match_count
+        elements = Locator.all(target, selector, options)
+        elements = elements.select(&block) if block
+        elements.size == count.to_i
+      end
+      
+      def match_element
+        element = Locator.locate(target, selector, options)
+        element && block ? Locator.within(element) { block.call(element) } : element
+      end
+
+      def failure_message # TODO
+        "expected following text to match selector #{selector.inspect} and #{options.inspect}:\n#{target}"
+      end
+
+      def negative_failure_message
+        "expected following text to not match selector #{selector.inspect} and #{options.inspect}:\n#{target}"
+      end
+
+      # def squeeze_space(inner_text)
+      #   (inner_text || '').gsub(/^\s*$/, "").squeeze("\n")
+      # end
+      # 
+      # def content_message
+      #   case @content
+      #   when String
+      #     "include \"#{@content}\""
+      #   when Regexp
+      #     "match #{@content.inspect}"
+      #   end
+      # end
+    end
+  end
+end

data/lib/locator/version.rb

@@ -1,3 +1,3 @@
 module Locator
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/test/all.rb

@@ -1,3 +1,6 @@
-Dir[File.dirname(__FILE__) + '/**/*_test.rb'].each do |filename|
+files = Dir[File.dirname(__FILE__) + '/**/*_test.rb']
+# files.reject! { |file| file.include?('htmlunit') }
+
+files.each do |filename|
   require filename unless filename.include?('_locator')
 end

data/test/locator/element_test.rb

@@ -9,29 +9,36 @@ class LocatorElementTest < Test::Unit::TestCase
     assert_equal './/*', Element.new.xpath
   end
 
-  test "xpath with a node name" do
+  test "xpath of an element with a node name" do
     xpath = Element.new(:div).xpath
     assert_equal './/div', xpath
   end
 
-  test "xpath with attributes" do
+  test "xpath of an element with attributes" do
     xpath = Element.new(nil, :type => 'type', :class => 'class').xpath
     assert_equal ".//*[@type=\"type\"][contains(concat(' ', @class, ' '), concat(' ', \"class\", ' '))]", xpath
   end
 
-  test "xpath with node name and attributes" do
+  test "xpath of an element with node name and attributes" do
     xpath = Element.new(:div, :type => 'type', :class => 'class').xpath
     assert_equal ".//div[@type=\"type\"][contains(concat(' ', @class, ' '), concat(' ', \"class\", ' '))]", xpath
   end
 
-  test "xpath with multiple node name and attributes" do
+  test "xpath of an element with multiple node name and attributes" do
     xpath = Element.new([:div, :p], :type => 'type').xpath
     assert_equal ".//div[@type=\"type\"] | .//p[@type=\"type\"]", xpath
   end
 
   test "xpath merges given attributes with element attributes" do
     xpath = Element.new(:div, :foo => 'foo').xpath(:bar => 'bar')
-    assert_equal ".//div[@foo=\"foo\"][@bar=\"bar\"]", xpath
+    assert xpath.include?(".//div")
+    assert xpath.include?("[@foo=\"foo\"]") # humpf, unsorted hash
+    assert xpath.include?("[@bar=\"bar\"]")
+  end
+
+  test "xpath with given xpath and attributes" do
+    xpath = Element.new.xpath('.//div', :foo => 'foo')
+    assert_equal ".//div[@foo=\"foo\"]", xpath
   end
 
   # all

data/test/locator/matcher/have_content_test.rb

@@ -0,0 +1,29 @@
+require File.expand_path('../../../test_helper', __FILE__)
+
+class LocatorMatcherHaveContentTest < Test::Unit::TestCase
+  include Locator::Matcher
+  
+  def setup
+    @html = '<p><a class="foo">The link</a></p>'
+  end
+  
+  test 'target matches a given text' do
+    assert contain('The link').matches?(@html)
+  end
+
+  test 'target does not match a given text' do
+    assert !contain('No link').matches?(@html)
+  end
+  
+  test 'target matches a given regex' do
+    assert contain(/The\slink/).matches?(@html)
+  end
+
+  test 'target does not match a given regex' do
+    assert !contain(/No\slink/).matches?(@html)
+  end
+  
+  test 'treats newslines as spaces' do
+    assert contain('Some text').matches?("<p>Some\ntext</p>")
+  end
+end

data/test/locator/matcher/have_tag_test.rb

@@ -0,0 +1,161 @@
+require File.expand_path('../../../test_helper', __FILE__)
+
+class LocatorMatcherHaveTagTest < Test::Unit::TestCase
+  include Locator::Matcher
+
+  def setup
+    @html = '<p><a class="foo">The link</a></p>'
+  end
+
+  # given a selector
+
+  test 'target matches a given selector' do
+    assert have_tag('The link').matches?(@html)
+  end
+
+  test 'target does not match a given selector' do
+    assert !have_tag('No link').matches?(@html)
+  end
+
+  # given an xpath
+
+  test 'target matches a given xpath' do
+    assert have_tag(:xpath => '//p/a[@class="foo"]').matches?(@html)
+  end
+
+  test 'target does not match a given xpath' do
+    assert !have_tag(:xpath => '//p/a[@id="foo"]').matches?(@html)
+  end
+
+  # given a css selector
+
+  test 'target matches a given css' do
+    assert have_tag(:css => 'p a.foo').matches?(@html)
+  end
+
+  test 'target does not match a given css' do
+    assert !have_tag(:css => 'p a#foo').matches?(@html)
+  end
+
+  # given a selector and xpath
+
+  test 'target matches a given selector and xpath' do
+    assert have_tag('The link', :xpath => '//p/a').matches?(@html)
+  end
+
+  test 'target does not match a given (wrong) selector and xpath' do
+    assert !have_tag('No link', :xpath => '//p/a').matches?(@html)
+  end
+
+  test 'target does not match a given selector and (wrong) xpath' do
+    assert !have_tag('The link', :xpath => '//p/div').matches?(@html)
+  end
+
+  # given a selector and css selector
+
+  test 'target matches a given selector and css selector' do
+    assert have_tag('The link', :css => 'p a').matches?(@html)
+  end
+
+  test 'target does not match a given (wrong) selector and css selector' do
+    assert !have_tag('No link', :css => 'p a').matches?(@html)
+  end
+
+  test 'target does not match a given selector and (wrong) css selector' do
+    assert !have_tag('The link', :css => 'p div').matches?(@html)
+  end
+
+  # given an xpath and attributes
+
+  test 'target matches a given xpath and attributes' do
+    assert have_tag(:xpath => '//p/a', :class => 'foo').matches?(@html)
+  end
+
+  test 'target does not match a given (wrong) xpath and attributes' do
+    assert !have_tag(:xpath => '//p/div', :class => 'foo').matches?(@html)
+  end
+
+  test 'target does not match a given xpath and (wrong) attributes' do
+    assert !have_tag(:xpath => '//p/a', :id => 'foo').matches?(@html)
+  end
+
+  # given selector, xpath and attributes
+
+  test 'target matches a given selector, xpath and attributes' do
+    assert have_tag('The link', :xpath => '//p/a', :class => 'foo').matches?(@html)
+  end
+
+  test 'target does not match a given (wrong) selector, xpath and attributes' do
+    assert !have_tag('The link', :xpath => '//p/div', :class => 'foo').matches?(@html)
+  end
+
+  test 'target does not match a given selector, (wrong) xpath and attributes' do
+    assert !have_tag('No link', :xpath => '//p/a', :class => 'foo').matches?(@html)
+  end
+
+  test 'target does not match a given selector, xpath and (wrong) attributes' do
+    assert !have_tag('The link', :xpath => '//p/a', :class => 'bar').matches?(@html)
+  end
+
+  # given a selector, css selector and attributes
+
+  test 'target matches a given selector, css selector and attributes' do
+    assert have_tag('The link', :css => 'p a', :class => 'foo').matches?(@html)
+  end
+
+  test 'target does not match a given (wrong) selector, css selector and attributes' do
+    assert !have_tag('The link', :css => 'p div', :class => 'foo').matches?(@html)
+  end
+
+  test 'target does not match a given selector, (wrong) css selector and attributes' do
+    assert !have_tag('No link', :css => 'p a', :class => 'foo').matches?(@html)
+  end
+
+  test 'target does not match a given selector, css selector and (wrong) attributes' do
+    assert !have_tag('The link', :css => 'p a', :class => 'bar').matches?(@html)
+  end
+
+  # using a block
+
+  # test 'given block selects from matched elements (block yields true)' do
+  #   assert have_tag(:xpath => '//p') { true }.matches?(@html)
+  # end
+  #
+  # test 'given block selects from matched elements (block yields false)' do
+  #   assert !have_tag(:xpath => '//p') { false }.matches?(@html)
+  # end
+
+  test 'can use have_path in the given block' do
+    assert have_tag(:xpath => '//p') { assert have_tag(:xpath => '//a').matches?(nil); true }.matches?(@html)
+  end
+
+  test 'uses a relative path when called in a block' do
+    assert have_tag(:xpath => '//p') { assert have_tag(:xpath => '//a').matches?(nil); true }.matches?(@html)
+  end
+
+  test 'does not match parent tags called in a block' do
+    assert have_tag(:xpath => '//a') { assert !have_tag(:xpath => '//p').matches?(nil); true }.matches?(@html)
+  end
+
+  # counting matches
+
+  test 'target contains the given number of elements' do
+    assert have_tag(:xpath => '//p/a', :count => 1).matches?(@html)
+  end
+
+  test 'target does not contain the given number of elements' do
+    assert !have_tag(:xpath => '//p/a', :count => 2).matches?(@html)
+  end
+
+  test 'target contains the given number of elements when used with a block' do
+    assert have_tag(:xpath => '//p/a', :count => 1) { |element| element.name == 'a' }.matches?(@html)
+  end
+
+  test 'target does not contain the given number of elements when used with a block (too few elements)' do
+    assert !have_tag(:xpath => '//p/a', :count => 2) { |element| element.name == 'a' }.matches?(@html)
+  end
+
+  test 'target does not contain the given number of elements when used with a block (block does not match)' do
+    assert !have_tag(:xpath => '//p/a', :count => 1) { |element| element.name == 'div' }.matches?(@html)
+  end
+end

data/test/locator_test.rb

@@ -3,18 +3,18 @@ require File.expand_path('../test_helper', __FILE__)
 class LocatorTest < Test::Unit::TestCase
   include Locator
 
-  test "returns the element if given an element" do
-    html = '<p></p>'
-    element = Locator.locate(html, :p)
-    assert_equal element, Locator.locate(html, element)
-  end
+  # test "returns the element if given an element" do
+  #   html = '<p></p>'
+  #   element = locate(html, :p)
+  #   assert_equal element, locate(html, element)
+  # end
 
   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
-    xpath = Locator.xpath(:form, :id => 'bar')
+    xpath = xpath(:form, :id => 'bar')
     assert_equal './/form[@id="bar"]', xpath
   end
 
@@ -22,13 +22,13 @@ class LocatorTest < Test::Unit::TestCase
 
   test "locates the first element by node name" do
     html = '<html><body><form id="foo"></form><form id="bar"></form></body></html>'
-    element = Locator.locate(html, :form)
+    element = locate(html, :form)
     assert_equal 'foo', element.attribute('id')
   end
 
   test "locates the first element by xpath" do
     html = '<html><body><form id="foo"></form><form id="bar"></form></body></html>'
-    element = Locator.locate(html, :xpath => '//form')
+    element = locate(html, :xpath => '//form')
     assert_equal 'foo', element.attribute('id')
   end
 
@@ -36,49 +36,49 @@ class LocatorTest < Test::Unit::TestCase
 
   test "within scopes to a locator" do
     html = '<form></form><div id="bar"><form id="foo"></form></div>'
-    element = Locator.within(:div, :id => 'bar') { |scope| scope.locate(html, :form) }
+    element = within(html, :div, :id => 'bar') { locate(:form) }
     assert_equal 'foo', element.attribute('id')
   end
 
   test "within scopes to a css selector" do
     html = '<form></form><div id="bar"><form id="foo"></form></div>'
-    element = Locator.within('#bar') { |scope| scope.locate(html, :form) }
+    element = within(html, '#bar') { locate(:form) }
     assert_equal 'foo', element.attribute('id')
   end
 
   test "within scopes to an xpath" do
     html = '<form></form><div id="bar"><form id="foo"></form></div>'
-    element = Locator.within('//div[@id="bar"]') { |scope| scope.locate(html, :form) }
+    element = within(html, '//div[@id="bar"]') { locate(:form) }
     assert_equal 'foo', element.attribute('id')
   end
 
   test "nested within blocks" do
     html = '<form></form><div><form><p id="foo"><p></form></div>'
-    element = Locator.within(:div) { |scope| scope.within(:form) { |scope| scope.locate(html, :p) } }
+    element = within(html, :div) { within(:form) { locate(:p) } }
     assert_equal 'foo', element.attribute('id')
   end
 
   test "locates scopes to :within option (css selector)" do
     html = '<form></form><div><form id="foo"></form></div>'
-    element = Locator.locate(html, :form, :within => 'div')
+    element = locate(html, :form, :within => 'div')
     assert_equal 'foo', element.attribute('id')
   end
 
   test "locates scopes to :within option (xpath)" do
     html = '<form></form><div><form id="foo"></form></div>'
-    element = Locator.locate(html, :form, :within => '//div')
+    element = locate(html, :form, :within => '//div')
     assert_equal 'foo', element.attribute('id')
   end
 
   test "within/locate with module included" do
     html = '<form></form><div><form id="foo"></form></div>'
-    element = within(:div) { locate(html, :form) }
+    element = within(html, :div) { locate(:form) }
     assert_equal 'foo', element.attribute('id')
   end
 
   test "locate when given a block scopes the block to the located element" do
     html = '<p id="foo"><p><form></form><div><form><p id="bar"><p></form></div>'
-    element = locate(html, :div) { locate(html, :form)  { locate(html, :p) } }
+    element = locate(html, :div) { locate(:form) { locate(:p) } }
     assert_equal 'bar', element.attribute('id')
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: locator
 version: !ruby/object:Gem::Version 
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors: 
 - Sven Fuchs
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-21 00:00:00 +01:00
+date: 2010-02-28 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -42,6 +42,7 @@ files:
 - lib/locator/element/area.rb
 - lib/locator/element/button.rb
 - lib/locator/element/check_box.rb
+- lib/locator/element/content.rb
 - lib/locator/element/elements_list.rb
 - lib/locator/element/field.rb
 - lib/locator/element/file.rb
@@ -56,6 +57,8 @@ files:
 - lib/locator/element/select.rb
 - lib/locator/element/select_option.rb
 - lib/locator/element/text_area.rb
+- lib/locator/matcher.rb
+- lib/locator/matcher/have_tag.rb
 - lib/locator/result.rb
 - lib/locator/version.rb
 - lib/locator/xpath.rb
@@ -73,6 +76,8 @@ files:
 - test/locator/element/select_test.rb
 - test/locator/element/text_area_test.rb
 - test/locator/element_test.rb
+- test/locator/matcher/have_content_test.rb
+- test/locator/matcher/have_tag_test.rb
 - test/locator/xpath_test.rb
 - test/locator_test.rb
 - test/test_helper.rb
@@ -119,6 +124,8 @@ test_files:
 - test/locator/element/select_test.rb
 - test/locator/element/text_area_test.rb
 - test/locator/element_test.rb
+- test/locator/matcher/have_content_test.rb
+- test/locator/matcher/have_tag_test.rb
 - test/locator/xpath_test.rb
 - test/locator_test.rb
 - test/test_helper.rb