dry-schema 0.1.0

data/lib/dry/schema/extensions.rb

@@ -0,0 +1,3 @@
+Dry::Schema.register_extension(:monads) do
+  require 'dry/schema/extensions/monads'
+end

data/lib/dry/schema/extensions/monads.rb

@@ -0,0 +1,18 @@
+require 'dry/monads/result'
+
+module Dry
+  module Schema
+    class Result
+      include Dry::Monads::Result::Mixin
+
+      def to_monad(options = EMPTY_HASH)
+        if success?
+          Success(output)
+        else
+          Failure(messages(options))
+        end
+      end
+      alias_method :to_result, :to_monad
+    end
+  end
+end

data/lib/dry/schema/json.rb

@@ -0,0 +1,16 @@
+require 'dry/schema/processor'
+
+module Dry
+  module Schema
+    # JSON schema type
+    #
+    # @see Processor
+    # @see Schema.JSON
+    #
+    # @api public
+    class JSON < Processor
+      config.key_map_type = :stringified
+      config.type_registry = config.type_registry.namespaced(:json)
+    end
+  end
+end

data/lib/dry/schema/key.rb

@@ -0,0 +1,166 @@
+module Dry
+  module Schema
+    # Key objects used by key maps
+    #
+    # @api public
+    class Key
+      extend Dry::Core::Cache
+
+      DEFAULT_COERCER = :itself.to_proc.freeze
+
+      include Dry.Equalizer(:name, :coercer)
+
+      # @!attribute[r] id
+      #   @return [Symbol] The key identifier
+      #   @api public
+      attr_reader :id
+
+      # @!attribute[r] name
+      #   @return [Symbol, String, Object] The actual key name expected in an input hash
+      #   @api public
+      attr_reader :name
+
+      # @!attribute[r] id
+      #   @return [Proc, #call] A key name coercer function
+      #   @api public
+      attr_reader :coercer
+
+      # @api private
+      def self.[](name, **opts)
+        new(name, **opts)
+      end
+
+      # @api private
+      def self.new(*args)
+        fetch_or_store(*args) { super }
+      end
+
+      # @api private
+      def initialize(id, name: id, coercer: DEFAULT_COERCER)
+        @id = id
+        @name = name
+        @coercer = coercer
+      end
+
+      # @api private
+      def read(source)
+        if source.key?(name)
+          yield(source[name])
+        elsif source.key?(coerced_name)
+          yield(source[coerced_name])
+        end
+      end
+
+      # @api private
+      def write(source, target)
+        read(source) { |value| target[coerced_name] = value }
+      end
+
+      # @api private
+      def coercible(&coercer)
+        new(coercer: coercer)
+      end
+
+      # @api private
+      def stringified
+        new(name: name.to_s)
+      end
+
+      # @api private
+      def new(new_opts = EMPTY_HASH)
+        self.class.new(id, { name: name, coercer: coercer }.merge(new_opts))
+      end
+
+      # @api private
+      def dump
+        name
+      end
+
+      private
+
+      # @api private
+      def coerced_name
+        @__coerced_name__ ||= coercer[name]
+      end
+    end
+
+    # A specialized key type which handles nested hashes
+    #
+    # @api private
+    class Key::Hash < Key
+      include Dry.Equalizer(:name, :members, :coercer)
+
+      # @api private
+      attr_reader :members
+
+      # @api private
+      def initialize(id, members:, **opts)
+        super(id, **opts)
+        @members = members
+      end
+
+      # @api private
+      def read(source)
+        super if source.is_a?(::Hash)
+      end
+
+      def write(source, target)
+        read(source) { |value|
+          target[coerced_name] = value.is_a?(::Hash) ? members.write(value) : value
+        }
+      end
+
+      # @api private
+      def coercible(&coercer)
+        new(coercer: coercer, members: members.coercible(&coercer))
+      end
+
+      # @api private
+      def stringified
+        new(name: name.to_s, members: members.stringified)
+      end
+
+      # @api private
+      def dump
+        { name => members.map(&:dump) }
+      end
+    end
+
+    # A specialized key type which handles nested arrays
+    #
+    # @api private
+    class Key::Array < Key
+      include Dry.Equalizer(:name, :member, :coercer)
+
+      attr_reader :member
+
+      # @api private
+      def initialize(id, member:, **opts)
+        super(id, **opts)
+        @member = member
+      end
+
+      # @api private
+      def write(source, target)
+        read(source) { |value|
+          target[coerced_name] = value.is_a?(::Array) ? value.map { |el| member.write(el) } : value
+        }
+      end
+
+      # @api private
+      def coercible(&coercer)
+        new(coercer: coercer, member: member.coercible(&coercer))
+      end
+
+      # @api private
+      def stringified
+        new(name: name.to_s, member: member.stringified)
+      end
+
+      # @api private
+      def dump
+        [name, member.dump]
+      end
+    end
+  end
+end

data/lib/dry/schema/key_coercer.rb

@@ -0,0 +1,37 @@
+require 'dry/core/cache'
+
+module Dry
+  module Schema
+    # Coerces keys in a hash using provided coercer function
+    #
+    # @api private
+    class KeyCoercer
+      extend Dry::Core::Cache
+
+      TO_SYM = :to_sym.to_proc.freeze
+
+      attr_reader :key_map, :coercer
+
+      # @api private
+      def self.new(*args, &coercer)
+        fetch_or_store(*args, coercer) { super(*args, &coercer) }
+      end
+
+      # @api private
+      def self.symbolized(*args)
+        new(*args, &TO_SYM)
+      end
+
+      # @api private
+      def initialize(key_map, &coercer)
+        @key_map = key_map.coercible(&coercer)
+      end
+      
+      # @api private
+      def call(source)
+        key_map.write(Hash(source))
+      end
+      alias_method :[], :call
+    end
+  end
+end

data/lib/dry/schema/key_map.rb

@@ -0,0 +1,133 @@
+require 'dry/equalizer'
+require 'dry/core/cache'
+require 'dry/schema/constants'
+require 'dry/schema/key'
+
+module Dry
+  module Schema
+    # Represents a list of keys defined by the DSL
+    #
+    # KeyMap objects expose an API for introspecting schema keys and the ability
+    # to rebuild an input hash using configured coercer function.
+    #
+    # Instances of this class are used as the very first step by the schema processors.
+    #
+    # @api public
+    class KeyMap
+      extend Dry::Core::Cache
+
+      include Dry.Equalizer(:keys)
+      include Enumerable
+
+      # @!attribute[r] keys
+      #   @return [Array<Key>] A list of defined key objects
+      attr_reader :keys
+
+      # Coerce a list of key specs into a key map
+      #
+      # @example
+      #   KeyMap[:id, :name]
+      #   KeyMap[:title, :artist, tags: [:name]]
+      #   KeyMap[:title, :artist, [:tags]]
+      #
+      # @return [KeyMap]
+      #
+      # @api public
+      def self.[](*keys)
+        new(keys)
+      end
+
+      # Build new, or returned a cached instance of a key map
+      #
+      # @param [Array<Symbol, Array, Hash<Symbol=>Array>>
+      #
+      # @return [KeyMap]
+      def self.new(*args)
+        fetch_or_store(*args) { super }
+      end
+
+      # Set key objects
+      #
+      # @api private
+      def initialize(keys)
+        @keys = keys.map { |key|
+          case key
+          when Hash
+            root, rest = key.flatten
+            Key::Hash[root, members: KeyMap[*rest]]
+          when Array
+            root, rest = key
+            Key::Array[root, member: KeyMap[*rest]]
+          when Key
+            key
+          else
+            Key[key]
+          end
+        }
+      end
+
+      # Write a new hash based on the source hash
+      #
+      # @param [Hash] source The source hash
+      # @param [Hash] target The target hash
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def write(source, target = EMPTY_HASH.dup)
+        each { |key| key.write(source, target) }
+        target
+      end
+
+      # Return a new key map that is configured to coerce keys using provided coercer function
+      #
+      # @return [KeyMap]
+      #
+      # @api public
+      def coercible(&coercer)
+        self.class.new(map { |key| key.coercible(&coercer) })
+      end
+
+      # Return a new key map with stringified keys
+      #
+      # A stringified key map is suitable for reading hashes with string keys
+      #
+      # @return [KeyMap]
+      #
+      # @api public
+      def stringified
+        self.class.new(map(&:stringified))
+      end
+
+      # Iterate over keys
+      #
+      # @api public
+      def each(&block)
+        keys.each(&block)
+      end
+
+      # Return a new key map merged with the provided one
+      #
+      # @param [KeyMap, Array] other Either a key map or an array with key specs
+      #
+      # @return [KeyMap]
+      def +(other)
+        self.class.new(keys + other.to_a)
+      end
+
+      # Return a string representation of a key map
+      #
+      # @return [String]
+      def inspect
+        "#<#{self.class}[#{keys.map(&:dump).map(&:inspect).join(", ")}]>"
+      end
+
+      # Dump keys to their spec format
+      #
+      # @return [Array]
+      def dump
+        keys.map(&:dump)
+      end
+    end
+  end
+end

data/lib/dry/schema/macros.rb

@@ -0,0 +1,6 @@
+require 'dry/schema/macros/each'
+require 'dry/schema/macros/filled'
+require 'dry/schema/macros/hash'
+require 'dry/schema/macros/maybe'
+require 'dry/schema/macros/optional'
+require 'dry/schema/macros/required'

data/lib/dry/schema/macros/core.rb

@@ -0,0 +1,51 @@
+require 'dry/initializer'
+
+require 'dry/schema/constants'
+require 'dry/schema/compiler'
+require 'dry/schema/trace'
+
+module Dry
+  module Schema
+    module Macros
+      # Abstract macro class
+      #
+      # @api private
+      class Core
+        extend Dry::Initializer
+
+        # @api private
+        option :name, default: proc { nil }, optional: true
+
+        # @api private
+        option :compiler, default: proc { Compiler.new }
+
+        # @api private
+        option :trace, default: proc { Trace.new }
+
+        # @api private
+        option :schema_dsl, optional: true
+
+        # @api private
+        def new(options = EMPTY_HASH)
+          self.class.new({ name: name, compiler: compiler, schema_dsl: schema_dsl }.merge(options))
+        end
+
+        # @api private
+        def to_rule
+          compiler.visit(to_ast)
+        end
+
+        # @api private
+        def to_ast(*)
+          trace.to_ast
+        end
+        alias_method :ast, :to_ast
+
+        # @api private
+        def operation
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/dry/schema/macros/dsl.rb

@@ -0,0 +1,74 @@
+require 'dry/logic/operators'
+
+require 'dry/schema/macros/core'
+
+module Dry
+  module Schema
+    module Macros
+      # Macro specialization used within the DSL
+      #
+      # @api public
+      class DSL < Core
+        include Dry::Logic::Operators
+
+        undef :eql?
+        undef :nil?
+
+        # @api private
+        option :chain, default: -> { true }
+
+        # Specify predicates that should be applied to a value
+        #
+        # @api public
+        def value(*predicates, **opts, &block)
+          append_macro(Macros::Value) do |macro|
+            macro.call(*predicates, **opts, &block)
+          end
+        end
+
+        # Prepends `:filled?` predicate
+        #
+        # @api public
+        def filled(*args, &block)
+          append_macro(Macros::Filled) do |macro|
+            macro.call(*args, &block)
+          end
+        end
+
+        # Specify a nested schema
+        #
+        # @api public
+        def schema(*args, &block)
+          append_macro(Macros::Hash) do |macro|
+            macro.call(*args, &block)
+          end
+        end
+
+        # Specify predicates that should be applied to each element of an array
+        #
+        # @api public
+        def each(*args, &block)
+          append_macro(Macros::Each) do |macro|
+            macro.value(*args, &block)
+          end
+        end
+
+        private
+
+        # @api private
+        def append_macro(macro_type, &block)
+          macro = macro_type.new(schema_dsl: schema_dsl, name: name)
+
+          yield(macro)
+
+          if chain
+            trace << macro
+            self
+          else
+            macro
+          end
+        end
+      end
+    end
+  end
+end