rspec-html-matchers 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6f28ddf0ddc2a0e321f8b3b291cfb2e3aa0b0e81
-  data.tar.gz: a4dedc6075e05857f5d97b9e133e3fa8ec8d230b
+  metadata.gz: ed044ed780b0ef4fefc403e3d644e6759b45232e
+  data.tar.gz: 3a9a74c22ee2c89bfae15fd3de267b3cf048604e
 SHA512:
-  metadata.gz: d66ca882d21fbba2ef260bdc3a5cebb5669568536583f1cdb10dac6a9c63068b3b46608def542c9960f3b90123a335048871aa49ed243fa92ae227683041cccf
-  data.tar.gz: b838ba419b4e5150ffc08944fe1faa3babaf9b9926340b8aa3654f54c1368f8678ed5b457257cbf646116ebaa1c003b2deb2f6ff90ab535ea5309916ae445594
+  metadata.gz: 52855bb634b6ccf3a31995e7d3a7730410d3f7c3209b9bfe9a42b9c924db3b7eb7d028d95a5523d1c02e87eab4929aad565a5483e7e1f1101a8eee8bad55cc2c
+  data.tar.gz: ecedc6b4e6791348db17d86a0338ccdeccfa3aa35e97a99a641358247cae14c89a39c6f2a56f026eba9b0f1d94b8f3757cc87b3186d8aa59a96ddfcb58fa3cac

data/CHANGELOG.md

@@ -11,6 +11,18 @@ unreleased(TODO)
 * order matching
 * improve documentation, add more usage examples (look at changelog and code!)
 
+0.7.0
+-----
+
+* new, explicit configuration, refer to README
+* added ruby 2.2.0 to CI
+
+0.6.1
+-----
+
+* rspec 3 version update
+* added ruby 2.1.2 to CI
+
 0.6.0
 -----
 

data/README.md

@@ -28,6 +28,33 @@ Add to your Gemfile in the `:test` group:
 gem 'rspec-html-matchers'
 ```
 
+and somewhere in RSpec configuration:
+
+```ruby
+RSpec.configure do |config|
+  config.include RSpecHtmlMatchers
+end
+```
+
+or just in you spec(s):
+
+```ruby
+describe "my view spec" do
+  include RSpecHtmlMatchers
+
+  it "has tags" do
+    expect(rendered).to have_tag('div')
+  end
+
+end
+```
+
+Cucumber configuration:
+
+```ruby
+World RSpecHtmlMatchers
+```
+
 as this gem requires **nokogiri**, here [instructions for installing it](http://nokogiri.org/tutorials/installing_nokogiri.html).
 
 Usage
@@ -195,6 +222,7 @@ Contributors
 - [Felix Tjandrawibawa](https://github.com/cemenghttps://github.com/cemeng)
 - [Szymon Przybył](https://github.com/apocalyptiq)
 - [Manuel Meurer](https://github.com/manuelmeurer)
+- [Andreas Riemer](https://github.com/arfl)
 
 MIT Licensed
 ============

data/features/support/env.rb

@@ -5,6 +5,8 @@ require 'sinatra/base'
 require 'capybara/cucumber'
 require 'rspec-html-matchers'
 
+World RSpecHtmlMatchers
+
 $ASSETS_DIR = File.expand_path('../tmp',__FILE__)
 $INDEX_HTML = File.join($ASSETS_DIR,'index.html')
 

data/lib/rspec-html-matchers.rb

@@ -2,568 +2,558 @@
 require 'rspec'
 require 'nokogiri'
 
-module RSpec
-  module HtmlMatchers
-
-    # @api
-    # @private
-    # for nokogiri regexp matching
-    class NokogiriRegexpHelper
-      def initialize(regex)
-        @regex = regex
-      end
+module RSpecHtmlMatchers
 
-      def regexp node_set
-        node_set.find_all { |node| node.content =~ @regex }
-      end
+  # @api
+  # @private
+  # for nokogiri regexp matching
+  class NokogiriRegexpHelper
+    def initialize(regex)
+      @regex = regex
     end
 
-    # @api
-    # @private
-    class NokogiriTextHelper
-      NON_BREAKING_SPACE = "\u00a0"
+    def regexp node_set
+      node_set.find_all { |node| node.content =~ @regex }
+    end
+  end
 
-      def initialize text
-        @text = text
-      end
+  # @api
+  # @private
+  class NokogiriTextHelper
+    NON_BREAKING_SPACE = "\u00a0"
 
-      def content node_set
-        node_set.find_all do |node|
-          actual_content = node.content.gsub(NON_BREAKING_SPACE, ' ')
+    def initialize text
+      @text = text
+    end
 
-          actual_content == @text
-        end
+    def content node_set
+      node_set.find_all do |node|
+        actual_content = node.content.gsub(NON_BREAKING_SPACE, ' ')
+
+        actual_content == @text
       end
     end
+  end
 
-    # @api
-    # @private
-    class HaveTag
-      attr_reader :failure_message, :failure_message_when_negated
-      attr_reader :parent_scope, :current_scope
+  # @api
+  # @private
+  class HaveTag
+    attr_reader :failure_message, :failure_message_when_negated
+    attr_reader :parent_scope, :current_scope
 
-      DESCRIPTIONS = {
-        :have_at_least_1 => %Q|have at least 1 element matching "%s"|,
-        :have_n          => %Q|have %i element(s) matching "%s"|
-      }
+    DESCRIPTIONS = {
+      :have_at_least_1 => %Q|have at least 1 element matching "%s"|,
+      :have_n          => %Q|have %i element(s) matching "%s"|
+    }
 
-      MESSAGES = {
-        :expected_tag         => %Q|expected following:\n%s\nto #{DESCRIPTIONS[:have_at_least_1]}, found 0.|,
-        :unexpected_tag       => %Q|expected following:\n%s\nto NOT have element matching "%s", found %s.|,
+    MESSAGES = {
+      :expected_tag         => %Q|expected following:\n%s\nto #{DESCRIPTIONS[:have_at_least_1]}, found 0.|,
+      :unexpected_tag       => %Q|expected following:\n%s\nto NOT have element matching "%s", found %s.|,
 
-        :expected_count       => %Q|expected following:\n%s\nto #{DESCRIPTIONS[:have_n]}, found %s.|,
-        :unexpected_count     => %Q|expected following:\n%s\nto NOT have %i element(s) matching "%s", but found.|,
+      :expected_count       => %Q|expected following:\n%s\nto #{DESCRIPTIONS[:have_n]}, found %s.|,
+      :unexpected_count     => %Q|expected following:\n%s\nto NOT have %i element(s) matching "%s", but found.|,
 
-        :expected_btw_count   => %Q|expected following:\n%s\nto have at least %i and at most %i element(s) matching "%s", found %i.|,
-        :unexpected_btw_count => %Q|expected following:\n%s\nto NOT have at least %i and at most %i element(s) matching "%s", but found %i.|,
+      :expected_btw_count   => %Q|expected following:\n%s\nto have at least %i and at most %i element(s) matching "%s", found %i.|,
+      :unexpected_btw_count => %Q|expected following:\n%s\nto NOT have at least %i and at most %i element(s) matching "%s", but found %i.|,
 
-        :expected_at_most     => %Q|expected following:\n%s\nto have at most %i element(s) matching "%s", found %i.|,
-        :unexpected_at_most   => %Q|expected following:\n%s\nto NOT have at most %i element(s) matching "%s", but found %i.|,
+      :expected_at_most     => %Q|expected following:\n%s\nto have at most %i element(s) matching "%s", found %i.|,
+      :unexpected_at_most   => %Q|expected following:\n%s\nto NOT have at most %i element(s) matching "%s", but found %i.|,
 
-        :expected_at_least    => %Q|expected following:\n%s\nto have at least %i element(s) matching "%s", found %i.|,
-        :unexpected_at_least  => %Q|expected following:\n%s\nto NOT have at least %i element(s) matching "%s", but found %i.|,
+      :expected_at_least    => %Q|expected following:\n%s\nto have at least %i element(s) matching "%s", found %i.|,
+      :unexpected_at_least  => %Q|expected following:\n%s\nto NOT have at least %i element(s) matching "%s", but found %i.|,
 
-        :expected_regexp      => %Q|%s regexp expected within "%s" in following template:\n%s|,
-        :unexpected_regexp    => %Q|%s regexp unexpected within "%s" in following template:\n%s\nbut was found.|,
+      :expected_regexp      => %Q|%s regexp expected within "%s" in following template:\n%s|,
+      :unexpected_regexp    => %Q|%s regexp unexpected within "%s" in following template:\n%s\nbut was found.|,
 
-        :expected_text        => %Q|"%s" expected within "%s" in following template:\n%s|,
-        :unexpected_text      => %Q|"%s" unexpected within "%s" in following template:\n%s\nbut was found.|,
+      :expected_text        => %Q|"%s" expected within "%s" in following template:\n%s|,
+      :unexpected_text      => %Q|"%s" unexpected within "%s" in following template:\n%s\nbut was found.|,
 
-        :wrong_count_error    => %Q|:count with :minimum or :maximum has no sence!|,
-        :min_max_error        => %Q|:minimum should be less than :maximum!|,
-        :bad_range_error      => %Q|Your :count range(%s) has no sence!|,
-      }
+      :wrong_count_error    => %Q|:count with :minimum or :maximum has no sence!|,
+      :min_max_error        => %Q|:minimum should be less than :maximum!|,
+      :bad_range_error      => %Q|Your :count range(%s) has no sence!|,
+    }
 
 
-      def initialize tag, options={}, &block
-        @tag, @options, @block = tag.to_s, options, block
+    def initialize tag, options={}, &block
+      @tag, @options, @block = tag.to_s, options, block
 
-        if with_attrs = @options.delete(:with)
-          if classes = with_attrs.delete(:class)
-            @tag << '.' + classes_to_selector(classes)
-          end
-          selector = with_attrs.inject('') do |html_attrs_string, (k, v)|
-            html_attrs_string << "[#{k}='#{v}']"
-            html_attrs_string
-          end
-          @tag << selector
+      if with_attrs = @options.delete(:with)
+        if classes = with_attrs.delete(:class)
+          @tag << '.' + classes_to_selector(classes)
         end
-
-        if without_attrs = @options.delete(:without)
-          if classes = without_attrs.delete(:class)
-            @tag << ":not(.#{classes_to_selector(classes)})"
-          end
+        selector = with_attrs.inject('') do |html_attrs_string, (k, v)|
+          html_attrs_string << "[#{k}='#{v}']"
+        html_attrs_string
         end
+        @tag << selector
+      end
 
-        validate_options!
+      if without_attrs = @options.delete(:without)
+        if classes = without_attrs.delete(:class)
+          @tag << ":not(.#{classes_to_selector(classes)})"
+        end
       end
 
-      def matches? document, &block
-        @block = block if block
+      validate_options!
+    end
 
-        document = document.html if defined?(Capybara::Session) && document.is_a?(Capybara::Session)
+    def matches? document, &block
+      @block = block if block
 
-        case document
-        when String
-          @parent_scope = @current_scope = Nokogiri::HTML(document).css(@tag)
-          @document     = document
-        else
-          @parent_scope  = document.current_scope
-          @current_scope = begin
-                             document.parent_scope.css(@tag)
-                             # on jruby this produce exception if css was not found:
-                             # undefined method `decorate' for nil:NilClass
-                           rescue NoMethodError
-                             Nokogiri::XML::NodeSet.new(Nokogiri::XML::Document.new)
-                           end
-          @document      = @parent_scope.to_html
-        end
+      document = document.html if defined?(Capybara::Session) && document.is_a?(Capybara::Session)
 
-        if tag_presents? and text_right? and count_right?
-          @current_scope = @parent_scope
-          @block.call if @block
-          true
-        else
-          false
-        end
+      case document
+      when String
+        @parent_scope = @current_scope = Nokogiri::HTML(document).css(@tag)
+        @document     = document
+      else
+        @parent_scope  = document.current_scope
+        @current_scope = begin
+                           document.parent_scope.css(@tag)
+                           # on jruby this produce exception if css was not found:
+                           # undefined method `decorate' for nil:NilClass
+                         rescue NoMethodError
+                           Nokogiri::XML::NodeSet.new(Nokogiri::XML::Document.new)
+                         end
+        @document      = @parent_scope.to_html
       end
 
-      def description
-        # TODO should it be more complicated?
-        if @options.has_key?(:count)
-          DESCRIPTIONS[:have_n] % [@options[:count],@tag]
-        else
-          DESCRIPTIONS[:have_at_least_1] % @tag
-        end
+      if tag_presents? and text_right? and count_right?
+        @current_scope = @parent_scope
+        @block.call if @block
+        true
+      else
+        false
       end
+    end
 
-      private
+    def description
+      # TODO should it be more complicated?
+      if @options.has_key?(:count)
+        DESCRIPTIONS[:have_n] % [@options[:count],@tag]
+      else
+        DESCRIPTIONS[:have_at_least_1] % @tag
+      end
+    end
 
-      def classes_to_selector(classes)
-        case classes
-        when Array
-          classes.join('.')
-        when String
-          classes.gsub(/\s+/, '.')
-        end
+    private
+
+    def classes_to_selector(classes)
+      case classes
+      when Array
+        classes.join('.')
+      when String
+        classes.gsub(/\s+/, '.')
       end
+    end
 
-      def tag_presents?
-        if @current_scope.first
-          @count = @current_scope.count
-          @failure_message_when_negated = MESSAGES[:unexpected_tag] % [@document, @tag, @count]
-          true
-        else
-          @failure_message          = MESSAGES[:expected_tag] % [@document, @tag]
-          false
-        end
+    def tag_presents?
+      if @current_scope.first
+        @count = @current_scope.count
+        @failure_message_when_negated = MESSAGES[:unexpected_tag] % [@document, @tag, @count]
+        true
+      else
+        @failure_message          = MESSAGES[:expected_tag] % [@document, @tag]
+        false
       end
+    end
 
-      def count_right?
-        case @options[:count]
-        when Integer
-          ((@failure_message_when_negated=MESSAGES[:unexpected_count] % [@document,@count,@tag]) && @count == @options[:count]) || (@failure_message=MESSAGES[:expected_count] % [@document,@options[:count],@tag,@count]; false)
-        when Range
-          ((@failure_message_when_negated=MESSAGES[:unexpected_btw_count] % [@document,@options[:count].min,@options[:count].max,@tag,@count]) && @options[:count].member?(@count)) || (@failure_message=MESSAGES[:expected_btw_count] % [@document,@options[:count].min,@options[:count].max,@tag,@count]; false)
-        when nil
-          if @options[:maximum]
-            ((@failure_message_when_negated=MESSAGES[:unexpected_at_most] % [@document,@options[:maximum],@tag,@count]) && @count <= @options[:maximum]) || (@failure_message=MESSAGES[:expected_at_most] % [@document,@options[:maximum],@tag,@count]; false)
-          elsif @options[:minimum]
-            ((@failure_message_when_negated=MESSAGES[:unexpected_at_least] % [@document,@options[:minimum],@tag,@count]) && @count >= @options[:minimum]) || (@failure_message=MESSAGES[:expected_at_least] % [@document,@options[:minimum],@tag,@count]; false)
-          else
-            true
-          end
+    def count_right?
+      case @options[:count]
+      when Integer
+        ((@failure_message_when_negated=MESSAGES[:unexpected_count] % [@document,@count,@tag]) && @count == @options[:count]) || (@failure_message=MESSAGES[:expected_count] % [@document,@options[:count],@tag,@count]; false)
+      when Range
+        ((@failure_message_when_negated=MESSAGES[:unexpected_btw_count] % [@document,@options[:count].min,@options[:count].max,@tag,@count]) && @options[:count].member?(@count)) || (@failure_message=MESSAGES[:expected_btw_count] % [@document,@options[:count].min,@options[:count].max,@tag,@count]; false)
+      when nil
+        if @options[:maximum]
+          ((@failure_message_when_negated=MESSAGES[:unexpected_at_most] % [@document,@options[:maximum],@tag,@count]) && @count <= @options[:maximum]) || (@failure_message=MESSAGES[:expected_at_most] % [@document,@options[:maximum],@tag,@count]; false)
+        elsif @options[:minimum]
+          ((@failure_message_when_negated=MESSAGES[:unexpected_at_least] % [@document,@options[:minimum],@tag,@count]) && @count >= @options[:minimum]) || (@failure_message=MESSAGES[:expected_at_least] % [@document,@options[:minimum],@tag,@count]; false)
+        else
+          true
         end
       end
+    end
+
+    def text_right?
+      return true unless @options[:text]
 
-      def text_right?
-        return true unless @options[:text]
-
-        case text=@options[:text]
-        when Regexp
-          new_scope = @current_scope.css(':regexp()',NokogiriRegexpHelper.new(text))
-          unless new_scope.empty?
-            @count = new_scope.count
-            @failure_message_when_negated = MESSAGES[:unexpected_regexp] % [text.inspect,@tag,@document]
-            true
-          else
-            @failure_message          = MESSAGES[:expected_regexp] % [text.inspect,@tag,@document]
-            false
-          end
+      case text=@options[:text]
+      when Regexp
+        new_scope = @current_scope.css(':regexp()',NokogiriRegexpHelper.new(text))
+        unless new_scope.empty?
+          @count = new_scope.count
+          @failure_message_when_negated = MESSAGES[:unexpected_regexp] % [text.inspect,@tag,@document]
+          true
         else
-          new_scope = @current_scope.css(':content()',NokogiriTextHelper.new(text))
-          unless new_scope.empty?
-            @count = new_scope.count
-            @failure_message_when_negated = MESSAGES[:unexpected_text] % [text,@tag,@document]
-            true
-          else
-            @failure_message          = MESSAGES[:expected_text] % [text,@tag,@document]
-            false
-          end
+          @failure_message          = MESSAGES[:expected_regexp] % [text.inspect,@tag,@document]
+          false
+        end
+      else
+        new_scope = @current_scope.css(':content()',NokogiriTextHelper.new(text))
+        unless new_scope.empty?
+          @count = new_scope.count
+          @failure_message_when_negated = MESSAGES[:unexpected_text] % [text,@tag,@document]
+          true
+        else
+          @failure_message          = MESSAGES[:expected_text] % [text,@tag,@document]
+          false
         end
       end
+    end
 
-      protected
+    protected
 
-      def validate_options!
-        raise 'wrong :count specified' unless [Range, NilClass].include?(@options[:count].class) or @options[:count].is_a?(Integer)
+    def validate_options!
+      raise 'wrong :count specified' unless [Range, NilClass].include?(@options[:count].class) or @options[:count].is_a?(Integer)
 
-        [:min, :minimum, :max, :maximum].each do |key|
-          raise MESSAGES[:wrong_count_error] if @options.has_key?(key) and @options.has_key?(:count)
-        end
+      [:min, :minimum, :max, :maximum].each do |key|
+        raise MESSAGES[:wrong_count_error] if @options.has_key?(key) and @options.has_key?(:count)
+      end
 
-        begin
-          raise MESSAGES[:min_max_error] if @options[:minimum] > @options[:maximum]
-        rescue NoMethodError # nil > 4
-        rescue ArgumentError # 2 < nil
-        end
+      begin
+        raise MESSAGES[:min_max_error] if @options[:minimum] > @options[:maximum]
+      rescue NoMethodError # nil > 4
+      rescue ArgumentError # 2 < nil
+      end
 
+      begin
         begin
-          begin
-            raise MESSAGES[:bad_range_error] % [@options[:count].to_s] if @options[:count] && @options[:count].is_a?(Range) && (@options[:count].min.nil? or @options[:count].min < 0)
-          rescue ArgumentError, "comparison of String with" # if @options[:count] == 'a'..'z'
-            raise MESSAGES[:bad_range_error] % [@options[:count].to_s]
-          end
-        rescue TypeError # fix for 1.8.7 for 'rescue ArgumentError, "comparison of String with"' stroke
+          raise MESSAGES[:bad_range_error] % [@options[:count].to_s] if @options[:count] && @options[:count].is_a?(Range) && (@options[:count].min.nil? or @options[:count].min < 0)
+        rescue ArgumentError, "comparison of String with" # if @options[:count] == 'a'..'z'
           raise MESSAGES[:bad_range_error] % [@options[:count].to_s]
         end
-
-        @options[:minimum] ||= @options.delete(:min)
-        @options[:maximum] ||= @options.delete(:max)
-
-        @options[:text] = @options[:text].to_s if @options.has_key?(:text) && !@options[:text].is_a?(Regexp)
+      rescue TypeError # fix for 1.8.7 for 'rescue ArgumentError, "comparison of String with"' stroke
+        raise MESSAGES[:bad_range_error] % [@options[:count].to_s]
       end
 
-    end
+      @options[:minimum] ||= @options.delete(:min)
+      @options[:maximum] ||= @options.delete(:max)
 
-    # tag assertion, this is the core of functionality, other matchers are shortcuts to this matcher
-    #
-    # @yield block where you should put with_tag, without_tag and/or other matchers
-    #
-    # @param [String] tag     css selector for tag you want to match, e.g. 'div', 'section#my', 'article.red'
-    # @param [Hash]   options options hash(see below)
-    # @option options [Hash]   :with  hash with html attributes, within this, *:class* option have special meaning, you may specify it as array of expected classes or string of classes separated by spaces, order does not matter
-    # @option options [Fixnum] :count for tag count matching(*ATTENTION:* do not use :count with :minimum(:min) or :maximum(:max))
-    # @option options [Range]  :count not strict tag count matching, count of tags should be in specified range
-    # @option options [Fixnum] :minimum minimum count of elements to match
-    # @option options [Fixnum] :min same as :minimum
-    # @option options [Fixnum] :maximum maximum count of elements to match
-    # @option options [Fixnum] :max same as :maximum
-    # @option options [String/Regexp] :text to match tag content, could be either String or Regexp
-    #
-    # @example
-    #   expect(rendered).to have_tag('div')
-    #   expect(rendered).to have_tag('h1.header')
-    #   expect(rendered).to have_tag('div#footer')
-    #   expect(rendered).to have_tag('input#email', :with => { :name => 'user[email]', :type => 'email' } )
-    #   expect(rendered).to have_tag('div', :count => 3)            # matches exactly 3 'div' tags
-    #   expect(rendered).to have_tag('div', :count => 3..7)         # shortcut for have_tag('div', :minimum => 3, :maximum => 7)
-    #   expect(rendered).to have_tag('div', :minimum => 3)          # matches more(or equal) than 3 'div' tags
-    #   expect(rendered).to have_tag('div', :maximum => 3)          # matches less(or equal) than 3 'div' tags
-    #   expect(rendered).to have_tag('p', :text => 'some content')  # will match "<p>some content</p>"
-    #   expect(rendered).to have_tag('p', :text => /some content/i) # will match "<p>sOme cOntEnt</p>"
-    #   expect(rendered).to have_tag('textarea', :with => {:name => 'user[description]'}, :text => "I like pie")
-    #   expect("<html>
-    #     <body>
-    #       <h1>some html document</h1>
-    #     </body>
-    #    </html>").to have_tag('body') { with_tag('h1', :text => 'some html document') }
-    #   expect('<div class="one two">').to have_tag('div', :with => { :class => ['two', 'one'] })
-    #   expect('<div class="one two">').to have_tag('div', :with => { :class => 'two one' })
-    def have_tag tag, options={}, &block
-      # for backwards compatibility with rpecs have tag:
-      options = { :text => options } if options.kind_of?(String) || options.kind_of?(Regexp)
-      @__current_scope_for_nokogiri_matcher = HaveTag.new(tag, options, &block)
+      @options[:text] = @options[:text].to_s if @options.has_key?(:text) && !@options[:text].is_a?(Regexp)
     end
 
-    def with_text text
-      raise StandardError, 'this matcher should be used inside "have_tag" matcher block' unless defined?(@__current_scope_for_nokogiri_matcher)
-      raise ArgumentError, 'this matcher does not accept block' if block_given?
-      tag = @__current_scope_for_nokogiri_matcher.instance_variable_get(:@tag)
-      expect(@__current_scope_for_nokogiri_matcher).to have_tag(tag, :text => text)
-    end
+  end
 
-    def without_text text
-      raise StandardError, 'this matcher should be used inside "have_tag" matcher block' unless defined?(@__current_scope_for_nokogiri_matcher)
-      raise ArgumentError, 'this matcher does not accept block' if block_given?
-      tag = @__current_scope_for_nokogiri_matcher.instance_variable_get(:@tag)
-      expect(@__current_scope_for_nokogiri_matcher).to_not have_tag(tag, :text => text)
-    end
-    alias :but_without_text :without_text
-
-    # with_tag matcher
-    # @yield block where you should put other with_tag or without_tag
-    # @see #have_tag
-    # @note this should be used within block of have_tag matcher
-    def with_tag tag, options={}, &block
-      expect(@__current_scope_for_nokogiri_matcher).to have_tag(tag, options, &block)
-    end
+  # tag assertion, this is the core of functionality, other matchers are shortcuts to this matcher
+  #
+  # @yield block where you should put with_tag, without_tag and/or other matchers
+  #
+  # @param [String] tag     css selector for tag you want to match, e.g. 'div', 'section#my', 'article.red'
+  # @param [Hash]   options options hash(see below)
+  # @option options [Hash]   :with  hash with html attributes, within this, *:class* option have special meaning, you may specify it as array of expected classes or string of classes separated by spaces, order does not matter
+  # @option options [Fixnum] :count for tag count matching(*ATTENTION:* do not use :count with :minimum(:min) or :maximum(:max))
+  # @option options [Range]  :count not strict tag count matching, count of tags should be in specified range
+  # @option options [Fixnum] :minimum minimum count of elements to match
+  # @option options [Fixnum] :min same as :minimum
+  # @option options [Fixnum] :maximum maximum count of elements to match
+  # @option options [Fixnum] :max same as :maximum
+  # @option options [String/Regexp] :text to match tag content, could be either String or Regexp
+  #
+  # @example
+  #   expect(rendered).to have_tag('div')
+  #   expect(rendered).to have_tag('h1.header')
+  #   expect(rendered).to have_tag('div#footer')
+  #   expect(rendered).to have_tag('input#email', :with => { :name => 'user[email]', :type => 'email' } )
+  #   expect(rendered).to have_tag('div', :count => 3)            # matches exactly 3 'div' tags
+  #   expect(rendered).to have_tag('div', :count => 3..7)         # shortcut for have_tag('div', :minimum => 3, :maximum => 7)
+  #   expect(rendered).to have_tag('div', :minimum => 3)          # matches more(or equal) than 3 'div' tags
+  #   expect(rendered).to have_tag('div', :maximum => 3)          # matches less(or equal) than 3 'div' tags
+  #   expect(rendered).to have_tag('p', :text => 'some content')  # will match "<p>some content</p>"
+  #   expect(rendered).to have_tag('p', :text => /some content/i) # will match "<p>sOme cOntEnt</p>"
+  #   expect(rendered).to have_tag('textarea', :with => {:name => 'user[description]'}, :text => "I like pie")
+  #   expect("<html>
+  #     <body>
+  #       <h1>some html document</h1>
+  #     </body>
+  #    </html>").to have_tag('body') { with_tag('h1', :text => 'some html document') }
+  #   expect('<div class="one two">').to have_tag('div', :with => { :class => ['two', 'one'] })
+  #   expect('<div class="one two">').to have_tag('div', :with => { :class => 'two one' })
+  def have_tag tag, options={}, &block
+    # for backwards compatibility with rpecs have tag:
+    options = { :text => options } if options.kind_of?(String) || options.kind_of?(Regexp)
+    @__current_scope_for_nokogiri_matcher = HaveTag.new(tag, options, &block)
+  end
 
-    # without_tag matcher
-    # @yield block where you should put other with_tag or without_tag
-    # @see #have_tag
-    # @note this should be used within block of have_tag matcher
-    def without_tag tag, options={}, &block
-      expect(@__current_scope_for_nokogiri_matcher).to_not have_tag(tag, options, &block)
-    end
+  def with_text text
+    raise StandardError, 'this matcher should be used inside "have_tag" matcher block' unless defined?(@__current_scope_for_nokogiri_matcher)
+    raise ArgumentError, 'this matcher does not accept block' if block_given?
+    tag = @__current_scope_for_nokogiri_matcher.instance_variable_get(:@tag)
+    expect(@__current_scope_for_nokogiri_matcher).to have_tag(tag, :text => text)
+  end
 
-    # form assertion
-    #
-    # it is a shortcut to
-    #   have_tag 'form', :with => { :action => action_url, :method => method ... }
-    # @yield block with with_<field>, see below
-    # @see #have_tag
-    def have_form action_url, method, options={}, &block
-      options[:with] ||= {}
-      id = options[:with].delete(:id)
-      tag = 'form'; tag << '#'+id if id
-      options[:with].merge!(:action => action_url)
-      options[:with].merge!(:method => method.to_s)
-      have_tag tag, options, &block
-    end
+  def without_text text
+    raise StandardError, 'this matcher should be used inside "have_tag" matcher block' unless defined?(@__current_scope_for_nokogiri_matcher)
+    raise ArgumentError, 'this matcher does not accept block' if block_given?
+    tag = @__current_scope_for_nokogiri_matcher.instance_variable_get(:@tag)
+    expect(@__current_scope_for_nokogiri_matcher).to_not have_tag(tag, :text => text)
+  end
+  alias :but_without_text :without_text
+
+  # with_tag matcher
+  # @yield block where you should put other with_tag or without_tag
+  # @see #have_tag
+  # @note this should be used within block of have_tag matcher
+  def with_tag tag, options={}, &block
+    expect(@__current_scope_for_nokogiri_matcher).to have_tag(tag, options, &block)
+  end
 
-    #TODO fix code duplications
+  # without_tag matcher
+  # @yield block where you should put other with_tag or without_tag
+  # @see #have_tag
+  # @note this should be used within block of have_tag matcher
+  def without_tag tag, options={}, &block
+    expect(@__current_scope_for_nokogiri_matcher).to_not have_tag(tag, options, &block)
+  end
 
-    def with_hidden_field name, value=nil
-      options = form_tag_options('hidden',name,value)
-      should_have_input(options)
-    end
+  # form assertion
+  #
+  # it is a shortcut to
+  #   have_tag 'form', :with => { :action => action_url, :method => method ... }
+  # @yield block with with_<field>, see below
+  # @see #have_tag
+  def have_form action_url, method, options={}, &block
+    options[:with] ||= {}
+    id = options[:with].delete(:id)
+    tag = 'form'; tag << '#'+id if id
+    options[:with].merge!(:action => action_url)
+    options[:with].merge!(:method => method.to_s)
+    have_tag tag, options, &block
+  end
 
-    def without_hidden_field name, value=nil
-      options = form_tag_options('hidden',name,value)
-      should_not_have_input(options)
-    end
+  #TODO fix code duplications
 
-    def with_text_field name, value=nil
-      options = form_tag_options('text',name,value)
-      should_have_input(options)
-    end
+  def with_hidden_field name, value=nil
+    options = form_tag_options('hidden',name,value)
+    should_have_input(options)
+  end
 
-    def without_text_field name, value=nil
-      options = form_tag_options('text',name,value)
-      should_not_have_input(options)
-    end
+  def without_hidden_field name, value=nil
+    options = form_tag_options('hidden',name,value)
+    should_not_have_input(options)
+  end
 
-    def with_email_field name, value=nil
-      options = form_tag_options('email',name,value)
-      should_have_input(options)
-    end
+  def with_text_field name, value=nil
+    options = form_tag_options('text',name,value)
+    should_have_input(options)
+  end
 
-    def without_email_field name, value=nil
-      options = form_tag_options('email',name,value)
-      should_not_have_input(options)
-    end
+  def without_text_field name, value=nil
+    options = form_tag_options('text',name,value)
+    should_not_have_input(options)
+  end
 
-    def with_url_field name, value=nil
-      options = form_tag_options('url',name,value)
-      should_have_input(options)
-    end
+  def with_email_field name, value=nil
+    options = form_tag_options('email',name,value)
+    should_have_input(options)
+  end
 
-    def without_url_field name, value=nil
-      options = form_tag_options('url',name,value)
-      should_not_have_input(options)
-    end
+  def without_email_field name, value=nil
+    options = form_tag_options('email',name,value)
+    should_not_have_input(options)
+  end
 
-    def with_number_field name, value=nil
-      options = form_tag_options('number',name,value)
-      should_have_input(options)
-    end
+  def with_url_field name, value=nil
+    options = form_tag_options('url',name,value)
+    should_have_input(options)
+  end
 
-    def without_number_field name, value=nil
-      options = form_tag_options('number',name,value)
-      should_not_have_input(options)
-    end
+  def without_url_field name, value=nil
+    options = form_tag_options('url',name,value)
+    should_not_have_input(options)
+  end
 
-    def with_range_field name, min, max, options={}
-      options = { :with => { :name => name, :type => 'range', :min => min.to_s, :max => max.to_s }.merge(options.delete(:with)||{}) }
-      should_have_input(options)
-    end
+  def with_number_field name, value=nil
+    options = form_tag_options('number',name,value)
+    should_have_input(options)
+  end
 
-    def without_range_field name, min=nil, max=nil, options={}
-      options = { :with => { :name => name, :type => 'range' }.merge(options.delete(:with)||{}) }
-      options[:with].merge!(:min => min.to_s) if min
-      options[:with].merge!(:max => max.to_s) if max
-      should_not_have_input(options)
-    end
+  def without_number_field name, value=nil
+    options = form_tag_options('number',name,value)
+    should_not_have_input(options)
+  end
 
-    DATE_FIELD_TYPES = %w( date month week time datetime datetime-local )
+  def with_range_field name, min, max, options={}
+    options = { :with => { :name => name, :type => 'range', :min => min.to_s, :max => max.to_s }.merge(options.delete(:with)||{}) }
+    should_have_input(options)
+  end
 
-    def with_date_field date_field_type, name=nil, options={}
-      date_field_type = date_field_type.to_s
-      raise "unknown type `#{date_field_type}` for date picker" unless DATE_FIELD_TYPES.include?(date_field_type)
-      options = { :with => { :type => date_field_type.to_s }.merge(options.delete(:with)||{}) }
-      options[:with].merge!(:name => name.to_s) if name
-      should_have_input(options)
-    end
+  def without_range_field name, min=nil, max=nil, options={}
+    options = { :with => { :name => name, :type => 'range' }.merge(options.delete(:with)||{}) }
+    options[:with].merge!(:min => min.to_s) if min
+    options[:with].merge!(:max => max.to_s) if max
+    should_not_have_input(options)
+  end
 
-    def without_date_field date_field_type, name=nil, options={}
-      date_field_type = date_field_type.to_s
-      raise "unknown type `#{date_field_type}` for date picker" unless DATE_FIELD_TYPES.include?(date_field_type)
-      options = { :with => { :type => date_field_type.to_s }.merge(options.delete(:with)||{}) }
-      options[:with].merge!(:name => name.to_s) if name
-      should_not_have_input(options)
-    end
+  DATE_FIELD_TYPES = %w( date month week time datetime datetime-local )
 
-    # TODO add ability to explicitly say that value should be empty
-    def with_password_field name, value=nil
-      options = form_tag_options('password',name,value)
-      should_have_input(options)
-    end
+  def with_date_field date_field_type, name=nil, options={}
+    date_field_type = date_field_type.to_s
+    raise "unknown type `#{date_field_type}` for date picker" unless DATE_FIELD_TYPES.include?(date_field_type)
+    options = { :with => { :type => date_field_type.to_s }.merge(options.delete(:with)||{}) }
+    options[:with].merge!(:name => name.to_s) if name
+    should_have_input(options)
+  end
 
-    def without_password_field name, value=nil
-      options = form_tag_options('password',name,value)
-      should_not_have_input(options)
-    end
+  def without_date_field date_field_type, name=nil, options={}
+    date_field_type = date_field_type.to_s
+    raise "unknown type `#{date_field_type}` for date picker" unless DATE_FIELD_TYPES.include?(date_field_type)
+    options = { :with => { :type => date_field_type.to_s }.merge(options.delete(:with)||{}) }
+    options[:with].merge!(:name => name.to_s) if name
+    should_not_have_input(options)
+  end
 
-    def with_file_field name, value=nil
-      options = form_tag_options('file',name,value)
-      should_have_input(options)
-    end
+  # TODO add ability to explicitly say that value should be empty
+  def with_password_field name, value=nil
+    options = form_tag_options('password',name,value)
+    should_have_input(options)
+  end
 
-    def without_file_field name, value=nil
-      options = form_tag_options('file',name,value)
-      should_not_have_input(options)
-    end
+  def without_password_field name, value=nil
+    options = form_tag_options('password',name,value)
+    should_not_have_input(options)
+  end
 
-    def with_text_area name#TODO, text=nil
-      #options = form_tag_options('text',name,value)
-      options = { :with => { :name => name } }
-      expect(@__current_scope_for_nokogiri_matcher).to have_tag('textarea', options)
-    end
+  def with_file_field name, value=nil
+    options = form_tag_options('file',name,value)
+    should_have_input(options)
+  end
 
-    def without_text_area name#TODO, text=nil
-      #options = form_tag_options('text',name,value)
-      options = { :with => { :name => name } }
-      expect(@__current_scope_for_nokogiri_matcher).to_not have_tag('textarea', options)
-    end
+  def without_file_field name, value=nil
+    options = form_tag_options('file',name,value)
+    should_not_have_input(options)
+  end
 
-    def with_checkbox name, value=nil
-      options = form_tag_options('checkbox',name,value)
-      should_have_input(options)
-    end
+  def with_text_area name#TODO, text=nil
+    #options = form_tag_options('text',name,value)
+    options = { :with => { :name => name } }
+    expect(@__current_scope_for_nokogiri_matcher).to have_tag('textarea', options)
+  end
 
-    def without_checkbox name, value=nil
-      options = form_tag_options('checkbox',name,value)
-      should_not_have_input(options)
-    end
+  def without_text_area name#TODO, text=nil
+    #options = form_tag_options('text',name,value)
+    options = { :with => { :name => name } }
+    expect(@__current_scope_for_nokogiri_matcher).to_not have_tag('textarea', options)
+  end
 
-    def with_radio_button name, value
-      options = form_tag_options('radio',name,value)
-      should_have_input(options)
-    end
+  def with_checkbox name, value=nil
+    options = form_tag_options('checkbox',name,value)
+    should_have_input(options)
+  end
 
-    def without_radio_button name, value
-      options = form_tag_options('radio',name,value)
-      should_not_have_input(options)
-    end
+  def without_checkbox name, value=nil
+    options = form_tag_options('checkbox',name,value)
+    should_not_have_input(options)
+  end
 
-    def with_select name, options={}, &block
-      options[:with] ||= {}
-      id = options[:with].delete(:id)
-      tag='select'; tag << '#'+id if id
-      options[:with].merge!(:name => name)
-      expect(@__current_scope_for_nokogiri_matcher).to have_tag(tag, options, &block)
-    end
+  def with_radio_button name, value
+    options = form_tag_options('radio',name,value)
+    should_have_input(options)
+  end
 
-    def without_select name, options={}, &block
-      options[:with] ||= {}
-      id = options[:with].delete(:id)
-      tag='select'; tag << '#'+id if id
-      options[:with].merge!(:name => name)
-      expect(@__current_scope_for_nokogiri_matcher).to_not have_tag(tag, options, &block)
-    end
+  def without_radio_button name, value
+    options = form_tag_options('radio',name,value)
+    should_not_have_input(options)
+  end
 
-    def with_option text, value=nil, options={}
-      options[:with] ||= {}
-      if value.is_a?(Hash)
-        options.merge!(value)
-        value=nil
-      end
-      tag='option'
-      options[:with].merge!(:value => value.to_s) if value
-      if options[:selected]
-        options[:with].merge!(:selected => "selected")
-      end
-      options.delete(:selected)
-      options.merge!(:text => text) if text
-      expect(@__current_scope_for_nokogiri_matcher).to have_tag(tag, options)
-    end
+  def with_select name, options={}, &block
+    options[:with] ||= {}
+    id = options[:with].delete(:id)
+    tag='select'; tag << '#'+id if id
+    options[:with].merge!(:name => name)
+    expect(@__current_scope_for_nokogiri_matcher).to have_tag(tag, options, &block)
+  end
 
-    def without_option text, value=nil, options={}
-      options[:with] ||= {}
-      if value.is_a?(Hash)
-        options.merge!(value)
-        value=nil
-      end
-      tag='option'
-      options[:with].merge!(:value => value.to_s) if value
-      if options[:selected]
-        options[:with].merge!(:selected => "selected")
-      end
-      options.delete(:selected)
-      options.merge!(:text => text) if text
-      expect(@__current_scope_for_nokogiri_matcher).to_not have_tag(tag, options)
-    end
+  def without_select name, options={}, &block
+    options[:with] ||= {}
+    id = options[:with].delete(:id)
+    tag='select'; tag << '#'+id if id
+    options[:with].merge!(:name => name)
+    expect(@__current_scope_for_nokogiri_matcher).to_not have_tag(tag, options, &block)
+  end
 
-    def with_button text, value=nil, options={}
-      options[:with] ||= {}
-      if value.is_a?(Hash)
-        options.merge!(value)
-        value=nil
-      end
-      options[:with].merge!(:value => value.to_s) if value
-      options.merge!(:text => text) if text
-      expect(@__current_scope_for_nokogiri_matcher).to have_tag('button', options)
+  def with_option text, value=nil, options={}
+    options[:with] ||= {}
+    if value.is_a?(Hash)
+      options.merge!(value)
+      value=nil
+    end
+    tag='option'
+    options[:with].merge!(:value => value.to_s) if value
+    if options[:selected]
+      options[:with].merge!(:selected => "selected")
     end
+    options.delete(:selected)
+    options.merge!(:text => text) if text
+    expect(@__current_scope_for_nokogiri_matcher).to have_tag(tag, options)
+  end
 
-    def without_button text, value=nil, options={}
-      options[:with] ||= {}
-      if value.is_a?(Hash)
-        options.merge!(value)
-        value=nil
-      end
-      options[:with].merge!(:value => value.to_s) if value
-      options.merge!(:text => text) if text
-      expect(@__current_scope_for_nokogiri_matcher).to_not have_tag('button', options)
+  def without_option text, value=nil, options={}
+    options[:with] ||= {}
+    if value.is_a?(Hash)
+      options.merge!(value)
+      value=nil
+    end
+    tag='option'
+    options[:with].merge!(:value => value.to_s) if value
+    if options[:selected]
+      options[:with].merge!(:selected => "selected")
     end
+    options.delete(:selected)
+    options.merge!(:text => text) if text
+    expect(@__current_scope_for_nokogiri_matcher).to_not have_tag(tag, options)
+  end
 
-    def with_submit value
-      options = { :with => { :type => 'submit', :value => value } }
-      #options = form_tag_options('text',name,value)
-      should_have_input(options)
+  def with_button text, value=nil, options={}
+    options[:with] ||= {}
+    if value.is_a?(Hash)
+      options.merge!(value)
+      value=nil
     end
+    options[:with].merge!(:value => value.to_s) if value
+    options.merge!(:text => text) if text
+    expect(@__current_scope_for_nokogiri_matcher).to have_tag('button', options)
+  end
 
-    def without_submit value
-      #options = form_tag_options('text',name,value)
-      options = { :with => { :type => 'submit', :value => value } }
-      should_not_have_input(options)
+  def without_button text, value=nil, options={}
+    options[:with] ||= {}
+    if value.is_a?(Hash)
+      options.merge!(value)
+      value=nil
     end
+    options[:with].merge!(:value => value.to_s) if value
+    options.merge!(:text => text) if text
+    expect(@__current_scope_for_nokogiri_matcher).to_not have_tag('button', options)
+  end
 
-    private
+  def with_submit value
+    options = { :with => { :type => 'submit', :value => value } }
+    #options = form_tag_options('text',name,value)
+    should_have_input(options)
+  end
 
-    def should_have_input(options)
-      expect(@__current_scope_for_nokogiri_matcher).to have_tag('input', options)
-    end
+  def without_submit value
+    #options = form_tag_options('text',name,value)
+    options = { :with => { :type => 'submit', :value => value } }
+    should_not_have_input(options)
+  end
 
-    def should_not_have_input(options)
-      expect(@__current_scope_for_nokogiri_matcher).to_not have_tag('input', options)
-    end
+  private
 
-    # form_tag in method name name mean smth. like input, submit, tags that should appear in a form
-    def form_tag_options form_tag_type, form_tag_name, form_tag_value=nil
-      options = { :with => { :name => form_tag_name, :type => form_tag_type } }
-      # .to_s if value is a digit or smth. else, see issue#10
-      options[:with].merge!(:value => form_tag_value.to_s) if form_tag_value
-      return options
-    end
+  def should_have_input(options)
+    expect(@__current_scope_for_nokogiri_matcher).to have_tag('input', options)
+  end
 
+  def should_not_have_input(options)
+    expect(@__current_scope_for_nokogiri_matcher).to_not have_tag('input', options)
   end
-end
 
-if defined? Cucumber
-  World RSpec::HtmlMatchers
-else
-  RSpec.configure do |config|
-    config.include(RSpec::HtmlMatchers)
+  # form_tag in method name name mean smth. like input, submit, tags that should appear in a form
+  def form_tag_options form_tag_type, form_tag_name, form_tag_value=nil
+    options = { :with => { :name => form_tag_name, :type => form_tag_type } }
+    # .to_s if value is a digit or smth. else, see issue#10
+    options[:with].merge!(:value => form_tag_value.to_s) if form_tag_value
+    return options
   end
+
 end