grape-roar 0.4.0 → 0.4.1

data/gemfiles/with_mongoid.gemfile

@@ -0,0 +1,22 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "mongoid", ">= 5.0.0", require: "mongoid"
+
+group :development do
+  gem "appraisal", "2.2.0"
+end
+
+group :test do
+  gem "rack-test"
+  gem "rspec", "~> 3.1"
+end
+
+group :development, :test do
+  gem "nokogiri", "1.6.3.1"
+  gem "rake", "~> 10.5.0"
+  gem "rubocop", "0.49.1"
+end
+
+gemspec path: "../"

data/grape-roar.gemspec

@@ -1,4 +1,6 @@
 # -*- encoding: utf-8 -*-
+# frozen_string_literal: true
+
 require File.expand_path('../lib/grape/roar/version', __FILE__)
 
 Gem::Specification.new do |gem|
@@ -17,6 +19,7 @@ Gem::Specification.new do |gem|
   gem.version       = Grape::Roar::VERSION
 
   gem.add_dependency 'grape'
+  gem.add_dependency 'multi_json'
   gem.add_dependency 'roar', '~> 1.1.0'
   gem.required_ruby_version = '>= 2.1.0'
 end

data/lib/grape-roar.rb

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

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/decorator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'roar/decorator'
 
 module Grape

data/lib/grape/roar/extensions.rb

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

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/relations/adapters.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'grape/roar/extensions/relations/adapters/base'
+require 'grape/roar/extensions/relations/adapters/active_record'
+require 'grape/roar/extensions/relations/adapters/mongoid'
+
+module Grape
+  module Roar
+    module Extensions
+      module Relations
+        module Adapters
+          def self.for(klass)
+            (constants - [:Base]).inject(nil) do |m, c|
+              obj = const_get(c)
+              obj.valid_for?(klass) ? obj.new(klass) : m
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Grape
+  module Roar
+    module Extensions
+      module Relations
+        module Adapters
+          class ActiveRecord < Base
+            include Validations::ActiveRecord
+
+            valid_for { |klass| klass < ::ActiveRecord::Base }
+
+            def collection_methods
+              @collection_methods ||= %i[has_many has_and_belongs_to_many]
+            end
+
+            def name_for_represented(represented)
+              klass_name = case represented
+                           when ::ActiveRecord::Relation
+                             represented.klass.name
+                           else
+                             represented.class.name
+                           end
+              klass_name.demodulize.pluralize.downcase
+            end
+
+            def single_entity_methods
+              @single_entity_methods ||= %i[has_one belongs_to]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Grape
+  module Roar
+    module Extensions
+      module Relations
+        module Adapters
+          class Base
+            class << self
+              def valid_for?(klass)
+                valid_proc.call(klass)
+              rescue
+                false
+              end
+
+              def valid_for(&block)
+                @valid_proc = block
+              end
+
+              private
+
+              attr_reader :valid_proc
+            end
+
+            def initialize(klass)
+              @klass = klass
+            end
+
+            def collection_methods
+              raise NotImplementedError
+            end
+
+            def name_for_represented(_represented)
+              raise NotImplementedError
+            end
+
+            def single_entity_methods
+              raise NotImplementedError
+            end
+
+            private
+
+            attr_reader :klass
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Grape
+  module Roar
+    module Extensions
+      module Relations
+        module Adapters
+          class Mongoid < Base
+            include Validations::Mongoid
+
+            valid_for { |klass| klass < ::Mongoid::Document }
+
+            def collection_methods
+              @collection_methods ||= %i[
+                embeds_many has_many has_and_belongs_to_many
+              ]
+            end
+
+            def name_for_represented(represented)
+              klass_name = if represented.instance_of?(
+                ::Mongoid::Relations::Targets::Enumerable
+              )
+                             represented.klass.name
+                           else
+                             represented.class.name
+                           end
+              klass_name.demodulize.pluralize.downcase
+            end
+
+            def single_entity_methods
+              @single_entity_methods ||= %i[has_one belongs_to embeds_one]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Grape
+  module Roar
+    module Extensions
+      module Relations
+        module DSLMethods
+          def link_relation(relation, is_collection = false, dsl = self)
+            send(is_collection ? :links : :link, relation) do |opts|
+              data = represented.send(relation)
+
+              mapped = Array.wrap(data).map do |object|
+                href = [dsl.map_base_url.call(opts),
+                        dsl.map_resource_path.call(opts, object, relation)].join('/')
+
+                is_collection ? { href: href } : href
+              end
+
+              is_collection ? mapped : mapped.first
+            end
+          end
+
+          def link_self
+            relational_mapper[:self] = { relation_kind: :self }
+          end
+
+          def map_base_url(&block)
+            @map_base_url ||= if block.nil?
+                                proc do |opts|
+                                  request = Grape::Request.new(opts[:env])
+                                  "#{request.base_url}#{request.script_name}"
+                                end
+                              else
+                                block
+                              end
+          end
+
+          def map_self_url(dsl = self)
+            link :self do |opts|
+              resource_path = dsl.name_for_represented(represented)
+              [dsl.map_base_url.call(opts),
+               "#{resource_path}/#{represented.try(:id)}"].join('/')
+            end
+          end
+
+          def map_resource_path(&block)
+            @map_resource_path ||= if block.nil?
+                                     proc do |_opts, object, relation_name|
+                                       "#{relation_name}/#{object.id}"
+                                     end
+                                   else
+                                     block
+                                   end
+          end
+
+          def name_for_represented(represented)
+            relational_mapper.adapter.name_for_represented(represented)
+          end
+
+          def relation(relation_kind, rname, opts = {})
+            relational_mapper[rname] = opts.merge(relation_kind: relation_kind)
+          end
+
+          def represent(object, _options)
+            object.extend(self) unless is_a?(Class)
+            map_relations(object) unless relations_mapped
+            is_a?(Class) ? super : object
+          end
+
+          private
+
+          attr_reader :relations_mapped
+
+          def map_relations(object)
+            relational_mapper.decorate(object.class)
+            @relations_mapped = true
+          end
+
+          def relational_mapper
+            @relational_mapper ||= Mapper.new(self)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Grape
+  module Roar
+    module Extensions
+      module Relations
+        module Exceptions
+          class InvalidRelationError < StandardError; end
+          class UnsupportedRelationError < StandardError; end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Grape
+  module Roar
+    module Extensions
+      module Relations
+        class Mapper
+          extend Forwardable
+
+          def initialize(entity)
+            @entity = entity
+            @config = {}
+          end
+
+          def adapter
+            @adapter ||= Adapters.for(model_klass)
+          end
+
+          def decorate(klass)
+            @model_klass = klass
+
+            config.each_pair do |relation, opts|
+              representer_for(relation.to_s, opts) unless opts.key(:extend)
+              map_relation(relation, opts)
+            end
+          end
+
+          def_delegators :@config, :[], :[]=
+
+          private
+
+          attr_reader :config, :entity, :model_klass
+
+          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)
+          end
+
+          def map_collection(relation, opts)
+            return entity.link_relation(relation, true) unless opts.fetch(:embedded, false)
+            entity.collection(relation, opts)
+          end
+
+          def map_relation(relation, opts)
+            map = if adapter.collection_methods.include?(opts[:relation_kind])
+                    :map_collection
+                  elsif adapter.single_entity_methods
+                               .include?(opts[:relation_kind]) || opts[:relation_kind] == :self
+                    :map_single_entity
+                  else raise Exceptions::UnsupportedRelationError,
+                             'No such relation supported'
+                  end
+
+            send(map, relation, opts)
+            validate_relation(relation, opts[:relation_kind])
+          end
+
+          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
+
+          def representer_for(relation, opts)
+            base_path = entity.name.deconstantize
+            base_path = base_path.empty? ? Object : base_path.safe_constantize
+            return if base_path.nil?
+
+            to_extend = base_path.constants
+                                 .find(&method(:find_representer).curry[
+                                   base_path, relation
+                                 ])
+
+            opts.merge!(extend: "#{base_path}::#{to_extend}".safe_constantize)
+          end
+
+          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
+      end
+    end
+  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/validations/active_record.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Grape
+  module Roar
+    module Extensions
+      module Relations
+        module Validations
+          module ActiveRecord
+            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
+              )
+            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
+              )
+            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
+              )
+            end
+
+            def has_one_valid?(relation)
+              relation = klass.reflections[relation]
+
+              return true if relation.is_a?(
+                ::ActiveRecord::Reflection::HasOneReflection
+              )
+
+              invalid_relation(
+                ::ActiveRecord::Reflection::HasOneReflection,
+                relation.class
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end