simple_schema 0.0.1 → 0.0.2

data/README.md

@@ -0,0 +1,89 @@
+# Simple Schema
+
+simple schema gem is a fantastic converter / validator (only presence)
+
+# Features
+
+* Agnostic
+* Easy Use
+* Lambda support
+* Usefull with rack-api
+* Code Base Small < 2000 lines
+* Support Add On-the-fly Strategies
+
+# How to install
+
+## for Rails 3 app
+
+### Add on your Gemfile
+
+gem "simple_schema"
+
+# Examples
+
+## to conveter
+
+      schema = SimpleSchema::Schema.new({
+        :name => {
+          :key_name => :nome
+        }
+      })
+      converter = SimpleSchema::Converter.new(schema)
+      output = converter.translate({
+        :name => "renato"
+      }) 
+      #output is:  {:nome => "renato"}
+ 
+
+## to validate
+      validator = SimpleSchema::Validator.new(
+          SimpleSchema::Schema.new({
+           :friends => {
+             :items => {
+               :name => {}
+            }
+           }
+          })
+        )
+
+        check_valid = validator.valid?({
+         :friends => [{:name => "Lenon"},{:name => "Madson"}]
+        })
+        
+        #check_valid is true
+        
+        
+        validator.validate!({
+         :friends => [{:name => "Lenon"},{}]
+        })
+        }
+        
+        # raise error  SimpleSchema::MissingAttribute with "Missing friends/1/name"
+ 
+
+# License
+
+(The MIT License)
+
+  Copyright (c) 2011
+
+  Permission is hereby granted, free of charge, to any person obtaining
+  a copy of this software and associated documentation files (the
+      'Software'), to deal in the Software without restriction, including
+  without limitation the rights to use, copy, modify, merge, publish,
+  distribute, sublicense, and/or sell copies of the Software, and to
+  permit persons to whom the Software is furnished to do so, subject to
+  the following conditions:
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+

data/lib/simple_schema.rb

@@ -1,3 +1,26 @@
 require 'simple_schema/errors'
+require 'simple_schema/injection'
+require 'simple_schema/schema_items'
+require 'simple_schema/schema_properties'
+require 'simple_schema/schema'
+require 'simple_schema/validator_items'
+require 'simple_schema/validator_properties'
+require 'simple_schema/validator_lambda'
 require 'simple_schema/validator'
+require 'simple_schema/converter_items'
+require 'simple_schema/converter_properties'
+require 'simple_schema/converter'
 
+
+module SimpleSchema
+  def self.translate(key, key_name)
+        begin 
+          translated_key = key_name
+          translated_key = key if translated_key.empty?
+          translated_key = translated_key.to_sym
+        rescue
+          translated_key = key
+        end
+    translated_key
+  end
+end

data/lib/simple_schema/converter.rb

@@ -0,0 +1,34 @@
+module SimpleSchema
+  class Converter
+    attr_reader :schema, :options
+
+    def initialize(schema, options = {})
+      options[:translates] ||= [ConverterItems,ConverterProperties]
+      @schema = schema
+      @schema = @schema.schema if @schema.respond_to?(:schema)
+      @options = options
+    end
+
+    def translate(data)
+       if !data.respond_to?(:each) && !data.respond_to?(:fetch)
+          raise InvalidDataType.new(data.class)
+       end
+
+      translated_data  = {}
+      @schema.each do |key, properties|
+
+        translated_key = SimpleSchema.translate(key, properties[:key_name])
+        value = data.fetch(key, nil)
+
+        @options[:translates].each do |normalizer|
+          value = normalizer.build(value, properties, @options)
+        end
+
+        translated_data[translated_key] = value
+      end
+
+      translated_data
+    end
+ end
+end
+

data/lib/simple_schema/converter_items.rb

@@ -0,0 +1,14 @@
+module SimpleSchema
+  class ConverterItems
+    def self.build(data, schema, options)
+      return data unless (schema[:type] == :array)
+      conveter = Converter::new(schema[:items], options)
+      items = []
+      data.each do |item|
+        items << conveter.translate(item)
+      end
+      return items
+    end
+  end
+end
+

data/lib/simple_schema/converter_properties.rb

@@ -0,0 +1,9 @@
+module SimpleSchema
+  class ConverterProperties
+    def self.build(data, schema, options)
+      return data unless (schema[:type] == :object)
+      return Converter::new(schema[:properties], options).translate(data)
+    end
+  end
+end
+

data/lib/simple_schema/errors.rb

@@ -1,29 +1,30 @@
 module SimpleSchema
-  class Validator
-    class InvalidSchemaType < Exception
+  class InvalidBuilder < Exception
+
+  end
+
+  class InvalidSchemaType < Exception
       attr_reader :type
       def initialize(type)
         @type = type
         super "Schema must be either an Array or a Hash, got #{type}"
       end
-    end
+  end
 
-    class InvalidDataType < Exception
-      attr_reader :type
-      def initialize(type)
-        @type = type
-        super "Data must be a Hash, got #{type}"
-      end
+  class InvalidDataType < Exception
+    attr_reader :type
+    def initialize(type)
+      @type = type
+      super "Data must be a Hash, got #{type}"
     end
+  end
 
-    class MissingAttribute < Exception
-      attr_reader :attribute, :fragments
+  class MissingAttribute < Exception
+    attr_reader :fragments
 
-      def initialize(attribute, fragments)
-        @attribute = attribute
-        @fragments = fragments
-        super "Missing #{fragments.join('/')}"
-      end
+    def initialize(fragments)
+      @fragments = fragments
+      super "Missing #{fragments.join('/')}"
     end
   end
 end

data/lib/simple_schema/injection.rb

@@ -0,0 +1,23 @@
+module SimpleSchema
+  module Injection
+
+    def normalizers
+      build_injection
+    end
+
+    def registry(normalizer)
+      raise SimpleSchema::InvalidBuilder.new unless normalizer.respond_to?(:build)
+      build_injection << normalizer
+    end
+
+    def unregistry(class_name)
+      build_injection.slice!(build_injection.index(class_name))
+    end
+
+    def build_injection
+      self.class_variable_set(:@@normalizers_table, []) unless self.class_variable_defined?(:@@normalizers_table)
+      self.class_variable_get(:@@normalizers_table)
+    end
+ end
+end
+

data/lib/simple_schema/schema.rb

@@ -0,0 +1,31 @@
+module SimpleSchema
+  class Schema
+    attr_reader :schema, :options
+
+    def initialize(defined_schema, options = {})
+      options[:normalizers] ||= [SchemaItems, SchemaProperties]
+      options[:defaults] ||= {:required => true, :type => :string}
+      raise InvalidSchemaType.new(defined_schema.class) unless defined_schema.is_a?(Hash) || defined_schema.is_a?(Array)
+      @options = options
+      @schema = normalize(defined_schema)
+    end
+
+    private
+
+    def normalize(properties)
+      h = {}
+      properties.each do |key,value|
+        value = {} if value.nil?
+        key = key.to_sym
+        value = {:key_name => key}.merge(@options[:defaults].merge(value))
+        @options[:normalizers].each do |normalizer|
+          value = normalizer.build(value, options)
+        end
+        h[key] = value
+      end
+      
+      h
+    end
+ end
+end
+

data/lib/simple_schema/schema_items.rb

@@ -0,0 +1,12 @@
+module SimpleSchema
+  class SchemaItems
+    def self.build(schema, options)
+      if schema[:items]
+        schema[:type] = :array
+        schema[:items] = Schema.new(schema[:items], options).schema
+      end
+      schema
+    end
+  end
+end
+

data/lib/simple_schema/schema_properties.rb

@@ -0,0 +1,12 @@
+module SimpleSchema
+  class SchemaProperties
+    def self.build(schema, options)
+      if schema[:properties]
+        schema[:type] = :object
+        schema[:properties] = Schema.new(schema[:properties], options).schema
+      end
+      schema
+    end
+  end
+end
+

data/lib/simple_schema/validator.rb

@@ -1,159 +1,77 @@
 module SimpleSchema
   class Validator
-    attr_reader :schema, :fragments, :data
-
-    def initialize(schema, data)
-      if !schema.is_a?(Hash) && !schema.is_a?(Array)
-        raise InvalidSchemaType.new(schema.class)
-      end
-
-      if !data.is_a?(Hash)
-        raise InvalidDataType.new(data.class)
-      end
-
-      @data = data
-      @fragments = []
-      @schema = build_schema({ :properties => schema })[:properties]
+    attr_reader :schema, :options
+    
+    def initialize(schema, options = {})
+      options[:validators] ||= [ValidatorItems, ValidatorLambda, ValidatorProperties]
+      @options = options
+      @schema = schema
+      @schema = @schema.schema if @schema.respond_to?(:schema)
     end
 
-    def valid?
+    def valid?(data, options = {
+      :original_data => nil,
+      :original_schema => nil
+    })
       begin
-        validate(@schema, @data)
-      rescue MissingAttribute
+        self.validate(data, options)
+      rescue MissingAttribute => e
         false
       end
     end
 
-    def validate!
-      validate(@schema, @data)
-    end
-
-    def translated_data
-      translate_data(@data, @schema)
+    def validate!(data, options = {
+      :original_data => nil,
+      :original_schema => nil
+    })
+      self.validate(data, options)
     end
 
-    private
-
-    def schema_defaults
-      { :required => true, :type => :string }
-    end
-
-    def normalize_properties(properties)
-      return properties unless properties.is_a?(Array)
-      h = {}
-      properties.each do |key|
-        h[key] = {}
-      end
-      h
-    end
-
-    def build_schema(current_schema)
-      schema = schema_defaults
-
-      current_schema.each do |property, value|
-        property = property.to_sym
-
-        case property
-        when :required
-          schema[:required] = value
-        when :type
-          schema[:type] = value.to_sym
-        when :properties
-          schema[:type] = :object
-          schema[:properties] = Hash.new
-
-          normalize_properties(value).each do |property, value|
-            original_key = property.to_sym
-            property = value[:key_name] unless value[:key_name].nil?
-            value[:key_name] = original_key
-            schema[:properties][property.to_sym] = build_schema(value)
-          end
-        when :items
-          schema[:type] = :array
-          schema[:items] = Hash.new
-
-          normalize_properties(value).each do |property, value|
-            original_key = property.to_sym
-            property = value[:key_name] unless value[:key_name].nil?
-            value[:key_name] = original_key
-            schema[:items][property.to_sym] = build_schema(value)
-          end
-        when :key_name
-          schema[:key_name] = value
-        end
+    protected
+    def validate(data, options)
+      if !data.is_a?(Hash)
+        raise InvalidDataType.new(data.class)
       end
+      
+      options[:original_data] ||= data
+      options[:original_schema] ||= @schema
+      options[:path] ||= []
 
-      schema
-    end
+      @schema.each do |key, properties|
+        required = properties[:required]
+        required = false if properties[:required].is_a?(Proc)
 
-    def validate(current_schema, data)
-      current_schema.each do |property_name, schema|
-
-        @fragments << property_name
-
-        required_value = schema[:required]
-
-        if required_value.respond_to?(:call)
-           required_value = required_value.call(@data, @schema)
-        end
+        requireds = [required]
 
-        if required_value && (data.respond_to?(:has_key?) && !data.has_key?(property_name))
-          raise MissingAttribute.new(property_name, fragments)
+        translated_key = if options[:translate]
+          SimpleSchema.translate(key, properties[:key_name])
+        else
+          key
         end
+        
+        value = data.fetch(translated_key, nil)
 
-        if required_value
-
-          case schema[:type]
-          when :string
-            if !data[property_name].is_a?(String) || data[property_name].strip.empty?
-              raise MissingAttribute.new(property_name, fragments)
-            end
-          when :object
-            if !data[property_name].is_a?(Hash) || !data[property_name].any?
-              raise MissingAttribute.new(property_name, fragments)
-            end
-            validate(schema[:properties], data[property_name])
-          when :array
-            if !data[property_name].is_a?(Array) || !data[property_name].any?
-              raise MissingAttribute.new(property_name, fragments)
-            end
-            data[property_name].each_with_index do |item, index|
-              @fragments << index
-              validate(schema[:items], item)
-              @fragments.pop
-            end
-          end
+        if value.respond_to?(:empty?)
+          nuller = value.nil? || value.empty?
+        elsif value.respond_to?(:blank?)
+          nuller = value.nil? || value.blank?
+        else
+          nuller = value.nil?
         end
 
-        @fragments.pop
-      end
-    end
-
-    def translate_data(data, current_schema)
-      new_data = {}
-
-      data.each do |key, value|
-        if !current_schema || !current_schema.has_key?(key)
-          new_data[key] = value
-          next
+        path = options[:path] + [translated_key]
+        
+        @options[:validators].each do |normalizer|
+          requireds << normalizer.build(value, properties, @options, options.merge({:path => path}))
         end
 
-        new_key = current_schema[key][:key_name]
+        requireds.each { |required|
+          raise MissingAttribute.new(path) if required && nuller
+        }
 
-        if value.is_a?(Array)
-          new_value = []
-          value.each do |value|
-            new_value << translate_data(value, current_schema[key][:items])
-          end
-          new_data[new_key] = new_value
-        elsif value.is_a?(Hash)
-          new_data[new_key] = translate_data(value, current_schema[key][:properties])
-        else
-          new_data[new_key] = value
-        end
       end
 
-      new_data
+      true
     end
   end
 end

data/lib/simple_schema/validator_items.rb

@@ -0,0 +1,14 @@
+module SimpleSchema
+  class ValidatorItems
+    def self.build(data, schema, class_options, options)
+      return false unless (schema[:type] == :array)
+      raise MissingAttribute.new(options[:path]) unless data.respond_to?(:each_index)
+      data.each_index do |index|
+        options_item = options.merge({:path => options[:path] + [index] })
+        validator = Validator::new(schema[:items], class_options)
+        validator.validate!(data[index], options_item)
+      end
+    end
+  end
+end
+

data/lib/simple_schema/validator_lambda.rb

@@ -0,0 +1,9 @@
+module SimpleSchema
+  class ValidatorLambda
+    def self.build(data, schema, class_options, options)
+      return false unless (schema[:required].is_a?(Proc))
+      schema[:required].call(options[:original_data], options[:original_schema])
+    end
+  end
+end
+

data/lib/simple_schema/validator_properties.rb

@@ -0,0 +1,14 @@
+module SimpleSchema
+  class ValidatorProperties
+    def self.build(data, schema, class_options, options)
+      return false unless (schema[:type] == :object)
+      begin
+        validator = Validator::new(schema[:properties], class_options)
+        validator.validate!(data, options)
+     rescue InvalidDataType
+        raise MissingAttribute.new(options[:path])
+      end
+    end
+  end
+end
+

data/lib/simple_schema/version.rb

@@ -1,4 +1,4 @@
 module SimpleSchema
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple_schema
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -13,11 +13,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-16 00:00:00.000000000Z
+date: 2011-09-02 00:00:00.000000000 -03:00
+default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &12972440 !ruby/object:Gem::Requirement
+  requirement: &14768220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -25,7 +26,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *12972440
+  version_requirements: *14768220
 description: Simple schema validator for Ruby
 email:
 - lenon.marcel@gmail.com
@@ -37,12 +38,23 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/simple_schema/version.rb
+- lib/simple_schema/validator_items.rb
+- lib/simple_schema/schema.rb
+- lib/simple_schema/validator_lambda.rb
+- lib/simple_schema/converter.rb
+- lib/simple_schema/schema_items.rb
+- lib/simple_schema/injection.rb
+- lib/simple_schema/converter_properties.rb
 - lib/simple_schema/validator.rb
+- lib/simple_schema/version.rb
+- lib/simple_schema/schema_properties.rb
 - lib/simple_schema/errors.rb
+- lib/simple_schema/validator_properties.rb
+- lib/simple_schema/converter_items.rb
 - lib/simple_schema.rb
 - LICENSE
-- README
+- README.md
+has_rdoc: true
 homepage: http://github.com/concretesolutions/simple_schema/
 licenses: []
 post_install_message: 
@@ -63,7 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.6
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Simple schema validator for Ruby