classy_hash 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9462ba9bbda68a8f041537f21350db0341030dfd
+  data.tar.gz: bc4645ff1e3da6c864c96de07930130b32723ede
+SHA512:
+  metadata.gz: 1cd58d6a703ddbd622c412c3d826b048a188af021deff0e9c0e02e53568315103473889ffcc5d1657da207a9f1184886e47758bdf7ab24e904f3856cae59a9e8
+  data.tar.gz: df4c9a612073aa3a437b9d9b003f8394dfd14e6a9ffbc843701ae21d5ae78c4f97cd7330b9f3391b8ac10f656778f3eeaf3f3251e8217910c33646d5a47ac0b7

data/lib/classy_hash.rb

@@ -0,0 +1,163 @@
+# Classy Hash: Keep Your Hashes Classy
+# Created May 2014 by Mike Bourgeous, DeseretBook.com
+# Copyright (C)2014 Deseret Book
+# See LICENSE and README.md for details.
+
+# This module contains the ClassyHash methods for making sure Ruby Hash objects
+# match a given schema.  ClassyHash runs fast by taking advantage of Ruby
+# language features and avoiding object creation during validation.
+module ClassyHash
+  # Validates a +hash+ against a +schema+.  The +parent_path+ parameter is used
+  # internally to generate error messages.
+  def self.validate(hash, schema, parent_path=nil)
+    raise 'Must validate a Hash' unless hash.is_a?(Hash) # TODO: Allow validating other types by passing to #check_one?
+    raise 'Schema must be a Hash' unless schema.is_a?(Hash) # TODO: Allow individual element validations?
+
+    schema.each do |key, constraint|
+      if hash.include?(key)
+        self.check_one(key, hash[key], constraint, parent_path)
+      elsif !(constraint.is_a?(Array) && constraint.include?(:optional))
+        self.raise_error(parent_path, key, "present")
+      end
+    end
+
+    nil
+  end
+
+  # As with #validate, but members not specified in the +schema+ are forbidden.
+  # Only the top-level schema is strictly validated.
+  def self.validate_strict(hash, schema, parent_path=nil)
+    raise 'Must validate a Hash' unless hash.is_a?(Hash) # TODO: Allow validating other types by passing to #check_one?
+    raise 'Schema must be a Hash' unless schema.is_a?(Hash) # TODO: Allow individual element validations?
+
+    unless (hash.keys - schema.keys).empty?
+      raise "Hash contains members not specified in schema"
+    end
+
+    # TODO: Strict validation for nested schemas as well
+
+    self.validate(hash, schema, parent_path)
+  end
+
+  # Raises an error unless the given +value+ matches one of the given multiple
+  # choice +constraints+.
+  def self.check_multi(key, value, constraints, parent_path=nil)
+    if constraints.length == 0
+        self.raise_error(parent_path, key, "a valid multiple choice constraint (array must not be empty)")
+    end
+
+    # Optimize the common case of a direct class match
+    return if constraints.include?(value.class)
+
+    error = nil
+    constraints.each do |c|
+      next if c == :optional
+      begin
+        self.check_one(key, value, c, parent_path)
+        return
+      rescue => e
+        # Throw schema and array errors immediately
+        if (c.is_a?(Hash) && value.is_a?(Hash)) ||
+          (c.is_a?(Array) && value.is_a?(Array) && c.length == 1 && c.first.is_a?(Array))
+          raise e
+        end
+      end
+    end
+
+    self.raise_error(parent_path, key, "one of #{multiconstraint_string(constraints)}")
+  end
+
+  # Generates a semi-compact String describing the given +constraints+.
+  def self.multiconstraint_string constraints
+    constraints.map{|c|
+      if c.is_a?(Hash)
+        "{...schema...}"
+      elsif c.is_a?(Array)
+        "[#{self.multiconstraint_string(c)}]"
+      elsif c == :optional
+        nil
+      else
+        c.inspect
+      end
+    }.compact.join(', ')
+  end
+
+  # Checks a single value against a single constraint.
+  def self.check_one(key, value, constraint, parent_path=nil)
+    case constraint
+    when Class
+      # Constrain value to be a specific class
+      if constraint == TrueClass || constraint == FalseClass
+        unless value == true || value == false
+          self.raise_error(parent_path, key, "true or false")
+        end
+      elsif !value.is_a?(constraint)
+        self.raise_error(parent_path, key, "a/an #{constraint}")
+      end
+
+    when Hash
+      # Recursively check nested Hashes
+      self.raise_error(parent_path, key, "a Hash") unless value.is_a?(Hash)
+      self.validate(value, constraint, self.join_path(parent_path, key))
+
+    when Array
+      # Multiple choice or array validation
+      if constraint.length == 1 && constraint.first.is_a?(Array)
+        # Array validation
+        self.raise_error(parent_path, key, "an Array") unless value.is_a?(Array)
+
+        constraints = constraint.first
+        value.each_with_index do |v, idx|
+          self.check_multi(idx, v, constraints, self.join_path(parent_path, key))
+        end
+      else
+        # Multiple choice
+        self.check_multi(key, value, constraint, parent_path)
+      end
+
+    when Proc
+      # User-specified validator
+      result = constraint.call(value)
+      if result != true
+        self.raise_error(parent_path, key, result.is_a?(String) ? result : "accepted by Proc")
+      end
+
+    when Range
+      # Range (with type checking for common classes)
+      if constraint.min.is_a?(Integer) && constraint.max.is_a?(Integer)
+        self.raise_error(parent_path, key, "an Integer") unless value.is_a?(Integer)
+      elsif constraint.min.is_a?(Numeric)
+        self.raise_error(parent_path, key, "a Numeric") unless value.is_a?(Numeric)
+      elsif constraint.min.is_a?(String)
+        self.raise_error(parent_path, key, "a String") unless value.is_a?(String)
+      end
+
+      unless constraint.cover?(value)
+        self.raise_error(parent_path, key, "in range #{constraint.inspect}")
+      end
+
+    when :optional
+      # Optional key marker in multiple choice validators
+      nil
+
+    else
+      # Unknown schema constraint
+      self.raise_error(parent_path, key, "a valid schema constraint: #{constraint.inspect}")
+    end
+
+    nil
+  end
+
+  def self.join_path(parent_path, key)
+    parent_path ? "#{parent_path}[#{key.inspect}]" : key.inspect
+  end
+
+  # Raises an error indicating that the given +key+ under the given
+  # +parent_path+ fails because the value "is not #{+message+}".
+  def self.raise_error(parent_path, key, message)
+    # TODO: Ability to validate all keys
+    raise "#{self.join_path(parent_path, key)} is not #{message}"
+  end
+end
+
+require 'classy_hash/generate'

data/lib/classy_hash/generate.rb

@@ -0,0 +1,103 @@
+
+module ClassyHash
+  # This module contains helpers that generate constraints for common
+  # ClassyHash validation tasks.
+  module Generate
+    # Generates a ClassyHash constraint that ensures a value is equal to one of
+    # the arguments in +args+.
+    #
+    # Example:
+    #     schema = {
+    #       a: ClassyHash::Generate.enum(1, 2, 3, 4)
+    #     }
+    #     ClassyHash.validate({ a: 1 }, schema)
+    def self.enum *args
+      lambda {|v|
+        args.include?(v) || "an element of #{args.inspect}"
+      }
+    end
+
+    # Generates a constraint that imposes a length limitation (an exact length
+    # or a range) on any type that responds to the :length method (e.g. String,
+    # Array, Hash).
+    #
+    # Example:
+    #     schema = {
+    #       a: ClassyHash::Generate.length(0..5)
+    #     }
+    #     ClassyHash.validate({a: '12345'}, schema)
+    #     ClassyHash.validate({a: [1, 2, 3, 4, 5]}, schema)
+    def self.length length
+      raise "length must be an Integer or a Range" unless length.is_a?(Integer) || length.is_a?(Range)
+
+      if length.is_a?(Range) && !(length.min.is_a?(Integer) && length.max.is_a?(Integer))
+        raise "Range length endpoints must be Integers"
+      end
+
+      lambda {|v|
+        if v.respond_to?(:length)
+          if v.length == length || (length.is_a?(Range) && length.cover?(v.length))
+            true
+          else
+            "of length #{length}"
+          end
+        else
+          "a type that responds to :length"
+        end
+      }
+    end
+
+    # Generates a constraint that validates an Array's +length+ and contents
+    # using one or more +constraints+.
+    #
+    # Example:
+    #     schema = {
+    #       a: ClassyHash::Generate.array_length(4..5, Integer, String)
+    #     }
+    #     ClassyHash.validate({ a: [ 1, 2, 3, 'four', 5 ] }, schema)
+    def self.array_length length, *constraints
+      raise 'one or more constraints must be provided' if constraints.empty?
+
+      length_lambda = self.length(length)
+      msg = "an Array of length #{length}"
+
+      lambda {|v|
+        if v.is_a?(Array)
+          result = length_lambda.call(v)
+          if result == true
+            begin
+              ClassyHash.validate({array: v}, {array: [constraints]})
+              true
+            rescue => e
+              "valid: #{e}"
+            end
+          else
+            msg
+          end
+        else
+          msg
+        end
+      }
+    end
+
+    # Generates a constraint that validates the +length+ of a String.
+    #
+    # Example:
+    #     schema = {
+    #       a: ClassyHash::Generate.string_length(3)
+    #     }
+    #     ClassyHash.validate({a: '123'}, schema)
+    def self.string_length length
+      length_lambda = self.length(length)
+      msg = "a String of length #{length}"
+
+      lambda {|v|
+        if v.is_a?(String)
+          length_lambda.call(v) == true || msg
+        else
+          msg
+        end
+      }
+    end
+  end
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: classy_hash
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Deseret Book
+- Mike Bourgeous
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-03 00:00:00.000000000 Z
+dependencies: []
+description: |2
+      Classy Hash is a schema validator for Ruby Hashes.  You provide a simple
+      schema Hash, and Classy Hash will make sure your data matches, providing
+      helpful error messages if it doesn't.
+email: mike@mikebourgeous.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/classy_hash.rb
+- lib/classy_hash/generate.rb
+homepage: https://github.com/deseretbook/classy_hash
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: 'Classy Hash: Keep your Hashes classy; a Hash schema validator'
+test_files: []