dzl 1.0.0.beta4 → 1.0.0.rc0

data/config.ru

@@ -40,7 +40,12 @@ end
 #   run Dzl::Examples::FunWithHooks
 # end
 
-require 'dzl/examples/fun_with_scopes'
+# require 'dzl/examples/fun_with_scopes'
+# map '/' do
+#   run Dzl::Examples::FunWithScopes
+# end
+
+require 'dzl/examples/fun_with_hashes'
 map '/' do
-  run Dzl::Examples::FunWithScopes
+  run Dzl::Examples::FunWithHashes
 end

data/lib/dzl/core_ext.rb

@@ -0,0 +1,15 @@
+class Hash
+  def try_keys(*keys)
+    keys.inject(self) { |c, k| c.has_key?(k) ? c[k] : nil }
+  end
+
+  def recursively_symbolize_keys!
+    self.symbolize_keys!
+    self.values.each do |v|
+      if v.is_a?(Hash)
+        v.recursively_symbolize_keys!
+      end
+    end
+    self
+  end
+end

data/lib/dzl/dsl_proxies/parameter.rb

@@ -42,6 +42,12 @@ class Dzl::DSLProxies::Parameter < Dzl::DSLProxy
   def type(type, type_opts = {})
     @subject.validations[:type] = type
     @subject.opts[:type_opts] = type_opts
+
+    if type == Hash && !type_opts.try_keys(:validator).is_a?(HashValidator)
+      raise ArgumentError.new("Must pass :validator, an instance of HashValidator")
+    elsif type == Hash && block_given?
+      type_opts[:validator].instance_exec(&Proc.new)
+    end
   end
 
   def integer

data/lib/dzl/dsl_subjects/parameter.rb

@@ -64,9 +64,21 @@ class Dzl::DSLSubjects::Parameter < Dzl::DSLSubject
     input = begin
       if opts[:preformatted]
         if input.is_a?(param_type)
-          Dzl::ValueOrError.new(
-            v: input
-          )
+          if param_type == Hash
+            if @opts[:type_opts][:validator].valid?(input)
+              Dzl::ValueOrError.new(
+                v: input
+              )
+            else
+              Dzl::ValueOrError.new(
+                e: :hash_validation_failed
+              )
+            end
+          else
+            Dzl::ValueOrError.new(
+              v: input
+            )
+          end
         else
           Dzl::ValueOrError.new(
             e: :type_conversion_error

data/lib/dzl/examples/fun_with_hashes.rb

@@ -0,0 +1,20 @@
+require 'dzl/examples/base'
+
+class Dzl::Examples::FunWithHashes < Dzl::Examples::Base
+  post '/h' do
+    required :foo do
+      type Hash, validator: HashValidator.new do
+        required :str
+        required :ary do
+          type Array
+          allowed_values [3, 5, 7]
+        end
+
+        required :nest do
+          type Hash
+          required(:int) { type Fixnum }
+        end
+      end
+    end
+  end
+end

data/lib/dzl/request.rb

@@ -24,7 +24,7 @@ class Dzl::Request < Rack::Request
     @params ||= begin
       @request_body = body.read
       unless preformatted_params.empty?
-        @preformatted_keys = preformatted_params.keys.collect {|k| k.to_sym}
+        @preformatted_keys = preformatted_params.keys
       end
 
       super.merge(preformatted_params)
@@ -63,6 +63,12 @@ class Dzl::Request < Rack::Request
 
   protected
   def preformatted_params
-    @preformatted_params ||= (content_type == "application/json") ? JSON.parse(@request_body) : {}
+    @preformatted_params ||= begin
+      if content_type == "application/json"
+        JSON.parse(@request_body).recursively_symbolize_keys!
+      else
+        {}
+      end
+    end
   end
 end

data/lib/dzl/version.rb

@@ -1,3 +1,3 @@
 module Dzl
-  VERSION = "1.0.0.beta4"
+  VERSION = "1.0.0.rc0"
 end

data/lib/dzl.rb

@@ -1,5 +1,7 @@
 require 'active_support'
 require 'active_support/core_ext'
+require 'hash_validator'
+require 'dzl/core_ext'
 require 'dzl/version'
 require 'dzl/logger'
 require 'dzl/errors'
@@ -18,7 +20,7 @@ require 'dzl/dsl_subjects/parameter_block'
 require 'dzl/dsl_subjects/endpoint'
 
 module Dzl
-  class NYI < StandardError; end
+  class NYI < Dzl::Error; end
 
   def self.env
     ENV['RACK_ENV']

data/lib/hash_validator/hash_validator.rb

@@ -0,0 +1,124 @@
+class HashValidator
+  class << self
+    alias_method :orig_new, :new
+    def new(*args)
+      v = orig_new(*args)
+      v.instance_exec(&Proc.new) if block_given?
+      v
+    end
+  end
+
+  def initialize
+    @template = {
+      keys: {}
+    }
+
+    @key_stack = []
+    @dsl_proxy = DSLProxy.new(self)
+  end
+
+  def valid?(hsh)
+    top[:keys].each do |k, v|
+      if !hsh.has_key?(k)
+        if v[:opts][:required]
+          return false
+        else
+          next
+        end
+      end
+      
+      input = hsh[k]
+
+      # Check type of input
+      return false unless input.is_a?(v[:opts][:type])
+
+      if input.is_a?(Hash)
+        @key_stack.push(k)
+
+        valid?(input) or begin
+          @key_stack = []
+          return false
+        end
+
+        @key_stack.pop
+      elsif input.is_a?(Array)
+        return false if v[:opts][:allowed_values].present? &&
+                        !input.all? {|_input| v[:opts][:allowed_values].include?(_input)}
+
+        return false if v[:opts][:forbidden_values].present? &&
+                        input.any? {|_input| v[:opts][:forbidden_values].include?(_input)}
+      else
+        return false if v[:opts][:allowed_values].present? &&
+                        !v[:opts][:allowed_values].include?(hsh[k])
+
+        return false if v[:opts][:forbidden_values].present? &&
+                        v[:opts][:forbidden_values].include?(hsh[k])
+      end
+    end
+
+    true
+  end
+
+  def key(k, opts, &block)
+    top[:keys][k] = {
+      opts: opts,
+      block: block,
+      keys: {}
+    }
+
+    @key_stack.push(k)
+    @dsl_proxy.instance_exec(&block) if block_given?
+    @key_stack.pop
+  end
+
+  def top
+    @key_stack.inject(@template) { |ref, key| ref[:keys][key] } || @template
+  end
+
+  def add_option(k, v)
+    top[:opts][k] = v
+  end
+
+  def method_missing(m, *args, &block)
+    if @dsl_proxy.respond_to?(m)
+      @dsl_proxy.send(m, *args, &block)
+    else
+      super(m, *args, &block)
+    end
+  end
+
+  class DSLProxy
+    def initialize(subject)
+      @subject = subject
+    end
+
+    def key(k, opts = {}, &block)
+      opts.reverse_merge!({
+        type: String
+      })
+
+      @subject.key(k, opts, &block)
+    end
+
+    def optional(k, opts = {}, &block)
+      key(k, opts.merge({required: false}), &block)
+    end
+
+    def required(k, opts = {}, &block)
+      key(k, opts.merge({required: true}), &block)
+    end
+
+    def type(klass)
+      raise ArgumentError unless klass.is_a?(Class)
+      @subject.add_option(:type, klass)
+    end
+
+    def allowed_values(ary)
+      @subject.add_option(:allowed_values, ary)
+    end
+
+    def forbidden_values(ary)
+      @subject.add_option(:forbidden_values, ary)
+    end
+  end
+end

data/lib/hash_validator.rb

@@ -0,0 +1 @@
+require 'hash_validator/hash_validator'

data/spec/fun_with_hashes_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'rack/test'
+require 'dzl/examples/fun_with_hashes'
+
+describe 'hash parameters' do
+  include Rack::Test::Methods
+  def app; Dzl::Examples::FunWithHashes; end
+
+  context 'DSL' do
+    specify 'hash parameters must have a validator, for now' do
+      expect {
+        class T1 < Dzl::Examples::Base
+          get '/foo' do
+            required :bar do
+              type Hash
+            end
+          end
+        end
+      }.to raise_exception(ArgumentError)
+
+      expect {
+        class T1 < Dzl::Examples::Base
+          get '/foo' do
+            required :bar do
+              type Hash, validator: HashValidator.new
+            end
+          end
+        end
+      }.to_not raise_exception(ArgumentError)
+    end
+  end
+
+  context 'validate' do
+    specify 'JSON post bodies' do
+      header 'Content-Type', 'application/json'
+      valid_body = {
+        foo: {
+          str: 'hello',
+          ary: [7, 3],
+          nest: {
+            int: 5
+          }
+        }
+      }
+
+      invalid_body = {
+        foo: {
+          str: 'hello',
+          ary: [7, 6, 5],
+          nest: {
+            int: 7
+          }
+        }
+      }
+
+      missing_foo = {
+        baz: {
+          str: 'hello',
+          ary: [7, 5],
+          nest: {
+            int: 5
+          }
+        }
+      }
+
+      post('/h', valid_body.to_json).status.should == 200
+      post('/h', missing_foo.to_json).status.should == 404
+      post('/h', invalid_body.to_json).status.should == 404
+    end
+  end
+end

data/spec/hash_validator_spec.rb

@@ -0,0 +1,244 @@
+require 'spec_helper'
+require 'hash_validator'
+
+describe HashValidator do
+  context 'required/optional keys' do
+    ok = {foo: 'bar', bar: 'foo'}
+    also_ok = {foo: 'bar'}
+    bad = {bar: 'foo'}
+
+    v = HashValidator.new
+    v.required(:foo)
+    v.optional(:bar)
+
+    v.valid?(ok).should == true
+    v.valid?(bad).should == false
+
+    v.valid?(also_ok).should == true
+  end
+
+  context 'key type specification' do
+    specify 'key type defaults to string' do
+      ok = {foo: 'bar'}
+      bad = {foo: 1}
+
+      v = HashValidator.new
+      v.required(:foo)
+
+      v.valid?(ok).should == true
+      v.valid?(bad).should == false
+    end
+
+    specify 'must be ruby classes' do
+      v = HashValidator.new
+      v.required(:foo) { type Fixnum }
+      v.required(:bar) { type Array }
+
+      ok = {foo: 3, bar: [1, 2, 3]}
+      bad = {foo: 3, bar: 4}
+
+      v.valid?(ok).should == true
+      v.valid?(bad).should == false
+
+      expect {
+        v.required(:baz) { type :invalid }
+      }.to raise_exception(ArgumentError)
+    end
+
+    specify 'mixed type arrays are allowed' do
+      v = HashValidator.new
+      v.required(:foo) { type Array }
+
+      v.valid?({
+        foo: [1, 2, 'three']
+      }).should == true
+    end
+  end
+
+  context 'arrays of allowed values may be specified' do
+    specify 'for strings and fixnums' do
+      v = HashValidator.new
+      v.required :foo do
+        type Fixnum
+        allowed_values [1, 2, 3]
+      end
+
+      v.required :bar do
+        allowed_values %w{one two three}
+      end
+
+      ok = {foo: 2, bar: 'two'}
+      bad = {foo: 4, bar: 'four'}
+
+      v.valid?(ok).should == true
+      v.valid?(bad).should == false
+    end
+
+    specify 'for arrays' do
+      v = HashValidator.new
+      v.required :foo do
+        type Array
+        allowed_values [1, 2, 3]
+      end
+
+      v.optional :bar do
+        type Array
+        allowed_values [1, 2, 'three']
+      end
+
+      v.valid?({foo: [2, 3, 4]}).should == false
+      v.valid?({foo: [2, 3]}).should == true
+      v.valid?({foo: [2], bar: [1, 'three']}).should == true
+      v.valid?({foo: [2], bar: [4]}).should == false
+
+      v = HashValidator.new do
+        required :ary do
+          type Array
+          allowed_values [3, 5, 7]
+        end
+      end
+
+      v.valid?({
+        ary: [2, 4]
+      }).should == false
+    end
+  end
+
+  context 'arrays of forbidden values may be specified' do
+    specify 'for strings and fixnums' do
+      v = HashValidator.new
+      v.required :foo do
+        type Fixnum
+        forbidden_values [1, 2, 3]
+      end
+
+      v.required :bar do
+        forbidden_values %w{one two three}
+      end
+
+      bad = {foo: 2, bar: 'two'}
+      ok = {foo: 4, bar: 'four'}
+
+      v.valid?(ok).should == true
+      v.valid?(bad).should == false
+    end
+
+    specify 'for arrays' do
+      v = HashValidator.new
+      v.required :foo do
+        type Array
+        forbidden_values [1, 2, 3]
+      end
+
+      v.valid?({foo: [2, 3, 4]}).should == false
+      v.valid?({foo: [2, 3]}).should == false
+      v.valid?({foo: [0, 4]}).should == true
+    end
+  end
+
+  context 'nested hash validation' do
+    specify 'works as expected' do
+      v = HashValidator.new
+      v.required(:foo) do
+        type Hash
+        required(:bar) { type Fixnum }
+        required :baz
+      end
+
+      v.valid?({
+        foo: {
+          bar: 4,
+          baz: 'omg'
+        }
+      }).should == true
+
+      v.valid?({
+        foo: {
+          bar: 5,
+          baz: 7
+        }
+      }).should == false
+    end
+
+    specify 'supports multiple levels of nesting' do
+      v = HashValidator.new
+
+      v.required(:hsh1) do
+        type Hash
+        required(:hsh2) do
+          type Hash
+          required(:hsh3) do
+            type Hash
+            required :foo
+          end
+        end
+      end
+
+      v.valid?({
+        hsh1: {
+          hsh2: {
+            hsh3: {
+              foo: 'hello'
+            }
+          }
+        }
+      }).should == true
+    end
+
+    specify 'supports multiple levels of nesting among other keys' do
+      v = HashValidator.new
+
+      v.required(:hsh1) do
+        type Hash
+        required :str
+        required(:int) { type Fixnum }
+
+        required(:hsh2) do
+          type Hash
+          required(:ary) do
+            type Array
+            allowed_values [1, 2, 3, 'four']
+          end
+        end
+      end
+
+      v.valid?({
+        hsh1: {
+          str: 'hello',
+          int: 8,
+          hsh2: {
+            ary: [1, 'fo']
+          }
+        }
+      }).should == false
+
+      v.valid?({
+        hsh1: {
+          str: 'hello',
+          int: 5,
+          hsh2: {
+            ary: [1, 'four']
+          }
+        }
+      }).should == true
+    end
+  end
+
+  specify '.new instance_execs a block, if given' do
+    v = HashValidator.new do
+      required :hsh1 do
+        type Hash
+        required :str
+      end
+
+      required(:ary) { type Array }
+    end
+
+    v.valid?({
+      hsh1: {
+        str: 'hello'
+      },
+      ary: [1, 2, 3]
+    }).should == true
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dzl
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta4
+  version: 1.0.0.rc0
   prerelease: 6
 platform: ruby
 authors:
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-26 00:00:00.000000000 Z
+date: 2012-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
-  requirement: &70279829324860 !ruby/object:Gem::Requirement
+  requirement: &70190801357240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -22,10 +22,10 @@ dependencies:
         version: 1.4.1
   type: :runtime
   prerelease: false
-  version_requirements: *70279829324860
+  version_requirements: *70190801357240
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &70279829322760 !ruby/object:Gem::Requirement
+  requirement: &70190801356740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,7 +33,7 @@ dependencies:
         version: 3.2.2
   type: :runtime
   prerelease: false
-  version_requirements: *70279829322760
+  version_requirements: *70190801356740
 description: Small, fast racktivesupport web framework with handy DSL and explicit
   parameter validation.
 email:
@@ -52,6 +52,7 @@ files:
 - config.ru
 - dzl.gemspec
 - lib/dzl.rb
+- lib/dzl/core_ext.rb
 - lib/dzl/doc.rb
 - lib/dzl/doc/endpoint_doc.rb
 - lib/dzl/doc/router_doc.rb
@@ -78,6 +79,7 @@ files:
 - lib/dzl/errors.rb
 - lib/dzl/examples/base.rb
 - lib/dzl/examples/fun_with_handlers.rb
+- lib/dzl/examples/fun_with_hashes.rb
 - lib/dzl/examples/fun_with_hooks.rb
 - lib/dzl/examples/fun_with_params.rb
 - lib/dzl/examples/fun_with_requests.rb
@@ -95,13 +97,17 @@ files:
 - lib/dzl/validators/value.rb
 - lib/dzl/value_or_error.rb
 - lib/dzl/version.rb
+- lib/hash_validator.rb
+- lib/hash_validator/hash_validator.rb
 - spec/dsl_subject_spec.rb
 - spec/endpoint_doc_spec.rb
 - spec/fun_with_handlers_spec.rb
+- spec/fun_with_hashes_spec.rb
 - spec/fun_with_hooks_spec.rb
 - spec/fun_with_params_spec.rb
 - spec/fun_with_requests_spec.rb
 - spec/fun_with_scopes_spec.rb
+- spec/hash_validator_spec.rb
 - spec/logger_spec.rb
 - spec/route_params_spec.rb
 - spec/router_doc_spec.rb
@@ -136,10 +142,12 @@ test_files:
 - spec/dsl_subject_spec.rb
 - spec/endpoint_doc_spec.rb
 - spec/fun_with_handlers_spec.rb
+- spec/fun_with_hashes_spec.rb
 - spec/fun_with_hooks_spec.rb
 - spec/fun_with_params_spec.rb
 - spec/fun_with_requests_spec.rb
 - spec/fun_with_scopes_spec.rb
+- spec/hash_validator_spec.rb
 - spec/logger_spec.rb
 - spec/route_params_spec.rb
 - spec/router_doc_spec.rb