cuprum-rails 0.1.0 → 0.2.0

data/lib/cuprum/rails/controller_action.rb

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-
-require 'cuprum/rails'
-
-module Cuprum::Rails
-  # @api private
-  #
-  # Implements a controller action.
-  #
-  # @note This class should not be initialized directly. Instead, use the
-  #   Cuprum::Rails::Controller.action class method to define an action.
-  class ControllerAction
-    extend Forwardable
-
-    # @param configuration [Cuprum::Rails::Controllers::Configuration] the
-    #   configuration for the originating controller.
-    # @param action_class [Class] The class of the action command. Must be
-    #   constructible with keyword :resource.
-    # @param action_name [String, Symbol] The name of the action.
-    # @param member_action [Boolean] True if the action acts on a collection
-    #   item, not on the collection as a whole.
-    # @param serializers
-    #   [Hash<Class, Object>, Hash<Symbol, Hash<Class, Object>>] The serializers
-    #   for converting result values into serialized data.
-    def initialize(
-      configuration,
-      action_class:,
-      action_name:,
-      member_action: false,
-      serializers:   {}
-    )
-      @configuration = configuration
-      @action_class  = action_class
-      @action_name   = action_name
-      @member_action = !!member_action # rubocop:disable Style/DoubleNegation
-      @serializers   = serializers
-    end
-
-    # @return [Class] the class of the action command.
-    attr_reader :action_class
-
-    # @return [String, Symbol] the name of the action.
-    attr_reader :action_name
-
-    # @return [Cuprum::Rails::Controllers::Configuration] the configuration for
-    #   the originating controller.
-    attr_reader :configuration
-
-    # @return [Hash<Class, Object>, Hash<Symbol, Hash<Class, Object>>] the
-    #   serializers for converting result values into serialized data.
-    attr_reader :serializers
-
-    # @!method resource
-    #   @return [Cuprum::Rails::Resource] the resource defined for the
-    #     controller.
-
-    # @!method responder_for(format)
-    #   Finds the configured responder for the requested format.
-    #
-    #   @param format [Symbol] The format to respond to.
-    #
-    #   @return [Class] the responder class defined for the format.
-    #
-    #   @raise [Cuprum::Rails::Controller::UnknownFormatError] if the controller
-    #     does not define a responder for the given format.
-
-    def_delegators :@configuration,
-      :resource,
-      :responder_for
-
-    # Executes the controller action.
-    #
-    # 1. Initializes the action command with the resource.
-    # 2. Calls the command with the request.
-    # 3. Builds the responder with the resource and action metadata.
-    # 4. Calls the responder with the action result.
-    #
-    # @param request [ActionDispatch::Request] The request to process.
-    #
-    # @return [#call] The response object.
-    def call(request)
-      responder = build_responder(request)
-      action    = action_class.new(resource: resource)
-      result    = action.call(request: request)
-
-      responder.call(result)
-    end
-
-    # @return [Boolean] true if the action acts on a collection item, not on the
-    #   collection as a whole.
-    def member_action?
-      @member_action
-    end
-
-    private
-
-    def build_responder(request)
-      responder_class = responder_for(request.format)
-
-      responder_class.new(
-        action_name:   action_name,
-        member_action: member_action?,
-        resource:      resource,
-        serializers:   merge_serializers_for(request.format)
-      )
-    end
-
-    def merge_serializers_for(format)
-      scoped_serializers(configuration.serializers, format: format)
-        .merge(scoped_serializers(serializers, format: format))
-    end
-
-    def scoped_serializers(serializers, format:)
-      serializers
-        .select { |key, _| key.is_a?(Class) }
-        .merge(serializers.fetch(format, {}))
-    end
-  end
-end

data/lib/cuprum/rails/errors/missing_parameters.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'cuprum/error'
-
-require 'cuprum/rails/errors'
-
-module Cuprum::Rails::Errors
-  # Error class when a parameters hash does not include a resource.
-  class MissingParameters < Cuprum::Error
-    # Short string used to identify the type of error.
-    TYPE = 'cuprum.rails.errors.missing_parameters'
-
-    # @param resource_name [Cuprum::Rails::Resource] The name of the resource.
-    def initialize(resource_name:)
-      @resource_name = resource_name
-
-      super(message: default_message, resource_name: resource_name)
-    end
-
-    # @return [Cuprum::Rails::Resource] the name of the resource.
-    attr_reader :resource_name
-
-    private
-
-    def as_json_data
-      { 'resource_name' => resource_name }
-    end
-
-    def default_message
-      "The #{resource_name.inspect} parameter is missing or empty"
-    end
-  end
-end

data/lib/cuprum/rails/errors/missing_primary_key.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'cuprum/error'
-
-require 'cuprum/rails/errors'
-
-module Cuprum::Rails::Errors
-  # Error class when a parameters hash does not include a primary key.
-  class MissingPrimaryKey < Cuprum::Error
-    # Short string used to identify the type of error.
-    TYPE = 'cuprum.rails.errors.missing_primary_key'
-
-    # @param primary_key [String, Symbol] The name of the resource primary key.
-    # @param resource_name [Cuprum::Rails::Resource] The name of the resource.
-    def initialize(primary_key:, resource_name:)
-      @primary_key   = primary_key
-      @resource_name = resource_name
-
-      super(
-        message:       default_message,
-        primary_key:   primary_key,
-        resource_name: resource_name
-      )
-    end
-
-    # @return [String] the name of the resource primary key.
-    attr_reader :primary_key
-
-    # @return [Cuprum::Rails::Resource] the name of the resource.
-    attr_reader :resource_name
-
-    private
-
-    def as_json_data
-      {
-        'primary_key'   => primary_key,
-        'resource_name' => resource_name
-      }
-    end
-
-    def default_message
-      "Unable to find #{resource_name} because the #{primary_key.inspect}" \
-        ' parameter is missing or empty'
-    end
-  end
-end

data/lib/cuprum/rails/errors/undefined_permitted_attributes.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require 'cuprum/error'
-
-require 'cuprum/rails/errors'
-
-module Cuprum::Rails::Errors
-  # Error class when a resource does not define permitted attributes.
-  class UndefinedPermittedAttributes < Cuprum::Error
-    # Short string used to identify the type of error.
-    TYPE = 'cuprum.rails.errors.undefined_permitted_attributes'
-
-    # @param resource_name [Cuprum::Rails::Resource] The name of the resource.
-    def initialize(resource_name:)
-      @resource_name = resource_name
-
-      super(message: default_message, resource_name: resource_name)
-    end
-
-    # @return [Cuprum::Rails::Resource] the name of the resource.
-    attr_reader :resource_name
-
-    private
-
-    def as_json_data
-      { 'resource_name' => resource_name }
-    end
-
-    def default_message
-      "Resource #{resource_name.inspect} does not define" \
-        ' permitted attributes'
-    end
-  end
-end

data/lib/cuprum/rails/rspec/command_contract.rb

@@ -1,460 +0,0 @@
-# frozen_string_literal: true
-
-require 'cuprum/rails/rspec'
-
-require 'support/book'
-require 'support/tome'
-
-module Cuprum::Rails::RSpec
-  # Contract validating the behavior of a Rails command implementation.
-  COMMAND_CONTRACT = lambda do
-    describe '.subclass' do
-      let(:subclass) { described_class.subclass }
-      let(:constructor_options) do
-        {
-          record_class: Book,
-          optional_key: 'optional value'
-        }
-      end
-
-      it 'should define the class method' do
-        expect(described_class)
-          .to respond_to(:subclass)
-          .with(0).arguments
-          .and_any_keywords
-      end
-
-      it { expect(subclass).to be_a Class }
-
-      it { expect(subclass).to be < described_class }
-
-      it 'should define the constructor' do
-        expect(subclass)
-          .to respond_to(:new)
-          .with(0).arguments
-          .and_any_keywords
-      end
-
-      it 'should return the record class' do
-        expect(subclass.new(**constructor_options).record_class)
-          .to be record_class
-      end
-
-      it 'should return the options' do
-        expect(subclass.new(**constructor_options).options)
-          .to be == { optional_key: 'optional value' }
-      end
-
-      describe 'with options' do
-        let(:default_options) do
-          {
-            record_class: Book,
-            custom_key:   'custom value'
-          }
-        end
-        let(:constructor_options) do
-          {
-            optional_key: 'optional value'
-          }
-        end
-        let(:subclass) { described_class.subclass(**default_options) }
-
-        it { expect(subclass).to be_a Class }
-
-        it { expect(subclass).to be < described_class }
-
-        it 'should define the constructor' do
-          expect(subclass)
-            .to respond_to(:new)
-            .with(0).arguments
-            .and_any_keywords
-        end
-
-        it 'should return the record class' do
-          expect(subclass.new(**constructor_options).record_class)
-            .to be record_class
-        end
-
-        it 'should return the options' do
-          expect(subclass.new(**constructor_options).options)
-            .to be == {
-              custom_key:   'custom value',
-              optional_key: 'optional value'
-            }
-        end
-      end
-    end
-
-    describe '#collection_name' do
-      let(:expected) { record_class.name.underscore.pluralize }
-
-      include_examples 'should define reader',
-        :collection_name,
-        -> { be == expected }
-
-      context 'when initialized with collection_name: string' do
-        let(:collection_name) { 'books' }
-        let(:constructor_options) do
-          super().merge(collection_name: collection_name)
-        end
-
-        it { expect(command.collection_name).to be == collection_name }
-      end
-
-      context 'when initialized with collection_name: symbol' do
-        let(:collection_name) { :books }
-        let(:constructor_options) do
-          super().merge(collection_name: collection_name)
-        end
-
-        it { expect(command.collection_name).to be == collection_name.to_s }
-      end
-    end
-
-    describe '#member_name' do
-      def tools
-        SleepingKingStudios::Tools::Toolbelt.instance
-      end
-
-      include_examples 'should have reader',
-        :member_name,
-        -> { record_class.name.underscore }
-
-      context 'when initialized with collection_name: value' do
-        let(:collection_name) { :books }
-
-        it 'should return the singular collection name' do
-          expect(command.member_name)
-            .to be == tools.str.singularize(collection_name.to_s)
-        end
-      end
-
-      context 'when initialized with member_name: string' do
-        let(:member_name)         { 'tome' }
-        let(:constructor_options) { super().merge(member_name: member_name) }
-
-        it 'should return the singular collection name' do
-          expect(command.member_name).to be member_name
-        end
-      end
-
-      context 'when initialized with member_name: symbol' do
-        let(:member_name)         { :tome }
-        let(:constructor_options) { super().merge(member_name: member_name) }
-
-        it 'should return the singular collection name' do
-          expect(command.member_name).to be == member_name.to_s
-        end
-      end
-    end
-
-    describe '#options' do
-      let(:expected_options) do
-        defined?(super()) ? super() : constructor_options
-      end
-
-      include_examples 'should define reader',
-        :options,
-        -> { be == expected_options }
-
-      context 'when initialized with options' do
-        let(:constructor_options) { super().merge({ key: 'value' }) }
-        let(:expected_options)    { super().merge({ key: 'value' }) }
-
-        it { expect(command.options).to be == expected_options }
-      end
-    end
-
-    describe '#primary_key_name' do
-      include_examples 'should define reader', :primary_key_name, :id
-
-      context 'with a record class with custom primary key' do
-        let(:record_class) { Tome }
-
-        include_examples 'should define reader', :primary_key_name, :uuid
-      end
-    end
-
-    describe '#primary_key_type' do
-      include_examples 'should define reader', :primary_key_type, Integer
-
-      context 'with a record class with custom primary key' do
-        let(:record_class) { Tome }
-
-        include_examples 'should define reader', :primary_key_type, String
-      end
-    end
-
-    describe '#record_class' do
-      include_examples 'should define reader',
-        :record_class,
-        -> { record_class }
-    end
-
-    describe '#validate_entity' do
-      let(:expected_error) do
-        type     = record_class
-        contract = Stannum::Contracts::ParametersContract.new do
-          keyword :entity, type
-        end
-        errors = contract.errors_for(
-          {
-            arguments: [],
-            block:     nil,
-            keywords:  { entity: nil }
-          }
-        )
-
-        Cuprum::Collections::Errors::InvalidParameters.new(
-          command: command,
-          errors:  errors
-        )
-      end
-
-      it 'should define the private method' do
-        expect(command)
-          .to respond_to(:validate_entity, true)
-          .with(1).argument
-      end
-
-      describe 'with nil' do
-        it 'should return a failing result' do
-          expect(command.send(:validate_entity, nil))
-            .to be_a_failing_result
-            .with_error(expected_error)
-        end
-      end
-
-      describe 'with an Object' do
-        it 'should return a failing result' do
-          expect(command.send(:validate_entity, Object.new.freeze))
-            .to be_a_failing_result
-            .with_error(expected_error)
-        end
-      end
-
-      describe 'with an invalid record instance' do
-        it 'should return a failing result' do
-          expect(command.send(:validate_entity, Tome.new))
-            .to be_a_failing_result
-            .with_error(expected_error)
-        end
-      end
-
-      describe 'with a valid record instance' do
-        it 'should not return a result' do
-          expect(command.send(:validate_entity, Book.new))
-            .not_to be_a_result
-        end
-      end
-    end
-
-    describe '#validate_primary_key' do
-      let(:primary_key_type) { Integer }
-      let(:expected_error) do
-        type     = primary_key_type
-        contract = Stannum::Contracts::ParametersContract.new do
-          keyword :primary_key, type
-        end
-        errors = contract.errors_for(
-          {
-            arguments: [],
-            block:     nil,
-            keywords:  { primary_key: nil }
-          }
-        )
-
-        Cuprum::Collections::Errors::InvalidParameters.new(
-          command: command,
-          errors:  errors
-        )
-      end
-
-      it 'should define the private method' do
-        expect(command)
-          .to respond_to(:validate_primary_key, true)
-          .with(1).argument
-      end
-
-      describe 'with nil' do
-        it 'should return a failing result' do
-          expect(command.send(:validate_primary_key, nil))
-            .to be_a_failing_result
-            .with_error(expected_error)
-        end
-      end
-
-      describe 'with an Object' do
-        it 'should return a failing result' do
-          expect(command.send(:validate_primary_key, Object.new.freeze))
-            .to be_a_failing_result
-            .with_error(expected_error)
-        end
-      end
-
-      describe 'with a String' do
-        it 'should return a failing result' do
-          expect(command.send(:validate_primary_key, '12345'))
-            .to be_a_failing_result
-            .with_error(expected_error)
-        end
-      end
-
-      describe 'with an Integer' do
-        it 'should not return a result' do
-          expect(command.send(:validate_primary_key, 12_345)).not_to be_a_result
-        end
-      end
-
-      context 'with a record class with custom primary key' do
-        let(:record_class)     { Tome }
-        let(:primary_key_type) { String }
-
-        describe 'with an Integer' do
-          it 'should return a failing result' do
-            expect(command.send(:validate_primary_key, 12_345))
-              .to be_a_failing_result
-              .with_error(expected_error)
-          end
-        end
-
-        describe 'with a String' do
-          it 'should not return a result' do
-            expect(command.send(:validate_primary_key, '12345'))
-              .not_to be_a_result
-          end
-        end
-      end
-    end
-
-    describe '#validate_primary_keys' do
-      let(:primary_keys)     { nil }
-      let(:primary_key_type) { Integer }
-      let(:expected_error) do
-        type     = primary_key_type
-        contract = Stannum::Contracts::ParametersContract.new do
-          keyword :primary_keys,
-            Stannum::Constraints::Types::ArrayType.new(item_type: type)
-        end
-        errors = contract.errors_for(
-          {
-            arguments: [],
-            block:     nil,
-            keywords:  { primary_keys: primary_keys }
-          }
-        )
-
-        Cuprum::Collections::Errors::InvalidParameters.new(
-          command: command,
-          errors:  errors
-        )
-      end
-
-      it 'should define the private method' do
-        expect(command)
-          .to respond_to(:validate_primary_keys, true)
-          .with(1).argument
-      end
-
-      describe 'with nil' do
-        it 'should return a failing result' do
-          expect(command.send(:validate_primary_keys, nil))
-            .to be_a_failing_result
-            .with_error(expected_error)
-        end
-      end
-
-      describe 'with an Object' do
-        it 'should return a failing result' do
-          expect(command.send(:validate_primary_keys, Object.new.freeze))
-            .to be_a_failing_result
-            .with_error(expected_error)
-        end
-      end
-
-      describe 'with a String' do
-        it 'should return a failing result' do
-          expect(command.send(:validate_primary_keys, '12345'))
-            .to be_a_failing_result
-            .with_error(expected_error)
-        end
-      end
-
-      describe 'with an Integer' do
-        it 'should return a failing result' do
-          expect(command.send(:validate_primary_keys, 12_345))
-            .to be_a_failing_result
-            .with_error(expected_error)
-        end
-      end
-
-      describe 'with an empty Array' do
-        it 'should not return a result' do
-          expect(command.send(:validate_primary_keys, []))
-            .not_to be_a_result
-        end
-      end
-
-      describe 'with an Array with nil values' do
-        let(:primary_keys) { Array.new(3, nil) }
-
-        it 'should return a failing result' do
-          expect(command.send(:validate_primary_keys, primary_keys))
-            .to be_a_failing_result
-            .with_error(expected_error)
-        end
-      end
-
-      describe 'with an Array with Object values' do
-        let(:primary_keys) { Array.new(3) { Object.new.freeze } }
-
-        it 'should return a failing result' do
-          expect(command.send(:validate_primary_keys, primary_keys))
-            .to be_a_failing_result
-            .with_error(expected_error)
-        end
-      end
-
-      describe 'with an Array with String values' do
-        let(:primary_keys) { %w[ichi ni san] }
-
-        it 'should return a failing result' do
-          expect(command.send(:validate_primary_keys, primary_keys))
-            .to be_a_failing_result
-            .with_error(expected_error)
-        end
-      end
-
-      describe 'with an Array with Integer values' do
-        it 'should not return a result' do
-          expect(command.send(:validate_primary_keys, [0, 1, 2]))
-            .not_to be_a_result
-        end
-      end
-
-      context 'with a record class with custom primary key' do
-        let(:record_class)     { Tome }
-        let(:primary_key_type) { String }
-
-        describe 'with an Array with String values' do
-          let(:primary_keys) { %w[ichi ni san] }
-
-          it 'should not return a result' do
-            expect(command.send(:validate_primary_keys, primary_keys))
-              .not_to be_a_result
-          end
-        end
-
-        describe 'with an Array with Integer values' do
-          let(:primary_keys) { [0, 1, 2] }
-
-          it 'should return a failing result' do
-            expect(command.send(:validate_primary_keys, primary_keys))
-              .to be_a_failing_result
-              .with_error(expected_error)
-          end
-        end
-      end
-    end
-  end
-end