ree_lib 1.0.35 → 1.0.37

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 190a7da138d373c34c6e7636265ccce86c37e6ad5fd0c02b4e3c81c7e376393a
-  data.tar.gz: ad6b89d186eec9a9006cc6d217ee82d6f20a34428bd052953aac7e2624a6b41c
+  metadata.gz: bfa479493ff3b8d80a181db242e9f443324b5c7f46b3629dae816f06eb2fd758
+  data.tar.gz: 371e0a229e967c47f8ad61de6c86aba1bb0e0b17651bf6447e7727734629e294
 SHA512:
-  metadata.gz: 45199483809ad7917a207699df3acd7689db5dd246dfdce7910a7427a4d100750196a903b51aba2e24d0594141a01b8086e0767f9427b555fa2bdece22e83491
-  data.tar.gz: d20668755d3da265a0ec0351220dfe9604cfaf21ebbb78833b093445afd01280e7b6e7d83ebba428b3808c346754fb1debcbed29197098f136c3b1a30bb24369
+  metadata.gz: 71b4a7f35d1a0569af42794acf8bf8c1193cf390ca773fd6ebab395cb86192199496812c9ae356e29a299a453304d6c25217cd20d9bd7884ded1e10fa798d68f
+  data.tar.gz: c5b3cf9ea44d8012ea7be12cf8ef9f33ac735a28c8d9bb384bf69fec6f8bc7932b7a1cf6f43be4439d7fa220b3cc2e630d8e0816b75c732fcb9b13e3e1b6ef22

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ree_lib (1.0.35)
+    ree_lib (1.0.37)
       binding_of_caller (~> 1.0.0)
       i18n (~> 1.12.0)
       loofah (~> 2.18.0)
@@ -36,17 +36,24 @@ GEM
       crass (~> 1.0.2)
       nokogiri (>= 1.5.9)
     msgpack (1.6.0)
+    nokogiri (1.14.2-x86_64-darwin)
+      racc (~> 1.4)
     nokogiri (1.14.2-x86_64-linux)
       racc (~> 1.4)
     oj (3.13.23)
     pg (1.4.6)
     public_suffix (5.0.1)
     racc (1.6.2)
+    rack (3.0.5)
+    rack-test (2.0.2)
+      rack (>= 1.3)
     rainbow (3.1.1)
     rake (13.0.6)
-    ree (1.0.23)
+    ree (1.0.27)
       commander (~> 4.6.0)
     rexml (3.2.5)
+    roda (3.58.0)
+      rack
     rollbar (3.3.3)
     rspec (3.12.0)
       rspec-core (~> 3.12.0)
@@ -79,8 +86,10 @@ PLATFORMS
 DEPENDENCIES
   bootsnap
   pg (~> 1.4.1)
+  rack-test
   rake (~> 13.0)
   ree_lib!
+  roda (~> 3.58.0)
   rollbar (~> 3.3.1)
   rspec
   sqlite3 (~> 1.4.4)

data/lib/ree_lib/Packages.schema.json

@@ -2,6 +2,10 @@
   "schema_version": "1.0",
   "schema_type": "packages",
   "packages": [
+    {
+      "name": "ree_actions",
+      "schema": "packages/ree_actions/Package.schema.json"
+    },
     {
       "name": "ree_array",
       "schema": "packages/ree_array/Package.schema.json"
@@ -66,6 +70,10 @@
       "name": "ree_object",
       "schema": "packages/ree_object/Package.schema.json"
     },
+    {
+      "name": "ree_roda",
+      "schema": "packages/ree_roda/Package.schema.json"
+    },
     {
       "name": "ree_string",
       "schema": "packages/ree_string/Package.schema.json"

data/lib/ree_lib/packages/ree_actions/.rspec

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

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

@@ -0,0 +1,20 @@
+{
+  "schema_type": "package",
+  "schema_version": "1.1",
+  "name": "ree_actions",
+  "entry_path": "packages/ree_actions/package/ree_actions.rb",
+  "tags": [
+    "ree_actions"
+  ],
+  "depends_on": [
+    {
+      "name": "ree_mapper"
+    }
+  ],
+  "env_vars": [
+
+  ],
+  "objects": [
+
+  ]
+}

data/lib/ree_lib/packages/ree_actions/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_actions/package/ree_actions/action.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class ReeActions::Action
+  attr_accessor :summary, :request_method, :serializer, :respond_to,
+                :sections, :action, :warden_scope, :path
+
+  def valid?
+    !@action.nil? && !summary.nil? && !warden_scope.nil?
+  end
+end

data/lib/ree_lib/packages/ree_actions/package/ree_actions/action_builder.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "action"
+
+class ReeActions::ActionBuilder
+  Redirect = Struct.new(:path, :code)
+
+  def initialize
+    @action = ReeActions::Action.new
+    @action.respond_to = :json
+  end
+
+  contract Symbol => Symbol
+  def warden_scope(scope)
+    @action.warden_scope = scope
+  end
+
+  contract Symbol => Symbol
+  def respond_to(v)
+    @action.respond_to = v
+  end
+
+  contract None => ReeActions::Action
+  def get_action
+    @action
+  end
+
+  contract Block => nil
+  def before(&proc)
+    @action.before = proc
+    nil
+  end
+
+  contract String => String
+  def summary(str)
+    @action.summary = str
+  end
+
+  contract Symbol, Symbol => nil
+  def serializer(name, from:)
+    object = Ree.container.packages_facade.get_object(from, name)
+    @action.serializer = object
+    nil
+  end
+
+  contract SplatOf[String] => nil
+  def sections(*names)
+    @action.sections = names
+    nil
+  end
+
+  contract Symbol, Symbol => nil
+  def action(name, from:)
+    object = Ree.container.packages_facade.get_object(from, name)
+    @action.action = object
+    nil
+  end
+
+  contract String, Kwargs[code: Integer] => nil
+  def redirect(path, code: 301)
+    raise ArgumentError if ![301, 302, 303, 307, 308].include?(code)
+    @action.redirect = Redirect.new(path, code)
+    nil
+  end
+end

data/lib/ree_lib/packages/ree_actions/package/ree_actions/action_dsl.rb

@@ -0,0 +1,60 @@
+module ReeActions
+  module ActionDSL
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.include(ReeMapper::DSL)
+    end
+
+    def self.extended(base)
+      base.extend(ClassMethods)
+      base.include(ReeMapper::DSL)
+    end
+
+    module ClassMethods
+      include Ree::Contracts::Core
+      include Ree::Contracts::ArgContracts
+
+      def action(name, &proc)
+        dsl = Ree::ObjectDsl.new(
+          Ree.container.packages_facade, name, self, :fn
+        )
+
+        dsl.instance_exec(&proc) if block_given?
+        dsl.tags(["action"])
+        dsl.freeze(false)
+        dsl.object.set_as_compiled(false)
+
+        Ree.container.compile(dsl.package, name)
+      end
+
+      def method_added(method_name)
+        return super if method_name != :call
+
+        if @__original_call_defined
+          remove_instance_variable(:@__original_call_defined)
+          return
+        end
+
+        @__original_call_defined = true
+
+        alias_method(:__original_call, :call)
+
+        define_method :call do |user_access, attrs|
+          if self.class.const_defined?(:ActionCaster)
+            caster = self.class.const_get(:ActionCaster)
+
+            if !caster.respond_to?(:cast)
+              raise ArgumentError.new("ActionCaster does not respond to `cast` method")
+            end
+
+            __original_call(user_access, caster.cast(attrs))
+          else
+            __original_call(user_access, attrs)
+          end
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/ree_lib/packages/ree_actions/package/ree_actions/dsl.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative "action_builder"
+require "uri"
+
+module ReeActions
+  module DSL
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def self.extended(base)
+      base.extend(ClassMethods)
+    end
+
+    module FactoryMethod
+      def build
+        self.class.instance_variable_get(:@actions) || []
+      end
+    end
+
+    module ClassMethods
+      include Ree::Contracts::Core
+      include Ree::Contracts::ArgContracts
+
+      def actions(name, &proc)
+        raise ArgumentError.new("block is required") if !block_given?
+
+        @dsl = Ree::ObjectDsl.new(
+          Ree.container.packages_facade, name, self, :object
+        )
+
+        @dsl.singleton
+        @dsl.factory(:build)
+        @dsl.tags(["actions"])
+
+        instance_exec(&proc)
+
+        klass = @dsl.object.klass
+        klass.send(:include, FactoryMethod)
+
+
+        Ree.container.compile(@dsl.package, name)
+      end
+
+      def default_warden_scope(method_name)
+        @default_warden_scope = method_name
+      end
+
+      [:get, :post, :put, :delete, :patch, :head, :options].each do |request_method|
+        define_method request_method do |path, &proc|
+          define_action(request_method, path, &proc)
+        end
+      end
+
+      private
+
+      contract Symbol, String, Block => ReeActions::Action
+      def define_action(request_method, path, &proc)
+        raise ArgumentError.new("actions should be called") if !@dsl
+        raise ArgumentError.new("block is required") if !block_given?
+
+        @actions ||= []
+
+        builder = ReeActions::ActionBuilder.new
+        builder.instance_exec(&proc)
+
+        if @default_warden_scope && !builder.get_action.warden_scope
+          builder.warden_scope(@default_warden_scope)
+        end
+
+        uri = URI.parse(path) rescue nil
+
+        if uri.nil? || uri.path != path
+          raise ArgumentError.new("invalid path provided #{path}")
+        end
+
+        if uri.query && !uri.query.empty?
+          raise ArgumentError.new("action path should not include query params: #{path}")
+        end
+
+        builder.get_action.path = path
+        builder.get_action.request_method = request_method
+
+        if !builder.get_action.valid?
+          raise ArgumentError.new("action, summary and auth scope should be provider for #{builder.get_action.inspect}")
+        end
+
+        action = builder.get_action
+
+        @dsl.link(action.action.name, from: action.action.package_name)
+
+        if action.serializer
+          @dsl.link(action.serializer.name, from: action.serializer.package_name)
+        end
+
+        @actions << action
+        action
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ReeActions
+  include Ree::PackageDSL
+
+  package do
+    depends_on :ree_mapper
+  end
+end
+
+require_relative "ree_actions/dsl"
+require_relative "ree_actions/action_dsl"

data/lib/ree_lib/packages/ree_actions/spec/package_schema_spec.rb

@@ -0,0 +1,14 @@
+RSpec.describe "ReeActions" do
+  it "generates package schema" do
+    require "fileutils"
+
+    packages_schema_path = Ree.locate_packages_schema(__dir__)
+    packages_schema_dir = Pathname.new(packages_schema_path).dirname.to_s
+
+    FileUtils.cd packages_schema_dir do
+      expect(
+        system("REE_SKIP_ENV_VARS_CHECK=true bundle exec ree gen.package_json ree_actions --silence")
+      ).to eq(true)
+    end
+  end
+end

data/lib/ree_lib/packages/ree_actions/spec/ree_actions/action_dsl_spec.rb

@@ -0,0 +1,62 @@
+package_require("ree_actions/action_dsl")
+
+RSpec.describe ReeActions::ActionDSL, type: [:autoclean] do
+  before do
+    Ree.enable_irb_mode
+  end
+
+  after do
+    Ree.disable_irb_mode
+  end
+
+  it {
+    module ReeActionsTest
+      include Ree::PackageDSL
+
+      package do
+        depends_on :ree_mapper
+      end
+
+      class TestAction
+        include ReeActions::ActionDSL
+
+        action :test_action
+
+        ActionCaster = build_mapper.use(:cast) do
+          integer :user_id
+        end
+
+        contract Any, ActionCaster.dto(:cast) => Integer
+        def call(user_access, attrs)
+          attrs[:user_id]
+        end
+      end
+    end
+
+    result = ReeActionsTest::TestAction.new.call('user_access', {user_id: 1})
+    expect(result).to eq(1)
+  }
+
+  it {
+    module ReeActionsTest
+      include Ree::PackageDSL
+
+      package do
+      end
+
+      class TestAction2
+        include ReeActions::ActionDSL
+
+        action :test_action2
+
+        contract Any, Hash => Integer
+        def call(user_access, attrs)
+          attrs[:user_id]
+        end
+      end
+    end
+
+    result = ReeActionsTest::TestAction2.new.call('user_access', {user_id: 1})
+    expect(result).to eq(1)
+  }
+end

data/lib/ree_lib/packages/ree_actions/spec/ree_actions/dsl_spec.rb

@@ -0,0 +1,93 @@
+package_require("ree_actions/dsl")
+
+RSpec.describe ReeActions::DSL, type: [:autoclean] do
+  before :all do
+    Ree.enable_irb_mode
+
+    module ReeActionsTest
+      include Ree::PackageDSL
+
+      package
+    end
+
+    class ReeActionsTest::EmptyActions
+      include ReeActions::DSL
+
+      actions :empty_actions do
+      end
+    end
+
+    class ReeActionsTest::Cmd
+      include Ree::FnDSL
+
+      fn :cmd
+
+      def call
+      end
+    end
+
+    class ReeActionsTest::Serializer
+      include ReeMapper::DSL
+
+      mapper :serializer
+
+      build_mapper.use(:serialize) do
+        integer :id
+      end
+    end
+
+    class ReeActionsTest::Caster
+      include ReeMapper::DSL
+
+      mapper :caster
+
+      build_mapper.use(:cast) do
+        integer :id
+      end
+    end
+
+    class ReeActionsTest::Actions
+      include ReeActions::DSL
+
+      actions :actions do
+        default_warden_scope :user
+
+        post "users" do
+          summary "Test action"
+          action :cmd, from: :ree_actions_test
+          serializer :serializer, from: :ree_actions_test
+          respond_to :json
+        end
+
+        get "files.csv" do
+          summary "Test action"
+          action :cmd, from: :ree_actions_test
+          respond_to :csv
+        end
+      end
+    end
+  end
+
+  after :all do
+    Ree.disable_irb_mode
+  end
+
+  it {
+    expect(ReeActionsTest::EmptyActions.new).to eq([])
+  }
+
+  it {
+    actions = ReeActionsTest::Actions.new
+
+    expect(actions.size).to eq(2)
+
+    post_action = actions.first
+    csv_action = actions.last
+
+    expect(post_action.serializer.name).to eq(:serializer)
+    expect(post_action.action.name).to eq(:cmd)
+    expect(post_action.respond_to).to eq(:json)
+
+    expect(csv_action.respond_to).to eq(:csv)
+  }
+end

data/lib/ree_lib/packages/ree_actions/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+RSpec.configure do |config|
+  config.extend Ree::RSpecLinkDSL
+end

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

@@ -18,13 +18,13 @@ class ReeMapper::BuildMapperFactory
       @strategies = strategies
     }
 
-    klass.register(:bool, Mapper.build(strategies, ReeMapper::Bool.new))
-    klass.register(:date_time, Mapper.build(strategies, ReeMapper::DateTime.new))
-    klass.register(:time, Mapper.build(strategies, ReeMapper::Time.new))
-    klass.register(:date, Mapper.build(strategies, ReeMapper::Date.new))
-    klass.register(:float, Mapper.build(strategies, ReeMapper::Float.new))
-    klass.register(:integer, Mapper.build(strategies, ReeMapper::Integer.new))
-    klass.register(:string, Mapper.build(strategies, ReeMapper::String.new))
+    klass.register_type(:bool, ReeMapper::Bool.new)
+    klass.register_type(:date_time, ReeMapper::DateTime.new)
+    klass.register_type(:time, ReeMapper::Time.new)
+    klass.register_type(:date, ReeMapper::Date.new)
+    klass.register_type(:float, ReeMapper::Float.new)
+    klass.register_type(:integer, ReeMapper::Integer.new)
+    klass.register_type(:string, ReeMapper::String.new)
 
     klass
   end

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

@@ -7,7 +7,7 @@ class ReeMapper::Mapper
       strategies.each do |strategy|
         method = strategy.method
         next if type.respond_to?(method)
-        raise ReeMapper::UnsupportedTypeError, "type #{type.name} should implement method `#{method}`"
+        raise ReeMapper::UnsupportedTypeError, "type #{type.inspect} should implement method `#{method}`"
       end
     end
 
@@ -113,7 +113,7 @@ class ReeMapper::Mapper
 
   contract(Symbol => Class).throws(ArgumentError)
   def dto(strategy_method)
-    strategy = strategies.detect { _1.method == strategy_method }
+    strategy = find_strategy(strategy_method)
     raise ArgumentError, "there is no :#{strategy_method} strategy" unless strategy
     strategy.dto
   end
@@ -124,4 +124,9 @@ class ReeMapper::Mapper
     strategies.each { _1.prepare_dto(fields.keys) }
     nil
   end
+
+  contract(Symbol => Nilor[ReeMapper::MapperStrategy])
+  def find_strategy(strategy_method)
+    strategies.detect { _1.method == strategy_method }
+  end
 end

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

@@ -5,35 +5,42 @@ class ReeMapper::MapperFactory
     attr_reader :types, :strategies
   end
 
-  contract(Symbol, Any => Class).throws(ArgumentError)
-  def self.register_type(name, object_type)
-    register(
+  contract(Symbol => Nilor[ReeMapper::MapperStrategy])
+  def self.find_strategy(strategy_method)
+    strategies.detect { _1.method == strategy_method }
+  end
+
+  contract(Symbol, ReeMapper::AbstractType, Kwargs[strategies: ArrayOf[ReeMapper::MapperStrategy]] => Class)
+  def self.register_type(name, object_type, strategies: self.strategies)
+    register_mapper(
       name,
       ReeMapper::Mapper.build(strategies, object_type)
     )
   end
 
-  contract(Symbol, Any => Class).throws(ArgumentError)
-  def self.register(name, type)
-    raise ArgumentError, "name of mapper type should not include `?`" if name.to_s.end_with?('?')
-    raise ArgumentError, "type :#{name} already registered" if types.key?(name)
-    raise ArgumentError, "method :#{name} already defined" if method_defined?(name)
+  contract(Symbol, ReeMapper::Mapper => Class).throws(ArgumentError)
+  def self.register_mapper(name, type)
+    raise ArgumentError, "name of mapper type 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
+    raise ArgumentError, "method :#{name} already defined" if !types.key?(name) && method_defined?(name)
 
     type = type.dup
     type.name = name
     type.freeze
-    types[name] = type
+    types[name] ||= []
+    types[name] << type
 
     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
 
-        type = self.class.types.fetch(:#{name})
+        type = self.class.types.fetch(:#{name}).detect { (@mapper.strategy_methods - _1.strategy_methods).empty? }
 
-        @mapper.strategy_methods.each do |method|
-          next if type.respond_to?(method)
-          raise ReeMapper::UnsupportedTypeError, "type :#{name} should implement method `\#{method}`"
+        unless type
+          raise ReeMapper::UnsupportedTypeError, "type :#{name} should implement `\#{@mapper.strategy_methods.join(', ')}`"
         end
 
         return ReeMapper::Field.new(type, optional: optional, **opts) unless field_name

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

@@ -22,7 +22,7 @@ class ReeMapper::MapperFactoryProxy
     if strategy_or_method.is_a?(ReeMapper::MapperStrategy)
       strategy = strategy_or_method
     else
-      strategy = mapper_factory.strategies.detect { _1.method == strategy_or_method }
+      strategy = mapper_factory.find_strategy(strategy_or_method)
       raise ArgumentError, "MapperFactory strategy :#{strategy_or_method} not found" unless strategy
       strategy = strategy.dup
       strategy.dto = dto if dto
@@ -36,7 +36,7 @@ class ReeMapper::MapperFactoryProxy
     mapper_factory.new(mapper).instance_exec(&blk)
     mapper.prepare_dto
 
-    mapper_factory.register(register_as, mapper) if register_as
+    mapper_factory.register_mapper(register_as, mapper) if register_as
 
     after_build&.call(mapper)
 

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

@@ -1,17 +1,2 @@
 class ReeMapper::AbstractType
-  def serialize(value, name:, role: nil)
-    raise NotImplementedError
-  end
-
-  def cast(value, name:, role: nil)
-    raise NotImplementedError
-  end
-
-  def db_dump(value, name:, role: nil)
-    raise NotImplementedError
-  end
-
-  def db_load(value, name:, role: nil)
-    raise NotImplementedError
-  end
 end