definition 0.1.0.rc1

data/lib/definition.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "definition/version"
+require "definition/dsl"
+
+module Definition
+  extend Dsl
+end

data/lib/definition/conform_error.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Definition
+  class ConformError
+    def initialize(definition, message, sub_errors: [])
+      self.definition = definition
+      self.message = message
+      self.sub_errors = sub_errors
+    end
+
+    attr_accessor :definition, :sub_errors
+    attr_writer :message
+
+    def message
+      if sub_errors.empty?
+        @message
+      else
+        "#{@message}: { " + sub_errors.map(&:message).join(", ") + " }"
+      end
+    end
+  end
+end

data/lib/definition/conform_result.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Definition
+  class ConformResult
+    def initialize(value, errors: [])
+      self.value = value
+      self.errors = errors
+    end
+
+    attr_accessor :value, :errors
+
+    def passed?
+      errors.empty?
+    end
+
+    def error_message
+      errors.map(&:message).join(", ")
+    end
+  end
+end

data/lib/definition/dsl.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "definition/types"
+
+module Definition
+  module Dsl
+    # Example:
+    # Keys do
+    #   required :name, Types::Type(String)
+    #   optional :age, Types::Type(Integer)
+    # end
+    def Keys(&block) # rubocop:disable Naming/MethodName
+      Types::Keys.new(:hash).tap do |instance|
+        instance.instance_exec(&block)
+      end
+    end
+
+    # Example:
+    # And(Types::Type(Float), Types::GreaterThen(10.0))
+    def And(*definitions) # rubocop:disable Naming/MethodName
+      Types::And.new(:and, *definitions)
+    end
+
+    # Example:
+    # Or(Types::Type(Float), Types::Type(Integer))
+    def Or(*definitions) # rubocop:disable Naming/MethodName
+      Types::Or.new(:or, *definitions)
+    end
+
+    # Example:
+    # Type(Integer)
+    def Type(klass) # rubocop:disable Naming/MethodName
+      Types::Type.new(:type, klass)
+    end
+
+    # Example:
+    # CoercibleType(Integer)
+    def CoercibleType(klass) # rubocop:disable Naming/MethodName
+      unless Kernel.respond_to?(klass.name)
+        raise ArgumentError.new("#{klass} can't be used as CoercibleType because its not "\
+                                "a primitive that has a coercion function defined")
+      end
+      Types::Type.new(:type, klass) do |value|
+        begin
+          method(klass.name).call(value)
+        rescue ArgumentError
+          value
+        end
+      end
+    end
+
+    # Example:
+    # Lambda(:even) do |value|
+    #   value.even?
+    # end
+    def Lambda(name, &block) # rubocop:disable Naming/MethodName
+      Types::Lambda.new(name, &block)
+    end
+
+    # Example:
+    # Enum("allowed_value1", "allowed_value2")
+    def Enum(*allowed_values) # rubocop:disable Naming/MethodName
+      Lambda("enum #{allowed_values.inspect}") do |value|
+        conform_with(value) if allowed_values.include?(value)
+      end
+    end
+
+    # Example:
+    # Each(Definition::Type(Integer))
+    def Each(definition) # rubocop:disable Naming/MethodName
+      Types::Each.new(:each, definition: definition)
+    end
+  end
+end

data/lib/definition/types.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "definition/types/and"
+require "definition/types/or"
+require "definition/types/include"
+require "definition/types/keys"
+require "definition/types/lambda"
+require "definition/types/type"
+require "definition/types/each"

data/lib/definition/types/and.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "definition/types/base"
+
+module Definition
+  module Types
+    class And < Base
+      module Dsl
+        def validate(definition)
+          definitions << definition
+        end
+      end
+
+      include Dsl
+      attr_accessor :definitions
+
+      def initialize(name, *args)
+        self.definitions = *args
+        super(name)
+      end
+
+      def conform(value)
+        Conformer.new(self).conform(value)
+      end
+
+      class Conformer
+        def initialize(definition)
+          self.definition = definition
+        end
+
+        def conform(value)
+          results = conform_all(value)
+
+          if results.all? { |r| r.errors.empty? }
+            ConformResult.new(results.last.value)
+          else
+            ConformResult.new(value, errors: [
+                                ConformError.new(definition, "Not all children are valid for #{definition.name}",
+                                                 sub_errors: results.map(&:errors).flatten)
+                              ])
+          end
+        end
+
+        private
+
+        attr_accessor :definition
+
+        def conform_all(value)
+          results = []
+          definition.definitions.each do |definition|
+            result = definition.conform(value)
+            value = result.value
+            results << result
+          end
+          results
+        end
+      end
+    end
+  end
+end

data/lib/definition/types/base.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "definition/conform_result"
+require "definition/conform_error"
+
+module Definition
+  module Types
+    class Base
+      attr_accessor :name
+
+      def initialize(name)
+        self.name = name
+      end
+
+      def explain(value)
+        result = conform(value)
+        return "value passes definition" if result.passed?
+
+        result.error_message
+      end
+
+      def conform(_value)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/definition/types/each.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "definition/types/base"
+
+module Definition
+  module Types
+    class Each < Base
+      attr_accessor :item_definition
+
+      def initialize(name, definition:)
+        self.item_definition = definition
+        super(name)
+      end
+
+      def conform(value)
+        Conformer.new(self).conform(value)
+      end
+
+      class Conformer
+        def initialize(definition)
+          self.definition = definition
+        end
+
+        def conform(value)
+          return non_array_error(value) unless value.is_a?(Array)
+
+          results = conform_all(value)
+
+          if results.all? { |r| r.errors.empty? }
+            ConformResult.new(results.map(&:value))
+          else
+            ConformResult.new(value, errors: [ConformError.new(definition,
+                                                               "Not all items conform with #{definition.name}",
+                                                               sub_errors: errors(results))])
+          end
+        end
+
+        private
+
+        attr_accessor :definition
+
+        def errors(results)
+          results.reject(&:passed?).map do |r|
+            ConformError.new(
+              definition,
+              "Item #{r.value.inspect} did not conform to #{definition.name}",
+              sub_errors: r.errors
+            )
+          end
+        end
+
+        def conform_all(values)
+          values.map do |value|
+            definition.item_definition.conform(value)
+          end
+        end
+
+        def non_array_error(value)
+          ConformResult.new(value, errors: [
+                              ConformError.new(definition,
+                                               "Non-Array value does not conform with #{definition.name}")
+                            ])
+        end
+      end
+    end
+  end
+end

data/lib/definition/types/include.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# frozen_string_literal: true
+
+require "definition/types/base"
+
+module Definition
+  module Types
+    class Include < Base
+      attr_accessor :required_items
+
+      def initialize(name, *args)
+        self.required_items = *args
+        super(name)
+      end
+
+      def conform(value)
+        Conformer.new(self).conform(value)
+      end
+
+      class Conformer
+        def initialize(definition)
+          self.definition = definition
+        end
+
+        def conform(value)
+          errors = gather_errors(value)
+
+          if errors.empty?
+            ConformResult.new(value)
+          else
+            ConformResult.new(value, errors: errors)
+          end
+        end
+
+        private
+
+        def gather_errors(value)
+          definition.required_items.map do |item|
+            next if value.include?(item)
+
+            ConformError.new(definition, "#{definition.name} does not include #{item.inspect}")
+          end.compact
+        end
+
+        attr_accessor :definition
+      end
+    end
+  end
+end

data/lib/definition/types/keys.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+# frozen_string_literal: true
+
+require "definition/types/base"
+require "definition/types/include"
+
+module Definition
+  module Types
+    class Keys < Base
+      module Dsl
+        def required(key, definition)
+          required_definitions[key] = definition
+        end
+
+        def optional(key, definition)
+          optional_definitions[key] = definition
+        end
+      end
+
+      include Dsl
+      attr_accessor :required_definitions, :optional_definitions
+
+      def initialize(name, req: {}, opt: {})
+        super(name)
+        self.required_definitions = req
+        self.optional_definitions = opt
+      end
+
+      def conform(value)
+        Conformer.new(self, value).conform
+      end
+
+      class Conformer
+        def initialize(definition, value)
+          self.definition = definition
+          self.value = value
+          self.errors = []
+        end
+
+        def conform
+          add_extra_key_errors
+          add_missing_key_errors
+          values = conform_all_keys
+
+          ConformResult.new(values, errors: errors)
+        end
+
+        private
+
+        attr_accessor :errors
+
+        def add_extra_key_errors
+          extra_keys = value.keys - all_keys
+          return if extra_keys.empty?
+
+          errors.push(ConformError.new(
+                        definition,
+                        "#{definition.name} has extra keys: #{extra_keys.map(&:inspect).join(', ')}"
+                      ))
+        end
+
+        def conform_all_keys
+          required_keys_values = conform_definitions(required_definitions)
+          optional_keys_values = conform_definitions(optional_definitions)
+
+          required_keys_values.merge!(optional_keys_values)
+        end
+
+        def all_keys
+          required_keys + optional_keys
+        end
+
+        def required_definitions
+          definition.required_definitions
+        end
+
+        def required_keys
+          required_definitions.keys
+        end
+
+        def optional_definitions
+          definition.optional_definitions
+        end
+
+        def optional_keys
+          optional_definitions.keys
+        end
+
+        def conform_definitions(keys)
+          keys.each_with_object({}) do |(key, key_definition), result_value|
+            next unless value.key?(key)
+
+            result = key_definition.conform(value[key])
+            result_value[key] = result.value
+            next if result.passed?
+
+            errors.push(ConformError.new(key_definition,
+                                         "#{definition.name} fails validation for key #{key}",
+                                         sub_errors: result.errors))
+          end
+        end
+
+        def add_missing_key_errors
+          required_definition = Types::Include.new(
+            definition.name,
+            *required_keys
+          )
+
+          result = required_definition.conform(value)
+          return if result.passed?
+
+          errors.concat(result.errors)
+        end
+
+        attr_accessor :definition, :value
+      end
+    end
+  end
+end