grape-roar 0.4.0 → 0.5.0

data/lib/grape/roar/extensions/relations/validations/active_record.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Grape
+  module Roar
+    module Extensions
+      module Relations
+        module Validations
+          module ActiveRecord
+            include Validations::Misc
+
+            def belongs_to_valid?(relation)
+              _valid_relation? relation, ::ActiveRecord::Reflection::BelongsToReflection
+            end
+
+            def has_many_valid?(relation)
+              _valid_relation? relation, ::ActiveRecord::Reflection::HasManyReflection
+            end
+
+            def has_and_belongs_to_many_valid?(relation)
+              _valid_relation? relation, ::ActiveRecord::Reflection::HasAndBelongsToManyReflection
+            end
+
+            def has_one_valid?(relation)
+              _valid_relation? relation, ::ActiveRecord::Reflection::HasOneReflection
+            end
+
+            private
+
+            def _valid_relation?(relation, relation_klass)
+              relation = klass.reflections[relation]
+              return true if relation.is_a?(relation_klass)
+
+              invalid_relation(relation_klass, relation.class)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/roar/extensions/relations/validations/misc.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Grape
+  module Roar
+    module Extensions
+      module Relations
+        module Validations
+          module Misc
+            def invalid_relation(valid, invalid)
+              raise Exceptions::InvalidRelationError,
+                    "Expected #{valid}, got #{invalid}!"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/roar/extensions/relations/validations/mongoid/6.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Grape
+  module Roar
+    module Extensions
+      module Relations
+        module Validations
+          module Mongoid
+            include Validations::Misc
+
+            def belongs_to_valid?(relation)
+              _valid_relation? relation, ::Mongoid::Relations::Referenced::In
+            end
+
+            def embeds_many_valid?(relation)
+              _valid_relation? relation, ::Mongoid::Relations::Embedded::Many
+            end
+
+            def embeds_one_valid?(relation)
+              _valid_relation? relation, ::Mongoid::Relations::Embedded::One
+            end
+
+            def has_many_valid?(relation)
+              _valid_relation? relation, ::Mongoid::Relations::Referenced::Many
+            end
+
+            def has_and_belongs_to_many_valid?(relation)
+              _valid_relation? relation, ::Mongoid::Relations::Referenced::ManyToMany
+            end
+
+            def has_one_valid?(relation)
+              _valid_relation? relation, ::Mongoid::Relations::Referenced::One
+            end
+
+            private
+
+            def _valid_relation?(relation, relation_klass)
+              relation = klass.reflect_on_association(relation)
+              return true if relation[:relation] == relation_klass
+
+              invalid_relation(relation_klass, relation[:relation])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/roar/extensions/relations/validations/mongoid/7.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Grape
+  module Roar
+    module Extensions
+      module Relations
+        module Validations
+          module Mongoid
+            include Validations::Misc
+
+            def belongs_to_valid?(relation)
+              _valid_relation?(
+                relation,
+                ::Mongoid::Association::Referenced::BelongsTo,
+                ::Mongoid::Association::Referenced::BelongsTo::Proxy
+              )
+            end
+
+            def embeds_many_valid?(relation)
+              _valid_relation?(
+                relation,
+                ::Mongoid::Association::Embedded::EmbedsMany,
+                ::Mongoid::Association::Embedded::EmbedsMany::Proxy
+              )
+            end
+
+            def embeds_one_valid?(relation)
+              _valid_relation?(
+                relation,
+                ::Mongoid::Association::Embedded::EmbedsOne,
+                ::Mongoid::Association::Embedded::EmbedsOne::Proxy
+              )
+            end
+
+            def has_many_valid?(relation)
+              _valid_relation?(
+                relation,
+                ::Mongoid::Association::Referenced::HasMany,
+                ::Mongoid::Association::Referenced::HasMany::Proxy
+              )
+            end
+
+            def has_and_belongs_to_many_valid?(relation)
+              _valid_relation?(
+                relation,
+                ::Mongoid::Association::Referenced::HasAndBelongsToMany,
+                ::Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy
+              )
+            end
+
+            def has_one_valid?(relation)
+              _valid_relation?(
+                relation,
+                ::Mongoid::Association::Referenced::HasOne,
+                ::Mongoid::Association::Referenced::HasOne::Proxy
+              )
+            end
+
+            private
+
+            def _valid_relation?(relation, relation_klass, relation_proxy_klass)
+              relation = klass.reflect_on_association(relation)
+
+              related = relation.is_a?(Hash) ? relation[:relation] : relation.relation
+
+              return true if related == relation_klass || related == relation_proxy_klass
+
+              invalid_relation(relation.class, related)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/roar/extensions/relations/validations/mongoid.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+if defined?(Mongoid)
+  if Gem::Version.new(Mongoid::VERSION) < Gem::Version.new('7')
+    require_relative 'mongoid/6'
+  else
+    require_relative 'mongoid/7'
+  end
+end

data/lib/grape/roar/extensions/relations/validations.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'grape/roar/extensions/relations/validations/misc'
+require 'grape/roar/extensions/relations/validations/active_record'
+require 'grape/roar/extensions/relations/validations/mongoid'

data/lib/grape/roar/extensions/relations.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'grape/roar/extensions/relations/validations'
+require 'grape/roar/extensions/relations/adapters'
+require 'grape/roar/extensions/relations/dsl_methods'
+require 'grape/roar/extensions/relations/exceptions'
+require 'grape/roar/extensions/relations/mapper'
+
+module Grape
+  module Roar
+    module Extensions
+      module Relations
+        class << self
+          def included(other)
+            class << other
+              include Extensions::Relations::DSLMethods
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/roar/extensions.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'grape/roar/extensions/relations'

data/lib/grape/roar/formatter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Formatter
     module Roar

data/lib/grape/roar/representer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Roar
     module Representer
@@ -7,7 +9,10 @@ module Grape
 
       module ClassMethods
         def represent(object, _options = {})
-          object.extend self
+          # See https://github.com/ruby-grape/grape-roar/issues/16
+          raise TypeError if object.singleton_class == object.class
+
+          object.extend(self)
           object
         end
       end

data/lib/grape/roar/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Grape
   module Roar
-    VERSION = '0.4.0'
+    VERSION = '0.5.0'
   end
 end

data/lib/grape/roar.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'grape/roar/version'
 require 'grape/roar/formatter'
 require 'grape/roar/representer'
 require 'grape/roar/decorator'
+require 'grape/roar/extensions'

data/lib/grape-roar.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'roar'
 require 'grape'
 require 'grape/roar'

data/spec/config/mongoid.yml

@@ -0,0 +1,6 @@
+test:
+  clients:
+    default:
+      database: grape_roar_test
+      hosts:
+        - localhost:27017

data/spec/decorator_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 describe Grape::Roar::Decorator do
   subject do

data/spec/extensions/relations/adapters/active_record_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+if defined?(ActiveRecord)
+  describe Grape::Roar::Extensions::Relations::Adapters::ActiveRecord, :activerecord do
+    let(:model) { Class.new(ActiveRecord::Base) }
+
+    subject { described_class.new(model) }
+
+    describe '.valid_for?' do
+      it 'is only valid for ActiveRecord::Base descendants' do
+        expect(described_class.valid_for?(model)).to eql(true)
+        expect(described_class.valid_for?('foo')).to eql(false)
+      end
+    end
+
+    describe '#collection_methods' do
+      it 'returns all collection methods' do
+        expect(subject.collection_methods)
+          .to match_array(%i[has_many has_and_belongs_to_many])
+      end
+    end
+
+    describe '#single_entity_methods' do
+      it 'returns all single entity methods' do
+        expect(subject.single_entity_methods)
+          .to match_array(%i[has_one belongs_to])
+      end
+    end
+  end
+end

data/spec/extensions/relations/adapters/adapters_module_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+describe Grape::Roar::Extensions::Relations::Adapters, :activerecord do
+  describe '.for' do
+    let(:model) { Class.new(ActiveRecord::Base) }
+
+    it 'looks up the correct adapter for a given class' do
+      expect(described_class.for(model))
+        .to be_an_instance_of(described_class::ActiveRecord)
+    end
+  end
+end

data/spec/extensions/relations/adapters/mongoid_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+if defined?(Mongoid)
+  describe Grape::Roar::Extensions::Relations::Adapters::Mongoid, :mongoid do
+    let(:model) { Class.new.tap { |c| c.include(Mongoid::Document) } }
+
+    subject { described_class.new(model) }
+
+    describe '.valid_for?' do
+      it 'is only valid for classes that mixed in Mongoid::Document' do
+        expect(described_class.valid_for?(model)).to eql(true)
+        expect(described_class.valid_for?('foo')).to eql(false)
+      end
+    end
+
+    describe '#collection_methods' do
+      it 'returns all collection methods' do
+        expect(subject.collection_methods)
+          .to match_array(%i[embeds_many has_many has_and_belongs_to_many])
+      end
+    end
+
+    describe '#single_entity_methods' do
+      it 'returns all single entity methods' do
+        expect(subject.single_entity_methods)
+          .to match_array(%i[has_one belongs_to embeds_one])
+      end
+    end
+  end
+end

data/spec/extensions/relations/dsl_methods_spec.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+describe Grape::Roar::Extensions::Relations::DSLMethods do
+  subject do
+    Class.new.tap { |c| c.singleton_class.include(described_class) }
+  end
+
+  describe '#link_relation' do
+    let(:relation) { double }
+    let(:collection) { false }
+
+    before do
+      allow(subject).to receive(:link)
+      allow(subject).to receive(:links)
+    end
+
+    after { subject.link_relation(relation, collection) }
+
+    it 'calls the correct method' do
+      expect(subject).to receive(:link).with(relation)
+    end
+
+    context 'with a collection of objects' do
+      let(:collection) { true }
+
+      it 'uses the links method' do
+        expect(subject).to receive(:links).with(relation)
+      end
+    end
+  end
+
+  describe '#name_for_represented' do
+    let(:represented) { double }
+
+    after { subject.name_for_represented(represented) }
+
+    it 'calls the methods correctly' do
+      expect(subject).to receive_message_chain(
+        :relational_mapper, :adapter, :name_for_represented
+      ).with(represented)
+    end
+  end
+
+  context 'with relational mapper' do
+    let(:relational_mapper) { double }
+
+    before do
+      allow(subject).to receive(:relational_mapper)
+        .and_return(relational_mapper)
+    end
+
+    describe '#relation' do
+      let(:relation_name) { double }
+      let(:relation_kind) { :has_many }
+      let(:opts) { {} }
+
+      after { subject.relation(relation_kind, relation_name, opts) }
+
+      it 'correctly stores the info in mapper' do
+        expect(relational_mapper).to receive(:[]=).with(
+          relation_name, opts.merge(relation_kind: relation_kind)
+        )
+      end
+    end
+
+    describe '#link_self' do
+      after { subject.link_self }
+
+      it 'calls the method correctly' do
+        expect(relational_mapper).to receive(:[]=).with(
+          :self, { relation_kind: :self }
+        )
+      end
+    end
+  end
+
+  describe '#map_base_url' do
+    let(:grape_request) do
+      OpenStruct.new(base_url: 'foo/', script_name: 'v1')
+    end
+
+    let(:opts) { { env: double } }
+
+    before do
+      allow(Grape::Request).to receive(:new).with(opts[:env])
+                                            .and_return(grape_request)
+    end
+
+    it 'provides a default implementation' do
+      expect(subject.map_base_url.call(opts)).to eql('foo/v1')
+    end
+
+    context 'with user provided block' do
+      let(:block) { proc {} }
+
+      it 'returns the user block' do
+        subject.map_base_url(&block)
+        expect(subject.map_base_url).to eql(block)
+      end
+    end
+  end
+
+  describe '#map_self_url' do
+    after { subject.map_self_url }
+
+    it 'calls the correct method' do
+      expect(subject).to receive(:link).with(:self)
+    end
+  end
+
+  describe '#map_resource_path' do
+    let(:object)   { OpenStruct.new(id: 4) }
+    let(:opts)     { double }
+    let(:relation) { 'baz' }
+
+    it 'provides a default implementation' do
+      expect(
+        subject.map_resource_path.call(opts, object, relation)
+      ).to eql('baz/4')
+    end
+
+    context 'with user provided block' do
+      let(:block) { proc {} }
+
+      it 'returns the user block' do
+        subject.map_resource_path(&block)
+        expect(subject.map_resource_path).to eql(block)
+      end
+    end
+  end
+
+  describe '#represent' do
+    let(:object) { double }
+    let(:options) { double }
+
+    let(:relations_mapped) { false }
+
+    before do
+      expect(subject).to receive(:relations_mapped)
+        .and_return(relations_mapped)
+    end
+
+    after { subject.represent(object, options) }
+
+    it 'maps relations and invoke super' do
+      expect(subject).to receive(:map_relations).with(object)
+      expect(subject.superclass).to receive(:represent).with(object, options)
+    end
+
+    context 'with relations mapped' do
+      let(:relations_mapped) { true }
+
+      it 'does not map relations and invoke super' do
+        expect(subject).not_to receive(:map_relations).with(object)
+        expect(subject.superclass).to receive(:represent).with(object, options)
+      end
+    end
+  end
+end

data/spec/extensions/relations/mapper_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+describe Grape::Roar::Extensions::Relations::Mapper do
+  subject { described_class.new(entity) }
+
+  let(:entity) { double }
+  let(:klass)  { double }
+
+  describe '#initialize' do
+    it 'assigns the correct variables' do
+      expect(subject.instance_variable_get(:@entity)).to eql(entity)
+      expect(subject.instance_variable_get(:@config)).to eql({})
+      subject
+    end
+  end
+
+  describe '#adapter' do
+    let(:klass) { class_double('ActiveRecord::Base') }
+
+    before do
+      subject.instance_variable_set(:@model_klass, klass)
+    end
+
+    after { subject.adapter }
+
+    it 'calls the correct method' do
+      expect(Grape::Roar::Extensions::Relations::Adapters)
+        .to receive(:for).with(klass)
+    end
+  end
+
+  describe '#decorate' do
+    let(:adapter) { double }
+    let(:config) do
+      { test_single: {
+          relation_kind: :belongs_to, embedded: true, misc_opt: 'foo'
+        },
+        test_collection: {
+          relation_kind: :has_many, embedded: true, misc_opt: 'baz'
+        } }
+    end
+
+    let(:klass) { double }
+
+    before do
+      allow(subject).to receive(:adapter).and_return(adapter)
+
+      allow(adapter).to receive(:collection_methods).and_return(%i[has_many])
+      allow(adapter).to receive(:single_entity_methods).and_return(%i[belongs_to])
+      allow(entity).to receive(:name).and_return('Foo::Bar')
+
+      subject.instance_variable_set(:@config, config)
+    end
+
+    it 'correctlies decorate the entity' do
+      expect(adapter).to receive(:belongs_to_valid?).with(
+        'test_single'
+      ).and_return(true)
+
+      expect(adapter).to receive(:has_many_valid?).with(
+        'test_collection'
+      ).and_return(true)
+
+      expect(entity).to receive(:collection).with(
+        :test_collection, config[:test_collection]
+      )
+
+      expect(entity).to receive(:property).with(
+        :test_single, config[:test_single]
+      )
+
+      subject.decorate(klass)
+      expect(subject.instance_variable_get(:@model_klass)).to eql(klass)
+    end
+
+    context 'with an invalid relation type' do
+      let(:config) do
+        { test_single: { relation_kind: :has_baz, misc_opt: 'foo' } }
+      end
+
+      it 'raises the correct exception' do
+        expect { subject.decorate(klass) }.to raise_error(
+          Grape::Roar::Extensions::Relations::Exceptions::UnsupportedRelationError
+        )
+      end
+    end
+  end
+end

data/spec/extensions/relations/validations/active_record_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+if defined?(ActiveRecord)
+  describe Grape::Roar::Extensions::Relations::Validations::ActiveRecord, :activerecord do
+    let(:model_klass) { double }
+
+    subject do
+      klass = Class.new do
+        def initialize(klass)
+          @klass = klass
+        end
+
+        attr_reader :klass
+      end
+
+      klass.include(described_class)
+      klass.new(model_klass)
+    end
+
+    before do
+      expect(model_klass).to receive(:reflections).twice
+                                                  .and_return(reflections)
+    end
+
+    %w[
+      belongs_to
+      has_many
+      has_one
+      has_and_belongs_to_many
+    ].each do |relation|
+      describe "##{relation}_valid?" do
+        let(:relation_klass) do
+          "::ActiveRecord::Reflection::#{relation.camelize}" \
+          'Reflection'.constantize.allocate
+        end
+
+        let(:reflections) { { test: relation_klass, fail: Class.new } }
+
+        it 'properly validates the relation' do
+          expect(subject.send("#{relation}_valid?", :test)).to eql(true)
+          expect { subject.send("#{relation}_valid?", :fail) }.to raise_error(
+            Grape::Roar::Extensions::Relations::
+            Exceptions::InvalidRelationError
+          )
+        end
+      end
+    end
+  end
+end