parametric 0.0.1 → 0.2.10

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "parametric"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/lib/parametric/block_validator.rb

@@ -0,0 +1,64 @@
+module Parametric
+  class BlockValidator
+    def self.build(meth, &block)
+      klass = Class.new(self)
+      klass.public_send(meth, &block)
+      klass
+    end
+
+    def self.message(&block)
+      @message_block = block if block_given?
+      @message_block if instance_variable_defined?('@message_block')
+    end
+
+    def self.validate(&validate_block)
+      @validate_block = validate_block if block_given?
+      @validate_block if instance_variable_defined?('@validate_block')
+    end
+
+    def self.coerce(&coerce_block)
+      @coerce_block = coerce_block if block_given?
+      @coerce_block
+    end
+
+    def self.eligible(&block)
+      @eligible_block = block if block_given?
+      @eligible_block if instance_variable_defined?('@eligible_block')
+    end
+
+    def self.meta_data(&block)
+      @meta_data_block = block if block_given?
+      @meta_data_block if instance_variable_defined?('@meta_data_block')
+    end
+
+    attr_reader :message
+
+    def initialize(*args)
+      @args = args
+      @message = 'is invalid'
+      @validate_block = self.class.validate || ->(*args) { true }
+      @coerce_block = self.class.coerce || ->(v, *_) { v }
+      @eligible_block = self.class.eligible || ->(*args) { true }
+      @meta_data_block = self.class.meta_data || ->(*args) { {} }
+    end
+
+    def eligible?(value, key, payload)
+      args = (@args + [value, key, payload])
+      @eligible_block.call(*args)
+    end
+
+    def coerce(value, key, context)
+      @coerce_block.call(value, key, context)
+    end
+
+    def valid?(value, key, payload)
+      args = (@args + [value, key, payload])
+      @message = self.class.message.call(*args) if self.class.message
+      @validate_block.call(*args)
+    end
+
+    def meta_data
+      @meta_data_block.call *@args
+    end
+  end
+end

data/lib/parametric/context.rb

@@ -0,0 +1,44 @@
+module Parametric
+  class Top
+    attr_reader :errors
+
+    def initialize
+      @errors = {}
+    end
+
+    def add_error(key, msg)
+      errors[key] ||= []
+      errors[key] << msg
+    end
+  end
+
+  class Context
+    def initialize(path = nil, top = Top.new)
+      @top = top
+      @path = Array(path).compact
+    end
+
+    def errors
+      top.errors
+    end
+
+    def add_error(msg)
+      top.add_error(string_path, msg)
+    end
+
+    def sub(key)
+      self.class.new(path + [key], top)
+    end
+
+    protected
+    attr_reader :path, :top
+
+    def string_path
+      path.reduce(['$']) do |m, segment|
+        m << (segment.is_a?(Integer) ? "[#{segment}]" : ".#{segment}")
+        m
+      end.join
+    end
+  end
+
+end

data/lib/parametric/default_types.rb

@@ -0,0 +1,95 @@
+require "date"
+
+module Parametric
+  # type coercions
+  Parametric.policy :integer do
+    coerce do |v, k, c|
+      v.to_i
+    end
+
+    meta_data do
+      {type: :integer}
+    end
+  end
+
+  Parametric.policy :number do
+    coerce do |v, k, c|
+      v.to_f
+    end
+
+    meta_data do
+      {type: :number}
+    end
+  end
+
+  Parametric.policy :string do
+    coerce do |v, k, c|
+      v.to_s
+    end
+
+    meta_data do
+      {type: :string}
+    end
+  end
+
+  Parametric.policy :boolean do
+    coerce do |v, k, c|
+      !!v
+    end
+
+    meta_data do
+      {type: :boolean}
+    end
+  end
+
+  # type validations
+  Parametric.policy :array do
+    message do |actual|
+      "expects an array, but got #{actual.inspect}"
+    end
+
+    validate do |value, key, payload|
+      !payload.key?(key) || value.is_a?(Array)
+    end
+
+    meta_data do
+      {type: :array}
+    end
+  end
+
+  Parametric.policy :object do
+    message do |actual|
+      "expects a hash, but got #{actual.inspect}"
+    end
+
+    validate do |value, key, payload|
+      !payload.key?(key) ||
+        value.respond_to?(:[]) &&
+        value.respond_to?(:key?)
+    end
+
+    meta_data do
+      {type: :object}
+    end
+  end
+
+  Parametric.policy :split do
+    coerce do |v, k, c|
+      v.kind_of?(Array) ? v : v.to_s.split(/\s*,\s*/)
+    end
+
+    meta_data do
+      {type: :array}
+    end
+  end
+
+  Parametric.policy :datetime do
+    coerce do |v, k, c|
+      DateTime.parse(v.to_s)
+    end
+
+    meta_data do
+      {type: :datetime}
+    end
+  end
+end

data/lib/parametric/dsl.rb

@@ -0,0 +1,68 @@
+require "parametric"
+
+module Parametric
+  module DSL
+    # Example
+    #   class Foo
+    #     include Parametric::DSL
+    #
+    #     schema do
+    #       field(:title).type(:string).present
+    #       field(:age).type(:integer).default(20)
+    #     end
+    #
+    #      attr_reader :params
+    #
+    #      def initialize(input)
+    #        @params = self.class.schema.resolve(input)
+    #      end
+    #   end
+    #
+    #   foo = Foo.new(title: "A title", nope: "hello")
+    #
+    #   foo.params # => {title: "A title", age: 20}
+    #
+    DEFAULT_SCHEMA_NAME = :schema
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.schemas = {DEFAULT_SCHEMA_NAME => Parametric::Schema.new}
+    end
+
+    module ClassMethods
+      def schema=(sc)
+        @schemas[DEFAULT_SCHEMA_NAME] = sc
+      end
+
+      def schemas=(sc)
+        @schemas = sc
+      end
+
+      def inherited(subclass)
+        subclass.schemas = @schemas.each_with_object({}) do |(key, sc), hash|
+          hash[key] = sc.merge(Parametric::Schema.new)
+        end
+      end
+
+      def schema(*args, &block)
+        options = args.last.is_a?(Hash) ? args.last : {}
+        key = args.first.is_a?(Symbol) ? args.first : DEFAULT_SCHEMA_NAME
+        current_schema = @schemas.fetch(key) { Parametric::Schema.new }
+        new_schema = if block_given? || options.any?
+          Parametric::Schema.new(options, &block)
+        elsif args.first.respond_to?(:schema)
+          args.first
+        end
+
+        return current_schema unless new_schema
+
+        @schemas[key] = current_schema ? current_schema.merge(new_schema) : new_schema
+        parametric_after_define_schema(@schemas[key])
+      end
+
+      def parametric_after_define_schema(sc)
+        # noop hook
+      end
+    end
+  end
+end

data/lib/parametric/field.rb

@@ -0,0 +1,111 @@
+require "parametric/field_dsl"
+
+module Parametric
+  class ConfigurationError < StandardError; end
+
+  class Field
+    include FieldDSL
+
+    attr_reader :key, :meta_data
+    Result = Struct.new(:eligible?, :value)
+
+    def initialize(key, registry = Parametric.registry)
+      @key = key
+      @policies = []
+      @registry = registry
+      @default_block = nil
+      @meta_data = {}
+      @policies = []
+    end
+
+    def meta(hash = nil)
+      @meta_data = @meta_data.merge(hash) if hash.is_a?(Hash)
+      self
+    end
+
+    def default(value)
+      meta default: value
+      @default_block = (value.respond_to?(:call) ? value : ->(key, payload, context) { value })
+      self
+    end
+
+    def policy(key, *args)
+      pol = lookup(key, args)
+      meta pol.meta_data
+      policies << pol
+      self
+    end
+    alias_method :type, :policy
+
+    def schema(sc = nil, &block)
+      sc = (sc ? sc : Schema.new(&block))
+      meta schema: sc
+      policy sc.schema
+    end
+
+    def visit(meta_key = nil, &visitor)
+      if sc = meta_data[:schema]
+        r = sc.visit(meta_key, &visitor)
+        (meta_data[:type] == :array) ? [r] : r
+      else
+        meta_key ? meta_data[meta_key] : yield(self)
+      end
+    end
+
+    def resolve(payload, context)
+      eligible = payload.key?(key)
+      value = payload[key] # might be nil
+
+      if !eligible && has_default?
+        eligible = true
+        value = default_block.call(key, payload, context)
+        return Result.new(eligible, value)
+      end
+
+      policies.each do |policy|
+        if !policy.eligible?(value, key, payload)
+          eligible = false
+          if has_default?
+            eligible = true
+            value = default_block.call(key, payload, context)
+          end
+          break
+        else
+          value = resolve_one(policy, value, context)
+          if !policy.valid?(value, key, payload)
+            eligible = true # eligible, but has errors
+            context.add_error policy.message
+            break # only one error at a time
+          end
+        end
+      end
+
+      Result.new(eligible, value)
+    end
+
+    private
+    attr_reader :policies, :registry, :default_block
+
+    def resolve_one(policy, value, context)
+      begin
+        policy.coerce(value, key, context)
+      rescue StandardError => e
+        context.add_error e.message
+        value
+      end
+    end
+
+    def has_default?
+      !!default_block && !meta_data[:skip_default]
+    end
+
+    def lookup(key, args)
+      obj = key.is_a?(Symbol) ? registry.policies[key] : key
+
+      raise ConfigurationError, "No policies defined for #{key.inspect}" unless obj
+
+      obj.respond_to?(:new) ? obj.new(*args) : obj
+    end
+  end
+end
+

data/lib/parametric/field_dsl.rb

@@ -0,0 +1,24 @@
+module Parametric
+  # Field DSL
+  # host instance must implement:
+  # #meta(options Hash)
+  # #policy(key Symbol) self
+  #
+  module FieldDSL
+    def required
+      policy :required
+    end
+
+    def present
+      required.policy :present
+    end
+
+    def declared
+      policy :declared
+    end
+
+    def options(opts)
+      policy :options, opts
+    end
+  end
+end

data/lib/parametric/policies.rb

@@ -1,62 +1,133 @@
 module Parametric
   module Policies
+    class Format
+      attr_reader :message
 
-    class Policy
-      def initialize(value, options, decorated = nil)
-        @value, @options = value, options
-        @decorated = decorated
+      def initialize(fmt, msg = "invalid format")
+        @message = msg
+        @fmt = fmt
       end
 
-      def wrap(decoratedClass)
-        decoratedClass.new(@value, @options, self)
+      def eligible?(value, key, payload)
+        payload.key?(key)
       end
 
-      def value
-        Array(@value)
+      def coerce(value, key, context)
+        value
       end
 
-      protected
-      attr_reader :decorated, :options
-    end
+      def valid?(value, key, payload)
+        !payload.key?(key) || !!(value.to_s =~ @fmt)
+      end
 
-    class DefaultPolicy < Policy
-      def value
-        v = decorated.value
-        v.any? ? v : Array(options[:default])
+      def meta_data
+        {}
       end
     end
+  end
 
-    class MultiplePolicy < Policy
-      OPTION_SEPARATOR = /\s*,\s*/.freeze
+  # Default validators
+  EMAIL_REGEXP = /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i.freeze
 
-      def value
-        v = decorated.value.first
-        v = v.split(options.fetch(:separator, OPTION_SEPARATOR)) if v.is_a?(String)
-        Array(v)
-      end
+  Parametric.policy :format, Policies::Format
+  Parametric.policy :email, Policies::Format.new(EMAIL_REGEXP, 'invalid email')
+
+  Parametric.policy :noop do
+    eligible do |value, key, payload|
+      true
     end
+  end
 
-    class SinglePolicy < Policy
-      def value
-        decorated.value.first
-      end
+  Parametric.policy :declared do
+    eligible do |value, key, payload|
+      payload.key? key
     end
+  end
 
-    class OptionsPolicy < Policy
-      def value
-        decorated.value.each_with_object([]){|a,arr| 
-          arr << a if options[:options].include?(a)
-        }
-      end
+  Parametric.policy :declared_no_default do
+    eligible do |value, key, payload|
+      payload.key? key
+    end
+
+    meta_data do
+      {skip_default: true}
+    end
+  end
+
+  Parametric.policy :required do
+    message do |*|
+      "is required"
     end
 
-    class MatchPolicy < Policy
-      def value
-        decorated.value.each_with_object([]){|a,arr| 
-          arr << a if a.to_s =~ options[:match]
-        }
+    validate do |value, key, payload|
+      payload.key? key
+    end
+
+    meta_data do
+      {required: true}
+    end
+  end
+
+  Parametric.policy :present do
+    message do |*|
+      "is required and value must be present"
+    end
+
+    validate do |value, key, payload|
+      case value
+      when String
+        value.strip != ''
+      when Array, Hash
+        value.any?
+      else
+        !value.nil?
       end
     end
 
+    meta_data do
+      {present: true}
+    end
+  end
+
+  Parametric.policy :gt do
+    message do |num, actual|
+      "must be greater than #{num}, but got #{actual}"
+    end
+
+    validate do |num, actual, key, payload|
+      !payload[key] || actual.to_i > num.to_i
+    end
+  end
+
+  Parametric.policy :lt do
+    message do |num, actual|
+      "must be less than #{num}, but got #{actual}"
+    end
+
+    validate do |num, actual, key, payload|
+      !payload[key] || actual.to_i < num.to_i
+    end
+  end
+
+  Parametric.policy :options do
+    message do |options, actual|
+      "must be one of #{options.join(', ')}, but got #{actual}"
+    end
+
+    eligible do |options, actual, key, payload|
+      payload.key?(key)
+    end
+
+    validate do |options, actual, key, payload|
+      !payload.key?(key) || ok?(options, actual)
+    end
+
+    meta_data do |opts|
+      {options: opts}
+    end
+
+    def ok?(options, actual)
+      [actual].flatten.all?{|v| options.include?(v)}
+    end
   end
-end
+end

data/lib/parametric/registry.rb

@@ -0,0 +1,21 @@
+require 'parametric/block_validator'
+
+module Parametric
+  class Registry
+    attr_reader :policies
+
+    def initialize
+      @policies = {}
+    end
+
+    def coercions
+      policies
+    end
+
+    def policy(name, plcy = nil, &block)
+      policies[name] = (plcy || BlockValidator.build(:instance_eval, &block))
+      self
+    end
+  end
+end
+

data/lib/parametric/results.rb

@@ -0,0 +1,13 @@
+module Parametric
+  class Results
+    attr_reader :output, :errors
+
+    def initialize(output, errors)
+      @output, @errors = output, errors
+    end
+
+    def valid?
+      !errors.keys.any?
+    end
+  end
+end