oval 0.0.4 → 0.0.5

data/CHANGELOG

@@ -1,4 +1,9 @@
 2014-02-03 Pawel Tomulik <ptomulik@meil.pw.edu.pl>
+  * release 0.0.5
+  * refactored ensure_match -> validate
+  * added Oval::Match declarator
+  * fixed error message in OneOf to be more verbose
+  * added it_should method to declarators
   * release 0.0.4
 2014-02-02 Pawel Tomulik <ptomulik@meil.pw.edu.pl>
   * corrections to README.md

data/Modulefile

@@ -1,5 +1,5 @@
 name    'ptomulik-oval'
-version '0.0.4'
+version '0.0.5'
 source 'git://github.com/ptomulik/rubygems-oval.git'
 author 'ptomulik'
 license 'Apache License, Version 2.0'

data/README.md

@@ -248,6 +248,26 @@ document all the core non-terminal declarators implemented in **Oval**.
   end
   ```
   
+####<a id="ov\_match"></a>ov\_match                                       
+
+- Declaration
+
+  ```ruby
+  ov_match[re]
+  ```
+  
+- Validation - permits only values matching regular expression **re**,
+- Allowed values for **re** - must be a kind of `Regexp`.
+- Example
+
+  ```ruby
+  # Only valid identifiers are allowed as :bar option
+  ov = ov_options[ :bar => ov_match[/^[a-z_]\w+$/] ]
+  def foo(ops = {})
+    ov.validate(ops,'ops')
+  end
+  ```
+  
 ####<a id="ov\_one\_of"></a>ov\_one\_of   
 
 - Declaration

data/lib/oval.rb

@@ -3,6 +3,7 @@ module Oval
   require 'oval/collection'
   require 'oval/instance_of'
   require 'oval/kind_of'
+  require 'oval/match'
   require 'oval/one_of'
   require 'oval/options'
   require 'oval/subclass_of'
@@ -12,7 +13,13 @@ module Oval
   def ov_collection; Oval::Collection; end
   def ov_instance_of; Oval::InstanceOf; end
   def ov_kind_of; Oval::KindOf; end
+  def ov_match; Oval::Match; end
   def ov_one_of; Oval::OneOf; end
   def ov_options; Oval::Options; end
   def ov_subclass_of; Oval::SubclassOf; end
+
+  module_function
+  def validate(thing, decl, subject = nil)
+    Oval::Base.validate(thing, decl, subject)
+  end
 end

data/lib/oval/anything.rb

@@ -8,5 +8,6 @@ class Oval::Anything < Oval::Base
     private :new
   end
   def validate(x,subject=nil); end
+  def it_should; "be anything"; end
   def initialize(); end
 end

data/lib/oval/array_item.rb

@@ -4,7 +4,11 @@ class Oval::ArrayItem < Oval::Base
 
   def validate(item, i, subject = nil)
     item_subject = subject.nil? ? nil : "#{subject}[#{i}]"
-    self.class.ensure_match(item,item_decl,item_subject)
+    self.class.validate(item,item_decl,item_subject)
+  end
+
+  def it_should
+    self.class.it_should(item_decl)
   end
 
   def self.[](item_decl)

data/lib/oval/base.rb

@@ -13,7 +13,7 @@ class Oval::Base
     end
   end
 
-  def self.ensure_match(thing, decl, subject = nil)
+  def self.validate(thing, decl, subject = nil)
     if decl.is_a? Oval::Base
       decl.validate(thing,subject)
     else
@@ -22,6 +22,17 @@ class Oval::Base
     end
   end
 
+  def self.it_should(decl)
+    if decl.is_a? Oval::Base
+      decl.it_should
+    elsif decl == Oval::Anything
+      Oval::Anything[].it_should
+    else
+      # "terminal symbol"
+      "be equal #{decl.inspect}"
+    end
+  end
+
   def self.[](*args)#,subject = default_subject)
     return new(*args)
   end
@@ -30,6 +41,10 @@ class Oval::Base
     raise NotImplementedError, "This method should be overwritten by a subclass"
   end
 
+  def it_should()
+    raise NotImplementedError, "This method should be overwritten by a subclass"
+  end
+
   def initialize(*args)
   end
 

data/lib/oval/collection.rb

@@ -43,14 +43,17 @@ require 'oval/hash_item'
 # ```
 #
 class Oval::Collection < Oval::Base
-
   def validate(collection, subject = nil)
     class_subject = subject.nil? ? nil : "#{subject}.class"
-    self.class.ensure_match(collection.class, class_decl, class_subject)
+    self.class.validate(collection.class, class_decl, class_subject)
     i = 0
     collection.each { |item| item_validator.validate(item, i, subject); i+= 1}
   end
 
+  def it_should
+    "be #{klass} whose item should #{self.class.it_should(item_validator)}"
+  end
+
   def self.[](class_decl,item_decl = Oval::Anything[])
     new(class_decl,item_decl)
   end

data/lib/oval/hash_item.rb

@@ -6,8 +6,13 @@ class Oval::HashItem < Oval::Base
   def validate(item, i, subject = nil)
     key_subject = subject.nil? ? nil: "#{subject} key"
     val_subject = subject.nil? ? nil: "#{subject}[#{item[0].inspect}]"
-    self.class.ensure_match(item[0],key_decl,key_subject)
-    self.class.ensure_match(item[1],val_decl,val_subject)
+    self.class.validate(item[0],key_decl,key_subject)
+    self.class.validate(item[1],val_decl,val_subject)
+  end
+
+  def it_should
+    "be {key => value} where key should #{self.class.it_should(key_decl)} " +
+    "and value should #{self.class.it_should(val_decl)}"
   end
 
   def self.[](item_decl)

data/lib/oval/instance_of.rb

@@ -8,4 +8,7 @@ class Oval::InstanceOf < Oval::ClassDeclBase
         "#{for_subject(subject)}. Should be an instance of #{klass.name}"
     end
   end
+  def it_should
+    "be an instance of #{klass.name}"
+  end
 end

data/lib/oval/kind_of.rb

@@ -8,4 +8,7 @@ class Oval::KindOf < Oval::ClassDeclBase
         "#{for_subject(subject)}. Should be a kind of #{klass.name}"
     end
   end
+  def it_should
+    "be a kind of #{klass.name}"
+  end
 end

data/lib/oval/match.rb

@@ -0,0 +1,40 @@
+require 'oval/base'
+
+class Oval::Match < Oval::Base
+
+  def validate(thing, subject = nil)
+    unless re.match(thing)
+      raise Oval::ValueError,
+        "Invalid value #{thing.inspect}#{for_subject(subject)}. " +
+        "Should #{it_should}"
+    end
+  end
+
+  def it_should
+    "match #{re.inspect}"
+  end
+
+  def self.[](re)
+    new(re)
+  end
+
+  def initialize(re)
+    self.re = re
+  end
+
+  attr_reader :re
+
+  private
+
+  def re=(re)
+    self.class.validate_re(re)
+    @re = re
+  end
+
+  def self.validate_re(re)
+    unless re.is_a?(Regexp)
+      raise Oval::DeclError, "Invalid regular expression #{re.inspect}. " +
+        "Should be an instance of Regexp"
+    end
+  end
+end

data/lib/oval/one_of.rb

@@ -12,14 +12,26 @@ class Oval::OneOf < Oval::Base
     ok = false
     self.decls.each do |decl|
       begin
-        self.class.ensure_match(thing, decl)
+        self.class.validate(thing, decl)
         ok = true
         break
       rescue Oval::ValueError
       end
     end
     unless ok
-      raise Oval::ValueError, "Invalid value #{thing.inspect}#{for_subject(subject)}"
+      raise Oval::ValueError,
+        "Invalid value #{thing.inspect}#{for_subject(subject)}. " +
+        "Should #{self.it_should}"
+    end
+  end
+
+  def it_should
+    if decls.empty?
+      "be absent"
+    else
+      output = decls[0..-2].map{|k| self.class.it_should(k)}.join(', ')
+      output.empty? ? self.class.it_should(decls[0]) :
+                      [output, self.class.it_should(decls[-1])].join(' or ')
     end
   end
 

data/lib/oval/options.rb

@@ -39,7 +39,7 @@ class Oval::Options < Oval::Base
 
   def validate_option_value(value, name, subject = nil)
     subject = "#{subject}[#{name.inspect}]" if subject
-    self.class.ensure_match(value, decl[name], subject)
+    self.class.validate(value, decl[name], subject)
   end
 
   def self.validate_decl(decl)

data/lib/oval/subclass_of.rb

@@ -8,4 +8,7 @@ class Oval::SubclassOf < Oval::ClassDeclBase
         "Should be subclass of #{klass.name}"
     end
   end
+  def it_should
+    "be a subclass of #{klass.name}"
+  end
 end

data/oval.gemspec

@@ -3,7 +3,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |gem|
   gem.name          = 'oval'
-  gem.version       = '0.0.4'
+  gem.version       = '0.0.5'
   gem.authors       = ["Pawel Tomulik"]
   gem.email         = ["ptomulik@meil.pw.edu.pl"]
   gem.description   = %q{Validate options when passed to methods}

data/spec/unit/oval/anything_spec.rb

@@ -2,26 +2,36 @@ require 'spec_helper'
 require 'oval/anything'
 describe Oval::Anything do
   let(:subject) { described_class.instance }
+
+  it "should be subclass of Oval::Base" do
+    described_class.should < Oval::Base
+  end
+
   context 'the class' do
     it { described_class.should respond_to :instance }
     it { described_class.should respond_to :[] }
     it { described_class.should_not respond_to :new }
   end
+
   context 'an instance' do
     it { should respond_to :validate }
+    it { should respond_to :it_should }
   end
+
   describe "instance (i.e. class method called instance)" do
     it "should return singleton" do
       previous = described_class.instance
       described_class.instance.should be previous
     end
   end
+
   describe "[]" do
     it "should == #{described_class}.instance" do
       described_class.stubs(:instance).once.with().returns :ok
       described_class[].should be :ok
     end
   end
+
   describe "#validate" do
     # It should accept anything, which is quite hard to test, so I put here
     # some random stuff ...
@@ -35,4 +45,8 @@ describe Oval::Anything do
       end
     end
   end
+
+  describe "#it_should" do
+    its(:it_should) { should == "be anything" }
+  end
 end

data/spec/unit/oval/array_item_spec.rb

@@ -1,14 +1,20 @@
-require 'spec_helper.rb'
-require 'oval/array_item.rb'
+require 'spec_helper'
+require 'oval/array_item'
 
 describe Oval::ArrayItem do
+  it "should be subclass of Oval::Base" do
+    described_class.should < Oval::Base
+  end
+
   context 'the class' do
     it { described_class.should respond_to :[] }
   end
+
   context 'an instance' do
     let(:subject) { described_class[:item_decl0] }
     it { should respond_to :validate }
     it { should respond_to :item_decl }
+    it { should respond_to :it_should }
   end
 
   describe "[]" do
@@ -44,17 +50,39 @@ describe Oval::ArrayItem do
   describe "#validate" do
     let(:subject) { described_class[:item_decl0] }
     context "validate(:item1,0)" do
-      it 'should invoke self.class.ensure_match(:item1,:item_decl0,nil) once' do
-        described_class.expects(:ensure_match).once.with(:item1,:item_decl0,nil)
+      it 'should invoke self.class.validate(:item1,:item_decl0,nil) once' do
+        described_class.expects(:validate).once.with(:item1,:item_decl0,nil)
         subject.validate(:item1,0)
       end
     end
     context "validate(:item1,0,'foo')" do
-      it 'should invoke self.class.ensure_match(:item1,:item_decl0,"foo[0]") once' do
-        described_class.expects(:ensure_match).once.with(:item1,:item_decl0,"foo[0]")
+      it 'should invoke self.class.validate(:item1,:item_decl0,"foo[0]") once' do
+        described_class.expects(:validate).once.with(:item1,:item_decl0,"foo[0]")
         subject.validate(:item1,0,'foo')
       end
     end
   end
+
+  describe "#it_should" do
+    [
+      [:foo, "be equal :foo"],
+      [10, "be equal 10"],
+      [Class.new(Oval::Base) do
+        def it_should
+          "be a test value"
+        end
+        def inspect
+          '<Oval::Test>'
+        end
+      end.new,
+      "be a test value"]
+    ].each do |item_decl,msg|
+      context "#{described_class}[#{item_decl.inspect}].it_should" do
+        let(:item_decl) { item_decl }
+        let(:msg) { msg }
+        it { described_class[item_decl].it_should.should == msg }
+      end
+    end
+  end
 end
 

data/spec/unit/oval/base_spec.rb

@@ -5,7 +5,7 @@ describe Oval::Base do
   context "the class" do
     [
       :ensure_equal,
-      :ensure_match,
+      :validate,
       :[],
       :for_subject,
       :enumerate,
@@ -23,31 +23,31 @@ describe Oval::Base do
     end
   end
 
-  describe "ensure_match" do
-    context "ensure_match(:foo,:bar)" do
+  describe "validate" do
+    context "validate(:foo,:bar)" do
       it "should invoke ensure_equal(:foo,:bar,nil) once" do
         described_class.expects(:ensure_equal).once.with(:foo,:bar,nil)
-        expect { described_class.ensure_match(:foo,:bar) }.to_not raise_error
+        expect { described_class.validate(:foo,:bar) }.to_not raise_error
       end
     end
-    context "ensure_match(:foo,:bar,'subj1')" do
+    context "validate(:foo,:bar,'subj1')" do
       it "should invoke ensure_equal(:foo,:bar,'subj1') once" do
         described_class.expects(:ensure_equal).once.with(:foo,:bar,'subj1')
-        expect { described_class.ensure_match(:foo,:bar,'subj1') }.to_not raise_error
+        expect { described_class.validate(:foo,:bar,'subj1') }.to_not raise_error
       end
     end
-    context "ensure_match(:foo,shape)" do
+    context "validate(:foo,shape)" do
       let(:shape) { described_class[:shape0] }
       it "should invoke shape.validate(:foo,nil) once" do
         shape.expects(:validate).once.with(:foo,nil)
-        expect { described_class.ensure_match(:foo,shape) }.to_not raise_error
+        expect { described_class.validate(:foo,shape) }.to_not raise_error
       end
     end
-    context "ensure_match(:foo,shape,'subj1')" do
+    context "validate(:foo,shape,'subj1')" do
       let(:shape) { described_class[:shape0] }
       it "should invoke shape.validate(:foo,'subj1') once" do
         shape.expects(:validate).once.with(:foo,'subj1')
-        expect { described_class.ensure_match(:foo,shape,'subj1') }.to_not raise_error
+        expect { described_class.validate(:foo,shape,'subj1') }.to_not raise_error
       end
     end
   end

data/spec/unit/oval/class_decl_base_spec.rb

@@ -2,6 +2,11 @@ require 'spec_helper'
 require 'oval/class_decl_base'
 
 describe Oval::ClassDeclBase do
+
+  it "should be subclass of Oval::Base" do
+    described_class.should < Oval::Base
+  end
+
   context "the class" do
     [
       :[],
@@ -22,12 +27,6 @@ describe Oval::ClassDeclBase do
   end
 
   describe "#validate_class" do
-##    let(:subject) { described_class.new(:klass0) }
-##    before do
-##      described_class.stubs(:validate_class)
-##      subject
-##      described_class.unstub(:validate_class)
-##    end
     context "validate_class(:symbol1)" do
       let(:msg) { "Invalid class :symbol1 for ClassDeclBase" }
       it { expect { described_class.send(:validate_class,:symbol1,Oval::ClassDeclBase) }.to raise_error Oval::DeclError, msg }

data/spec/unit/oval/collection_spec.rb

@@ -5,16 +5,22 @@ require 'oval/instance_of'
 require 'oval/kind_of'
 
 describe Oval::Collection do
+  it "should be subclass of Oval::Base" do
+    described_class.should < Oval::Base
+  end
+
   describe 'the class' do
     it { described_class.should respond_to :[] }
     it { described_class.should respond_to :new }
     it { described_class.should respond_to :validate_class_decl }
   end
+
   describe 'an instance' do
     let(:subject)  { described_class[Array,nil] }
     it { should respond_to :validate }
     it { should respond_to :class_decl }
     it { should respond_to :item_decl }
+    it { should respond_to :it_should }
   end
 
   describe "[]" do
@@ -74,33 +80,6 @@ describe Oval::Collection do
     end
   end
 
-##  describe "validate_item_decl" do
-##    [
-##      [Hash, "Hash"],
-##      [Class.new(Hash), "Class.new(Hash)" ],
-##    ].each do |class_decl,class_desc|
-##      context "validate_item_decl(:decl1, #{class_desc})" do
-##        let(:class_decl) { class_decl }
-##        it "should invoke validate_hash_item_decl(:decl1) once" do
-##          described_class.stubs(:validate_hash_item_decl).once.with(:decl1)
-##          expect { described_class.validate_item_decl(:decl1,class_decl) }.to_not raise_error
-##        end
-##      end
-##    end
-##    [
-##      [Array, "Array"],
-##      [Class.new(Array), "Class.new(Array)" ],
-##    ].each do |class_decl,class_desc|
-##      context "validate_item_decl(:decl1, #{class_desc})" do
-##        let(:class_decl) { class_decl }
-##        it "should not invoke validate_hash_item_decl(:decl1)" do
-##          described_class.stubs(:validate_hash_item_decl).never
-##          expect { described_class.validate_item_decl(:decl1,class_decl) }.to_not raise_error
-##        end
-##      end
-##    end
-##  end
-
   describe "#class_decl" do
     before do
       described_class.stubs(:validate_class_decl)
@@ -254,4 +233,25 @@ describe Oval::Collection do
       end
     end
   end
+
+  describe "#it_should" do
+    [
+      [ [Array,Oval::Anything],
+        "be Array whose item should be anything" ],
+      [ [Array,nil],
+        "be Array whose item should be equal nil"],
+      [ [Array, Oval::InstanceOf[Fixnum]],
+        "be Array whose item should be an instance of Fixnum"],
+      [ [Hash, {:foo => :bar}],
+        "be Hash whose item should be {key => value} where key should be equal :foo and value should be equal :bar"],
+      [ [Hash, {Oval::InstanceOf[Symbol] => Oval::KindOf[Numeric]}],
+        "be Hash whose item should be {key => value} where key should be an instance of Symbol and value should be a kind of Numeric"],
+    ].each do |decls,msg|
+      context "#{described_class.name}[#{decls.map{|x| x.inspect}.join(', ')}].it_should" do
+        let(:decls) { decls }
+        let(:msg) { msg }
+        it { described_class[*decls].it_should.should == msg}
+      end
+    end
+  end
 end

data/spec/unit/oval/hash_item_spec.rb

@@ -4,16 +4,22 @@ require 'oval/instance_of'
 require 'oval/kind_of'
 
 describe Oval::HashItem do
+  it "should be subclass of Oval::Base" do
+    described_class.should < Oval::Base
+  end
+
   context 'the class' do
     it { described_class.should respond_to :[] }
     it { described_class.should respond_to :validate_item_decl }
   end
+
   context 'an instance' do
     let(:subject) { described_class[{:key_decl0 => :val_decl0}] }
     it { should respond_to :validate }
     it { should respond_to :key_decl }
     it { should respond_to :val_decl }
     it { subject.private_methods.map{|m| m.is_a?(Symbol) ? m : m.intern}.should include :item_decl= }
+    it { should respond_to :it_should }
   end
 
   describe "[]" do
@@ -143,4 +149,39 @@ describe Oval::HashItem do
       end
     end
   end
+
+  describe "#it_should" do
+    [
+      [{:foo => :bar}, 'be equal :foo', 'be equal :bar' ],
+      [{'x'  => 10}, 'be equal "x"', 'be equal 10' ],
+      [
+        {
+          Class.new(Oval::Base) do
+            def it_should
+              'be the test1 value'
+            end
+            def inspect
+              'Oval::Test1'
+            end
+          end.new =>
+          Class.new(Oval::Base) do
+            def it_should
+              'be the test2 value'
+            end
+            def inspect
+              'Oval::Test2'
+            end
+          end.new
+        },
+        'be the test1 value',
+        'be the test2 value',
+      ]
+    ].each do |item_decl,key_should, val_should|
+      context "#{described_class}[#{item_decl.inspect}].it_should" do
+        let(:item_decl) { item_decl }
+        let(:msg) { "be {key => value} where key should #{key_should} and value should #{val_should}" }
+        it { described_class[item_decl].it_should.should == msg }
+      end
+    end
+  end
 end

data/spec/unit/oval/instance_of_spec.rb

@@ -2,10 +2,15 @@ require 'spec_helper'
 require 'oval/instance_of'
 
 describe Oval::InstanceOf do
+  it "should be subclass of Oval::ClassDeclBase" do
+    described_class.should < Oval::ClassDeclBase
+  end
+
   describe 'an instance' do
     let(:subject)  { described_class[:klass] }
     before { described_class.stubs(:validate_class) }
     it { should respond_to :validate }
+    it { should respond_to :it_should }
   end
 
   context "#{described_class.name}[:symbol1]" do
@@ -41,4 +46,13 @@ describe Oval::InstanceOf do
       end
     end
   end
+
+  describe "#it_should" do
+    [ String, NilClass, Numeric ].each do |klass|
+      context "#{described_class.name}[#{klass.name}].it_should" do
+        let(:klass) { klass }
+        it { described_class[klass].it_should.should == "be an instance of #{klass.name}"}
+      end
+    end
+  end
 end

data/spec/unit/oval/kind_of_spec.rb

@@ -2,10 +2,15 @@ require 'spec_helper'
 require 'oval/kind_of'
 
 describe Oval::KindOf do
+  it "should be subclass of Oval::ClassDeclBase" do
+    described_class.should < Oval::ClassDeclBase
+  end
+
   describe 'an instance' do
     let(:subject)  { described_class[:klass] }
     before { described_class.stubs(:validate_class) }
     it { should respond_to :validate }
+    it { should respond_to :it_should }
   end
 
   context "#{described_class.name}[:symbol1]" do
@@ -42,4 +47,13 @@ describe Oval::KindOf do
       end
     end
   end
+
+  describe "#it_should" do
+    [ String, NilClass, Numeric ].each do |klass|
+      context "#{described_class.name}[#{klass.name}].it_should" do
+        let(:klass) { klass }
+        it { described_class[klass].it_should.should == "be a kind of #{klass.name}"}
+      end
+    end
+  end
 end

data/spec/unit/oval/match_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+require 'oval/match'
+
+describe Oval::Match do
+  it "should be subclass of Oval::Base" do
+    described_class.should < Oval::Base
+  end
+
+  context 'the class' do
+    it { described_class.should respond_to :[] }
+  end
+
+  context 'an instance' do
+    let(:subject) { described_class[:re0] }
+    before { described_class.stubs(:validate_re).with(:re0) }
+    it { should respond_to :validate }
+    it { should respond_to :re }
+    it { should respond_to :it_should }
+  end
+
+  describe "[]" do
+    context "#{described_class.name}[:re0]" do
+      it "should == new(:re0)" do
+        described_class.stubs(:new).once.with(:re0).returns :ok
+        described_class[:re0].should be :ok
+      end
+    end
+  end
+
+  describe "re" do
+    let(:subject) { described_class[:re0] }
+    before { described_class.stubs(:validate_re).with(:re0) }
+    context "#{described_class.name}[:re0].re" do
+      it { subject.re.should be :re0 }
+    end
+    context "when @re = :re1" do
+      before { subject.instance_variable_set(:@re, :re1) }
+      it { subject.re.should be :re1 }
+    end
+  end
+
+  describe "re=" do
+    let(:subject) { described_class[:re0] }
+    before { described_class.stubs(:validate_re).with(:re0) }
+    context "re = :re1" do
+      it "should invoke self.class.validate_re(:re1) once" do
+        described_class.expects(:validate_re).once.with(:re1)
+        expect { subject.send(:re=, :re1) }.to_not raise_error
+      end
+      it "should assign @re = :re1" do
+        described_class.stubs(:validate_re).with(:re1)
+        subject.send(:re=, :re1)
+        subject.instance_variable_get(:@re).should be :re1
+      end
+    end
+  end
+
+  describe "validate_re" do
+    context "#{described_class.name}.validate_re(:re1)" do
+      let(:msg) { "Invalid regular expression :re1. Should be an instance of Regexp" }
+      it { expect { described_class.validate_re(:re1) }.to raise_error Oval::DeclError, msg }
+    end
+    context "#{described_class.name}.validate_re(/^.*$/)" do
+      it { expect { described_class.validate_re(/^.*$/) }.to_not raise_error }
+    end
+  end
+
+  describe "#validate" do
+    # Valid
+    [
+      [/.*/, ['foo']],
+      [/.*/, ['foo','subj']],
+      [/^[a-z_][a-z0-9_]+/, ['_123a','subj']]
+    ].each do |re,args|
+      context "#{described_class.name}[#{re.inspect}].validate(#{args.map{|x| x.inspect}.join(', ')})" do
+        let(:re) { re }
+        let(:args) { args }
+        it { expect { described_class[re].validate(*args) }.to_not raise_error }
+      end
+    end
+    # Validation error
+    [
+      [ /^[a-z_][a-z0-9_]+/, ['5643'], "Invalid value \"5643\". Should match #{(/^[a-z_][a-z0-9_]+/).inspect}" ],
+      [ /^[a-z_][a-z0-9_]+/, ['5643','subj'], "Invalid value \"5643\" for subj. Should match #{(/^[a-z_][a-z0-9_]+/).inspect}" ],
+      [ /^[a-z_][a-z0-9_]+/, [nil,'subj'], "Invalid value nil for subj. Should match #{(/^[a-z_][a-z0-9_]+/).inspect}" ]
+    ].each do |re,args,msg|
+      context "#{described_class.name}[#{re.inspect}].validate(#{args.map{|x| x.inspect}.join(', ')})" do
+        let(:re) { re }
+        let(:args) { args }
+        let(:msg) { msg }
+        it { expect { described_class[re].validate(*args) }.to raise_error Oval::ValueError, msg }
+      end
+    end
+  end
+
+  describe "#it_should" do
+    [ //, /^.*$/, /^[a-z_][a-z0-9_]+$/].each do |re|
+      context "#{described_class}[#{re.inspect}].it_should" do
+        let(:re) { re }
+        let(:msg) { "match #{re.inspect}" }
+        it { described_class[re].it_should.should == msg }
+      end
+    end
+  end
+end

data/spec/unit/oval/one_of_spec.rb

@@ -2,11 +2,17 @@ require 'spec_helper'
 require 'oval/one_of'
 
 describe Oval::OneOf do
+  it "should be subclass of Oval::Base" do
+    described_class.should < Oval::Base
+  end
+
   context 'the class' do
     it { described_class.should respond_to :[] }
   end
+
   context 'an instance' do
     it { should respond_to :validate }
+    it { should respond_to :it_should }
     it { should respond_to :decls }
   end
 
@@ -47,9 +53,9 @@ describe Oval::OneOf do
       end
     end
     [
-      [ [:foo ], [:bar], "Invalid value :bar" ],
-      [ [:foo, :bar], [:geez], "Invalid value :geez" ],
-      [ [:foo, :bar], [:geez,'subj'], "Invalid value :geez for subj" ],
+      [ [:foo ], [:bar], "Invalid value :bar. Should be equal :foo" ],
+      [ [:foo, :bar], [:geez], "Invalid value :geez. Should be equal :foo or be equal :bar" ],
+      [ [:foo, :bar], [:geez,'subj'], "Invalid value :geez for subj. Should be equal :foo or be equal :bar" ],
     ].each do |decls,args,msg|
       context "#{described_class}[#{decls.map{|x| x.inspect}.join(', ')}].validate(#{args.map{|x| x.inspect}.join(', ')})" do
         let(:args) { args }
@@ -59,4 +65,19 @@ describe Oval::OneOf do
       end
     end
   end
+
+  describe "#it_should" do
+    [
+      [ [], "be absent" ],
+      [ [:foo], "be equal :foo"],
+      [ [:foo, :bar], "be equal :foo or be equal :bar"],
+      [ [:foo, :bar, :geez], "be equal :foo, be equal :bar or be equal :geez"],
+    ].each do |decls,msg|
+      context "#{described_class.name}[#{decls.map{|x| x.inspect}.join(', ')}].it_should" do
+        let(:decls) { decls }
+        let(:msg) { msg }
+        it { described_class[*decls].it_should.should == msg}
+      end
+    end
+  end
 end

data/spec/unit/oval/options_spec.rb

@@ -2,6 +2,10 @@ require 'spec_helper'
 require 'oval/options'
 
 describe Oval::Options do
+  it "should be subclass of Oval::Base" do
+    described_class.should < Oval::Base
+  end
+
   context "the class" do
     [
       :validate_decl,
@@ -140,8 +144,8 @@ describe Oval::Options do
         let(:subject) { described_class[decl] }
         context "validate_option_value(#{args.map{|x| x.inspect}.join(', ')})" do
           let(:name) { name }
-          it "should invoke self.class.ensure_match(#{args2.map{|x| x.inspect}.join(', ')}) once" do
-            described_class.stubs(:ensure_match).once.with(*args2)
+          it "should invoke self.class.validate(#{args2.map{|x| x.inspect}.join(', ')}) once" do
+            described_class.stubs(:validate).once.with(*args2)
             expect { subject.send(:validate_option_value,*args) }.to_not raise_error
           end
         end

data/spec/unit/oval/subclass_of_spec.rb

@@ -6,6 +6,7 @@ describe Oval::SubclassOf do
   it "should be subclass of Oval::ClassDeclBase" do
     described_class.should < Oval::ClassDeclBase
   end
+
   describe "#validate" do
     [
       [Integer,[Fixnum]],
@@ -31,4 +32,13 @@ describe Oval::SubclassOf do
       end
     end
   end
+
+  describe "#it_should" do
+    [ String, NilClass, Numeric ].each do |klass|
+      context "#{described_class.name}[#{klass.name}].it_should" do
+        let(:klass) { klass }
+        it { described_class[klass].it_should.should == "be a subclass of #{klass.name}"}
+      end
+    end
+  end
 end

data/spec/unit/oval_spec.rb

@@ -9,6 +9,7 @@ describe Oval do
     it { should respond_to :ov_collection }
     it { should respond_to :ov_instance_of }
     it { should respond_to :ov_kind_of }
+    it { should respond_to :ov_match }
     it { should respond_to :ov_one_of }
     it { should respond_to :ov_options }
     it { should respond_to :ov_subclass_of }
@@ -18,9 +19,25 @@ describe Oval do
   its(:ov_collection) { should be Oval::Collection }
   its(:ov_instance_of) { should be Oval::InstanceOf }
   its(:ov_kind_of) { should be Oval::KindOf }
+  its(:ov_match) { should be Oval::Match }
   its(:ov_one_of) { should be Oval::OneOf }
   its(:ov_options) { should be Oval::Options }
   its(:ov_subclass_of) { should be Oval::SubclassOf }
+
+  describe "validate" do
+    context "#{described_class.name}.validate(:foo,:bar)" do
+      it "should invoke Oval::Base.validate(:foo,:bar,nil) once" do
+        Oval::Base.expects(:validate).once.with(:foo,:bar,nil)
+        expect { described_class.validate(:foo,:bar) }.to_not raise_error
+      end
+    end
+    context "#{described_class.name}.validate(:foo,:bar,'subj')" do
+      it "should invoke Oval::Base.validate(:foo,:bar,'subj') once" do
+        Oval::Base.expects(:validate).once.with(:foo,:bar,'subj')
+        expect { described_class.validate(:foo,:bar,'subj') }.to_not raise_error
+      end
+    end
+  end
 end
 
 # examples from README.md and other sources

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: oval
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -168,6 +168,7 @@ files:
 - lib/oval/hash_item.rb
 - lib/oval/instance_of.rb
 - lib/oval/kind_of.rb
+- lib/oval/match.rb
 - lib/oval/one_of.rb
 - lib/oval/options.rb
 - lib/oval/subclass_of.rb
@@ -181,6 +182,7 @@ files:
 - spec/unit/oval/hash_item_spec.rb
 - spec/unit/oval/instance_of_spec.rb
 - spec/unit/oval/kind_of_spec.rb
+- spec/unit/oval/match_spec.rb
 - spec/unit/oval/one_of_spec.rb
 - spec/unit/oval/options_spec.rb
 - spec/unit/oval/subclass_of_spec.rb
@@ -200,7 +202,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1914845513131623040
+      hash: 2837400115143885778
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -209,7 +211,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1914845513131623040
+      hash: 2837400115143885778
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -228,6 +230,7 @@ test_files:
 - spec/unit/oval/hash_item_spec.rb
 - spec/unit/oval/instance_of_spec.rb
 - spec/unit/oval/kind_of_spec.rb
+- spec/unit/oval/match_spec.rb
 - spec/unit/oval/one_of_spec.rb
 - spec/unit/oval/options_spec.rb
 - spec/unit/oval/subclass_of_spec.rb