valuedate 0.0.2

data/.gitignore

@@ -0,0 +1,4 @@
+doc
+pkg
+coverage
+tags

data/README.rdoc

@@ -0,0 +1,61 @@
+= Valuedate
+
+Validates values using a schema.
+
+Source[http://github.com/splattael/valuedate] | RDoc[http://rdoc.info/projects/splattael/valuedate] | Metrics[http://getcaliper.com/caliper/project?repo=git%3A%2F%2Fgithub.com%2Fsplattael%2Fvaluedate.git]
+
+== Usage
+
+  schema = Valuedate.schema do
+    value.is_a(String).equals("test")
+  end
+
+  schema.validate("test") # => true
+  schema.validate("fail") # => false
+  schema.validate(23) # => false
+
+  deep = Valuedate.schema do
+    value.hash(
+      :type => value.is_a(String),
+      :value => value.hash(
+        :src => value.is_a(String),
+        :height => optional_value.is_a(Fixnum),
+        :width => optional_value.is_a(Fixnum)
+      )
+    )
+  end
+
+  deep.validate(
+    :type => "image",
+    :value => {
+      :src => "/bold.gif",
+      :height => 80,
+      :width => 80
+    }
+  ) # => true
+
+  # :height and width are optional
+  deep.validate(:type => "image", :value => { :src => "/bold.gif" }) # => true
+
+== Matchers
+
+Following matchers are defined:
+* is_a(Class)
+* equals(expected)
+* any(list of validators)
+* is(range, array or anything that responds_to #include?)
+
+== Defining matchers
+
+  Valuedate.matcher(:equals) { |value, expected| value == expected }
+
+== Install
+
+  git clone ...
+  rake install
+
+== Authors
+* Peter Suschlik
+
+== TODO
+* Implement and aggregate errors

data/Rakefile

@@ -0,0 +1,57 @@
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "valuedate"
+    gem.summary = 'Validates values.'
+    gem.email = "peter-valuedate@suschlik.de"
+    gem.homepage = "http://github.com/splattael/valuedate"
+    gem.authors = ["Peter Suschlik"]
+
+    gem.has_rdoc = true
+    gem.extra_rdoc_files = [ "README.rdoc" ]
+
+    gem.add_dependency "riot", ">= 0.10.11"
+    gem.add_development_dependency "riot_notifier"
+
+    gem.test_files = Dir.glob('test/test_*.rb')
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+# Test
+require 'rake/testtask'
+desc 'Default: run unit tests.'
+task :default => :test
+task :test => :check_dependencies
+
+Rake::TestTask.new(:test) do |test|
+  test.test_files = FileList.new('test/test_*.rb')
+  test.libs << 'test'
+  test.verbose = true
+end
+
+# RDoc
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rd|
+  rd.title = "Valuedate"
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc", "lib/*.rb")
+  rd.rdoc_dir = "doc"
+end
+
+
+# Misc
+desc "Tag files for vim"
+task :ctags do
+  dirs = $LOAD_PATH.select {|path| File.directory?(path) }
+  system "ctags -R #{dirs.join(" ")}"
+end
+
+desc "Find whitespace at line ends"
+task :eol do
+  system "grep -nrE ' +$' *"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.2

data/lib/valuedate.rb

@@ -0,0 +1,86 @@
+class Valuedate
+
+  class Scope
+    def value
+      Value.new
+    end
+
+    def optional_value
+      OptionalValue.new
+    end
+  end
+
+  class Value < Valuedate
+  end
+
+  class OptionalValue < Valuedate
+    def validate(value = nil)
+      value.nil? || super
+    end
+  end
+
+
+  def initialize(&block)
+    @validators = []
+    if block
+      validator = Scope.new.instance_eval(&block)
+      @validators << validator if validator.respond_to?(:call)
+    end
+  end
+
+  def hash(schema={})
+    valid? do |value|
+      value ||= {}
+      schema.all? do |(key, validator)|
+        validator.validate(value[key])
+      end
+    end
+  end
+
+  def validate(value = nil)
+    @validators.all? { |validator| validator.call(value) }
+  end
+
+  def call(value)
+    validate(value)
+  end
+
+  def valid?(&block)
+    @validators << block
+    self
+  end
+
+  def method_missing(method, *args, &block)
+    if matcher = Valuedate.matchers[method]
+      valid? { |value| matcher.call(value, *args) }
+    else
+      super
+    end
+  end
+
+  @matchers = {}
+  class << self
+    attr_reader :matchers
+
+    def validate(value, &block)
+      schema(&block).validate(value)
+    end
+
+    def schema(&block)
+      new(&block)
+    end
+
+    def matcher(name, &block)
+      undef_method(name) if respond_to?(name)
+      @matchers[name] = block
+    end
+  end
+
+end
+
+Valuedate.matcher(:equals) { |value, expected| value == expected }
+Valuedate.matcher(:is_a) { |value, expected| value.is_a?(expected) }
+Valuedate.matcher(:any) do |value, *validators|
+  validators.any? { |validator| validator.validate(value) }
+end
+Valuedate.matcher(:in) { |value, expected| expected.include?(value) }

data/test.watchr

@@ -0,0 +1,20 @@
+#!/usr/bin/env watchr
+
+begin
+  require File.join(ENV["HOME"], ".watchr.test.rb")
+rescue LoadError
+  warn "Unable to load #{File.join(ENV["HOME"], ".watchr.test.rb")}"
+  warn "You might try this: http://gist.github.com/raw/273574/8804dff44b104e9b8706826dc8882ed985b4fd13/.watchr.test.rb"
+  exit
+end
+
+run_tests
+
+watch('test/test_.*\.rb')  {|md| run md[0] }
+watch('lib/(.*)\.rb')      {|md| run "test/test_#{underscore(md[1])}.rb" }
+watch('test/helper.rb')    { run_tests }
+
+watch('VERSION') do
+  puts "Building gem"
+  system "rake build"
+end

data/test/helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'riot'
+require 'riot_notifier'
+
+require 'valuedate'
+
+Riot.reporter = RiotNotifier

data/test/test_valuedate.rb

@@ -0,0 +1,172 @@
+require 'helper'
+
+class Riot::Situation
+  def v(value=nil, &block)
+    Valuedate.validate(value, &block)
+  end
+end
+
+context "Valuedate" do
+
+  asserts(:class) { Valuedate.schema }.equals(Valuedate)
+
+  context "empty" do
+    asserts("valid without block") { v }
+    asserts("valid empty block") { v {} }
+    asserts("valid nil block") { v { nil } }
+    asserts("valid nil") { v(nil) }
+    asserts("valid 1") { v(1) }
+  end
+
+  context "callable" do
+    asserts("valid with true") { v { proc {|v| true } } }
+    asserts("invalid with false") { !v { proc {|v| false } } }
+  end
+
+  context "matchers" do
+    asserts("equals") { Valuedate.matchers[:equals].call(1, 1) }
+    asserts("!equals") { !Valuedate.matchers[:equals].call(1, 2) }
+    asserts("is_a") { Valuedate.matchers[:is_a].call("string", String) }
+    asserts("!is_a") { !Valuedate.matchers[:is_a].call("string", Fixnum) }
+  end
+
+  context "equals" do
+    asserts("valid 1") { v(1) { value.equals 1 } }
+    asserts("invalid 2") { !v(2) { value.equals 1 } }
+    asserts("valid String") { v("test") { value.equals "test" } }
+    asserts("invalid String") { !v("test") { value.equals "tests" } }
+    asserts("invalid multiple") { !v(1) { value.equals 1; value.equals 2} }
+  end
+
+  context "is_a" do
+    asserts("valid String") { v("test") { value.is_a(String) } }
+    asserts("invalid String") { !v(1) { value.is_a(String) } }
+    asserts("valid multiple") { v("test") { value.is_a(String); value.is_a(Object) } }
+    asserts("invalid multiple") { !v("test") { value.is_a(String); value.is_a(Fixnum) } }
+  end
+
+  context "chaining" do
+    asserts("valid") { v(1) { value.is_a(Fixnum).equals(1) }}
+    asserts("invalid") { !v(1) { value.is_a(Fixnum).equals(2) }}
+  end
+
+  context "nesting" do
+    setup do
+      Valuedate.schema do
+        value.hash(
+          :key    => value.is_a(String),
+          :value  => value.is_a(Fixnum)
+        )
+      end
+    end
+
+    asserts("valid") { topic.validate(:key => "fasel", :value => 23) }
+    asserts("invalid") { !topic.validate(:key => 23, :value => 23) }
+    asserts("missing") { !topic.validate(:key => "fasel") }
+  end
+
+  context "deep nesting" do
+    setup do
+      Valuedate.schema do
+        value.hash(
+          :image => value.hash(
+            :src => value.is_a(String),
+            :height => value.is_a(Fixnum)
+          ),
+          :text => value.is_a(String)
+        )
+      end
+    end
+
+    asserts("valid") do
+      topic.validate(
+        :image => {
+          :src => "/image.gif",
+          :height => 80
+        },
+        :text => "Image"
+      )
+    end
+    asserts("invalid") do
+      !topic.validate(
+        :image => {
+          :src => "/image.gif",
+        },
+        :text => "Image"
+      )
+    end
+
+  end # deep nesting
+
+  context "optional_value" do
+    asserts("valid nil") { v(nil) { optional_value } }
+    asserts("valid 1") { v(1) { optional_value } }
+    asserts("valid empty optional String") { v(nil) { optional_value.is_a(String) } }
+    asserts("valid given and String") { v("test") { optional_value.is_a(String) } }
+    asserts("invalid given non-String") { !v(1) { optional_value.is_a(String) } }
+
+    context "netsted" do
+      setup do
+        Valuedate.schema do
+          optional_value.hash(
+            :image => value.hash(
+              :src  => value.is_a(String),
+              :alt  => optional_value.is_a(String),
+              :size => optional_value.hash(
+                :width => value.is_a(Fixnum),
+                :height => value.is_a(Fixnum)
+              )
+            )
+          )
+        end
+      end
+
+      asserts("valid empty") { topic.validate }
+      asserts("invalid non Hash") { !topic.validate(23) }
+      asserts("invalid wrong key") { !topic.validate(:type => {}) }
+      asserts("invalid empty image") { !topic.validate(:image => {}) }
+      asserts("valid all given") do
+        topic.validate(
+          :image => {
+            :src  => "/img.gif",
+            :alt  => "Alt",
+            :size => { :width => 80, :height => 80 }
+          }
+        )
+      end
+      asserts("valid minimal Hash") { topic.validate(:image => { :src => "/img.gif" }) }
+      asserts("invalid alt") { !topic.validate(:image => { :src => "/img.gif", :alt => 23 }) }
+    end
+  end
+
+  context "any" do
+    asserts("valid") { v(1) { value.any(value.equals(1), value.equals(2)) } }
+    asserts("valid") { v(2) { value.any(value.equals(1), value.equals(2)) } }
+    asserts("invalid") { !v(3) { value.any(value.equals(1), value.equals(2)) } }
+
+    context "nested" do
+      setup do
+        Valuedate.schema do
+          value.any(
+            value.hash(:result => value.equals("ok")),
+            value.hash(:error => value.equals("failed"), :init => value.equals(23))
+          )
+        end
+      end
+
+      asserts("invalid when empty") { !topic.validate }
+      asserts("valid when result ok") { topic.validate(:result => "ok") }
+      asserts("invalid when result nok") { !topic.validate(:result => "nok") }
+      asserts("valid when error") { topic.validate(:error => "failed", :init => 23) }
+      asserts("invalid missing init") { !topic.validate(:error => "failed") }
+    end
+  end
+
+  context "in" do
+    asserts("valid range") { v(1) { value.in(1..5) } }
+    asserts("invalid range") { !v(0) { value.in(1..5) } }
+    asserts("valid array") { v(1) { value.in([1,2,3]) } }
+    asserts("invalid array") { !v(0) { value.in([1,2,3]) } }
+  end
+
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: valuedate
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Peter Suschlik
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-28 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: riot
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.10.11
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: riot_notifier
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: peter-valuedate@suschlik.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- .gitignore
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/valuedate.rb
+- test.watchr
+- test/helper.rb
+- test/test_valuedate.rb
+has_rdoc: true
+homepage: http://github.com/splattael/valuedate
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Validates values.
+test_files: 
+- test/test_valuedate.rb