mal 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e9e34384af7d008d577ba4062c834b0bf5c8cedb
-  data.tar.gz: f47b158a59a3fd77b9013d63312101be8efc8e0f
+  metadata.gz: 8322ccc3484573bae624022558dcd1c09f590617
+  data.tar.gz: 92eeb1370d980bc3a811fe5d2656ba82f78d53cd
 SHA512:
-  metadata.gz: a6665014e7b2ec843c58877678c9b4e8df1cc16c32cfed0619ec524e10df9158e2cd919d83fd9aa1a54b2331fc4ef3e65d3fe85378311ecd2c52151234c05ee4
-  data.tar.gz: ca145ca000f736042934203cca6a68fb6e5e7fb8da5a81e8ded06e350f03485254b14f2e1dca76585ad81de9a652d654e087a082f7855a3490ee0271743c45f6
+  metadata.gz: 2fbc206db73bb0abb489a1ce55c418a20a53ca702ac75e0d4a813a4ccd27ab73be0ddae8daafe14c517e34e80bb6a7570fdae7771340ac5d0f78bdf97ab36f39
+  data.tar.gz: 9e956f361b93855316c5a67cd1f0e322311e2eaf2755113e3050c03ecad3237410f106e1dee9cd21976dd99e171508d1bb2bdf08eebb29ba30e7810755e47b46

data/README.md

@@ -1,6 +1,6 @@
 # mal
 
-Minuscule (Type) Algerba - a type-matching thing for Ruby.
+Minuscule (Type) Algebra - a type-matching thing for Ruby.
 
 The library allows you to do simple type matching based on _any_ Ruby types that support the "triqual"
 operator (type equality). It is distantly related to libraries like rb_dry_types
@@ -18,7 +18,7 @@ Array only contains booleans:
 
 You can also match Hashes, which lends itself to JSON assertions quite nicely:
 
-    Mal.HashOf(name: String, age: Numeric) === {name: 'Jane', age: 22, accepted_license_agreement: true} #=> true
+    Mal.HashWith(name: String, age: Numeric) === {name: 'Jane', age: 22, accepted_license_agreement: true} #=> true
 
 You can also use these type matchers for case statements:
 

data/lib/mal.rb

@@ -1,5 +1,49 @@
+# The module allows you to define simple data structure schemas, and to match your data against
+# those schemas. Primary use is for HTTP parameters, JSON-derived datastructures and the like.
+#
+# Let's start with the basics. Any "typespec" returned by the library responds to `===`. The most
+# basic (and all-encompassing) typespec there is is called `Anything()`.
+#
+#     Anything() === false  #=> true
+#     Anything() === true   #=> true
+#     Anything() === Module #=> true
+#
+# A more specific type is an Only(), which is similar to just using a class, module or Regexp (which
+# all support ===), but it can be composed with other typespecs.
+#
+#    Only(/hello/) === 123           #=> false
+#    Only(/hello/) === "hello world" #=> true
+#
+# Interesting things come into play when you use combinations of the typespecs. For example, you want
+# to ensure the value referenced by `my_var` is either a Fixnum or a String matching a regular expression.
+# For this, you need to create a compound matcher using an `Either()` typespec (disjoint union):
+#
+#    Either(Fixnum, Both(String, /hello/)) === "hello world"  #=> true
+#    Either(Fixnum, Both(String, /hello/)) === 123            #=> true
+#    Either(Fixnum, Both(String, /hello/)) === Module         #=> false, since it is neither of
+#
+# You can also use the `|` operator on most of the typespecs to create these disjoint unions - but
+# if you have a matchable object on the left side of the expression you mught have to wrap it in an
+# `Only()`:
+#
+#    Only(Fixnum) | Only(String) #=> Either(Fixnum, String)
+#
+# Even more entertainment becomes possible when you match deeper structures with nesting - hashes for example.
+# There are two methods for those - `HashWith()` and `HashOf`. `HashWith` checks for the presence of the given
+# key/value pairs and checks values for matches, but if there are _other_ keys present in the Hash given for
+# verification it won't complain. `HashOf()`, in contrast, will ensure there are _only_ the mentioned keys
+# in the Hash, and will not match if something else is present.
+#
+#    HashWith(age: Fixnum) === {age: 12, name: 'Cisco Kid'} #=> true
+#    HashOf(age: Fixnum) === {age: 12, name: 'Cisco Kid'} #=> false
+#
+# Note that it is _entirely_ plausible that you would not want to include Mal into
+# your object/class/whatever. For that case, calling methods using their qualified
+# module name (`Mal.Some()...`) can become a nuisance. If it does,
+# use `Mal.typespec` which is a shortcut to `instance_exec` - but has the convenient
+# property of not alerting your style watchers to your use of `instance_exec` :-P
 module Mal
-  VERSION = '0.0.2'
+  VERSION = '0.0.4'
   
   class AnythingT
     def ===(value)
@@ -8,6 +52,14 @@ module Mal
     def inspect
       'Anything()'
     end
+    
+    def |(another)
+      self
+    end
+    
+    def &(another)
+      another # Another is automatically considered more specific, and replaces Anything
+    end
   end
 
   class OnlyT
@@ -22,13 +74,30 @@ module Mal
     def inspect
       'Only(%s)' % @matchable.inspect
     end
+    
+    def |(another)
+      if another.is_a?(AnythingT)
+        another
+      else
+        EitherT.new(self, another)
+      end
+    end
+    
+    def &(another)
+      if another.is_a?(AnythingT)
+        self
+      else
+        UnionT.new(self, another)
+      end
+    end
   end
 
   class NilT < OnlyT
     def inspect; 'Nil()'; end
+    def |(another); MaybeT.new(another); end
   end
 
-  class HashT
+  class HashT < OnlyT
     def initialize(**required_keys_to_matchers)
       @required_keys_to_matchers = required_keys_to_matchers
     end
@@ -47,6 +116,31 @@ module Mal
     end
   end
   
+  class ObjectT < OnlyT
+    attr_reader :supported_methods
+    def initialize(*supported_methods)
+      @supported_methods = supported_methods.map(&:to_sym)
+    end
+  
+    def ===(value)
+      @supported_methods.each do |m|
+        return false unless value.respond_to?(m)
+      end
+      true
+    end
+
+    def inspect
+      'ObjectWith(%s)' % @supported_methods.map(&:inspect).join(', ')
+    end
+    
+    def &(another)
+      if another.is_a?(ObjectT)
+        methods_of_both = (@supported_methods + another.supported_methods).uniq
+        ObjectT.new(*methods_of_both)
+      end
+    end
+  end
+  
   class HashOfOnlyT < HashT
     def ===(value)
       return false unless super
@@ -57,7 +151,20 @@ module Mal
       'HashOf(%s)' % @required_keys_to_matchers.inspect[1..-2]
     end
   end
-  
+
+  class HashPermittingT < HashT
+    def ===(value)
+      return false unless super
+      permitted = Set.new(@required_keys_to_matchers.keys)
+      present = Set.new(value.keys)
+      present.subset?(permitted)
+    end
+    
+    def inspect
+      'HashPermitting(%s)' % @required_keys_to_matchers.inspect[1..-2]
+    end
+  end
+
   class ArrayT < OnlyT
     def initialize(matcher_for_each_array_element)
       @matcher_for_each_array_element = matcher_for_each_array_element
@@ -86,6 +193,8 @@ module Mal
       return false unless value.respond_to? :length
       @desired_length == value.length
     end
+    
+    def inspect; 'OfElements(%d)' % @desired_length; end
   end
 
   class MinLengthT < LengthT
@@ -105,6 +214,7 @@ module Mal
   end
 
   class EitherT < OnlyT
+    attr_reader :types
     def initialize(*types)
       @types = types
     end
@@ -116,9 +226,19 @@ module Mal
     def inspect
       'Either(%s)' % @types.map{|e| e.inspect }.join(', ')
     end
+    
+    def |(another)
+      types_matched = if another.is_a?(EitherT)
+        (@types + another.types).uniq
+      else
+        (@types + [another]).uniq
+      end
+      EitherT.new(*types_matched)
+    end
   end
 
   class UnionT < OnlyT
+    attr_reader :types
     def initialize(*types)
       @types = types
     end
@@ -130,19 +250,58 @@ module Mal
     def inspect
       'Both(%s)' % @types.map{|e| e.inspect }.join(', ')
     end
+    
+    def &(another)
+      if another.is_a?(UnionT)
+        unique_types = (@types + another.types).uniq
+        return UnionT.new(*unique_types)
+      end
+      super
+    end
   end
 
   class MaybeT < EitherT
+    def initialize(matchable); super(NilClass, matchable); end
     def inspect; 'Maybe(%s)' % @types[1].inspect; end
   end
   
   class BoolT < EitherT
     def initialize; super(TrueClass, FalseClass); end
     def inspect; 'Bool()'; end
+    def |(another); EitherT.new(self, another); end
   end
   
-  private_constant :NilT, :BoolT, :EitherT, :MaybeT, :ArrayT, :HashT, :BoolT, :HashOfOnlyT, :MaxLengthT, :MinLengthT
+  class ValueT < OnlyT
+    def ===(value)
+      @matchable == value
+    end
+    def inspect; 'Value(%s)' % @matchable.inspect; end
+  end
   
+  class SatisfyingT < OnlyT
+    def initialize(&blk)
+      super(blk.to_proc) # Use an OnlyT since Proc objects support ===
+    end
+    def inspect; 'Satisfying(&blk)'; end
+  end
+
+  class IncludingT < ValueT
+    def ===(value)
+      @matchable.include?(value)
+    end
+    def inspect; 'IncludedIn(%s)' % @matchable.inspect; end
+  end
+  
+  class CoveringT < ValueT
+    def ===(value)
+      @matchable.cover?(value)
+    end
+    def inspect; 'CoveredBy(%s)' % @matchable.inspect; end
+  end
+
+  typespec_consts = self.constants.grep(/[a-z]T$/)
+  private_constant *typespec_consts
+
   # Specifies a value that may only ever be `nil` and nothing else
   def Nil()
     NilT.new(NilClass)
@@ -171,7 +330,7 @@ module Mal
 
   # Specifies a value that is either matching the given typespec, or is nil
   def Maybe(matchable)
-    MaybeT.new(NilClass, matchable)
+    MaybeT.new(matchable)
   end
 
   # Specifies an Array of at least 1 element, where each element matches the
@@ -183,12 +342,22 @@ module Mal
   # Specifies a Hash containing at least the given keys, with values at those
   # keys matching the given matchers. For example, for a Hash having at
   # least the `:name` key with a corresponding value that is a String:
-  #   HashOf(name: String)
+  #
+  #   HashWith(name: String)
+  #
   # Since the match is non-strict, it will also match a Hash having more keys
-  #   HashOf(name: String) === {name: 'John Doe', age: 21} #=> true
+  #
+  #   HashWith(name: String) === {name: 'John Doe', age: 21} #=> true
   def HashWith(**keys_to_values)
     HashT.new(**keys_to_values)
   end
+
+  # Specifies an object responding to certain methods
+  #
+  #   ObjectWith(:downcase) === "foo" #=> true
+  def ObjectWith(*properties)
+    ObjectT.new(*properties)
+  end
   
   def OfAtLeastElements(n)
     MinLengthT.new(n)
@@ -211,10 +380,46 @@ module Mal
     HashOfOnlyT.new(**keys_to_values)
   end
   
+  # Specifies a Hash containing the given keys/values or their subset,
+  # will also match an empty Hash. Will _not_ match a Hash having extra
+  # keys.
+  def HashPermitting(**keys_to_values)
+    HashPermittingT.new(**keys_to_values)
+  end
+  
   # Just like it says: will match any value given to it
   def Anything()
     AnythingT.new
   end
   
+  # Matches the contained value exactly using the == operator. Will work well
+  # where exact matches are desired, i.e. for strings, numbers and native language
+  # types.
+  def Value(value)
+    ValueT.new(value)
+  end
+  
+  # Matches the given value if the passed block/Proc returns true when called with that value
+  #   Satisfying {|x| x > 10 } === 11 #=> true
+  def Satisfying(&blk)
+    SatisfyingT.new(&blk)
+  end
+  
+  def CoveredBy(range)
+    CoveringT.new(range)
+  end
+
+  def IncludedIn(*values)
+    IncludingT.new(values)
+  end
+  
+  # A shortcut for `instance_exec`, for defining types using shorthand method names
+  # from outside the module:
+  #
+  #    Mal.typespec { Either(Value(1), Value(2)) }
+  def self.typespec(&blk)
+    instance_exec(&blk)
+  end
+  
   extend self
 end

data/mal.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: mal 0.0.2 ruby lib
+# stub: mal 0.0.4 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "mal"
-  s.version = "0.0.2"
+  s.version = "0.0.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Julik Tarkhanov"]
-  s.date = "2016-09-16"
+  s.date = "2016-09-28"
   s.description = "Minuscule algebraic types for Ruby"
   s.email = "me@julik.nl"
   s.extra_rdoc_files = [
@@ -27,6 +27,7 @@ Gem::Specification.new do |s|
     "Rakefile",
     "lib/mal.rb",
     "mal.gemspec",
+    "spec/mal_external_eval_spec.rb",
     "spec/mal_spec.rb",
     "spec/spec_helper.rb"
   ]

data/spec/mal_external_eval_spec.rb

@@ -0,0 +1,10 @@
+require_relative 'spec_helper'
+
+describe 'Mal' do
+  describe '.typespec' do
+    it 'allows shorthand typespecs to be created without module prefixing' do
+      matcher = Mal.typespec { Maybe(String) }
+      expect(matcher.inspect).to eq('Maybe(String)')
+    end
+  end
+end

data/spec/mal_spec.rb

@@ -13,6 +13,34 @@ describe 'Mal' do
     expect(match_v).to eq(false), "Expected #{value.inspect} not to match #{typespec.inspect}"
   end
 
+  describe '.typespec' do
+    # TODO: we include Mal in this spec as is, so we might need to make another file
+    it 'allows shorthand typespecs to be created'
+  end
+  
+  describe 'Anything()' do
+    it 'provides a good inspect' do
+      expect(Anything().inspect).to eq('Anything()')
+    end
+    
+    it 'matches anything' do
+      expect_match_of(Anything(), 0)
+      expect_match_of(Anything(), self)
+      expect_match_of(Anything(), true)
+      expect_match_of(Anything(), nil)
+    end
+    
+    it 'ORs to itself' do
+      m = Anything() | Bool()
+      expect(m.inspect).to eq('Anything()')
+    end
+
+    it 'ANDs to the right operand' do
+      m = Anything() & Bool()
+      expect(m.inspect).to eq('Bool()')
+    end
+  end
+  
   describe 'Nil()' do
     it 'provides a good inspect' do
       expect(Nil().inspect).to eq('Nil()')
@@ -24,6 +52,20 @@ describe 'Mal' do
       expect_no_match_of(Nil(), Object.new)
       expect_no_match_of(Nil(), self)
     end
+    
+    it 'ORs to a Maybe of Nil() and Bool()' do
+      m = Nil() | Bool()
+      expect(m.inspect).to eq('Maybe(Bool())')
+      expect_match_of(m, nil)
+      expect_match_of(m, true)
+      expect_match_of(m, false)
+      expect_no_match_of(m, 0)
+    end
+    
+    it 'ANDs to a Both()' do
+      m = Nil() & Bool()
+      expect(m.inspect).to eq('Both(Nil(), Bool())')
+    end
   end
 
   describe 'Bool()' do
@@ -39,6 +81,21 @@ describe 'Mal' do
       expect_no_match_of(Bool(), 'hello world')
       expect_no_match_of(Bool(), 123)
     end
+    
+    it 'ORs to a an Either()' do
+      m = Bool() | Fixnum
+      expect(m.inspect).to eq('Either(Bool(), Fixnum)')
+      expect_match_of(m, true)
+      expect_match_of(m, false)
+      expect_match_of(m, 12)
+      expect_no_match_of(m, 'hello world')
+      expect_no_match_of(m, [])
+    end
+    
+    it 'ANDs to a Both()' do
+      m = Bool() & TrueClass
+      expect(m.inspect).to eq('Both(Bool(), TrueClass)')
+    end
   end
   
   describe 'Either()' do
@@ -54,6 +111,31 @@ describe 'Mal' do
       expect_no_match_of(m, nil)
       expect_no_match_of(m, self)
     end
+    
+    it 'ORs to a union Either()' do
+      m = Either(Fixnum, TrueClass) | Anything()
+      expect(m.inspect).to eq('Either(Fixnum, TrueClass, Anything())')
+      expect_match_of(m, true)
+      expect_match_of(m, false)
+      expect_match_of(m, 12)
+      expect_match_of(m, 'hello world')
+      expect_match_of(m, [])
+    end
+    
+    it 'ORs to a union of two Either() types' do
+      m = Either(Fixnum, TrueClass) | Either(Fixnum, FalseClass)
+      expect(m.inspect).to eq('Either(Fixnum, TrueClass, FalseClass)')
+      expect_match_of(m, true)
+      expect_match_of(m, false)
+      expect_match_of(m, 12)
+      expect_no_match_of(m, 'hello world')
+      expect_no_match_of(m, [])
+    end
+    
+    it 'ANDs to a Both()' do
+      m = Either(Fixnum, TrueClass) & TrueClass
+      expect(m.inspect).to eq('Both(Either(Fixnum, TrueClass), TrueClass)')
+    end
   end
 
   describe 'Maybe()' do
@@ -68,6 +150,16 @@ describe 'Mal' do
       expect_no_match_of(m, false)
       expect_no_match_of(m, self)
     end
+    
+    it 'ORs to an Either()' do
+      m = Maybe(String) | Fixnum
+      expect(m.inspect).to eq('Either(NilClass, String, Fixnum)')
+    end
+    
+    it 'ANDs to a Both()' do
+      m = Maybe(String) & TrueClass
+      expect(m.inspect).to eq('Both(Maybe(String), TrueClass)')
+    end
   end
   
   describe 'ArrayOf()' do
@@ -97,6 +189,19 @@ describe 'Mal' do
       expect_no_match_of(m, [true, false, 1, 'foo'])
       expect_match_of(m, [true, false, 1])
     end
+    
+    it 'ORs to an Either()' do
+      m = ArrayOf(String) | ArrayOf(Fixnum)
+      expect(m.inspect).to eq('Either(ArrayOf(String), ArrayOf(Fixnum))')
+      expect_match_of(m, ['a', 'b', 'c'])
+      expect_match_of(m, [1, 2, 3])
+      expect_no_match_of(m, ['a', 2, 3])
+    end
+    
+    it 'ANDs to a Both()' do
+      m = ArrayOf(Maybe(String)) & ArrayOf(String)
+      expect(m.inspect).to eq('Both(ArrayOf(Maybe(String)), ArrayOf(String))')
+    end
   end
 
   describe 'Both()' do
@@ -110,6 +215,30 @@ describe 'Mal' do
       expect_match_of(m, 'this is an abc string')
       expect_no_match_of(m, 'this is a string that does match the second parameter')
     end
+    
+    it 'ORs to an Either()' do
+      m = Both(String, /hello/) | Fixnum
+      expect(m.inspect).to eq('Either(Both(String, /hello/), Fixnum)')
+      expect_match_of(m, 'hello')
+      expect_no_match_of(m, 'goodbye')
+      expect_match_of(m, 123)
+    end
+
+    it 'ANDs to a Both()' do
+      m = Both(String, /hello/) & Maybe(Fixnum)
+      expect(m.inspect).to eq('Both(Both(String, /hello/), Maybe(Fixnum))')
+      expect_no_match_of(m, 'hello')
+      expect_no_match_of(m, 'goodbye')
+      expect_no_match_of(m, 123)
+    end
+
+    it 'ANDs to a flattened Both() if the right hand operand is also a Both' do
+      m = Both(String, /hello/) & Both(String, /he/)
+      expect(m.inspect).to eq('Both(String, /hello/, /he/)')
+      expect_match_of(m, 'hello')
+      expect_no_match_of(m, 'goodbye')
+      expect_no_match_of(m, 123)
+    end
   end
 
   describe 'HashWith()' do
@@ -145,8 +274,75 @@ describe 'Mal' do
       m = HashWith(name: String)
       expect_match_of(m, {name: 'John Doe', age: 21})
     end
+    
+    it 'ORs to an Either()' do
+      m = HashWith(name: String) | HashWith(first_name: String, last_name: String)
+      expect(m.inspect).to eq('Either(HashWith(:name=>String), HashWith(:first_name=>String, :last_name=>String))')
+      expect_match_of(m, {name: 'Jane'})
+      expect_match_of(m, {first_name: 'Jane', last_name: 'Doe'})
+      expect_match_of(m, {name: 'Jane', first_name: 'Jane', last_name: 'Doe'})
+    end
+    
+    it 'ANDs to a Both' do
+      m = Both(HashWith(name: Anything()), HashWith(age: Anything()))
+      expect(m.inspect).to eq('Both(HashWith(:name=>Anything()), HashWith(:age=>Anything()))')
+      expect_match_of(m, {name: nil, age: 12})
+      expect_no_match_of(m, {name: 'Jane'})
+      expect_no_match_of(m, {age: 21})
+    end
   end
-  
+
+  describe 'HashPermitting()' do
+    it 'provides a good inspect' do
+      m = HashPermitting(foo: Maybe(Fixnum))
+      expect(m.inspect).to eq("HashPermitting(:foo=>Maybe(Fixnum))")
+    end
+    
+    it 'does not match other types' do
+      m = HashPermitting(foo: Symbol)
+      expect_no_match_of(m, nil)
+      expect_no_match_of(m, [])
+      expect_no_match_of(m, self)
+    end
+    
+    it 'does match an empty Hash when asked to' do
+      m = HashPermitting({})
+      expect_match_of(m, {})
+    end
+    
+    it 'does not match a Hash whose value does not satisfy the matcher' do
+      m = HashPermitting(some_key: Nil())
+      expect_no_match_of(m, {some_key: true})
+    end
+    
+    it 'does match a Hash whose keys/values do satisfy the matcher' do
+      m = HashPermitting(some_key: Maybe(String))
+      expect_match_of(m, {some_key: nil})
+      expect_match_of(m, {some_key: 'hello world'})
+    end
+
+    it 'does not match a Hash that has more keys than requested' do
+      m = HashPermitting(name: String)
+      expect_no_match_of(m, {name: 'John Doe', age: 21})
+    end
+    
+    it 'ORs to an Either()' do
+      m = HashPermitting(name: String) | HashPermitting(first_name: String, last_name: String)
+      expect(m.inspect).to eq('Either(HashPermitting(:name=>String), HashPermitting(:first_name=>String, :last_name=>String))')
+      expect_match_of(m, {name: 'Jane'})
+      expect_match_of(m, {first_name: 'Jane', last_name: 'Doe'})
+      expect_no_match_of(m, {name: 'Jane', first_name: 'Jane', last_name: 'Doe'})
+    end
+    
+    it 'ANDs to a Both' do
+      m = Both(HashPermitting(name: Anything()), HashPermitting(name: Anything(), age: Anything()))
+      expect(m.inspect).to eq('Both(HashPermitting(:name=>Anything()), HashPermitting(:name=>Anything(), :age=>Anything()))')
+      expect_no_match_of(m, {name: nil, age: 12})
+      expect_no_match_of(m, {name: 'Jane'})
+      expect_no_match_of(m, {age: 21})
+    end
+  end
+
   describe 'HashOf()' do
     it 'provides a good inspect' do
       m = HashOf(foo: Maybe(Fixnum))
@@ -180,6 +376,14 @@ describe 'Mal' do
       m = HashOf(name: String)
       expect_no_match_of(m, {name: 'John Doe', age: 21})
     end
+    
+    it 'ORs to an Either()' do
+      m = HashOf(name: String) | HashOf(first_name: String, last_name: String)
+      expect(m.inspect).to eq('Either(HashOf(:name=>String), HashOf(:first_name=>String, :last_name=>String))')
+      expect_match_of(m, {name: 'Jane'})
+      expect_match_of(m, {first_name: 'Jane', last_name: 'Doe'})
+      expect_no_match_of(m, {name: 'Jane', first_name: 'Jane', last_name: 'Doe'})
+    end
   end
   
   describe 'HashOf with complex nested matchers' do
@@ -229,5 +433,91 @@ describe 'Mal' do
       expect_match_of(Anything(), true)
       expect_match_of(Anything(), false)
     end
+    
+    it 'ANDs to the right hand operand' do
+      m = Anything() & Bool()
+      expect(m.inspect).to eq('Bool()')
+    end
+  end
+
+  describe 'ObjectWith()' do
+    it 'has a reasonable inspect' do
+      expect(ObjectWith(:upcase, :downcase).inspect).to eq('ObjectWith(:upcase, :downcase)')
+    end
+    
+    it 'matches only objects that respond to the methods defined' do
+      m = ObjectWith(:upcase, :downcase)
+      only_downcase = Struct.new(:downcase).new('nope')
+      only_upcase = Struct.new(:upcase).new('nope')
+      both = Struct.new(:upcase, :downcase).new('A', 'a')
+      
+      expect_match_of(m, 'foo')
+      expect_match_of(m, both)
+      expect_no_match_of(m, only_downcase)
+      expect_no_match_of(m, only_upcase)
+    end
+    
+    it 'ORs to a Both' do
+      m = ObjectWith(:upcase) | Nil()
+      
+      expect(m.inspect).to eq('Either(ObjectWith(:upcase), Nil())')
+    end
+    
+    it 'ANDs to a single ObjectWith' do
+      m = ObjectWith(:upcase) & ObjectWith(:downcase)
+      
+      expect(m.inspect).to eq('ObjectWith(:upcase, :downcase)')
+      
+      only_downcase = Struct.new(:downcase).new('nope')
+      only_upcase = Struct.new(:upcase).new('nope')
+      both = Struct.new(:upcase, :downcase).new('A', 'a')
+      
+      expect_match_of(m, 'foo')
+      expect_match_of(m, both)
+      expect_no_match_of(m, only_downcase)
+      expect_no_match_of(m, only_upcase)
+    end
+  end
+  
+  describe 'Value()' do
+    it 'provides a good inspect' do
+      expect(Value('ohai').inspect).to eq('Value("ohai")')
+    end
+    
+    it 'matches only the exact value given' do
+      expect_match_of(Value(8), 8)
+      expect_no_match_of(Value(8), 4)
+      expect_no_match_of(Value(8), {})
+      expect_no_match_of(Value(:ohai), {})
+    end
+    
+    it 'ORs to an Either' do
+      m = Value(7) | Value(5)
+      expect(m.inspect).to eq('Either(Value(7), Value(5))')
+    end
+
+    it 'ANDs to the right operand' do
+      m = Value(10) & Value(2)
+      expect(m.inspect).to eq('Both(Value(10), Value(2))')
+    end
+  end
+
+  describe 'CoveredBy()' do
+    it 'provides a good inspect' do
+      expect(CoveredBy(1..4).inspect).to eq('CoveredBy(1..4)')
+    end
+
+    it 'matches values covered by the Range' do
+      m = CoveredBy(1..4)
+      expect_match_of(m, 1)
+      expect_match_of(m, 2)
+      expect_match_of(m, 3)
+      expect_match_of(m, 4)
+
+      expect_no_match_of(m, 0)
+      expect_no_match_of(m, 5)
+      expect_no_match_of(m, 'Ohai')
+      expect_no_match_of(m, nil)
+    end
   end
 end

data/spec/spec_helper.rb

@@ -5,5 +5,7 @@ RSpec.configure do |config|
 end
 
 require 'simplecov'
-SimpleCov.start
+SimpleCov.start do
+  add_filter "/spec/"
+end
 require_relative '../lib/mal'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mal
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Julik Tarkhanov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-16 00:00:00.000000000 Z
+date: 2016-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -96,6 +96,7 @@ files:
 - Rakefile
 - lib/mal.rb
 - mal.gemspec
+- spec/mal_external_eval_spec.rb
 - spec/mal_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/julik/mal