weasel_diesel 1.2.1 → 1.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 76695321f4c49f270788ffc3743ed2ca1668c774
+  data.tar.gz: 567a24d4bac5544bb3d7d89df0fea271afa273b0
+SHA512:
+  metadata.gz: 9fc1388dc4e52f7ec91b518f26319d85e4b14f92bf586f036cc53e920ee9017cbffeda361b4b0c786aa06d5fde37f79ba01df0fabbc2ae4e68c4be4688277377
+  data.tar.gz: be2eb8217e849bb8b4bdd9b2fe818d4c1ca7928750da35271f707f797636ec8a18722e51c2c83962e10660cb55c45aa6ef7603fa443d89488024c77875af0af5

data/.travis.yml

@@ -1,15 +1,12 @@
 language: ruby
 rvm:
   - 1.8.7
-  - 1.9.2
   - 1.9.3
-  - jruby-18mode
-  - jruby-19mode
-  - rbx-18mode
+  - 2.0.0
+  - jruby
   - rbx-19mode
   - ruby-head
   - jruby-head
-  - ree
 
 matrix:
   allow_failures:

data/CHANGELOG.md

@@ -3,6 +3,9 @@
 All changes can be seen on GitHub and git tags are used to isolate each
 release.
 
+1.2.2:
+* Added support for anonymous top level arrays.
+
 *1.2.1*:
 
 * Modified the way an empty string param is cast/verified. If a param is

data/README.md

@@ -196,6 +196,10 @@ service.params do |param|
     user.boolean :mailing_list, :default => true, :doc => "is the user subscribed to the ML?"
     user.array   :skills, :in => %w{ruby js cooking}
   end
+
+  service.params.namespace :attachment, :null => true do |attachment|
+    attachment.string :url, :required => true
+  end
 ```
 
 

data/lib/json_response_verification.rb

@@ -1,109 +1,138 @@
-# include this module in WeaselDiesel
+# Include this module in WeaselDiesel
 # to add response verification methods.
 #
 module JSONResponseVerification
 
-  # Validates a hash against the service's response description.
+  # Verifies the parsed body of a JSON response against the service's response description.
   #
   # @return [Array<TrueClass, FalseClass, Array<String>>] True/false and an array of errors.
-  def validate_hash_response(hash)
-    errors = []
-    # nodes without the arrays
-    response.nodes.each do |node|
-      if node.name
-        # Verify that the named node exists in the hash
-        unless hash.has_key?(node.name.to_s)
-          errors << json_response_error(node, hash) 
-          return [false, errors]
-        end
-      end
-      errors += validate_hash_against_template_node(hash, node)
-    end
-
+  def verify(parsed_json_body)
+    errors = [verify_element(parsed_json_body, response.nodes.first)]
+    errors.flatten!
     [errors.empty?, errors]
   end
 
+  alias :validate_hash_response :verify # backguard compatibility
+
   private
 
-  # Recursively validates a hash representing a json response.
+  # Recursively validates an element found when parsing a JSON.
   #
-  # @param [Hash>] hash the hash to verify.
-  # @param [WDSL::Response::Element] node the reference element defined in the response description.
-  # @param [TrueClass, FalseClass] nested if the node/hash to verify is nested or not. If nested, the method expects to get the subhash 
-  #   & won't verify that the name exists since it was done a level higher.
-  # @param [Arrays<String>] errors the list of errors encountered while verifying.
-  # @param []
-  # @return [TrueClass, FalseClass]
-  def validate_hash_against_template_node(hash, node, nested=false, errors=[], array_item=false)
-    if hash.nil?
-      errors << json_response_error(node, hash)
-      return errors
-    end
-
-    if node.name && !nested
-      if hash.has_key?(node.name.to_s)
-        subhash = hash[node.name.to_s]
+  # @param [Hash, Array, nil] el parsed JSON to be verified.
+  # @param [WDSL::Response::Element] expected the reference element defined in the response description.
+  # @param [TrueClass, FalseClass] verify_namespace if the nesting must be verified.
+  # @return [Arrays<String>] errors the list of errors encountered while verifying.
+  def verify_element(el, expected, verify_namespace=true)
+    if expected.name && verify_namespace
+      if verified_namespace?(el, expected.name)
+        el = el[expected.name.to_s]
+        verify_namespace = false
       else
-        errors << json_response_error(node, hash)
+        return something_is_missing_error(expected)
       end
+    else
+      verify_namespace = true
     end
-
-    subhash ||= hash
-    if node.is_a?(WeaselDiesel::Response::Vector) && !array_item
-      errors << json_response_error(node, subhash, true) unless subhash.is_a?(Array)
-      subhash.each do |obj|
-        validate_hash_against_template_node(obj, node, true, errors, true)
-      end
+    if el.nil?
+      something_is_missing_error(expected)
+    elsif el.is_a?(Array)
+      verify_array(el, expected, verify_namespace)
     else
-      node.properties.each do |prop|
-        if !array_item && !subhash.has_key?(prop.name.to_s) && (prop.opts && prop.respond_to?(:opts) && !prop.opts[:null])
-          errors << json_response_error(prop, subhash)
-        end
-        errors << json_response_error(prop, subhash, true) unless valid_hash_type?(subhash, prop)
-      end
-
-      node.objects.each do |obj|
-        # recursive call
-        validate_hash_against_template_node(subhash[obj.name.to_s], obj, true, errors)
-      end if node.objects
+      verify_object(el, expected, verify_namespace)
     end
+  end
 
-    errors
+  # Verifies hash corresponding to a JSON response against a given namespace
+  #
+  # @param [Array] array array to be verified.
+  # @param [WDSL::Response::Element] expected the reference element defined in the response description.
+  # @return [TrueClass, FalseClass] if the nesting name found is correct.
+  def verified_namespace?(hash, expected_name)
+    hash.respond_to?(:has_key?) && hash.has_key?(expected_name.to_s)
+  end
+
+  # Validates an array found when parsing a JSON.
+  #
+  # @param [Array] array array to be verified.
+  # @param [WDSL::Response::Element] expected the reference element defined in the response description.
+  # @return [Arrays<String>] errors the list of errors encountered while verifying.
+  def verify_array(array, expected, verify_nesting)
+    return wrong_type_error(array, expected.name, expected.type) unless expected.is_a?(WeaselDiesel::Response::Vector)
+    expected = expected.elements && expected.elements.any? ? expected.elements.first : expected
+    array.map{ |el| verify_element(el, expected, verify_nesting) }
   end
 
-  def json_response_error(el_or_attr, hash, type_error=false)
-    if el_or_attr.is_a?(WeaselDiesel::Response::Element)
-      "#{el_or_attr.name || 'top level'} Node/Object/Element is missing"
-    elsif type_error
-      error = "#{el_or_attr.name || el_or_attr.inspect} was of wrong type, expected #{el_or_attr.type}"
-      if el_or_attr.name
-        error << " and the value was: #{hash[el_or_attr.name.to_s]}"
+  # Validates a hash corresponding to a JSON object.
+  #
+  # @param [Hash] hash hash to be verified.
+  # @param [WDSL::Response::Element] expected the reference element defined in the response description.
+  # @return [Arrays<String>] errors the list of errors encountered while verifying.
+  def verify_object(hash, expected, verify_nesting)
+    [verify_attributes(hash, expected)] + [verify_objects(hash, expected)]
+  end
+
+  # Validates the objects found in a hash corresponding to a JSON object.
+  #
+  # @param [Hash] hash hash representing a JSON object whose internal objects will be verified.
+  # @param [WDSL::Response::Element] expected the reference element defined in the response description.
+  # @return [Arrays<String>] errors the list of errors encountered while verifying.
+  def verify_objects(hash, expected)
+    return [] unless expected.objects
+    expected.objects.map do |expected|
+      found = hash[expected.name.to_s]
+      null_allowed = expected.respond_to?(:opts) && expected.opts[:null]
+      if found.nil?
+        null_allowed ? [] : something_is_missing_error(expected)
+      else
+        verify_element(found, expected, false) # don't verify nesting
       end
-      error
-    else
-      "#{el_or_attr.name || el_or_attr.inspect} is missing in #{hash.inspect}"
     end
   end
 
-  def valid_hash_type?(hash, prop_template)
-    name = prop_template.name.to_s
-    attribute = hash[name]
+  # Validates the attributes found in a hash corresponding to a JSON object.
+  #
+  # @param [Hash] hash hash whose attributes will be verified.
+  # @param [WDSL::Response::Element] expected the reference element defined in the response description.
+  # @return [Arrays<String>] errors the list of errors encountered while verifying.
+  def verify_attributes(hash, expected)
+    return [] unless expected.attributes
+    expected.attributes.map{ |a| verify_attribute_value(hash[a.name.to_s], a) }
+  end
 
-    # Check for nullity
-    if attribute.nil?
-      return prop_template.opts[:null] == true
+  # Validates a value against a found in a hash corresponding to a JSON object.
+  #
+  # @param [value] value value to be verified.
+  # @param [WDSL::Response::Attribute] expected the reference element defined in the response description.
+  # @return [Arrays<String>] errors the list of errors encountered while verifying.
+  def verify_attribute_value(value, attribute)
+    null_allowed = attribute.respond_to?(:opts) && !!attribute.opts[:null]
+    if value.nil?
+      null_allowed ? [] : wrong_type_error(value, attribute.name, attribute.type)
+    else
+      type = attribute.type
+      return [] if type.to_sym == :string
+      rule = ParamsVerification.type_validations[attribute.type.to_sym]
+      puts "Don't know how to validate attributes of type #{type}" if rule.nil?
+      (rule.nil? || value.to_s =~ rule) ? [] : wrong_type_error(value, attribute.name, attribute.type)
     end
-    
-    type = prop_template.type
-    return true if type.nil?
+  end
 
-    rule = ParamsVerification.type_validations[type.to_sym]
-    if rule.nil?
-      puts "Don't know how to validate attributes of type #{type}" if type.to_sym != :string
-      return true
-    end
+  # Returns an error message reporting that an expected data hasn't been found in the JSON response.
+  #
+  # @param [WDSL::Response::Element, WDSL::Response::Attribute] expected missing data.
+  # @return [String] error message
+  def something_is_missing_error(expected)
+    "#{expected.name || 'top level'} Node/Object/Element is missing"
+  end
 
-    attribute.to_s =~ rule
+  # Returns an error message reporting that a value doesn't correspond to an expected data type.
+  #
+  # @param [value] value which doesn't correspond to the expected type.
+  # @param [data_name] data_name name of the data containing the value.
+  # @param [expected_type] expected type.
+  # @return [String] error message
+  def wrong_type_error(value, data_name, expected_type)
+    "#{data_name} was of wrong type, expected #{expected_type} and the value was #{value}"
   end
 
-end
+end

data/lib/params.rb

@@ -5,7 +5,30 @@ class WeaselDiesel
   # @see WeaselDiesel#params
   #
   # @api public
-  class Params  
+  class Params
+
+    # Namespaces have a name, and options.
+    #
+    # @api public
+    class Namespace
+      # @return [Symbol, String] name The name of the namespace.
+      # @api public
+      attr_reader :name
+
+      # @return [Boolean] :null Can this namespace be null?
+      # @api public
+      attr_reader :null
+
+      # @param [Symbol, String] name
+      #   The namespace's name
+      # @param [Hash] opts The namespace options
+      # @option opts [Boolean] :null Can this value be null?
+      # @api public
+      def initialize(name, opts={})
+        @name = name
+        @null = opts[:null] || false
+      end
+    end # of Namespace
 
     # Params usually have a few rules used to validate requests.
     # Rules are not usually initialized directly but instead via
@@ -31,17 +54,17 @@ class WeaselDiesel
       # @api public
       attr_reader :options
 
-      # @param [Symbol, String] name 
+      # @param [Symbol, String] name
       #   The param's name
       # @param [Hash] opts The rule options
       # @option opts [Symbol] :in A list of acceptable values.
       # @option opts [Symbol] :options A list of acceptable values.
       # @option opts [Symbol] :default The default value of the param.
-      # @option options [Symbol] :min_value The minimum acceptable value.
-      # @option options [Symbol] :max_value The maximum acceptable value.
-      # @option options [Symbol] :min_length The minimum acceptable string length.
-      # @option options [Symbol] :max_length The maximum acceptable string length.
-      # @option options [Boolean] :null Can this value be null?
+      # @option opts [Symbol] :min_value The minimum acceptable value.
+      # @option opts [Symbol] :max_value The maximum acceptable value.
+      # @option opts [Symbol] :min_length The minimum acceptable string length.
+      # @option opts [Symbol] :max_length The maximum acceptable string length.
+      # @option opts [Boolean] :null Can this value be null?
       # @option opts [Symbol] :doc Documentation for the param.
       # @api public
       def initialize(name, opts = {})
@@ -51,7 +74,7 @@ class WeaselDiesel
 
       # The namespace used if any
       #
-      # @return [NilClass, String]
+      # @return [NilClass, WeaselDiesel::Params::Namespace]
       # @api public
       def namespace
         @options[:space_name]
@@ -76,7 +99,7 @@ class WeaselDiesel
 
     # The namespace used if any
     #
-    # @return [String]
+    # @return [NilClass, WeaselDiesel::Params::Namespace]
     # @api public
     attr_reader :space_name
 
@@ -126,7 +149,7 @@ class WeaselDiesel
     #    service.param.string  :type, :in => LeaderboardType.names, :default => LeaderboardType::LIFETIME
     #
     # @api public
-    # @return [Arrays<WeaselDiesel::Params::Rule>] 
+    # @return [Arrays<WeaselDiesel::Params::Rule>]
     #   List of optional or required param rules depending on the new param rule type
     def string(name, options={})
       param(:string, name, options)
@@ -143,7 +166,7 @@ class WeaselDiesel
     #    service.param.string  :type, :in => LeaderboardType.names, :default => LeaderboardType::LIFETIME
     #
     # @api public
-    # @return [Arrays<WeaselDiesel::Params::Rule>] 
+    # @return [Arrays<WeaselDiesel::Params::Rule>]
     #   List of optional or required param rules depending on the new param rule type
     def integer(name, options={})
       param(:integer, name, options)
@@ -160,7 +183,7 @@ class WeaselDiesel
     #    service.param.string  :type, :in => LeaderboardType.names, :default => LeaderboardType::LIFETIME
     #
     # @api public
-    # @return [Arrays<WeaselDiesel::Params::Rule>] 
+    # @return [Arrays<WeaselDiesel::Params::Rule>]
     #   List of optional or required param rules depending on the new param rule type
     def float(name, options={})
       param(:float, name, options)
@@ -177,7 +200,7 @@ class WeaselDiesel
     #    service.param.string  :type, :in => LeaderboardType.names, :default => LeaderboardType::LIFETIME
     #
     # @api public
-    # @return [Arrays<WeaselDiesel::Params::Rule>] 
+    # @return [Arrays<WeaselDiesel::Params::Rule>]
     #   List of optional or required param rules depending on the new param rule type
     def decimal(name, options={})
       param(:decimal, name, options)
@@ -194,7 +217,7 @@ class WeaselDiesel
     #    service.param.string  :type, :in => LeaderboardType.names, :default => LeaderboardType::LIFETIME
     #
     # @api public
-    # @return [Arrays<WeaselDiesel::Params::Rule>] 
+    # @return [Arrays<WeaselDiesel::Params::Rule>]
     #   List of optional or required param rules depending on the new param rule type
     def boolean(name, options={})
       param(:boolean, name, options)
@@ -211,7 +234,7 @@ class WeaselDiesel
     #    service.param.string  :type, :in => LeaderboardType.names, :default => LeaderboardType::LIFETIME
     #
     # @api public
-    # @return [Arrays<WeaselDiesel::Params::Rule>] 
+    # @return [Arrays<WeaselDiesel::Params::Rule>]
     #   List of optional or required param rules depending on the new param rule type
     def datetime(name, options={})
       param(:datetime, name, options)
@@ -228,7 +251,7 @@ class WeaselDiesel
     #    service.param.string  :type, :in => LeaderboardType.names, :default => LeaderboardType::LIFETIME
     #
     # @api public
-    # @return [Arrays<WeaselDiesel::Params::Rule>] 
+    # @return [Arrays<WeaselDiesel::Params::Rule>]
     #   List of optional or required param rules depending on the new param rule type
     def text(name, options={})
       param(:text, name, options)
@@ -245,7 +268,7 @@ class WeaselDiesel
     #    service.param.string  :type, :in => LeaderboardType.names, :default => LeaderboardType::LIFETIME
     #
     # @api public
-    # @return [Arrays<WeaselDiesel::Params::Rule>] 
+    # @return [Arrays<WeaselDiesel::Params::Rule>]
     #   List of optional or required param rules depending on the new param rule type
     def binary(name, options={})
       param(:binary, name, options)
@@ -262,7 +285,7 @@ class WeaselDiesel
     #    service.param.string  :type, :in => LeaderboardType.names, :default => LeaderboardType::LIFETIME
     #
     # @api public
-    # @return [Array<WeaselDiesel::Params::Rule>] 
+    # @return [Array<WeaselDiesel::Params::Rule>]
     #   List of optional or required param rules depending on the new param rule type
     def array(name, options={})
       param(:array, name, options)
@@ -279,7 +302,7 @@ class WeaselDiesel
     #    service.param.string  :type, :in => LeaderboardType.names, :default => LeaderboardType::LIFETIME
     #
     # @api public
-    # @return [Arrays<WeaselDiesel::Params::Rule>] 
+    # @return [Arrays<WeaselDiesel::Params::Rule>]
     #   List of optional or required param rules depending on the new param rule type
     def file(name, options={})
       param(:file, name, options)
@@ -358,11 +381,16 @@ class WeaselDiesel
 
     # Defines a namespaced param
     #
+    # @param [Symbol, String] name
+    #   The name of the namespace
+    # @param [Hash] opts
+    #   A hash representing the namespace settings
+    #
     # @yield [Params] the newly created namespaced param
     # @return [Array<WeaselDiesel::Params>] the list of all the namespaced params
     # @api public
-    def namespace(name)
-      params = Params.new(:space_name => name)
+    def namespace(name, opts={})
+      params = Params.new(:space_name => Namespace.new(name, :null => opts[:null]))
       yield(params) if block_given?
       namespaced_params << params unless namespaced_params.include?(params)
     end
@@ -382,9 +410,10 @@ class WeaselDiesel
     # @api public
     def param_names
       first_level_expected_params = (list_required + list_optional).map{|rule| rule.name.to_s}
-      first_level_expected_params += namespaced_params.map{|r| r.space_name.to_s}
+      first_level_expected_params += namespaced_params.map{|r| r.space_name.name.to_s}
       first_level_expected_params
     end
 
   end # of Params
+
 end

data/lib/params_verification.rb

@@ -7,14 +7,14 @@ require 'erb' # used to sanitize the error message and avoid XSS attacks
 #
 # @api public
 module ParamsVerification
-  
+
   class ParamError        < StandardError; end #:nodoc
   class NoParamsDefined   < ParamError; end #:nodoc
   class MissingParam      < ParamError; end #:nodoc
   class UnexpectedParam   < ParamError; end #:nodoc
   class InvalidParamType  < ParamError; end #:nodoc
   class InvalidParamValue < ParamError; end #:nodoc
-  
+
   # An array of validation regular expressions.
   # The array gets cached but can be accessed via the symbol key.
   #
@@ -29,12 +29,12 @@ module ParamsVerification
                             #:array    => /,/
                           }
   end
-  
+
   # Validation against each required WeaselDiesel::Params::Rule
   # and returns the potentially modified params (with default values)
-  # 
+  #
   # @param [Hash] params The params to verify (incoming request params)
-  # @param [WeaselDiesel::Params] service_params A Playco service param compatible object listing required and optional params 
+  # @param [WeaselDiesel::Params] service_params A Playco service param compatible object listing required and optional params
   # @param [Boolean] ignore_unexpected Flag letting the validation know if unexpected params should be ignored
   #
   # @return [Hash]
@@ -42,53 +42,55 @@ module ParamsVerification
   #
   # @example Validate request params against a service's defined param rules
   #   ParamsVerification.validate!(request.params, @service.defined_params)
-  # 
+  #
   # @api public
   def self.validate!(params, service_params, ignore_unexpected=false)
-    
+
     # Verify that no garbage params are passed, if they are, an exception is raised.
     # only the first level is checked at this point
     unless ignore_unexpected
       unexpected_params?(params, service_params.param_names)
     end
-    
+
     # dupe the params so we don't modify the passed value
     updated_params = params.dup
     # Required param verification
     service_params.list_required.each do |rule|
       updated_params = validate_required_rule(rule, updated_params)
     end
-    
+
     # Set optional defaults if any optional
     service_params.list_optional.each do |rule|
       updated_params = validate_optional_rule(rule, updated_params)
     end
-    
+
     # check the namespaced params
     service_params.namespaced_params.each do |param|
-      param.list_required.each do |rule|
-        updated_params = validate_required_rule(rule, updated_params, param.space_name.to_s)
-      end
-      param.list_optional.each do |rule|
-        updated_params = validate_optional_rule(rule, updated_params, param.space_name.to_s)
+      unless param.space_name.null && updated_params[param.space_name.name.to_s].nil?
+        param.list_required.each do |rule|
+          updated_params = validate_required_rule(rule, updated_params, param.space_name.name.to_s)
+        end
+        param.list_optional.each do |rule|
+          updated_params = validate_optional_rule(rule, updated_params, param.space_name.name.to_s)
+        end
       end
     end
-    
+
     # verify nested params, only 1 level deep tho
     params.each_pair do |key, value|
       if value.is_a?(Hash)
-        namespaced = service_params.namespaced_params.find{|np| np.space_name.to_s == key.to_s}
+        namespaced = service_params.namespaced_params.find{|np| np.space_name.name.to_s == key.to_s}
         raise UnexpectedParam, "Request included unexpected parameter: #{ERB::Util.html_escape(key)}" if namespaced.nil?
         unexpected_params?(params[key], namespaced.param_names)
       end
     end
-    
+
     updated_params
   end
-  
-  
+
+
   private
-  
+
   # Validates a required rule against a list of params passed.
   #
   #
@@ -131,7 +133,7 @@ module ParamsVerification
   # @param [String] namespace An optional namespace
   #
   # @return [Hash] The potentially modified params
-  # 
+  #
   # @api private
   def self.validate_optional_rule(rule, params, namespace=nil)
     param_name  = rule.name.to_s
@@ -169,7 +171,7 @@ module ParamsVerification
   # @param [Hash] params The params that might need to be updated.
   # @param [String, Symbol] namespace The optional namespace used to access the `param_value`
   #
-  # @return [Array<Object, Hash>] An array containing the param value and 
+  # @return [Array<Object, Hash>] An array containing the param value and
   #   a hash representing the potentially modified params after going through the filter.
   #
   def self.validate_and_cast_type(param_value, param_name, rule_type, params, namespace=nil)
@@ -267,8 +269,8 @@ module ParamsVerification
       end
     end
   end
-  
-  
+
+
   def self.unexpected_params?(params, param_names)
     # Raise an exception unless no unexpected params were found
     unexpected_keys = (params.keys - param_names)
@@ -276,8 +278,8 @@ module ParamsVerification
       raise UnexpectedParam, "Request included unexpected parameter(s): #{unexpected_keys.map{|k| ERB::Util.html_escape(k)}.join(', ')}"
     end
   end
-  
-  
+
+
   def self.type_cast_value(type, value)
     return value if value == nil
     case type
@@ -311,7 +313,7 @@ module ParamsVerification
       value
     end
   end
-  
+
   # Checks that the value's type matches the expected type for a given param. If a nil value is passed
   # the verification is skipped.
   #

data/lib/response.rb

@@ -34,7 +34,7 @@ class WeaselDiesel
     # @param [String, Symbol] name the name of the element.
     # @param [Hash] opts the element options.
     # @see Vector#initialize
-    def array(name, type=nil)
+    def array(name=nil, type=nil)
       vector = Vector.new(name, type)
       yield(vector) if block_given?
       @arrays << vector
@@ -101,7 +101,7 @@ class WeaselDiesel
     end
 
     # The Response element class describing each element of a service response.
-    # Instances are usually not instiated directly but via the Response#element accessor.
+    # Instances are usually not instantiated directly but via the Response#element accessor.
     #
     # @see WeaselDiesel::Response#element
     # @api public
@@ -273,7 +273,7 @@ class WeaselDiesel
       #
       # @param [Symbol, String] name the name of the element.
       # @param [Hash] opts the options for the newly created element.
-      def object(name, opts={}, &block)
+      def object(name=nil, opts={}, &block)
         element(opts.merge(:name => name), &block)
       end
 

data/lib/weasel_diesel/version.rb

@@ -1,3 +1,3 @@
 class WeaselDiesel
-  VERSION = "1.2.1"
+  VERSION = "1.2.2"
 end

data/lib/weasel_diesel.rb

@@ -366,8 +366,8 @@ class WeaselDiesel
   # and in the documentation block.
   # @api private
   def sync_input_param_doc
-    defined_params.namespaced_params.each do |prms| 
-      doc.namespace(prms.space_name) do |ns|
+    defined_params.namespaced_params.each do |prms|
+      doc.namespace(prms.space_name.name) do |ns|
         prms.list_optional.each do |rule|
           ns.param(rule.name, rule.options[:doc]) if rule.options[:doc]
         end

data/spec/json_response_description_spec.rb

@@ -176,7 +176,7 @@ describe "WeaselDiesel anonymous JSON object response description" do
     @response  = @service.response
   end
 
-  it "should have a properly structured reponse" do
+  it "should have a properly structured response" do
     top_object = @service.response.elements.first
     top_object.should_not be_nil
     name_node = top_object.properties.find{|o| o.name == :name}
@@ -185,3 +185,35 @@ describe "WeaselDiesel anonymous JSON object response description" do
   end
 
 end
+
+
+describe "WeaselDiesel top level array response description" do
+
+=begin
+'[ { "name":"Bob" }, { "name": "Judy" } ]'
+=end
+
+  before :all do
+    @service = describe_service 'tl_array' do |service|
+      service.formats :json
+      service.response do |response|
+        # anonymous array response
+        response.array do |arr|
+          arr.object do |node|
+            node.string :name
+          end
+        end
+      end
+    end
+  end
+
+  it "should have a properly structured response" do
+    top_object = @service.response.nodes.first
+    top_object.should_not be_nil
+    top_object.should be_an_instance_of(WeaselDiesel::Response::Vector)
+    top_object.elements.first.should_not be_nil
+    top_object.elements.first.attributes.first.name.should eq(:name)
+    top_object.elements.first.attributes.first.type.should eq(:string)
+  end
+
+end

data/spec/json_response_verification_spec.rb

@@ -73,16 +73,28 @@ describe "JSON response verification" do
       end
     end
 
+    @top_level_array_service = describe_service "tl_array#{__LINE__}" do |service|
+      service.formats :json
+      service.response do |response|
+        # anonymous array response
+        response.array do |arr|
+          arr.object do |node|
+            node.string :name
+          end
+        end
+      end
+    end
+
   end
 
 
   def valid_response(namespaced=true)
-    response = { 
-      "id" => 1, 
+    response = {
+      "id" => 1,
       "name" => "matt",
-      "created_at" => "2011-09-22T16:32:46-07:00", 
+      "created_at" => "2011-09-22T16:32:46-07:00",
       "creds" => { "id" => 42, "price" => 2010.07, "enabled" => false }
-      } 
+      }
     namespaced ? {"user" => response} : response
   end
 
@@ -120,9 +132,12 @@ describe "JSON response verification" do
     }
   end
 
+  def valid_top_level_array_response
+    [ { "name" => "Bob" }, { "name" => "Judy" } ]
+  end
 
   it "should validate the response" do
-    valid, errors = @service.validate_hash_response(valid_response)
+    valid, errors = @service.verify(valid_response)
     errors.should == []
     valid.should be_true
     errors.should be_empty
@@ -131,7 +146,7 @@ describe "JSON response verification" do
   it "should detect that the response is missing the top level object" do
     response = valid_response
     response.delete("user")
-    valid, errors = @service.validate_hash_response(response)
+    valid, errors = @service.verify(response)
     valid.should be_false
     errors.should_not be_empty
   end
@@ -139,7 +154,7 @@ describe "JSON response verification" do
   it "should detect that a property integer type is wrong" do
      response = valid_response
      response["user"]["id"] = 'test'
-     valid, errors = @service.validate_hash_response(response)
+     valid, errors = @service.verify(response)
      valid.should be_false
      errors.should_not be_empty
      errors.first.should match(/id/)
@@ -149,7 +164,7 @@ describe "JSON response verification" do
   it "should detect that an integer attribute value is nil" do
     response = valid_response
      response["user"]["id"] = nil
-     valid, errors = @service.validate_hash_response(response)
+     valid, errors = @service.verify(response)
      valid.should be_false
      errors.should_not be_empty
      errors.first.should match(/id/)
@@ -159,38 +174,36 @@ describe "JSON response verification" do
   it "should detect that a string attribute value is nil [bug]" do
     response = valid_response
     response["user"]["name"] = nil
-    valid, errors = @service.validate_hash_response(response)
+    valid, errors = @service.verify(response)
     valid.should be_false
     errors.should_not be_empty
     errors.first.should match(/name/)
     errors.first.should match(/wrong type/)
   end
 
-
   it "should detect that a nested object is missing" do
     response = valid_response
     response["user"].delete("creds")
-    valid, errors = @service.validate_hash_response(response)
+    valid, errors = @service.verify(response)
     valid.should be_false
     errors.first.should match(/creds/)
     errors.first.should match(/missing/)
   end
 
   it "should validate non namespaced responses" do
-    valid, errors = @second_service.validate_hash_response(valid_response(false))
+    valid, errors = @second_service.verify(valid_response(false))
     valid.should be_true
   end
 
   it "should validate nil attributes if marked as nullable" do
     response = valid_response(false)
     response["name"] = nil
-    valid, errors = @second_service.validate_hash_response(response)
+    valid, errors = @second_service.verify(response)
     valid.should be_true
   end
 
-
   it "should validate array items" do
-    valid, errors = @third_service.validate_hash_response(valid_array_response)
+    valid, errors = @third_service.verify(valid_array_response)
     valid.should be_true
     errors.should be_empty
   end
@@ -198,28 +211,40 @@ describe "JSON response verification" do
   it "should validate an empty array" do
     response = valid_array_response
     response["users"] = []
-    valid, errors = @third_service.validate_hash_response(response)
+    valid, errors = @third_service.verify(response)
     valid.should be_true
   end
 
   it "should catch error in an array item" do
     response = valid_array_response
     response["users"][1]["id"] = 'test'
-    valid, errors = @third_service.validate_hash_response(response)
+    valid, errors = @third_service.verify(response)
     valid.should be_false
     errors.should_not be_empty
   end
 
   it "should validate nested arrays" do
-    valid, errors = @forth_service.validate_hash_response(valid_nested_array_response)
+    valid, errors = @forth_service.verify(valid_nested_array_response)
     valid.should be_true
   end
 
-
   it "should respect optional properties" do
-    valid, errors = @optional_prop_service.validate_hash_response({})
+    valid, errors = @optional_prop_service.verify({})
     valid.should be_true
   end
 
+  it "should validate the response" do
+    valid, errors = @service.verify(valid_response)
+    errors.should == []
+    valid.should be_true
+    errors.should be_empty
+  end
+
+  it "should validated a top level array" do
+    valid, errors = @top_level_array_service.verify(valid_top_level_array_response)
+    errors.should == []
+    valid.should be_true
+    errors.should be_empty
+  end
 
 end

data/spec/params_verification_spec.rb

@@ -1,24 +1,24 @@
 require_relative "spec_helper"
 
 describe ParamsVerification do
-  
+
   before :all do
     @service = WSList.find(:get, '/services/test.xml')
     @service.should_not be_nil
-    @valid_params = {'framework' => 'RSpec', 'version' => '1.02', 'user' => {'id' => '123', 'groups' => 'manager,developer', 'skills' => 'java,ruby'}}
+    @valid_params = {'framework' => 'RSpec', 'version' => '1.02', 'options' => nil, 'user' => {'id' => '123', 'groups' => 'manager,developer', 'skills' => 'java,ruby'}}
   end
 
   def copy(params)
     Marshal.load( Marshal.dump(params) )
   end
-  
+
   it "should validate valid params" do
     params = copy(@valid_params)
     lambda{ ParamsVerification.validate!(params, @service.defined_params) }.should_not raise_exception
     params['name'] = 'Mattetti'
     lambda{ ParamsVerification.validate!(params, @service.defined_params) }.should_not raise_exception
   end
-  
+
   it "should return the params" do
     params = copy(@valid_params)
     returned_params = ParamsVerification.validate!(params, @service.defined_params)
@@ -31,7 +31,7 @@ describe ParamsVerification do
     returned_params = ParamsVerification.validate!(params, @service.defined_params)
     returned_params.has_key?('name').should be_false
   end
-  
+
   it "should return array in the params" do
     params = copy(@valid_params)
     returned_params = ParamsVerification.validate!(params, @service.defined_params)
@@ -79,7 +79,21 @@ describe ParamsVerification do
     returned_params = ParamsVerification.validate!(params, @service.defined_params)
     returned_params['user']['mailing_list'].should be_true
   end
-  
+
+  it "should verify child param rules if namespace is not null, but it nullable" do
+    params = copy(@valid_params)
+    params['options'] = {'verbose' => 'true'}
+    returned_params = ParamsVerification.validate!(params, @service.defined_params)
+    returned_params['options']['verbose'].should be_true
+  end
+
+  it "should skip child param rules if namespace is null" do
+    params = copy(@valid_params)
+    params['options'].should be_nil
+    returned_params = ParamsVerification.validate!(params, @service.defined_params)
+    returned_params['options'].should be_nil
+  end
+
   it "should raise an exception when a required param is missing" do
     params = copy(@valid_params)
     params.delete('framework')
@@ -99,13 +113,13 @@ describe ParamsVerification do
     params = {'seq' => "a b c d e g"}
     lambda{ ParamsVerification.validate!(params, service.defined_params) }.should_not raise_exception(ParamsVerification::InvalidParamType)
   end
-  
+
   it "should raise an exception when a param is of the wrong type" do
     params = copy(@valid_params)
     params['user']['id'] = 'abc'
     lambda{ ParamsVerification.validate!(params, @service.defined_params) }.should raise_exception(ParamsVerification::InvalidParamType)
   end
-  
+
   it "should raise an exception when a param is under the min_value" do
     params = copy(@valid_params)
     params['num'] = '1'
@@ -131,7 +145,7 @@ describe ParamsVerification do
     params['name'] = "Whether 'tis nobler in the mind to suffer The slings and arrows of outrageous fortune"
     lambda{ ParamsVerification.validate!(params, @service.defined_params) }.should raise_exception(ParamsVerification::InvalidParamValue)
   end
-  
+
   it "should raise an exception when a param isn't in the param option list" do
     params = copy(@valid_params)
     params['alpha'] = 'z'
@@ -186,7 +200,7 @@ describe ParamsVerification do
     params['version'] = ''
     lambda{ ParamsVerification.validate!(params, @service.defined_params) }.should raise_exception(ParamsVerification::InvalidParamValue)
   end
-  
+
   it "should allow optional null integer params" do
     service = WeaselDiesel.new("spec")
     service.params do |p|

data/spec/test_services.rb

@@ -31,6 +31,10 @@ describe_service "services/test.xml" do |service|
     user.array   :skills, :in => %w{ruby java networking}
   end
 
+  service.params.namespace :options, :null => true do |option|
+    option.boolean :verbose, :default => false, :required => :true
+  end
+
   # the response contains a list of player creation ratings each object in the list
 
 =begin

data/spec/wd_params_spec.rb

@@ -10,8 +10,8 @@ describe WeaselDiesel::Params do
 
   it "should have the possibility to have a space name" do
     @sparams.should respond_to(:space_name)
-    service_params = WeaselDiesel::Params.new(:space_name => 'spec_test')
-    service_params.space_name.should == 'spec_test'
+    service_params = WeaselDiesel::Params.new(:space_name => WeaselDiesel::Params::Namespace.new('spec_test'))
+    service_params.space_name.name.should == 'spec_test'
   end
 
   it "should have a list of required param rules" do
@@ -26,8 +26,9 @@ describe WeaselDiesel::Params do
 
   it "should have a list of namespaced param rules" do
     @sparams.namespaced_params.should be_an_instance_of(Array)
-    @sparams.namespaced_params.length.should == 1
-    @sparams.namespaced_params.first.space_name.should == :user
+    @sparams.namespaced_params.length.should == 2
+    @sparams.namespaced_params.first.space_name.name.should == :user
+    @sparams.namespaced_params[1].space_name.name.should == :options
   end
 
   it "should allow to define namespaced param" do
@@ -38,7 +39,7 @@ describe WeaselDiesel::Params do
       end
     end
     service.params.namespaced_params.should_not be_empty
-    ns = service.params.namespaced_params.find{|ns| ns.space_name == :preference}
+    ns = service.params.namespaced_params.find{|ns| ns.space_name.name == :preference}
     ns.should_not be_nil
     ns.list_optional.first.name.should == "Ze id."
   end
@@ -51,7 +52,7 @@ describe WeaselDiesel::Params do
       end
     end
     service.params.namespaced_params.should_not be_empty
-    ns = service.params.namespaced_params.find{|ns| ns.space_name == :preference}
+    ns = service.params.namespaced_params.find{|ns| ns.space_name.name == :preference}
     ns.should_not be_nil
     ns.list_optional.first.name.should == "Ze id."
   end
@@ -73,4 +74,19 @@ describe WeaselDiesel::Params do
     end
   end
 
+  describe WeaselDiesel::Params::Namespace do
+    before :all do
+      @namespace = @sparams.namespaced_params.first.space_name
+      @namespace.should_not be_nil
+    end
+
+    it "should have a name" do
+      @namespace.name.should == :user
+    end
+
+    it "should have a null attribute" do
+      @namespace.null.should be_false
+    end
+  end
+
 end

metadata

@@ -1,94 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: weasel_diesel
 version: !ruby/object:Gem::Version
-  version: 1.2.1
-  prerelease: 
+  version: 1.2.2
 platform: ruby
 authors:
 - Matt Aimonetti
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-19 00:00:00.000000000 Z
+date: 2013-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rack-test
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: sinatra
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: Ruby DSL describing Web Services without implementation details.
@@ -134,33 +123,26 @@ files:
 - weasel_diesel.gemspec
 homepage: https://github.com/mattetti/Weasel-Diesel
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 1325572656893606813
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 1325572656893606813
 requirements: []
 rubyforge_project: wsdsl
-rubygems_version: 1.8.24
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Web Service DSL
 test_files:
 - spec/hello_world_controller.rb