rider-kick 0.0.1

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-09-01
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 kotarominami
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,62 @@
+# RiderKick
+This gem provides helper interfaces and classes to assist in the construction of application with
+Clean Architecture, as described in [Robert Martin's seminal book](https://www.amazon.com/gp/product/0134494164).
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rider-kick'
+```
+
+And then execute:
+
+    $ bundle install
+    $ bundle binstubs rider-kick
+
+## Philosophy
+
+The intention of this gem is to help you build applications that are built from the use case down,
+and decisions about I/O can be deferred until the last possible moment.
+
+## Clean Architecture
+This structure provides helper interfaces and classes to assist in the construction of application with Clean Architecture, as described in Robert Martin's seminal book.
+
+```
+- app
+  - services
+    - api
+      - ...
+  - domains 
+    - entities (Contract Response)
+    - builder
+    - repositories (Business logic)
+    - use_cases (Just Usecase)
+    - utils (Class Reusable)
+```
+## Screaming architecture - use cases as an organisational principle
+Uncle Bob suggests that your source code organisation should allow developers to easily find a listing of all use cases your application provides. Here's an example of how this might look in a this application.
+```
+- app
+  - domains 
+    - core
+      ...
+      - usecase
+        - retail_customer_opens_bank_account.rb
+        - retail_customer_makes_deposit.rb
+        - ...
+```
+Note that the use case name contains:
+
+- the user role
+- the action
+- the (sometimes implied) subject
+```ruby
+    [user role][action][subject].rb
+    # retail_customer_opens_bank_account.rb
+    # admin_fetch_info.rb [specific usecase]
+    # fetch_info.rb [generic usecase] every role can access it
+```
+

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/rider-kick.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'rider_kick/entities/failure_details'
+require 'rider_kick/builders/abstract_active_record_entity_builder'
+require 'rider_kick/matchers/use_case_result'
+require 'rider_kick/use_cases/abstract_use_case'
+require 'rider_kick/use_cases/contract'
+
+require 'rider_kick/types'
+require 'rider_kick/version'
+
+module RiderKick
+  class Error < StandardError; end
+end

data/lib/rider_kick/builders/abstract_active_record_entity_builder.rb

@@ -0,0 +1,124 @@
+# typed: false
+# frozen_string_literal: true
+
+module RiderKick
+  module Builders
+    # Helps to take an instance of an AR model and wrap it up in the given Entity
+    # Any columns from the AR model that do not directly map to an attribute on the Entity
+    # can be specified by overriding #attributes_for_entity.
+    class AbstractActiveRecordEntityBuilder
+      # @param [Class] A Dry::Struct based entity that this builder will construct instances of
+      def self.acts_as_builder_for_entity(entity_class)
+        @has_many_builders = []
+        @belongs_to_builders = []
+
+        define_singleton_method :has_many_builders do
+          @has_many_builders
+        end
+
+        define_singleton_method :belongs_to_builders do
+          @belongs_to_builders
+        end
+
+        define_method :entity_class do
+          entity_class
+        end
+
+        private :entity_class
+      end
+
+      def self.has_many(relation_name, use:)
+        @has_many_builders << [relation_name, use]
+      end
+
+      def self.belongs_to(relation_name, use:)
+        @belongs_to_builders << [relation_name, use]
+      end
+
+      # @param [ActiveRecord::Base] An ActiveRecord model to map to the entity
+      def initialize(params)
+        @params = params
+      end
+
+      def build
+        entity_class.new(all_attributes_for_entity)
+      end
+
+      private
+
+      attr_reader :params
+
+      def entity_attribute_names
+        @entity_attributes ||= begin
+          if entity_class.respond_to?(:schema) # Dry::Struct
+            schema_keys = entity_class.schema.keys
+          elsif entity_class.respond_to?(:decorator) # T::Struct
+            schema_keys = entity_class.decorator.props.keys
+          else
+            raise 'Cannot determine schema format'
+          end
+          first_key = schema_keys.first
+          if first_key.is_a?(Symbol)
+            schema_keys
+          elsif first_key.respond_to?(:name)
+            schema_keys.map(&:name)
+          else
+            raise 'Cannot determine schema format'
+          end
+        end
+      end
+
+      def params_attributes
+        @params_attributes ||= @params.attributes
+      end
+
+      def symbolized_params_attributes
+        @symbolized_params_attributes ||= Hash[
+          params_attributes.map { |(key, value)| [key.to_sym, value] }
+        ]
+      end
+
+      def ar_attributes_for_entity
+        symbolized_params_attributes.slice(*entity_attribute_names)
+      end
+
+      def attributes_for_belongs_to_relations
+        self.class.belongs_to_builders.map do |belongs_to_builder_config|
+          relation_name, builder_class = belongs_to_builder_config
+          relation = @params.public_send(relation_name)
+
+          [
+            relation_name,
+            relation ? builder_class.new(relation).build : nil
+          ]
+        end.to_h
+      end
+
+      def attributes_for_has_many_relations
+        self.class.has_many_builders.map do |has_many_builder_config|
+          relation_name, builder_class = has_many_builder_config
+          relations = @params.public_send(relation_name)
+          built_relations = relations.map do |relation|
+            builder_class.new(relation).build
+          end
+
+          [
+            relation_name,
+            built_relations
+          ]
+        end.to_h
+      end
+
+      def attributes_for_entity
+        {}
+      end
+
+      def all_attributes_for_entity
+        ar_attributes_for_entity
+          .merge(attributes_for_belongs_to_relations)
+          .merge(attributes_for_has_many_relations)
+          .merge(attributes_for_entity)
+      end
+    end
+  end
+end

data/lib/rider_kick/entities/failure_details.rb

@@ -0,0 +1,30 @@
+# typed: false
+# frozen_string_literal: true
+
+require 'rider_kick/types'
+require 'dry/struct'
+
+module RiderKick
+  module Entities
+    class FailureDetails < Dry::Struct
+      failure_types = Types::Strict::String.enum(
+                        'error',
+                        'expectation_failed',
+                        'not_found',
+                        'unauthorized',
+                        'unprocessable_entity'
+      )
+      attribute :type, failure_types
+      attribute :message, Types::Strict::String
+      attribute :other_properties, Types::Strict::Hash.default({}.freeze)
+
+      def self.from_array(array)
+        new(message: 'failure 1, failure 2', other_properties: {}, type: 'error')
+      end
+
+      def self.from_string(string)
+        new(message: string, other_properties: {}, type: 'error')
+      end
+    end
+  end
+end

data/lib/rider_kick/matchers/use_case_result.rb

@@ -0,0 +1,51 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'rider_kick/entities/failure_details'
+require 'dry-matcher'
+require 'dry/monads/all'
+
+module RiderKick
+  module Matchers
+    class UseCaseResult
+      def self.call(result, &block)
+        new.matcher.call(result, &block)
+      end
+
+      def matcher
+        Dry::Matcher.new(success: success_case, failure: failure_case)
+      end
+
+      private
+
+      def success_case
+        Dry::Matcher::Case.new(
+          match:   ->(value) { value.is_a?(Dry::Monads::Success) },
+          resolve: ->(value) { value.value! }
+        )
+      end
+
+      def failure_case
+        Dry::Matcher::Case.new(
+          match:   ->(value) { value.is_a?(Dry::Monads::Failure) },
+          resolve: ->(value) { resolve_failure_value(value) }
+        )
+      end
+
+      def resolve_failure_value(value)
+        failure = value.failure
+        case failure
+        when Array
+          Entities::FailureDetails.from_array(failure)
+        when String
+          Entities::FailureDetails.from_string(failure)
+        when Entities::FailureDetails
+          failure
+        else
+          type_list = [Array, String, Entities::FailureDetails].map(&:to_s).join(' or ')
+          raise ArgumentError, "Unexpected failure value - must be #{type_list}"
+        end
+      end
+    end
+  end
+end

data/lib/rider_kick/matchers/use_case_result_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'rider_kick/matchers/use_case_result'
+
+RSpec.describe RiderKick::Matchers::UseCaseResult do
+  describe '.call' do
+    subject(:call) do
+      described_class.call(result) do |matcher|
+        matcher.success(&:to_s)
+        matcher.failure { |failure_details| failure_details }
+      end
+    end
+
+    context do
+      let(:result) { Dry::Monads::Success('success!') }
+
+      it { is_expected.to eq 'success!' }
+    end
+
+    context do
+      let(:result) { Dry::Monads::Failure('failure!') }
+
+      specify do
+        expect(call).to eq RiderKick::Entities::FailureDetails.new(
+                             message:          'failure!',
+                             other_properties: {},
+                             type:             'error'
+        )
+      end
+    end
+
+    context do
+      let(:result) { Dry::Monads::Failure(['failure 1', 'failure 2']) }
+
+      specify do
+        expect(call).to eq RiderKick::Entities::FailureDetails.new(
+                             message:          'failure 1, failure 2',
+                             other_properties: {},
+                             type:             'error'
+        )
+      end
+    end
+
+    context do
+      let(:failure_details) do
+        RiderKick::Entities::FailureDetails.new(
+          message:          'failure!',
+          other_properties: { a: :b },
+          type:             'unauthorized'
+        )
+      end
+      let(:result) { Dry::Monads::Failure(failure_details) }
+
+      it { is_expected.to eq failure_details }
+    end
+
+    context do
+      let(:result) { Dry::Monads::Failure(:no) }
+
+      specify { expect { call }.to raise_error ArgumentError }
+    end
+  end
+end

data/lib/rider_kick/types.rb

@@ -0,0 +1,10 @@
+# typed: ignore
+# frozen_string_literal: true
+
+require 'dry-types'
+
+module Types
+  include Dry.Types()
+  # File = Types.Instance(::File) | Types.Instance(ActionDispatch::Http::UploadedFile)
+  # public_constant :File
+end

data/lib/rider_kick/use_cases/abstract_use_case.rb

@@ -0,0 +1,36 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'dry/monads/result'
+require 'dry/validation'
+require 'dry/matcher/result_matcher'
+require 'rider_kick/use_cases/contract'
+
+module RiderKick
+  module UseCases
+    class AbstractUseCase
+      include Dry::Monads[:result]
+
+      def self.contract(base_contract = Contract, &proc)
+        @contract ||= Class.new(base_contract, &proc)
+      end
+
+      def self.contract!(args)
+        context  = args.fetch(:context, {})
+        @results = @contract.new(context).call(args)
+      end
+
+      def initialize(contract)
+        @contract = contract
+      end
+
+      def build_parameter!
+        if @contract.success?
+          Success(Hashie::Mash.new(@contract.to_h))
+        else
+          Failure(@contract.errors.to_h)
+        end
+      end
+    end
+  end
+end

data/lib/rider_kick/use_cases/contract.rb

@@ -0,0 +1,9 @@
+# typed: strong
+# frozen_string_literal: true
+
+module RiderKick
+  module UseCases
+    class Contract < Dry::Validation::Contract
+    end
+  end
+end

data/lib/rider_kick/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module RiderKick
+  VERSION = '0.0.1'
+  public_constant :VERSION
+end

data/sig/rider_kick.rbs

@@ -0,0 +1,4 @@
+module RiderKick
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,185 @@
+--- !ruby/object:Gem::Specification
+name: rider-kick
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Kotaro Minami
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-09-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-matcher
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: dry-monads
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+- !ruby/object:Gem::Dependency
+  name: dry-struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+- !ruby/object:Gem::Dependency
+  name: dry-transaction
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.16.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.16.0
+- !ruby/object:Gem::Dependency
+  name: dry-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.7.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.7.2
+- !ruby/object:Gem::Dependency
+  name: dry-validation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.10.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.5.18
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.5.18
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.2.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.2.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.13.0
+description: An attempt at building a reusable Clean Architecture framework for Ruby.
+email:
+- kotaroisme@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rider-kick.rb
+- lib/rider_kick/builders/abstract_active_record_entity_builder.rb
+- lib/rider_kick/entities/failure_details.rb
+- lib/rider_kick/matchers/use_case_result.rb
+- lib/rider_kick/matchers/use_case_result_spec.rb
+- lib/rider_kick/types.rb
+- lib/rider_kick/use_cases/abstract_use_case.rb
+- lib/rider_kick/use_cases/contract.rb
+- lib/rider_kick/version.rb
+- sig/rider_kick.rbs
+homepage: https://github.com/kotaroisme/rider-kick
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.18
+signing_key:
+specification_version: 4
+summary: Clean Architecture Framework.
+test_files: []