oval 0.0.1

data/lib/oval.rb

@@ -0,0 +1,18 @@
+module Oval
+  require 'oval/anything'
+  require 'oval/collection'
+  require 'oval/instance_of'
+  require 'oval/kind_of'
+  require 'oval/one_of'
+  require 'oval/options'
+  require 'oval/subclass_of'
+
+
+  def ov_anything; Oval::Anything; end
+  def ov_collection; Oval::Collection; end
+  def ov_instance_of; Oval::InstanceOf; end
+  def ov_kind_of; Oval::KindOf; end
+  def ov_one_of; Oval::OneOf; end
+  def ov_options; Oval::Options; end
+  def ov_subclass_of; Oval::SubclassOf; end
+end

data/lib/oval/anything.rb

@@ -0,0 +1,12 @@
+require 'oval/base'
+
+# Describe value that is arbitrary.
+class Oval::Anything < Oval::Base
+  class << self
+    def instance; @instance ||= new; end
+    def []; instance; end
+    private :new
+  end
+  def validate(x,subject=nil); end
+  def initialize(); end
+end

data/lib/oval/array_item.rb

@@ -0,0 +1,25 @@
+require 'oval/base'
+
+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)
+  end
+
+  def self.[](item_decl)
+    new(item_decl)
+  end
+
+  def initialize(item_decl)
+    self.item_decl = item_decl
+  end
+
+  attr_reader :item_decl
+
+  protected
+
+  def item_decl=(decl)
+    @item_decl = decl
+  end
+end

data/lib/oval/base.rb

@@ -0,0 +1,58 @@
+module Oval; end
+
+class Oval::DeclError < ArgumentError; end
+class Oval::ValueError < ArgumentError; end
+
+class Oval::Base
+
+  def self.ensure_equal(thing, decl, subject = nil)
+    unless (decl == Oval::Anything) or (thing == decl)
+      raise Oval::ValueError,
+        "Invalid value #{thing.inspect}#{for_subject(subject)}. Should be " +
+        "equal #{decl.inspect}"
+    end
+  end
+
+  def self.ensure_match(thing, decl, subject = nil)
+    if decl.is_a? Oval::Base
+      decl.validate(thing,subject)
+    else
+      # "terminal symbol"
+      ensure_equal(thing, decl, subject)
+    end
+  end
+
+  def self.[](*args)#,subject = default_subject)
+    return new(*args)
+  end
+
+  def validate(value, subject = nil)
+    raise NotImplementedError, "This method should be overwritten by a subclass"
+  end
+
+  def initialize(*args)
+  end
+
+  protected
+
+  def self.for_subject(subject)
+    subject ? " for #{subject}" : ""
+  end
+
+  def for_subject(subject)
+    self.class.for_subject(subject)
+  end
+
+  def self.enumerate(items,op)
+    return 'none' if items.empty?
+    output = items[0..-2].map{|k| k.inspect}.join(', ')
+    output.empty? ? items[0].inspect : [output, items[-1].inspect].join(" #{op} ")
+  end
+
+  def enumerate(items,op)
+    self.class.enumerate(items,op)
+  end
+
+end
+
+require 'oval/anything'

data/lib/oval/class_decl_base.rb

@@ -0,0 +1,27 @@
+require 'oval/base'
+class Oval::ClassDeclBase < Oval::Base
+  attr_reader :klass
+  def self.[](klass)
+    new(klass)
+  end
+
+  def initialize(klass)
+    self.klass = klass
+  end
+
+  protected
+  def klass=(k)
+    validate_class(k)
+    @klass = k
+  end
+
+  def self.myname; 'ClassDeclBase'; end
+
+  def validate_class(klass)
+    unless klass.is_a?(Class)
+      subject = self.class.name.sub(/^.*::/,'')
+      raise Oval::DeclError,
+        "Invalid class #{klass.inspect}#{for_subject(subject)}"
+    end
+  end
+end

data/lib/oval/collection.rb

@@ -0,0 +1,125 @@
+require 'oval/base'
+require 'oval/anything'
+require 'oval/subclass_of'
+require 'oval/array_item'
+require 'oval/hash_item'
+
+# Declare container (e.g. array or hash).
+#
+# **Example 1**: Desclare array of arbitrary elements:
+#
+# ```ruby
+# Collection[Array]
+# ```
+#
+# or
+#
+# ```ruby
+# Collection[Array,Anything[]]
+# ```
+#
+# or
+#
+# ```ruby
+# Collection[InstanceOf[Array],Anything[]]
+# ```
+#
+# **Example 2**: Declare Array of Strings:
+#
+# ```ruby
+# Collection[Array,InstanceOf[String]]
+# ```
+#
+# **Example 3**: Desclare any Hash:
+#
+# ```ruby
+# Collection[Hash]
+# ```
+#
+# **Example 4**: Desclare Hash with Symbol keys and Fixnum values
+#
+# ```ruby
+# Collection[Hash,{Symbol => Fixnum}]
+# ```
+#
+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)
+    i = 0
+    collection.each { |item| item_validator.validate(item, i, subject); i+= 1}
+  end
+
+  def self.[](class_decl,item_decl = Oval::Anything[])
+    new(class_decl,item_decl)
+  end
+
+  def initialize(class_decl, item_decl = Oval::Anything[])
+    self.class_decl = class_decl
+    self.item_decl = item_decl
+  end
+
+  def self.klass(class_decl)
+    class_decl.is_a?(Oval::SubclassOf) ? class_decl.klass : class_decl
+  end
+
+  def klass
+    self.class.klass(class_decl)
+  end
+
+  attr_reader :class_decl
+  attr_reader :item_decl
+  attr_reader :class_validator
+  attr_reader :item_validator
+
+  protected
+
+  def class_decl=(decl)
+    self.class.validate_class_decl(decl)
+    @class_decl = decl
+  end
+
+  def item_decl=(decl)
+    bind_item_validator(decl)
+    @item_decl = decl
+  end
+
+  def bind_item_validator(item_decl)
+    @item_validator = select_item_validator[item_decl]
+  end
+
+  def select_class_validator
+    if klass.is_a?(Class) and klass <= Hash
+      Oval::HashClass
+    elsif klass.is_a?(Class) and klass <= Array
+      Oval::ArrayClass
+    else
+      # well, we also may have klass that is not a class, but I'm too lazy to
+      # handle all possible exceptions,
+      raise RuntimeError, "Invalid class #{klass.inspect} assigned to klass. " +
+        "It seems like we have a bug in #{self.class.name}"
+    end
+  end
+
+  def select_item_validator
+    if klass.is_a?(Class) and klass <= Hash
+      Oval::HashItem
+    elsif klass.is_a?(Class) and klass <= Array
+      Oval::ArrayItem
+    else
+      # well, we also may have klass that is not a class, but I'm too lazy to
+      # handle all possible exceptions,
+      raise RuntimeError, "Invalid class #{klass.inspect} assigned to klass. " +
+        "It seems like we have a bug in #{self.class.name}"
+    end
+  end
+
+  def self.validate_class_decl(decl)
+    klass = self.klass(decl)
+    unless klass.is_a?(Class) and ((klass<=Hash) or (klass<=Array))
+      raise Oval::DeclError, "Invalid collection class declarator " +
+        "#{decl.inspect}. Should be a (subclass of) Hash or Array"
+    end
+  end
+end

data/lib/oval/hash_item.rb

@@ -0,0 +1,41 @@
+require 'oval/base'
+require 'oval/anything'
+
+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)
+  end
+
+  def self.[](item_decl)
+    new(item_decl)
+  end
+
+  def initialize(item_decl)
+    self.item_decl = item_decl
+  end
+
+  attr_reader :key_decl
+  attr_reader :val_decl
+
+  def self.validate_item_decl(decl)
+    unless (decl.is_a?(Hash) and decl.size == 1)
+      raise Oval::DeclError, "Invalid item declaration #{decl.inspect}. " +
+        "Should be one-element Hash of type { key_decl => value_decl }"
+    end
+  end
+
+  private
+
+  def item_decl=(decl)
+    if decl.is_a?(Oval::Anything) or (decl.is_a?(Class) and decl == Oval::Anything)
+      @key_decl, @val_decl = [Oval::Anything[], Oval::Anything[]]
+    else
+      self.class.validate_item_decl(decl)
+      @key_decl, @val_decl = decl.first
+    end
+  end
+end

data/lib/oval/instance_of.rb

@@ -0,0 +1,11 @@
+require 'oval/class_decl_base'
+
+class Oval::InstanceOf < Oval::ClassDeclBase
+  def validate(object, subject = nil)
+    unless object.instance_of?(klass)
+      raise Oval::ValueError,
+        "Invalid object #{object.inspect} of type #{object.class.name}" +
+        "#{for_subject(subject)}. Should be an instance of #{klass.name}"
+    end
+  end
+end

data/lib/oval/kind_of.rb

@@ -0,0 +1,11 @@
+require 'oval/class_decl_base'
+
+class Oval::KindOf < Oval::ClassDeclBase
+  def validate(object, subject = nil)
+    unless object.kind_of?(klass)
+      raise Oval::ValueError,
+        "Invalid object #{object.inspect} of type #{object.class.name}" +
+        "#{for_subject(subject)}. Should be a kind of #{klass.name}"
+    end
+  end
+end

data/lib/oval/one_of.rb

@@ -0,0 +1,36 @@
+require 'oval/base'
+
+# Describe a value that must match one of the shapes.
+#
+# **Example 1**: Value must be an Array or nil
+#
+# ```ruby
+# OneOf[Container[Array], nil]
+# ```
+class Oval::OneOf < Oval::Base
+  def validate(thing, subject = nil)
+    ok = false
+    self.decls.each do |decl|
+      begin
+        self.class.ensure_match(thing, decl)
+        ok = true
+        break
+      rescue Oval::ValueError
+      end
+    end
+    unless ok
+      raise Oval::ValueError, "Invalid value #{thing.inspect}#{for_subject(subject)}"
+    end
+  end
+
+  def initialize(*decls)
+    self.decls = decls
+  end
+
+  attr_reader :decls
+
+  private
+  def decls=(decls)
+    @decls = decls
+  end
+end

data/lib/oval/options.rb

@@ -0,0 +1,61 @@
+require 'oval/base'
+
+class Oval::Options < Oval::Base
+  def validate(options, subject = nil)
+    unless options.is_a?(Hash)
+      raise Oval::ValueError,
+        "Invalid options #{options.inspect} of type #{options.class.name}. " +
+        "Should be a Hash"
+    end
+    options.each {|name, value| validate_option(name, value, subject) }
+  end
+
+  def initialize(decl)
+    self.decl = decl
+  end
+
+  attr_reader :decl
+
+  protected
+
+  def decl=(decl)
+    self.class.validate_decl(decl)
+    @decl = decl
+  end
+
+  def validate_option(name, value, subject = nil)
+    validate_option_name(name, subject)
+    validate_option_value(value, name, subject)
+  end
+
+  def validate_option_name(name, subject = nil)
+    unless decl.include?(name)
+      allowed = enumerate(decl.keys.sort{|x,y| x.to_s <=> y.to_s}, 'and')
+      raise Oval::ValueError,
+        "Invalid option #{name.inspect}#{for_subject(subject)}. Allowed " +
+        "options are #{allowed}"
+    end
+  end
+
+  def validate_option_value(value, name, subject = nil)
+    subject = "#{subject}[#{name.inspect}]" if subject
+    self.class.ensure_match(value, decl[name], subject)
+  end
+
+  def self.validate_decl(decl)
+    unless decl.is_a?(Hash)
+      raise Oval::DeclError,
+        "Invalid declaration #{decl.inspect} of type #{decl.class.name}. " +
+        "Should be a Hash"
+    end
+    decl.each {|optname,optdecl| validate_option_name_decl(optname) }
+  end
+
+  def self.validate_option_name_decl(optname)
+    unless optname.respond_to?(:to_s)
+      raise Oval::DeclError,
+        "Invalid name #{optname.inspect}. Should be convertible to String"
+    end
+  end
+
+end

data/lib/oval/subclass_of.rb

@@ -0,0 +1,11 @@
+require 'oval/class_decl_base'
+
+class Oval::SubclassOf < Oval::ClassDeclBase
+  def validate(thing, subject = nil)
+    unless thing.is_a?(Class) and (thing < self.klass)
+      raise Oval::ValueError,
+        "Invalid class #{thing.inspect}#{for_subject(subject)}. " +
+        "Should be subclass of #{klass.name}"
+    end
+  end
+end