rschema 2.4.0 → 3.0.1.pre1

data/lib/rschema/schemas/fixed_length_array.rb

@@ -0,0 +1,60 @@
+module RSchema
+  module Schemas
+    class FixedLengthArray
+      attr_reader :subschemas
+
+      def initialize(subschemas)
+        @subschemas = subschemas
+      end
+
+      def call(value, options=RSchema::Options.default)
+        unless value.kind_of?(Array)
+          return Result.failure(Error.new(
+            symbolic_name: :not_an_array,
+            schema: self,
+            value: value,
+          ))
+        end
+
+        unless value.size == @subschemas.size
+          return Result.failure(Error.new(
+            symbolic_name: :incorrect_size,
+            schema: self,
+            value: value,
+          ))
+        end
+
+        validate_value, error = apply_subschemas(value, options)
+        if error.empty?
+          Result.success(validate_value)
+        else
+          Result.failure(error)
+        end
+      end
+
+      def with_wrapped_subschemas(wrapper)
+        wrapped_subschemas = subschemas.map{ |ss| wrapper.wrap(ss) }
+        self.class.new(wrapped_subschemas)
+      end
+
+      private
+
+      def apply_subschemas(array_value, options)
+        validate_value = []
+        errors = {}
+
+        array_value.zip(@subschemas).each_with_index do |(subvalue, subschema), idx|
+          result = subschema.call(subvalue, options)
+          if result.valid?
+            validate_value << result.value
+          else
+            errors[idx] = result.error
+            break if options.fail_fast?
+          end
+        end
+
+        [validate_value, errors]
+      end
+    end
+  end
+end

data/lib/rschema/schemas/maybe.rb

@@ -0,0 +1,23 @@
+module RSchema
+  module Schemas
+    class Maybe
+      attr_reader :subschema
+
+      def initialize(subschema)
+        @subschema = subschema
+      end
+
+      def call(value, options=Options.default)
+        if value == nil
+          Result.success(value)
+        else
+          @subschema.call(value, options)
+        end
+      end
+
+      def with_wrapped_subschemas(wrapper)
+        self.class.new(wrapper.wrap(subschema))
+      end
+    end
+  end
+end

data/lib/rschema/schemas/pipeline.rb

@@ -0,0 +1,27 @@
+module RSchema
+  module Schemas
+    class Pipeline
+      attr_reader :subschemas
+
+      def initialize(subschemas)
+        @subschemas = subschemas
+      end
+
+      def call(value, options=Options.default)
+        result = Result.success(value)
+
+        subschemas.each do |subsch|
+          result = subsch.call(result.value, options)
+          break if result.invalid?
+        end
+
+        result
+      end
+
+      def with_wrapped_subschemas(wrapper)
+        wrapped_subschemas = subschemas.map{ |ss| wrapper.wrap(ss) }
+        self.class.new(wrapped_subschemas)
+      end
+    end
+  end
+end

data/lib/rschema/schemas/predicate.rb

@@ -0,0 +1,27 @@
+module RSchema
+  module Schemas
+    class Predicate
+      attr_reader :block
+
+      def initialize(block)
+        @block = block
+      end
+
+      def call(value, options=Options.default)
+        if block.call(value)
+          Result.success(value)
+        else
+          Result.failure(Error.new(
+            schema: self,
+            value: value,
+            symbolic_name: :false,
+          ))
+        end
+      end
+
+      def with_wrapped_subschemas(wrapper)
+        self
+      end
+    end
+  end
+end

data/lib/rschema/schemas/set.rb

@@ -0,0 +1,56 @@
+require 'set'
+
+module RSchema
+  module Schemas
+    class Set
+      attr_reader :subschema
+
+      def initialize(subschema)
+        @subschema = subschema
+      end
+
+      def call(value, options=RSchema::Options.default)
+        return not_a_set_result(value) unless value.is_a?(::Set)
+
+        result_value = ::Set.new
+        result_errors = []
+
+        value.each do |subvalue|
+          subresult = subschema.call(subvalue, options)
+          if subresult.valid?
+            result_value << subresult.value
+          else
+            result_errors << subresult.error
+          end
+
+          break if options.fail_fast?
+        end
+
+        if result_errors.empty?
+          Result.success(result_value)
+        else
+          Result.failure(Error.new(
+            schema: self,
+            value: value,
+            symbolic_name: :contents_invalid,
+            vars: result_errors,
+          ))
+        end
+      end
+
+      def with_wrapped_subschemas(wrapper)
+        wrapped_subschema = wrapper.wrap(subschema)
+        self.class.new(wrapped_subschema)
+      end
+
+      private
+        def not_a_set_result(value)
+          Result.failure(Error.new(
+            schema: self,
+            symbolic_name: :not_a_set,
+            value: value,
+          ))
+        end
+    end
+  end
+end

data/lib/rschema/schemas/sum.rb

@@ -0,0 +1,36 @@
+module RSchema
+  module Schemas
+    class Sum
+      attr_reader :subschemas
+
+      def initialize(subschemas)
+        @subschemas = subschemas
+      end
+
+      def call(value, options=Options.default)
+        suberrors = []
+
+        @subschemas.each do |subsch|
+          result = subsch.call(value, options)
+          if result.valid?
+            return result
+          else
+            suberrors << result.error
+          end
+        end
+
+        Result.failure(Error.new(
+          schema: self,
+          value: value,
+          symbolic_name: :all_invalid,
+          vars: suberrors,
+        ))
+      end
+
+      def with_wrapped_subschemas(wrapper)
+        wrapped_subschemas = subschemas.map{ |ss| wrapper.wrap(ss) }
+        self.class.new(wrapped_subschemas)
+      end
+    end
+  end
+end

data/lib/rschema/schemas/type.rb

@@ -0,0 +1,27 @@
+module RSchema
+  module Schemas
+    class Type
+      attr_reader :type
+
+      def initialize(type)
+        @type = type
+      end
+
+      def call(value, options = RSchema::Options.default)
+        if value.is_a?(@type)
+          Result.success(value)
+        else
+          Result.failure(Error.new(
+            schema: self,
+            value: value,
+            symbolic_name: :wrong_type,
+          ))
+        end
+      end
+
+      def with_wrapped_subschemas(wrapper)
+        self
+      end
+    end
+  end
+end

data/lib/rschema/schemas/variable_hash.rb

@@ -0,0 +1,67 @@
+module RSchema
+  module Schemas
+    class VariableHash
+      attr_reader :key_schema, :value_schema
+
+      def initialize(key_schema, value_schema)
+        @key_schema = key_schema
+        @value_schema = value_schema
+      end
+
+      def call(value, options=Options.default)
+        return not_a_hash_result(value) unless value.is_a?(Hash)
+
+        result, key_errors, value_errors = apply_subschemas(value, options)
+
+        if key_errors.empty? && value_errors.empty?
+          Result.success(result)
+        else
+          Result.failure(keys: key_errors, values: value_errors)
+        end
+      end
+
+      def with_wrapped_subschemas(wrapper)
+        self.class.new(
+          wrapper.wrap(key_schema),
+          wrapper.wrap(value_schema),
+        )
+      end
+
+      private
+
+        def not_a_hash_result(value)
+          Result.failure(Error.new(
+            schema: self,
+            value: value,
+            symbolic_name: :not_a_hash,
+          ))
+        end
+
+        def apply_subschemas(value, options)
+          result = {}
+          key_errors = {}
+          value_errors = {}
+
+          value.each do |key, subvalue|
+            key_result = key_schema.call(key, options)
+            if key_result.invalid?
+              key_errors[key] = key_result.error
+              break if options.fail_fast?
+            end
+
+            subvalue_result = value_schema.call(subvalue, options)
+            if subvalue_result.invalid?
+              value_errors[key] = subvalue_result.error
+              break if options.fail_fast?
+            end
+
+            if key_result.valid? && subvalue_result.valid?
+              result[key_result.value] = subvalue_result.value
+            end
+          end
+
+          return result, key_errors, value_errors
+        end
+    end
+  end
+end

data/lib/rschema/schemas/variable_length_array.rb

@@ -0,0 +1,49 @@
+module RSchema
+  module Schemas
+    class VariableLengthArray
+      attr_accessor :element_schema
+
+      def initialize(element_schema)
+        @element_schema = element_schema
+      end
+
+      def call(value, options = RSchema::Options.default)
+        if value.kind_of?(Array)
+          validated_values, errors = validate_elements(value, options)
+          if errors.empty?
+            Result.success(validated_values)
+          else
+            Result.failure(errors)
+          end
+        else
+          Result.failure(Error.new(
+            schema: self,
+            value: value,
+            symbolic_name: :not_an_array,
+          ))
+        end
+      end
+
+      def with_wrapped_subschemas(wrapper)
+        self.class.new(wrapper.wrap(element_schema))
+      end
+
+      def validate_elements(array, options)
+        errors = {}
+        validated_values = []
+
+        array.each_with_index do |subvalue, idx|
+          result = @element_schema.call(subvalue, options)
+          if result.valid?
+            validated_values[idx] = result.value
+          else
+            errors[idx] = result.error
+            break if options.fail_fast?
+          end
+        end
+
+        [validated_values, errors]
+      end
+    end
+  end
+end

data/lib/rschema/version.rb

@@ -1,3 +1,3 @@
 module RSchema
-  VERSION = '2.4.0'
+  VERSION = '3.0.1.pre1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rschema
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 3.0.1.pre1
 platform: ruby
 authors:
 - Tom Dalling
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-07 00:00:00.000000000 Z
+date: 2017-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -67,8 +67,8 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: |2
-      Schema-based validation and coercion for Ruby data structures. Heavily inspired
-      by (read: stolen from) Prismatic/schema for Clojure.
+      Schema-based validation and coercion for Ruby data structures, inspired
+      by Prismatic/schema for Clojure.
 email:
 - tom@tomdalling.com
 executables: []
@@ -78,11 +78,28 @@ files:
 - LICENSE.txt
 - README.md
 - lib/rschema.rb
-- lib/rschema/rails_interop.rb
+- lib/rschema/dsl.rb
+- lib/rschema/error.rb
+- lib/rschema/http_coercer.rb
+- lib/rschema/options.rb
+- lib/rschema/result.rb
+- lib/rschema/schemas/anything.rb
+- lib/rschema/schemas/boolean.rb
+- lib/rschema/schemas/enum.rb
+- lib/rschema/schemas/fixed_hash.rb
+- lib/rschema/schemas/fixed_length_array.rb
+- lib/rschema/schemas/maybe.rb
+- lib/rschema/schemas/pipeline.rb
+- lib/rschema/schemas/predicate.rb
+- lib/rschema/schemas/set.rb
+- lib/rschema/schemas/sum.rb
+- lib/rschema/schemas/type.rb
+- lib/rschema/schemas/variable_hash.rb
+- lib/rschema/schemas/variable_length_array.rb
 - lib/rschema/version.rb
-homepage: http://www.tomdalling.com/rschema
+homepage: https://github.com/tomdalling/rschema
 licenses:
-- MIT
+- Apache-2.0
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -95,12 +112,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Schema-based validation and coercion for Ruby data structures