cuprum-rails 0.1.0 → 0.2.0

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

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-require 'cuprum/rails/rspec'
-
-module Cuprum::Rails::RSpec
-  # Contract asserting that a Routes object defines the given route.
-  DEFINE_ROUTE_CONTRACT = lambda \
-  do |action_name:, path:, member_action: false, wildcards: {}|
-    describe "##{action_name}_path" do
-      let(:method_name) { "#{action_name}_path" }
-      let(:expected) do
-        next path unless member_action
-
-        primary_key_name  = entity.class.primary_key
-        primary_key_value = entity[primary_key_name]
-
-        path.sub(':id', primary_key_value.to_s)
-      end
-
-      define_method(:route_helper) do
-        scoped = wildcards.empty? ? routes : routes.with_wildcards(wildcards)
-
-        if member_action
-          scoped.send(method_name, entity)
-        else
-          scoped.send(method_name)
-        end
-      end
-
-      it 'should define the helper method' do
-        if member_action
-          expect(routes).to respond_to(method_name).with(1).argument
-        else
-          expect(routes).to respond_to(method_name).with(0).arguments
-        end
-      end
-
-      it 'should return the route path' do
-        expect(route_helper).to be == expected
-      end
-
-      if member_action
-        describe 'when the entity is nil' do
-          let(:entity)        { nil }
-          let(:error_message) { 'missing wildcard :id' }
-
-          it 'should raise an exception' do
-            expect { route_helper }
-              .to raise_error(
-                described_class::MissingWildcardError,
-                error_message
-              )
-          end
-        end
-      end
-
-      wildcards.each do |key, _|
-        wildcard = key.to_s.end_with?('_id') ? key.intern : :"#{key}_id"
-
-        describe "when the #{wildcard.inspect} wildcard is undefined" do
-          let(:error_message) { "missing wildcard #{wildcard.inspect}" }
-
-          define_method(:route_helper) do
-            scoped = routes.with_wildcards(wildcards.except(key))
-
-            if member_action
-              scoped.send(method_name, entity)
-            else
-              scoped.send(method_name)
-            end
-          end
-
-          it 'should raise an exception' do
-            expect { route_helper }
-              .to raise_error(
-                described_class::MissingWildcardError,
-                error_message
-              )
-          end
-        end
-      end
-    end
-  end
-end

data/lib/cuprum/rails/serializers/json/serializer.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require 'cuprum/rails/serializers/json'
-
-module Cuprum::Rails::Serializers::Json
-  # Converts objects or data structures to JSON based on configured serializers.
-  class Serializer
-    # Error class used when a serializer calls itself.
-    class RecursiveSerializerError < StandardError; end
-
-    # Error class used when there is no matching serializer for the object.
-    class UndefinedSerializerError < StandardError; end
-
-    # @return [Cuprum::Rails::Serializers::Json::Serializer] a cached instance
-    #   of the serializer.
-    def self.instance
-      @instance ||= new
-    end
-
-    # Converts the object to JSON using the given serializers.
-    #
-    # First, #call finds the best serializer from the :serializers Hash. This is
-    # done by walking up the object class's ancestors to find the closest
-    # ancestor which is a key in the :serializers Hash. The corresponding value
-    # is then called with the object.
-    #
-    # @param object [Object] The object to convert to JSON.
-    # @param serializers [Hash<Class, #call>] The serializers for different
-    #   object types.
-    #
-    # @return [Object] a JSON-compatible representation of the object.
-    #
-    # @raise RecursiveSerializerError if the serializer would create an infinite
-    #   loop, e.g. by calling itself.
-    # @raise UndefinedSerializerError if there is no matching serializer for
-    #   the object.
-    def call(object, serializers:)
-      serializer = handle_recursion!(object) do
-        serializer_for(object: object, serializers: serializers)
-      end
-
-      serializer.call(object, serializers: serializers)
-    end
-
-    private
-
-    def handle_recursion!(object)
-      serializer = yield
-
-      return serializer unless instance_of?(serializer.class)
-
-      raise RecursiveSerializerError,
-        "invalid serializer for #{object.class.name} - recursive calls to" \
-        " #{self.class.name}#call"
-    end
-
-    def serializer_for(object:, serializers:)
-      object.class.ancestors.each do |ancestor|
-        return serializers[ancestor] if serializers.key?(ancestor)
-      end
-
-      raise UndefinedSerializerError,
-        "no serializer defined for #{object.class.name}"
-    end
-  end
-end