argspec 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e489a3f3ed71350a6e16435cbf19efda2a9bac84
-  data.tar.gz: 2af97d57c3ea415a720d0db32c3ba22d0d7ae7c8
+  metadata.gz: 78bed1162720f96bec34e01c4b6f0dd1fd7d7a75
+  data.tar.gz: 204b8dc5273e335cf2da9f5bd6e30c86a43adc95
 SHA512:
-  metadata.gz: 3dda7ebf91f61ad7c310950f0788f0941f175019e46e470417c286756c27f1f932db0cda8443817af0bb7b93dc81a371562c83b1fa9e320c7ec1766374b3f47f
-  data.tar.gz: 44e82ea8b0b64566e51540615024e20b38b1f7225ed6eee4d57de71c642f8f6f9d2dfe0a1d0e2cbcef9fae5ee4979c0d0fd90690df4351969c97a1b88fcf37c2
+  metadata.gz: 4cbdb4f44be0effc0cefa45d89e51273af695b169d8c41e3b868e4fc6502fe4ef5d87b7fb01fa327b9d3f487d6855fc28ef68c5b7c635d7b56a2c1e6c0819d4a
+  data.tar.gz: c2fa42bb7e822850b1f2aafb03497888947e1f37904edff56dcf52a972e6e8e8d7c711ed75947f45ce2b87e76449d7c33b049ee3b8d0ab79df54da0fc01f59f6

data/README.md

@@ -41,9 +41,9 @@ class Person
   attr_reader :name, :gender, :birthdate
 
   def initialize(name, gender, birthdate)
-    raise ArgumentError, "The name must be a string and must not be nil." if !name.is_a?(String) || name.empty?
-    raise ArgumentError, "The gender must be a symbol." unless gender.is_a?(Symbol)
-    raise ArgumentError, "The birthdate must be a date." unless birthdate.is_a?(Date)
+    raise ArgumentError, 'The name must be a string and must not be nil.' if !name.is_a?(String) || name.empty?
+    raise ArgumentError, 'The gender must be a symbol.' unless gender.is_a?(Symbol)
+    raise ArgumentError, 'The birthdate must be a date.' unless birthdate.is_a?(Date)
 
     @name = name
     @gender = gender

data/lib/argspec.rb

@@ -8,9 +8,9 @@ module ArgumentSpecification
     #
     def require!
       require 'argspec/constants'
+      require 'argspec/dsl'
       require 'argspec/matchers'
       require 'argspec/argument'
-      require 'argspec/dsl'
 
       nil
     end

data/lib/argspec/argument.rb

@@ -1,130 +1,63 @@
 module ArgumentSpecification
   class Argument
-    attr_reader :object
+    attr_reader :actual
 
     # Create a new argument
     #
     # Arguments:
-    #   object: (?)
+    #   actual: (Object)
     #
     # Example:
     #   >> test = :test
     #   >> ArgumentSpecification::Argument.new(test)
-    #   => #<Argument:0x00000000000000 @object=:test>
+    #   => #<Argument:0x00000000000000 @actual=:test>
     #
-    def initialize(object)
-      @object = object
+    def initialize(actual)
+      @actual = actual
     end
 
-    # Should
+    # Ensure the argument matches
     #
     # Arguments:
-    #   matcher: (Symbol) A method name as a symbol (see the matchers.rb file)
-    #   args: (Splat)
+    #   matcher: (Matchers::BaseMatcher)
     #
     # Example:
-    #   >> argument.should(:be, true)
+    #   >> argument.should be_a(Symbol)
     #   => nil
     #
     # Raises:
-    #   ArgumentError: If the matcher determines the object does not match
+    #   ArgumentError: When the argument does not match
     #
-    def should(matcher, *args)
-      ensure_matcher(matcher)
+    def should(matcher)
+      return nil unless matcher.is_a?(Matchers::BaseMatcher)
 
-      return if Matchers.send(matcher, self, *args)
+      matcher.send(:actual=, @actual)
 
-      raise ArgumentError, "'#{prettify_object}' should #{prettify_matcher(matcher)} '#{prettify_args(args)}'"
-    end
+      return nil if matcher.matches?
 
-    # Should not
-    #
-    # Arguments:
-    #   matcher: (Symbol) A method name as a symbol (see the matchers.rb file)
-    #   args: (Splat)
-    #
-    # Example:
-    #   >> argument.should_not(:be, true)
-    #   => nil
-    #
-    # Raises:
-    #   ArgumentError: If the matcher determines the object does match
-    #
-    def should_not(matcher, *args)
-      ensure_matcher(matcher)
-
-      return if Matchers.send(matcher, self, *args) == false
-
-      raise ArgumentError, "'#{prettify_object}' should not #{prettify_matcher(matcher)} '#{prettify_args(args)}'"
+      raise ArgumentError, matcher.failure_message
     end
 
-    private
-    # Ensure a matcher exists
+    # Ensure the argument does not match
     #
     # Arguments:
-    #   matcher: (Symbol)
+    #   matcher: (Matchers::BaseMatcher)
     #
     # Example:
-    #   >> ensure_matcher(:be)
+    #   >> argument.should_not be_a(Symbol)
     #   => nil
     #
     # Raises:
-    #   ArgumentError: If the specified matcher does not exist
-    #
-    def ensure_matcher(matcher)
-      return if Matchers.all.include?(matcher)
-
-      raise ArgumentError, "The matcher '#{matcher}' does not exist."
-    end
-
-    # Prettify a matcher
+    #   ArgumentError: When the argument matches
     #
-    # Arguments:
-    #   matcher: (String)
-    #
-    # Example:
-    #   >> prettify_matcher(:be_a)
-    #   => "be a"
-    #
-    def prettify_matcher(matcher)
-      matcher.to_s.gsub('_', ' ')
-    end
+    def should_not(matcher)
+      return nil unless matcher.is_a?(Matchers::BaseMatcher)
 
-    # Prettify arguments
-    #
-    # Arguments:
-    #   args: (Array)
-    #
-    # Example:
-    #   >> prettify_args([:a])
-    #   => ":a"
-    #
-    def prettify_args(args)
-      pretty_args = args.map do |argument|
-        if argument == nil
-          next 'nil'
-        elsif argument.is_a?(Symbol)
-          next ":#{argument}"
-        else
-          next argument
-        end
-      end
+      matcher.send(:actual=, @actual)
 
-      return 'nil' if pretty_args.empty?
-      return pretty_args.first if pretty_args.count == 1
-
-      pretty_args
-    end
+      return nil unless matcher.matches?
 
-    # Prettify the object
-    #
-    # Example:
-    #   >> # argument.object = :a
-    #   >> prettify_object
-    #   => ":a"
-    #
-    def prettify_object
-      prettify_args([@object])
+      raise ArgumentError, matcher.failure_message_when_negated
     end
   end
 end

data/lib/argspec/constants.rb

@@ -1,3 +1,3 @@
 module ArgumentSpecification
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/argspec/dsl.rb

@@ -1,9 +1,34 @@
 module ArgumentSpecification
   module DSL
+    class << self
+      # Register a matcher
+      #
+      # Arguments:
+      #   klass: (Matchers::BaseMatcher)
+      #   name: (Symbol)
+      #
+      # Example:
+      #   >> register_matcher(TestMatcher, :test_matcher)
+      #   => true
+      #
+      def register_matcher(klass, name)
+        return unless klass.ancestors.include?(Matchers::BaseMatcher)
+        return unless name.is_a?(Symbol)
+
+        module_eval <<-EOS
+          def #{name}(*args, &block)
+            instance = #{klass}.new(*args, &block)
+            instance.send(:setup, '#{name}'.to_sym, args)
+            instance
+          end
+        EOS
+      end
+    end
+
     # Get an argument object
     #
     # Arguments:
-    #   object: (?)
+    #   object: (Object)
     #
     # Example:
     #   >> test = :test

data/lib/argspec/matchers.rb

@@ -1,60 +1,2 @@
-module ArgumentSpecification
-  module Matchers
-    class << self
-      # Get an array of all available matchers
-      #
-      # Example:
-      #   >> all
-      #   => [:be, ...]
-      #
-			def all
-				[:be, :be_a, :include]
-			end
-
-      # The be matcher
-      #
-      # Arguments:
-      #   argument: (ArgumentSpecification::Argument)
-      #   object: (?)
-      #
-      # Example:
-      #   >> test = 'Test'
-      #   >> argument(test).should_not(:be, nil)
-      #   => nil
-      #
-			def be(argument, object)
-				argument.object == object
-			end
-
-      # The be_a matcher
-      #
-      # Arguments:
-      #   argument: (ArgumentSpecification::Argument)
-      #   object: (?)
-      #
-      # Example:
-      #   >> test = :test
-      #   >> argument(test).should(:be_a, Symbol)
-      #   => nil
-      #
-			def be_a(argument, klass)
-				argument.object.is_a?(klass)
-			end
-
-      # The include matcher
-      #
-      # Arguments:
-      #   argument: (ArgumentSpecification::Argument)
-      #   object: (?)
-      #
-      # Example:
-      #   >> test = [:test]
-      #   >> argument(test).should(:include, :test)
-      #   => nil
-      #
-			def include(argument, object)
-				argument.object.include?(object)
-			end
-		end
-  end
-end
+require 'argspec/matchers/base_matcher'
+Dir.glob(File.expand_path('../matchers/**/*.rb', __FILE__)).each { |f| require(f) }

data/lib/argspec/matchers/all.rb

@@ -0,0 +1,82 @@
+module ArgumentSpecification
+  module Matchers
+    class All < BaseMatcher
+      matcher_name :all
+
+      attr_reader :expected
+
+      # Create a new matcher instance
+      #
+      # Arguments:
+      #   expected: (BaseMatcher)
+      #
+      # Example:
+      #   >> symbol_matcher = ArgumentSpecification::Matchers::BeA.new(Symbol)
+      #   >> ArgumentSpecification::Matchers::All.new(symbol_matcher)
+      #   => #<ArgumentSpecification::Matchers::All:0x00000000000000 @expected=#<ArgumentSpecification::Matchers::BeA:0x00000000000000 @expected=Symbol>>
+      #
+      def initialize(expected)
+        if expected.is_a?(BaseMatcher) == false || expected.is_a?(All)
+          raise ArgumentError, 'You must provide a matcher as an argument (excluding the all matcher).'
+        end
+
+        @expected = expected
+      end
+
+      # The failure message when using 'should'
+      #
+      # Example:
+      #   >> matcher.failure_message
+      #   => "'test' should be a 'Symbol'"
+      #
+      def failure_message
+        actual = prettify_args(@actual)
+        matcher = prettify_matcher(@expected.metadata[:name])
+
+        if @expected.metadata[:args].count > 0
+          args = prettify_args(*@expected.metadata[:args])
+
+          "'#{actual}' should all #{matcher} '#{args}'"
+        else
+          "'#{actual}' should all #{matcher}"
+        end
+      end
+
+      # The failure message when using 'should not'
+      #
+      # Example:
+      #   >> matcher.failure_message_when_negated
+      #   => "':test' should not be a 'Symbol'"
+      #
+      def failure_message_when_negated
+        actual = prettify_args(@actual)
+        matcher = prettify_matcher(@expected.metadata[:name])
+
+        if @expected.metadata[:args].count > 0
+          args = prettify_args(*@expected.metadata[:args])
+
+          "'#{actual}' should not all #{matcher} '#{args}'"
+        else
+          "'#{actual}' should not all #{matcher}"
+        end
+      end
+
+      # Check if the actual object matches
+      #
+      # Example:
+      #   >> matcher.matches?
+      #   => true
+      #
+      def matches?
+        actual = @actual.is_a?(Array) ? @actual : [@actual]
+        actual.each do |value|
+          @expected.send(:actual=, value)
+
+          return false unless @expected.matches?
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/argspec/matchers/base_matcher.rb

@@ -0,0 +1,145 @@
+module ArgumentSpecification
+  module Matchers
+    class BaseMatcher
+      class << self
+        # Add matcher names
+        #
+        # Arguments:
+        #   names: (Splat)
+        #
+        # Example:
+        #   >> class TestMatcher < BaseMatcher
+        #   >>   matcher_name :test_matcher
+        #   >> end
+        #   => TestMatcher
+        #
+        def matcher_name(*names)
+          names.each do |name|
+            next unless name.is_a?(Symbol)
+
+            DSL.register_matcher(self, name)
+          end
+        end
+      end
+
+      attr_reader :actual, :metadata
+
+      # The failure message when using 'should'
+      #
+      # Example:
+      #   >> matcher.failure_message
+      #   => "'test' should be a 'Symbol'"
+      #
+      def failure_message
+        actual = prettify_args(@actual)
+        matcher = prettify_matcher(@metadata[:name])
+
+        if @metadata[:args].count > 0
+          args = prettify_args(*@metadata[:args])
+
+          "'#{actual}' should #{matcher} '#{args}'"
+        else
+          "'#{actual}' should #{matcher}"
+        end
+      end
+
+      # The failure message when using 'should not'
+      #
+      # Example:
+      #   >> matcher.failure_message_when_negated
+      #   => "':test' should not be a 'Symbol'"
+      #
+      def failure_message_when_negated
+        actual = prettify_args(@actual)
+        matcher = prettify_matcher(@metadata[:name])
+
+        if @metadata[:args].count > 0
+          args = prettify_args(*@metadata[:args])
+
+          "'#{actual}' should not #{matcher} '#{args}'"
+        else
+          "'#{actual}' should not #{matcher}"
+        end
+      end
+
+      # Check if the actual object matches
+      #
+      # You must override this method!
+      #
+      # Example:
+      #   >> matcher.matches?
+      #   => true
+      #
+      def matches?
+        raise NotImplementedError, 'You must override the matches? method in your matcher.'
+      end
+
+      private
+      # Setup the matcher
+      #
+      # Arguments:
+      #   name: (Symbol)
+      #   args: (Array)
+      #
+      # Example:
+      #   >> matcher.setup(:test_matcher, [])
+      #   => { name: :test_matcher, args: [] }
+      #
+      def setup(name, args)
+        @metadata = { name: name, args: args }
+      end
+
+      # Set the actual object
+      #
+      # Arguments:
+      #   actual: (Object)
+      #
+      # Example:
+      #   >> matcher.actual = :test
+      #   => :test
+      #
+      def actual=(actual)
+        @actual = actual
+      end
+
+      # Prettify a matcher
+      #
+      # Arguments:
+      #   matcher: (String)
+      #
+      # Example:
+      #   >> prettify_matcher(:be_a)
+      #   => "be a"
+      #
+      def prettify_matcher(matcher)
+        matcher.to_s.gsub('_', ' ')
+      end
+
+      # Prettify arguments
+      #
+      # Arguments:
+      #   args: (Splat)
+      #
+      # Example:
+      #   >> prettify_args(:a)
+      #   => ":a"
+      #
+      def prettify_args(*args)
+        pretty_args = args.map do |argument|
+          if argument == nil
+            next 'nil'
+          elsif argument.is_a?(Symbol)
+            next ":#{argument}"
+          else
+            next argument
+          end
+        end
+
+        return 'nil' if pretty_args.empty?
+        return pretty_args.first if pretty_args.count == 1
+
+        pretty_args
+      end
+    end
+  end
+end

data/lib/argspec/matchers/be.rb

@@ -0,0 +1,33 @@
+module ArgumentSpecification
+  module Matchers
+    class Be < BaseMatcher
+      matcher_name :be
+
+      OPERATORS = {
+        :==  => :equal,
+        :=== => :case_equal,
+        :=~  => :match,
+        :<   => :be_less_than,
+        :>   => :be_greater_than,
+        :<=  => :be_less_than_or_equal_to,
+        :>=  => :be_greater_than_or_equal_to
+      }
+
+      OPERATORS.keys.each do |operator|
+        define_method(operator) do |expected|
+          send(OPERATORS[operator], expected)
+        end
+      end
+
+      # Check if the actual object matches
+      #
+      # Example:
+      #   >> matcher.matches?
+      #   => true
+      #
+      def matches?
+        !!@actual
+      end
+    end
+  end
+end

data/lib/argspec/matchers/be_a.rb

@@ -0,0 +1,32 @@
+module ArgumentSpecification
+  module Matchers
+    class BeA < BaseMatcher
+      matcher_name :be_a, :be_an
+
+      attr_reader :expected
+
+      # Create a new matcher instance
+      #
+      # Arguments:
+      #   expected: (Class)
+      #
+      # Example:
+      #   >> ArgumentSpecification::Matchers::BeA.new(Symbol)
+      #   => #<ArgumentSpecification::Matchers::BeA:0x00000000000000 @expected=Symbol>
+      #
+      def initialize(expected)
+        @expected = expected
+      end
+
+      # Check if the actual object matches
+      #
+      # Example:
+      #   >> matcher.matches?
+      #   => true
+      #
+      def matches?
+        @actual.is_a?(@expected)
+      end
+    end
+  end
+end

data/lib/argspec/matchers/be_empty.rb

@@ -0,0 +1,17 @@
+module ArgumentSpecification
+  module Matchers
+    class BeEmpty < BaseMatcher
+      matcher_name :be_empty
+
+      # Check if the actual object matches
+      #
+      # Example:
+      #   >> matcher.matches?
+      #   => true
+      #
+      def matches?
+        @actual.empty?
+      end
+    end
+  end
+end

data/lib/argspec/matchers/be_falsey.rb

@@ -0,0 +1,17 @@
+module ArgumentSpecification
+  module Matchers
+    class BeFalsey < BaseMatcher
+      matcher_name :be_falsey
+
+      # Check if the actual object matches
+      #
+      # Example:
+      #   >> matcher.matches?
+      #   => true
+      #
+      def matches?
+        !@actual
+      end
+    end
+  end
+end

data/lib/argspec/matchers/be_greater_than.rb

@@ -0,0 +1,32 @@
+module ArgumentSpecification
+  module Matchers
+    class BeGreaterThan < BaseMatcher
+      matcher_name :be_greater_than
+
+      attr_reader :expected
+
+      # Create a new matcher instance
+      #
+      # Arguments:
+      #   expected: (Object)
+      #
+      # Example:
+      #   >> ArgumentSpecification::Matchers::BeGreaterThan.new(10)
+      #   => #<ArgumentSpecification::Matchers::BeGreaterThan:0x00000000000000 @expected=10>
+      #
+      def initialize(expected)
+        @expected = expected
+      end
+
+      # Check if the actual object matches
+      #
+      # Example:
+      #   >> matcher.matches?
+      #   => true
+      #
+      def matches?
+        @actual > @expected
+      end
+    end
+  end
+end

data/lib/argspec/matchers/be_greater_than_or_equal_to.rb

@@ -0,0 +1,32 @@
+module ArgumentSpecification
+  module Matchers
+    class BeGreaterThanOrEqualTo < BaseMatcher
+      matcher_name :be_greater_than_or_equal_to
+
+      attr_reader :expected
+
+      # Create a new matcher instance
+      #
+      # Arguments:
+      #   expected: (Object)
+      #
+      # Example:
+      #   >> ArgumentSpecification::Matchers::BeGreaterThanOrEqualTo.new(10)
+      #   => #<ArgumentSpecification::Matchers::BeGreaterThanOrEqualTo:0x00000000000000 @expected=10>
+      #
+      def initialize(expected)
+        @expected = expected
+      end
+
+      # Check if the actual object matches
+      #
+      # Example:
+      #   >> matcher.matches?
+      #   => true
+      #
+      def matches?
+        @actual >= @expected
+      end
+    end
+  end
+end

data/lib/argspec/matchers/be_less_than.rb

@@ -0,0 +1,32 @@
+module ArgumentSpecification
+  module Matchers
+    class BeLessThan < BaseMatcher
+      matcher_name :be_less_than
+
+      attr_reader :expected
+
+      # Create a new matcher instance
+      #
+      # Arguments:
+      #   expected: (Object)
+      #
+      # Example:
+      #   >> ArgumentSpecification::Matchers::BeLessThan.new(10)
+      #   => #<ArgumentSpecification::Matchers::BeLessThan:0x00000000000000 @expected=10>
+      #
+      def initialize(expected)
+        @expected = expected
+      end
+
+      # Check if the actual object matches
+      #
+      # Example:
+      #   >> matcher.matches?
+      #   => true
+      #
+      def matches?
+        @actual < @expected
+      end
+    end
+  end
+end

data/lib/argspec/matchers/be_less_than_or_equal_to.rb

@@ -0,0 +1,32 @@
+module ArgumentSpecification
+  module Matchers
+    class BeLessThanOrEqualTo < BaseMatcher
+      matcher_name :be_less_than_or_equal_to
+
+      attr_reader :expected
+
+      # Create a new matcher instance
+      #
+      # Arguments:
+      #   expected: (Object)
+      #
+      # Example:
+      #   >> ArgumentSpecification::Matchers::BeLessThanOrEqualTo.new(10)
+      #   => #<ArgumentSpecification::Matchers::BeLessThanOrEqualTo:0x00000000000000 @expected=10>
+      #
+      def initialize(expected)
+        @expected = expected
+      end
+
+      # Check if the actual object matches
+      #
+      # Example:
+      #   >> matcher.matches?
+      #   => true
+      #
+      def matches?
+        @actual <= @expected
+      end
+    end
+  end
+end

data/lib/argspec/matchers/be_nil.rb

@@ -0,0 +1,17 @@
+module ArgumentSpecification
+  module Matchers
+    class BeNil < BaseMatcher
+      matcher_name :be_nil
+
+      # Check if the actual object matches
+      #
+      # Example:
+      #   >> matcher.matches?
+      #   => true
+      #
+      def matches?
+        @actual.nil?
+      end
+    end
+  end
+end

data/lib/argspec/matchers/be_truthy.rb

@@ -0,0 +1,17 @@
+module ArgumentSpecification
+  module Matchers
+    class BeTruthy < BaseMatcher
+      matcher_name :be_truthy
+
+      # Check if the actual object matches
+      #
+      # Example:
+      #   >> matcher.matches?
+      #   => true
+      #
+      def matches?
+        !!@actual
+      end
+    end
+  end
+end

data/lib/argspec/matchers/be_within_range.rb

@@ -0,0 +1,32 @@
+module ArgumentSpecification
+  module Matchers
+    class BeWithinRange < BaseMatcher
+      matcher_name :be_within_range
+
+      attr_reader :range
+
+      # Create a new matcher instance
+      #
+      # Arguments:
+      #   range: (Range)
+      #
+      # Example:
+      #   >> ArgumentSpecification::Matchers::BeWithinRange.new(1..10)
+      #   => #<ArgumentSpecification::Matchers::BeWithinRange:0x00000000000000 @range=1..10>
+      #
+      def initialize(range)
+        @range = range
+      end
+
+      # Check if the actual object matches
+      #
+      # Example:
+      #   >> matcher.matches?
+      #   => true
+      #
+      def matches?
+        @range.include?(@actual)
+      end
+    end
+  end
+end

data/lib/argspec/matchers/case_equal.rb

@@ -0,0 +1,32 @@
+module ArgumentSpecification
+  module Matchers
+    class CaseEqual < BaseMatcher
+      matcher_name :case_equal
+
+      attr_reader :expected
+
+      # Create a new matcher instance
+      #
+      # Arguments:
+      #   expected: (Object)
+      #
+      # Example:
+      #   >> ArgumentSpecification::Matchers::CaseEqual.new(:test)
+      #   => #<ArgumentSpecification::Matchers::CaseEqual:0x00000000000000 @expected=:test>
+      #
+      def initialize(expected)
+        @expected = expected
+      end
+
+      # Check if the actual object matches
+      #
+      # Example:
+      #   >> matcher.matches?
+      #   => true
+      #
+      def matches?
+        @actual === @expected
+      end
+    end
+  end
+end

data/lib/argspec/matchers/contain.rb

@@ -0,0 +1,32 @@
+module ArgumentSpecification
+  module Matchers
+    class Contain < BaseMatcher
+      matcher_name :contain
+
+      attr_reader :expected
+
+      # Create a new matcher instance
+      #
+      # Arguments:
+      #   expected: (Object)
+      #
+      # Example:
+      #   >> ArgumentSpecification::Matchers::Contain.new(Symbol)
+      #   => #<ArgumentSpecification::Matchers::Contain:0x00000000000000 @expected=Symbol>
+      #
+      def initialize(expected)
+        @expected = expected
+      end
+
+      # Check if the actual object matches
+      #
+      # Example:
+      #   >> matcher.matches?
+      #   => true
+      #
+      def matches?
+        @actual.include?(@expected)
+      end
+    end
+  end
+end

data/lib/argspec/matchers/cover.rb

@@ -0,0 +1,36 @@
+module ArgumentSpecification
+  module Matchers
+    class Cover < BaseMatcher
+      matcher_name :cover
+
+      attr_reader :values
+
+      # Create a new matcher instance
+      #
+      # Arguments:
+      #   values: (Splat)
+      #
+      # Example:
+      #   >> ArgumentSpecification::Matchers::Cover.new(1, 2)
+      #   => #<ArgumentSpecification::Matchers::Cover:0x00000000000000 @values=[1, 2]>
+      #
+      def initialize(*values)
+        @values = values
+      end
+
+      # Check if the actual object matches
+      #
+      # Example:
+      #   >> matcher.matches?
+      #   => true
+      #
+      def matches?
+        @values.each do |value|
+          return false unless @actual.include?(value)
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/argspec/matchers/end_with.rb

@@ -0,0 +1,32 @@
+module ArgumentSpecification
+  module Matchers
+    class EndWith < BaseMatcher
+      matcher_name :end_with
+
+      attr_reader :expected
+
+      # Create a new matcher instance
+      #
+      # Arguments:
+      #   expected: (String)
+      #
+      # Example:
+      #   >> ArgumentSpecification::Matchers::EndWith.new("test")
+      #   => #<ArgumentSpecification::Matchers::EndWith:0x00000000000000 @expected="test">
+      #
+      def initialize(expected)
+        @expected = expected
+      end
+
+      # Check if the actual object matches
+      #
+      # Example:
+      #   >> matcher.matches?
+      #   => true
+      #
+      def matches?
+        @actual.end_with?(@expected)
+      end
+    end
+  end
+end

data/lib/argspec/matchers/equal.rb

@@ -0,0 +1,32 @@
+module ArgumentSpecification
+  module Matchers
+    class Equal < BaseMatcher
+      matcher_name :equal
+
+      attr_reader :expected
+
+      # Create a new matcher instance
+      #
+      # Arguments:
+      #   expected: (Object)
+      #
+      # Example:
+      #   >> ArgumentSpecification::Matchers::Equal.new(:test)
+      #   => #<ArgumentSpecification::Matchers::Equal:0x00000000000000 @expected=:test>
+      #
+      def initialize(expected)
+        @expected = expected
+      end
+
+      # Check if the actual object matches
+      #
+      # Example:
+      #   >> matcher.matches?
+      #   => true
+      #
+      def matches?
+        @actual == @expected
+      end
+    end
+  end
+end

data/lib/argspec/matchers/match.rb

@@ -0,0 +1,32 @@
+module ArgumentSpecification
+  module Matchers
+    class Match < BaseMatcher
+      matcher_name :match
+
+      attr_reader :expected
+
+      # Create a new matcher instance
+      #
+      # Arguments:
+      #   expected: (Object)
+      #
+      # Example:
+      #   >> ArgumentSpecification::Matchers::Match.new(Symbol)
+      #   => #<ArgumentSpecification::Matchers::Match:0x00000000000000 @expected=Symbol>
+      #
+      def initialize(expected)
+        @expected = expected
+      end
+
+      # Check if the actual object matches
+      #
+      # Example:
+      #   >> matcher.matches?
+      #   => true
+      #
+      def matches?
+        @actual =~ @expected
+      end
+    end
+  end
+end

data/lib/argspec/matchers/respond_to.rb

@@ -0,0 +1,32 @@
+module ArgumentSpecification
+  module Matchers
+    class RespondTo < BaseMatcher
+      matcher_name :respond_to
+
+      attr_reader :expected
+
+      # Create a new matcher instance
+      #
+      # Arguments:
+      #   expected: (Symbol)
+      #
+      # Example:
+      #   >> ArgumentSpecification::Matchers::RespondTo.new(:hello)
+      #   => #<ArgumentSpecification::Matchers::RespondTo:0x00000000000000 @expected=:hello>
+      #
+      def initialize(expected)
+        @expected = expected
+      end
+
+      # Check if the actual object matches
+      #
+      # Example:
+      #   >> matcher.matches?
+      #   => true
+      #
+      def matches?
+        @actual.respond_to?(@expected)
+      end
+    end
+  end
+end

data/lib/argspec/matchers/satisfy.rb

@@ -0,0 +1,66 @@
+module ArgumentSpecification
+  module Matchers
+    class Satisfy < BaseMatcher
+      matcher_name :satisfy
+
+      attr_reader :description, :block
+
+      # Create a new matcher instance
+      #
+      # Arguments:
+      #   description: (String)
+      #   block: (Block)
+      #
+      # Example:
+      #   >> ArgumentSpecification::Matchers::Satisfy.new('always pass') { true }
+      #   => #<ArgumentSpecification::Matchers::Satisfy:0x00000000000000 @block=#<Proc:0x00000000000000>>
+      #
+      def initialize(description, &block)
+        @description = description
+        @block = block
+      end
+
+      # The failure message when using 'should'
+      #
+      # Example:
+      #   >> matcher.failure_message
+      #   => "'test' should always pass"
+      #
+      def failure_message
+        actual = prettify_args(@actual)
+
+        if @description
+          "'#{actual}' should #{@description}"
+        else
+          "'#{actual}' should satisfy the requirements"
+        end
+      end
+
+      # The failure message when using 'should not'
+      #
+      # Example:
+      #   >> matcher.failure_message_when_negated
+      #   => "':test' should not always pass"
+      #
+      def failure_message_when_negated
+        actual = prettify_args(@actual)
+
+        if @description
+          "'#{actual}' should not #{@description}"
+        else
+          "'#{actual}' should not satisfy the requirements"
+        end
+      end
+
+      # Check if the actual object matches
+      #
+      # Example:
+      #   >> matcher.matches?
+      #   => true
+      #
+      def matches?
+        @block.call(@actual)
+      end
+    end
+  end
+end

data/lib/argspec/matchers/start_with.rb

@@ -0,0 +1,32 @@
+module ArgumentSpecification
+  module Matchers
+    class StartWith < BaseMatcher
+      matcher_name :start_with, :begin_with
+
+      attr_reader :expected
+
+      # Create a new matcher instance
+      #
+      # Arguments:
+      #   expected: (String)
+      #
+      # Example:
+      #   >> ArgumentSpecification::Matchers::StartWith.new("test")
+      #   => #<ArgumentSpecification::Matchers::StartWith:0x00000000000000 @expected="test">
+      #
+      def initialize(expected)
+        @expected = expected
+      end
+
+      # Check if the actual object matches
+      #
+      # Example:
+      #   >> matcher.matches?
+      #   => true
+      #
+      def matches?
+        @actual.start_with?(@expected)
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: argspec
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Nialto Services
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-24 00:00:00.000000000 Z
+date: 2016-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -73,6 +73,28 @@ files:
 - lib/argspec/constants.rb
 - lib/argspec/dsl.rb
 - lib/argspec/matchers.rb
+- lib/argspec/matchers/all.rb
+- lib/argspec/matchers/base_matcher.rb
+- lib/argspec/matchers/be.rb
+- lib/argspec/matchers/be_a.rb
+- lib/argspec/matchers/be_empty.rb
+- lib/argspec/matchers/be_falsey.rb
+- lib/argspec/matchers/be_greater_than.rb
+- lib/argspec/matchers/be_greater_than_or_equal_to.rb
+- lib/argspec/matchers/be_less_than.rb
+- lib/argspec/matchers/be_less_than_or_equal_to.rb
+- lib/argspec/matchers/be_nil.rb
+- lib/argspec/matchers/be_truthy.rb
+- lib/argspec/matchers/be_within_range.rb
+- lib/argspec/matchers/case_equal.rb
+- lib/argspec/matchers/contain.rb
+- lib/argspec/matchers/cover.rb
+- lib/argspec/matchers/end_with.rb
+- lib/argspec/matchers/equal.rb
+- lib/argspec/matchers/match.rb
+- lib/argspec/matchers/respond_to.rb
+- lib/argspec/matchers/satisfy.rb
+- lib/argspec/matchers/start_with.rb
 - spec/argspec_spec.rb
 - spec/spec_helper.rb
 homepage: https://rubygems.org/gems/argspec