grape-roar 0.4.1 → 0.5.0

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

@@ -34,6 +34,7 @@ module Grape
           def find_representer(base, target_name, const)
             const = base.const_get(const)
             return false if const.nil? || !const.is_a?(Module)
+
             (const < ::Roar::JSON::HAL) && const.name
                                                 .downcase
                                                 .include?(target_name.singularize)
@@ -41,6 +42,7 @@ module Grape
 
           def map_collection(relation, opts)
             return entity.link_relation(relation, true) unless opts.fetch(:embedded, false)
+
             entity.collection(relation, opts)
           end
 
@@ -50,8 +52,9 @@ module Grape
                   elsif adapter.single_entity_methods
                                .include?(opts[:relation_kind]) || opts[:relation_kind] == :self
                     :map_single_entity
-                  else raise Exceptions::UnsupportedRelationError,
-                             'No such relation supported'
+                  else
+                    raise Exceptions::UnsupportedRelationError,
+                          'No such relation supported'
                   end
 
             send(map, relation, opts)
@@ -61,6 +64,7 @@ module Grape
           def map_single_entity(relation, opts)
             return entity.map_self_url if opts[:relation_kind] == :self
             return entity.link_relation(relation) unless opts.fetch(:embedded, false)
+
             entity.property(relation, opts)
           end
 
@@ -80,6 +84,7 @@ module Grape
           def validate_relation(relation, kind)
             validator_method = "#{kind}_valid?"
             return true unless adapter.respond_to?(validator_method)
+
             adapter.send(validator_method, relation.to_s)
           end
         end

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

@@ -9,55 +9,28 @@ module Grape
             include Validations::Misc
 
             def belongs_to_valid?(relation)
-              relation = klass.reflections[relation]
-
-              return true if relation.is_a?(
-                ::ActiveRecord::Reflection::BelongsToReflection
-              )
-
-              invalid_relation(
-                ::ActiveRecord::Reflection::BelongsToReflection,
-                relation.class
-              )
+              _valid_relation? relation, ::ActiveRecord::Reflection::BelongsToReflection
             end
 
             def has_many_valid?(relation)
-              relation = klass.reflections[relation]
-
-              return true if relation.is_a?(
-                ::ActiveRecord::Reflection::HasManyReflection
-              )
-
-              invalid_relation(
-                ::ActiveRecord::Reflection::HasManyReflection,
-                relation.class
-              )
+              _valid_relation? relation, ::ActiveRecord::Reflection::HasManyReflection
             end
 
             def has_and_belongs_to_many_valid?(relation)
-              relation = klass.reflections[relation]
-
-              return true if relation.is_a?(
-                ::ActiveRecord::Reflection::HasAndBelongsToManyReflection
-              )
-
-              invalid_relation(
-                ::ActiveRecord::Reflection::HasAndBelongsToManyReflection,
-                relation.class
-              )
+              _valid_relation? relation, ::ActiveRecord::Reflection::HasAndBelongsToManyReflection
             end
 
             def has_one_valid?(relation)
-              relation = klass.reflections[relation]
+              _valid_relation? relation, ::ActiveRecord::Reflection::HasOneReflection
+            end
+
+            private
 
-              return true if relation.is_a?(
-                ::ActiveRecord::Reflection::HasOneReflection
-              )
+            def _valid_relation?(relation, relation_klass)
+              relation = klass.reflections[relation]
+              return true if relation.is_a?(relation_klass)
 
-              invalid_relation(
-                ::ActiveRecord::Reflection::HasOneReflection,
-                relation.class
-              )
+              invalid_relation(relation_klass, relation.class)
             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

@@ -1,88 +1,9 @@
 # frozen_string_literal: true
 
-module Grape
-  module Roar
-    module Extensions
-      module Relations
-        module Validations
-          module Mongoid
-            include Validations::Misc
-
-            def belongs_to_valid?(relation)
-              relation = klass.reflect_on_association(relation)
-
-              return true if relation[:relation] ==
-                             ::Mongoid::Relations::Referenced::In
-
-              invalid_relation(
-                ::Mongoid::Relations::Referenced::In, relation[:relation]
-              )
-            end
-
-            def embeds_many_valid?(relation)
-              relation = klass.reflect_on_association(relation)
-
-              return true if relation[:relation] ==
-                             ::Mongoid::Relations::Embedded::Many
-
-              invalid_relation(
-                ::Mongoid::Relations::Embedded::Many, relation[:relation]
-              )
-            end
-
-            def embeds_one_valid?(relation)
-              relation = klass.reflect_on_association(relation)
-
-              return true if relation[:relation] ==
-                             ::Mongoid::Relations::Embedded::One
-
-              invalid_relation(
-                ::Mongoid::Relations::Embedded::One, relation[:relation]
-              )
-            end
-
-            # rubocop:disable Style/PredicateName
-            def has_many_valid?(relation)
-              relation = klass.reflect_on_association(relation)
-
-              return true if relation[:relation] ==
-                             ::Mongoid::Relations::Referenced::Many
-
-              invalid_relation(
-                ::Mongoid::Relations::Referenced::Many, relation[:relation]
-              )
-            end
-            # rubocop:enable Style/PredicateName
-
-            # rubocop:disable Style/PredicateName
-            def has_and_belongs_to_many_valid?(relation)
-              relation = klass.reflect_on_association(relation)
-
-              return true if relation[:relation] ==
-                             ::Mongoid::Relations::Referenced::ManyToMany
-
-              invalid_relation(
-                ::Mongoid::Relations::Referenced::ManyToMany,
-                relation[:relation]
-              )
-            end
-            # rubocop:enable Style/PredicateName
-
-            # rubocop:disable Style/PredicateName
-            def has_one_valid?(relation)
-              relation = klass.reflect_on_association(relation)
-
-              return true if relation[:relation] ==
-                             ::Mongoid::Relations::Referenced::One
-
-              invalid_relation(
-                ::Mongoid::Relations::Referenced::One, relation[:relation]
-              )
-            end
-            # rubocop:enable Style/PredicateName
-          end
-        end
-      end
-    end
+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/representer.rb

@@ -9,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

@@ -2,6 +2,6 @@
 
 module Grape
   module Roar
-    VERSION = '0.4.1'
+    VERSION = '0.5.0'
   end
 end

data/spec/decorator_spec.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-
-
 describe Grape::Roar::Decorator do
   subject do
     Class.new(Grape::API)

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

@@ -1,26 +1,30 @@
 # frozen_string_literal: true
-describe Grape::Roar::Extensions::Relations::Adapters::ActiveRecord, active_record: true do
-  let(:model) { Class.new(ActiveRecord::Base) }
-  subject { described_class.new(model) }
 
-  context '.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)
+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
-  end
 
-  context '#collection_methods' do
-    it 'should return all collection methods' do
-      expect(subject.collection_methods)
-        .to match_array(%i[has_many has_and_belongs_to_many])
+    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
-  end
 
-  context '#single_entity_methods' do
-    it 'should return all single entity methods' do
-      expect(subject.single_entity_methods)
-        .to match_array(%i[has_one belongs_to])
+    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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
-describe Grape::Roar::Extensions::Relations::Adapters, active_record: true do
-  context '.for' do
+
+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

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

@@ -1,26 +1,30 @@
 # frozen_string_literal: true
-describe Grape::Roar::Extensions::Relations::Adapters::Mongoid, mongoid: true do
-  let(:model) { Class.new.tap { |c| c.include(::Mongoid::Document) } }
-  subject { described_class.new(model) }
 
-  context '.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)
+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
-  end
 
-  context '#collection_methods' do
-    it 'should return all collection methods' do
-      expect(subject.collection_methods)
-        .to match_array(%i[embeds_many has_many has_and_belongs_to_many])
+    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
-  end
 
-  context '#single_entity_methods' do
-    it 'should return all single entity methods' do
-      expect(subject.single_entity_methods)
-        .to match_array(%i[has_one belongs_to embeds_one])
+    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

@@ -5,7 +5,7 @@ describe Grape::Roar::Extensions::Relations::DSLMethods do
     Class.new.tap { |c| c.singleton_class.include(described_class) }
   end
 
-  context '#link_relation' do
+  describe '#link_relation' do
     let(:relation) { double }
     let(:collection) { false }
 
@@ -29,7 +29,7 @@ describe Grape::Roar::Extensions::Relations::DSLMethods do
     end
   end
 
-  context '#name_for_represented' do
+  describe '#name_for_represented' do
     let(:represented) { double }
 
     after { subject.name_for_represented(represented) }
@@ -49,7 +49,7 @@ describe Grape::Roar::Extensions::Relations::DSLMethods do
         .and_return(relational_mapper)
     end
 
-    context '#relation' do
+    describe '#relation' do
       let(:relation_name) { double }
       let(:relation_kind) { :has_many }
       let(:opts) { {} }
@@ -63,18 +63,18 @@ describe Grape::Roar::Extensions::Relations::DSLMethods do
       end
     end
 
-    context '#link_self' do
+    describe '#link_self' do
       after { subject.link_self }
 
       it 'calls the method correctly' do
         expect(relational_mapper).to receive(:[]=).with(
-          :self, relation_kind: :self
+          :self, { relation_kind: :self }
         )
       end
     end
   end
 
-  context '#map_base_url' do
+  describe '#map_base_url' do
     let(:grape_request) do
       OpenStruct.new(base_url: 'foo/', script_name: 'v1')
     end
@@ -93,14 +93,14 @@ describe Grape::Roar::Extensions::Relations::DSLMethods do
     context 'with user provided block' do
       let(:block) { proc {} }
 
-      it 'should return the user block' do
+      it 'returns the user block' do
         subject.map_base_url(&block)
         expect(subject.map_base_url).to eql(block)
       end
     end
   end
 
-  context '#map_self_url' do
+  describe '#map_self_url' do
     after { subject.map_self_url }
 
     it 'calls the correct method' do
@@ -108,7 +108,7 @@ describe Grape::Roar::Extensions::Relations::DSLMethods do
     end
   end
 
-  context '#map_resource_path' do
+  describe '#map_resource_path' do
     let(:object)   { OpenStruct.new(id: 4) }
     let(:opts)     { double }
     let(:relation) { 'baz' }
@@ -122,14 +122,14 @@ describe Grape::Roar::Extensions::Relations::DSLMethods do
     context 'with user provided block' do
       let(:block) { proc {} }
 
-      it 'should return the user block' do
+      it 'returns the user block' do
         subject.map_resource_path(&block)
         expect(subject.map_resource_path).to eql(block)
       end
     end
   end
 
-  context '#represent' do
+  describe '#represent' do
     let(:object) { double }
     let(:options) { double }
 
@@ -142,7 +142,7 @@ describe Grape::Roar::Extensions::Relations::DSLMethods do
 
     after { subject.represent(object, options) }
 
-    it 'should map relations and invoke super' do
+    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
@@ -150,8 +150,8 @@ describe Grape::Roar::Extensions::Relations::DSLMethods do
     context 'with relations mapped' do
       let(:relations_mapped) { true }
 
-      it 'should not map relations and invoke super' do
-        expect(subject).to_not receive(:map_relations).with(object)
+      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

data/spec/extensions/relations/mapper_spec.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 describe Grape::Roar::Extensions::Relations::Mapper do
+  subject { described_class.new(entity) }
+
   let(:entity) { double }
   let(:klass)  { double }
 
-  subject { described_class.new(entity) }
-
-  context '#initialize' do
+  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({})
@@ -14,7 +14,7 @@ describe Grape::Roar::Extensions::Relations::Mapper do
     end
   end
 
-  context '#adapter' do
+  describe '#adapter' do
     let(:klass) { class_double('ActiveRecord::Base') }
 
     before do
@@ -23,18 +23,18 @@ describe Grape::Roar::Extensions::Relations::Mapper do
 
     after { subject.adapter }
 
-    it 'should call the correct method' do
+    it 'calls the correct method' do
       expect(Grape::Roar::Extensions::Relations::Adapters)
         .to receive(:for).with(klass)
     end
   end
 
-  context '#decorate' do
+  describe '#decorate' do
     let(:adapter) { double }
     let(:config) do
       { test_single: {
-        relation_kind: :belongs_to, embedded: true, misc_opt: 'foo'
-      },
+          relation_kind: :belongs_to, embedded: true, misc_opt: 'foo'
+        },
         test_collection: {
           relation_kind: :has_many, embedded: true, misc_opt: 'baz'
         } }
@@ -52,7 +52,7 @@ describe Grape::Roar::Extensions::Relations::Mapper do
       subject.instance_variable_set(:@config, config)
     end
 
-    it 'should correctly decorate the entity' do
+    it 'correctlies decorate the entity' do
       expect(adapter).to receive(:belongs_to_valid?).with(
         'test_single'
       ).and_return(true)
@@ -78,7 +78,7 @@ describe Grape::Roar::Extensions::Relations::Mapper do
         { test_single: { relation_kind: :has_baz, misc_opt: 'foo' } }
       end
 
-      it 'will raise the correct exception' do
+      it 'raises the correct exception' do
         expect { subject.decorate(klass) }.to raise_error(
           Grape::Roar::Extensions::Relations::Exceptions::UnsupportedRelationError
         )