ree_lib 1.0.36 → 1.0.38

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/mapper_factory.rb

@@ -2,7 +2,7 @@
 
 class ReeMapper::MapperFactory
   class << self
-    attr_reader :types, :strategies
+    attr_reader :types, :strategies, :wrappers
   end
 
   contract(Symbol => Nilor[ReeMapper::MapperStrategy])
@@ -18,9 +18,9 @@ class ReeMapper::MapperFactory
     )
   end
 
-  contract(Symbol, ReeMapper::Mapper => Class).throws(ArgumentError)
+  contract(Symbol, ReeMapper::Mapper => SubclassOf[self]).throws(ArgumentError)
   def self.register_mapper(name, type)
-    raise ArgumentError, "name of mapper type should not end with `?`" if name.to_s.end_with?('?')
+    raise ArgumentError, "mapper registration name should not end with `?`" if name.to_s.end_with?('?')
 
     defined_strategy_method = types[name]&.flat_map(&:strategy_methods)&.detect { type.find_strategy(_1) }
     raise ArgumentError, "type :#{name} with `#{defined_strategy_method}` strategy already registered" if defined_strategy_method
@@ -35,7 +35,7 @@ class ReeMapper::MapperFactory
     class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
       def #{name}(field_name = nil, optional: false, **opts)
         raise ReeMapper::Error, "invalid DSL usage" unless @mapper
-        raise ArgumentError, "array item can't be optional" if field_name.nil? && optional
+        raise ArgumentError, "wrapped item can't be optional" if field_name.nil? && optional
 
         type = self.class.types.fetch(:#{name}).detect { (@mapper.strategy_methods - _1.strategy_methods).empty? }
 
@@ -43,9 +43,11 @@ class ReeMapper::MapperFactory
           raise ReeMapper::UnsupportedTypeError, "type :#{name} should implement `\#{@mapper.strategy_methods.join(', ')}`"
         end
 
-        return ReeMapper::Field.new(type, optional: optional, **opts) unless field_name
+        field = ReeMapper::Field.new(type, field_name, optional: optional, **opts)
 
-        @mapper.add_field(type, field_name, optional: optional, **opts)
+        return field unless field_name
+
+        @mapper.add_field(field)
       end
 
       def #{name}?(field_name, **opts)
@@ -56,6 +58,68 @@ class ReeMapper::MapperFactory
     self
   end
 
+  contract(Symbol, SubclassOf[ReeMapper::AbstractWrapper] => SubclassOf[self])
+  def self.register_wrapper(name, wrapper)
+    raise ArgumentError, "wrapper registration name should not end with `?`" if name.to_s.end_with?('?')
+    raise ArgumentError, "method :#{name} already defined" if !wrappers.key?(name) && method_defined?(name)
+
+    wrappers[name] ||= []
+    wrappers[name] << wrapper
+
+    class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+      contract(
+        Nilor[Symbol, ReeMapper::Field],
+        Nilor[ReeMapper::Field],
+        Kwargs[optional: Bool, dto: Nilor[Class]],
+        Ksplat[RestKeys => Any],
+        Optblock => Nilor[ReeMapper::Field]
+      ).throws(ReeMapper::Error, ArgumentError, ReeMapper::UnsupportedTypeError)
+      def #{name}(field_name = nil, subject = nil, optional: false, dto: nil, **opts, &blk)
+        raise ReeMapper::Error, "invalid DSL usage" unless @mapper
+        raise ArgumentError, 'wrapped type does not permit :dto without :block' if dto && !blk
+
+        if field_name.is_a?(ReeMapper::Field)
+          raise ArgumentError, "field_name should be a Symbol" if subject
+
+          subject = field_name
+          field_name = nil
+        end
+
+        raise ArgumentError, "wrapped item can't be optional" if field_name.nil? && optional
+        raise ArgumentError, "wrapped type should use either :subject or :block" if subject && blk || !subject && !blk
+
+        if blk
+          subject = ReeMapper::Field.new(
+            hash_from_blk(dto: dto, &blk)
+          )
+        end
+
+        wrapper = self.class.wrappers.fetch(:#{name}).detect do |wrapper|
+          @mapper.strategy_methods.all? { wrapper.method_defined?(_1) }
+        end
+
+        unless wrapper
+          raise ReeMapper::UnsupportedTypeError, "wrapper :#{name} should implement `\#{@mapper.strategy_methods.join(', ')}`"
+        end
+
+        type = ReeMapper::Mapper.build(@mapper.strategies, wrapper.new(subject))
+        type.name = :#{name}
+
+        field = ReeMapper::Field.new(type, field_name, optional: optional, **opts)
+
+        return field unless field_name
+
+        @mapper.add_field(field)
+      end
+
+      def #{name}?(*args, **opts, &blk)
+        #{name}(*args, optional: true, **opts, &blk)
+      end
+    RUBY
+
+    self
+  end
+
   contract(
     Kwargs[
       register_as: Nilor[Symbol]
@@ -71,41 +135,15 @@ class ReeMapper::MapperFactory
     @mapper = mapper
   end
 
-  contract(Nilor[Symbol], Kwargs[each: Nilor[ReeMapper::Field], optional: Bool, dto: Nilor[Class]], Ksplat[RestKeys => Any], Optblock => Nilor[ReeMapper::Field])
-  def array(field_name = nil, each: nil, optional: false, dto: nil, **opts, &blk)
-    raise ReeMapper::Error, "invalid DSL usage" unless @mapper
-    raise ArgumentError, "array item can't be optional" if field_name.nil? && optional
-    raise ArgumentError, 'array type should use either :each or :block' if each && blk || !each && !blk
-    raise ArgumentError, 'array does not permit :dto without :block' if dto && !blk
-    raise ArgumentError, 'array does not permit :only and :except keys' if opts.key?(:only) || opts.key?(:except)
-
-    if blk
-      each = ReeMapper::Field.new(
-        hash_from_blk(dto: dto, &blk)
-      )
-    end
-
-    type = ReeMapper::Mapper.build(@mapper.strategies, ReeMapper::Array.new(each))
-
-    return ReeMapper::Field.new(type, optional: optional, **opts) unless field_name
-
-    @mapper.add_field(type, field_name, optional: optional, **opts)
-  end
-
-  contract(Symbol, Kwargs[each: Nilor[ReeMapper::Field]], Ksplat[RestKeys => Any], Optblock => Nilor[ReeMapper::Field])
-  def array?(field_name, each: nil, **opts, &blk)
-    raise ArgumentError if opts.key?(:optional)
-
-    array(field_name, each: each, optional: true, **opts, &blk)
-  end
-
   contract(Symbol, Kwargs[dto: Nilor[Class]], Ksplat[RestKeys => Any], Block => nil)
   def hash(field_name, dto: nil, **opts, &blk)
     raise ReeMapper::Error, "invalid DSL usage" unless @mapper
 
     type = hash_from_blk(dto: dto, &blk)
 
-    @mapper.add_field(type, field_name, **opts)
+    field = ReeMapper::Field.new(type, field_name, **opts)
+
+    @mapper.add_field(field)
   end
 
   contract(Symbol, Ksplat[RestKeys => Any], Block => nil)

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/types/any.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class ReeMapper::Any < ReeMapper::AbstractType
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Any)
+  def serialize(value, name:, role: nil)
+    value
+  end
+
+  contract(Any , Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Any)
+  def cast(value, name:, role: nil)
+    value
+  end
+
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Any)
+  def db_dump(value, name:, role: nil)
+    value
+  end
+
+  contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]]] => Any)
+  def db_load(value, name:, role: nil)
+    value
+  end
+end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/wrappers/abstract_wrapper.rb

@@ -0,0 +1,8 @@
+class ReeMapper::AbstractWrapper
+  attr_reader :subject
+
+  contract ReeMapper::Field => Any
+  def initialize(field)
+    @subject = field
+  end
+end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper/{types → wrappers}/array.rb

@@ -1,22 +1,15 @@
 # frozen_string_literal: true
 
-class ReeMapper::Array < ReeMapper::AbstractType
-  attr_reader :of
-
-  contract ReeMapper::Field => Any
-  def initialize(of)
-    @of = of
-  end
-
+class ReeMapper::Array < ReeMapper::AbstractWrapper
   contract(Any, Kwargs[name: String, role: Nilor[Symbol, ArrayOf[Symbol]], fields_filters: ArrayOf[ReeMapper::FieldsFilter]] => Array)
     .throws(ReeMapper::TypeError)
   def serialize(value, name:, role: nil, fields_filters: [])
     if value.is_a?(Array)
       value.map.with_index {
-        if _1.nil? && of.null
+        if _1.nil? && subject.null
           _1
         else
-          of.type.serialize(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [of.fields_filter])
+          subject.type.serialize(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [subject.fields_filter])
         end
       }
     else
@@ -29,10 +22,10 @@ class ReeMapper::Array < ReeMapper::AbstractType
   def cast(value, name:, role: nil, fields_filters: [])
     if value.is_a?(Array)
       value.map.with_index {
-        if _1.nil? && of.null
+        if _1.nil? && subject.null
           _1
         else
-          of.type.cast(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [of.fields_filter])
+          subject.type.cast(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [subject.fields_filter])
         end
       }
     else
@@ -45,10 +38,10 @@ class ReeMapper::Array < ReeMapper::AbstractType
   def db_dump(value, name:, role: nil, fields_filters: [])
     if value.is_a?(Array)
       value.map.with_index {
-        if _1.nil? && of.null
+        if _1.nil? && subject.null
           _1
         else
-          of.type.db_dump(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [of.fields_filter])
+          subject.type.db_dump(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [subject.fields_filter])
         end
       }
     else
@@ -61,14 +54,14 @@ class ReeMapper::Array < ReeMapper::AbstractType
   def db_load(value, name:, role: nil, fields_filters: [])
     if value.is_a?(Array)
       value.map.with_index {
-        if _1.nil? && of.null
+        if _1.nil? && subject.null
           _1
         else
-          of.type.db_load(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [of.fields_filter])
+          subject.type.db_load(_1, name: "#{name}[#{_2}]", role: role, fields_filters: fields_filters + [subject.fields_filter])
         end
       }
     else
       raise ReeMapper::TypeError, "`#{name}` should be an array"
     end
   end
-end
+end

data/lib/ree_lib/packages/ree_mapper/package/ree_mapper.rb

@@ -22,14 +22,18 @@ module ReeMapper
   require_relative 'ree_mapper/fields_filter'
   require_relative 'ree_mapper/field'
 
+
+  require_relative 'ree_mapper/wrappers/abstract_wrapper'
+  require_relative 'ree_mapper/wrappers/array'
+
   require_relative 'ree_mapper/types/bool'
+  require_relative 'ree_mapper/types/any'
   require_relative 'ree_mapper/types/date_time'
   require_relative 'ree_mapper/types/time'
   require_relative 'ree_mapper/types/date'
   require_relative 'ree_mapper/types/float'
   require_relative 'ree_mapper/types/integer'
   require_relative 'ree_mapper/types/string'
-  require_relative 'ree_mapper/types/array'
 
   require_relative 'ree_mapper/strategy_outputs/strategy_output'
   require_relative 'ree_mapper/strategy_outputs/object_output'

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/mapper_factory_spec.rb

@@ -43,7 +43,7 @@ RSpec.describe ReeMapper::MapperFactory do
       ).to eq({ val: { id: 1 } })
     }
 
-    it 'allow to register caster and serializer with same name' do
+    it 'allow to register caster and serializer with the same name' do
       caster = mapper_factory.call.use(:cast) { string :name }
 
       mapper_factory.register_mapper(:new_type, serializer)
@@ -69,7 +69,7 @@ RSpec.describe ReeMapper::MapperFactory do
     it 'raise an error if the mapper name is ended by ?' do
       expect {
         mapper_factory.register_mapper(:new_type?, serializer)
-      }.to raise_error(ArgumentError, 'name of mapper type should not end with `?`')
+      }.to raise_error(ArgumentError, 'mapper registration name should not end with `?`')
     end
 
     it 'raise an error if the mapper name is reserved' do
@@ -79,6 +79,66 @@ RSpec.describe ReeMapper::MapperFactory do
     end
   end
 
+  describe '.register_wrapper' do
+    let(:round_wrapper) {
+      Class.new(ReeMapper::AbstractWrapper) do
+        def serialize(value, name:, **opts)
+          raise ReeMapper::TypeError, "`#{name}` should be a number" if !value.is_a?(Numeric)
+
+          subject.type.serialize(value.round, name: name, **opts)
+        end
+      end
+    }
+
+    it {
+      mapper_factory.register_wrapper(:round, round_wrapper)
+
+      expect(
+        mapper_factory.call.use(:serialize) { round :val, integer }.serialize({ val: 1.1 })
+      ).to eq({ val: 1 })
+    }
+
+    it 'allow to register caster and serializer with the same name' do
+      caster_round_wrapper = Class.new(ReeMapper::AbstractWrapper) do
+        def cast(value, name:, **opts)
+          value = subject.type.cast(value, name: name, **opts)
+
+          raise ReeMapper::TypeError, "`#{name}` should be a number" if !value.is_a?(Numeric)
+          value.round
+        end
+      end
+
+      mapper_factory.register_wrapper(:round, round_wrapper)
+      mapper_factory.register_wrapper(:round, caster_round_wrapper)
+
+      expect(
+        mapper_factory.call.use(:serialize) { round :val, integer }.serialize({ val: 1.1 })
+      ).to eq({ val: 1 })
+
+      expect(
+        mapper_factory.call.use(:cast) { round :val, float }.cast({ val: '1.1' })
+      ).to eq({ val: 1 })
+    end
+
+    it 'raise an error if the registration wrapper name is ended by ?' do
+      expect {
+        mapper_factory.register_wrapper(:new_type?, round_wrapper)
+      }.to raise_error(ArgumentError, 'wrapper registration name should not end with `?`')
+    end
+
+    it 'raise an error if name is reserved' do
+      expect {
+        mapper_factory.register_wrapper(:hash, round_wrapper)
+      }.to raise_error(ArgumentError, 'method :hash already defined')
+    end
+
+    it 'raise an error if name is reserved by mapper' do
+      expect {
+        mapper_factory.register_wrapper(:integer, round_wrapper)
+      }.to raise_error(ArgumentError, 'method :integer already defined')
+    end
+  end
+
   describe '.use' do
     it {
       mapper = mapper_factory.call.use(:cast) do

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/any_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+RSpec.describe 'ReeMapper::Bool' do
+  link :build_mapper_factory, from: :ree_mapper
+  link :build_mapper_strategy, from: :ree_mapper
+
+  let(:mapper_factory) {
+    build_mapper_factory(
+      strategies: [
+        build_mapper_strategy(method: :cast,      dto: Hash),
+        build_mapper_strategy(method: :serialize, dto: Hash),
+        build_mapper_strategy(method: :db_dump,   dto: Hash),
+        build_mapper_strategy(method: :db_load,   dto: Hash)
+      ]
+    )
+  }
+
+  let(:mapper) {
+    mapper_factory.call.use(:cast).use(:serialize).use(:db_dump).use(:db_load) {
+      any :any
+    }
+  }
+
+  describe '#serialize' do
+    it {
+      expect(mapper.serialize({ any: true })).to eq({ any: true })
+    }
+  end
+
+  describe '#cast' do
+    it {
+      expect(mapper.cast({ 'any' => true })).to eq({ any: true })
+    }
+  end
+
+  describe '#db_dump' do
+    it {
+      expect(mapper.db_dump(OpenStruct.new({ any: true }))).to eq({ any: true })
+    }
+  end
+
+  describe '#db_load' do
+    it {
+      expect(mapper.db_load({ 'any' => true })).to eq({ any: true })
+    }
+  end
+end

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/types/type_options_spec.rb

@@ -21,7 +21,7 @@ RSpec.describe 'ReeMapper::MapperFactory type options' do
         integer :x
         integer :y
         integer :z
-      } 
+      }
     }
 
     context 'with only' do
@@ -71,7 +71,7 @@ RSpec.describe 'ReeMapper::MapperFactory type options' do
             point :y, except: [:x, :z]
           end
 
-          array :points, each: point(only: [:x, :y])
+          array :points, point(only: [:x, :y])
         }
       }
 
@@ -169,7 +169,7 @@ RSpec.describe 'ReeMapper::MapperFactory type options' do
         integer :number
         integer? :opt_number
         integer :opt_number_long, optional: true
-        array? :opt_array, each: integer
+        array? :opt_array, integer
         array? :opt_array_with_blk do
           integer :id
         end
@@ -278,7 +278,7 @@ RSpec.describe 'ReeMapper::MapperFactory type options' do
           integer :for_all
           integer :for_admin, role: :admin
         }
-        
+
         mapper_factory.call.use(:cast) {
           nested_type :my_field
         }

data/lib/ree_lib/packages/ree_mapper/spec/ree_mapper/{types → wrappers}/array_spec.rb

@@ -17,8 +17,8 @@ RSpec.describe 'ReeMapper::Array' do
 
   let(:mapper) {
     mapper_factory.call.use(:cast).use(:serialize).use(:db_dump).use(:db_load) {
-      array :tags, each: integer
-      array? :ary_of_ary, each: array(each: integer)
+      array :tags, integer
+      array? :ary_of_ary, array(integer)
     }
   }
 
@@ -73,7 +73,7 @@ RSpec.describe 'ReeMapper::Array' do
   context 'with array of array' do
     let(:mapper) {
       mapper_factory.call.use(:serialize) {
-        array :coords, each: array(each: integer)
+        array :coords, array(integer)
       }
     }
 
@@ -85,7 +85,7 @@ RSpec.describe 'ReeMapper::Array' do
   context 'with nullable element of array' do
     let(:mapper) {
       mapper_factory.call.use(:serialize) {
-        array :tags, each: integer(null: true)
+        array :tags, integer(null: true)
       }
     }
 
@@ -98,7 +98,7 @@ RSpec.describe 'ReeMapper::Array' do
     it {
       expect {
         mapper_factory.call.use(:serialize) {
-          array :tags, each: integer?
+          array :tags, integer?
         }
       }.to raise_error(ArgumentError)
     }
@@ -106,7 +106,7 @@ RSpec.describe 'ReeMapper::Array' do
     it {
       expect {
         mapper_factory.call.use(:serialize) {
-          array :tags, each: integer(optional: true)
+          array :tags, integer(optional: true)
         }
       }.to raise_error(ArgumentError)
     }
@@ -114,7 +114,7 @@ RSpec.describe 'ReeMapper::Array' do
     it {
       expect {
         mapper_factory.call.use(:serialize) {
-          array :tags, each: array(each: integer, optional: true)
+          array :tags, array(integer, optional: true)
         }
       }.to raise_error(ArgumentError)
     }

data/lib/ree_lib/packages/ree_roda/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/lib/ree_lib/packages/ree_roda/Package.schema.json

@@ -0,0 +1,58 @@
+{
+  "schema_type": "package",
+  "schema_version": "1.1",
+  "name": "ree_roda",
+  "entry_path": "packages/ree_roda/package/ree_roda.rb",
+  "tags": [
+    "ree_roda"
+  ],
+  "depends_on": [
+    {
+      "name": "ree_actions"
+    },
+    {
+      "name": "ree_errors"
+    },
+    {
+      "name": "ree_hash"
+    },
+    {
+      "name": "ree_json"
+    },
+    {
+      "name": "ree_logger"
+    },
+    {
+      "name": "ree_object"
+    },
+    {
+      "name": "ree_swagger"
+    }
+  ],
+  "env_vars": [
+
+  ],
+  "objects": [
+    {
+      "name": "build_action_errors",
+      "schema": "packages/ree_roda/schemas/ree_roda/services/build_action_errors.schema.json",
+      "tags": [
+        "fn"
+      ]
+    },
+    {
+      "name": "build_swagger_from_actions",
+      "schema": "packages/ree_roda/schemas/ree_roda/services/build_swagger_from_actions.schema.json",
+      "tags": [
+        "fn"
+      ]
+    },
+    {
+      "name": "status_from_error",
+      "schema": "packages/ree_roda/schemas/ree_roda/services/status_from_error.schema.json",
+      "tags": [
+        "fn"
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_roda/bin/console

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require "bundler/setup"
+require "ree"
+
+Ree.init(__dir__, irb: true)

data/lib/ree_lib/packages/ree_roda/package/ree_roda/app.rb

@@ -0,0 +1,46 @@
+package_require("ree_errors/error")
+package_require("ree_mapper/errors/type_error")
+
+class ReeRoda::App < Roda
+  include Ree::LinkDSL
+
+  link :logger, from: :ree_logger
+  link :status_from_error
+  link :to_json, from: :ree_json
+
+  plugin :error_handler
+  plugin :json_parser
+  plugin :type_routing, default_type: :json
+
+  error do |e|
+    response["Content-Type"] = "application/json"
+
+    if e.is_a?(ReeErrors::Error)
+      body = {
+        code: e.code,
+        message: e.message,
+        type: e.type,
+      }
+
+      response.status = status_from_error(e.type)
+      response.write(to_json(body))
+      response.finish
+    elsif e.is_a?(ReeMapper::TypeError) || e.is_a?(ReeMapper::CoercionError)
+      body = {
+        code: "param",
+        message: e.message,
+        type: :invalid_param,
+      }
+
+      response.status = 400
+      response.write(to_json(body))
+      response.finish
+    else
+      logger.error(e.message, {}, e)
+      response["Content-Type"] = "text/plain"
+      response.status = 500
+      response.write("unhandled server error")
+      response.finish
+    end
+  end
+end