active_model_serializers 0.10.0 → 0.10.6

data/lib/active_model/serializer/singular_reflection.rb

@@ -1,7 +0,0 @@
-module ActiveModel
-  class Serializer
-    # @api private
-    class SingularReflection < Reflection
-    end
-  end
-end

data/lib/active_model/serializer/type.rb

@@ -1,25 +0,0 @@
-module ActiveModel
-  class Serializer
-    module Type
-      extend ActiveSupport::Concern
-
-      included do
-        with_options instance_writer: false, instance_reader: true do |serializer|
-          serializer.class_attribute :_type # @api private
-        end
-
-        extend ActiveSupport::Autoload
-      end
-
-      module ClassMethods
-        # Set the JSON API type of a serializer.
-        # @example
-        #   class AdminAuthorSerializer < ActiveModel::Serializer
-        #     type 'authors'
-        def type(type)
-          self._type = type && type.to_s
-        end
-      end
-    end
-  end
-end

data/lib/active_model_serializers/key_transform.rb

@@ -1,70 +0,0 @@
-require 'active_support/core_ext/hash/keys'
-
-module ActiveModelSerializers
-  module KeyTransform
-    module_function
-
-    # Transforms values to UpperCamelCase or PascalCase.
-    #
-    # @example:
-    #    "some_key" => "SomeKey",
-    # @see {https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb#L66-L76 ActiveSupport::Inflector.camelize}
-    def camel(value)
-      case value
-      when Hash then value.deep_transform_keys! { |key| camel(key) }
-      when Symbol then camel(value.to_s).to_sym
-      when String then value.underscore.camelize
-      else value
-      end
-    end
-
-    # Transforms values to camelCase.
-    #
-    # @example:
-    #    "some_key" => "someKey",
-    # @see {https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb#L66-L76 ActiveSupport::Inflector.camelize}
-    def camel_lower(value)
-      case value
-      when Hash then value.deep_transform_keys! { |key| camel_lower(key) }
-      when Symbol then camel_lower(value.to_s).to_sym
-      when String then value.underscore.camelize(:lower)
-      else value
-      end
-    end
-
-    # Transforms values to dashed-case.
-    # This is the default case for the JsonApi adapter.
-    #
-    # @example:
-    #    "some_key" => "some-key",
-    # @see {https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb#L185-L187 ActiveSupport::Inflector.dasherize}
-    def dash(value)
-      case value
-      when Hash then value.deep_transform_keys! { |key| dash(key) }
-      when Symbol then dash(value.to_s).to_sym
-      when String then value.underscore.dasherize
-      else value
-      end
-    end
-
-    # Transforms values to underscore_case.
-    # This is the default case for deserialization in the JsonApi adapter.
-    #
-    # @example:
-    #    "some-key" => "some_key",
-    # @see {https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb#L89-L98 ActiveSupport::Inflector.underscore}
-    def underscore(value)
-      case value
-      when Hash then value.deep_transform_keys! { |key| underscore(key) }
-      when Symbol then underscore(value.to_s).to_sym
-      when String then value.underscore
-      else value
-      end
-    end
-
-    # Returns the value unaltered
-    def unaltered(value)
-      value
-    end
-  end
-end

data/test/active_model_serializers/key_transform_test.rb

@@ -1,263 +0,0 @@
-require 'test_helper'
-
-class ActiveModelSerializers::KeyTransformTest < ActiveSupport::TestCase
-  def test_camel
-    obj = Object.new
-    scenarios = [
-      {
-        value: { :"some-key" => 'value' },
-        expected: { :SomeKey => 'value' }
-      },
-      {
-        value: { :someKey => 'value' },
-        expected: { :SomeKey => 'value' }
-      },
-      {
-        value: { :some_key => 'value' },
-        expected: { :SomeKey => 'value' }
-      },
-      {
-        value: { 'some-key' => 'value' },
-        expected: { 'SomeKey' => 'value' }
-      },
-      {
-        value: { 'someKey' => 'value' },
-        expected: { 'SomeKey' => 'value' }
-      },
-      {
-        value: { 'some_key' => 'value' },
-        expected: { 'SomeKey' => 'value' }
-      },
-      {
-        value: :"some-value",
-        expected: :SomeValue
-      },
-      {
-        value: :some_value,
-        expected: :SomeValue
-      },
-      {
-        value: :someValue,
-        expected: :SomeValue
-      },
-      {
-        value: 'some-value',
-        expected: 'SomeValue'
-      },
-      {
-        value: 'someValue',
-        expected: 'SomeValue'
-      },
-      {
-        value: 'some_value',
-        expected: 'SomeValue'
-      },
-      {
-        value: obj,
-        expected: obj
-      },
-      {
-        value: nil,
-        expected: nil
-      }
-    ]
-    scenarios.each do |s|
-      result = ActiveModelSerializers::KeyTransform.camel(s[:value])
-      assert_equal s[:expected], result
-    end
-  end
-
-  def test_camel_lower
-    obj = Object.new
-    scenarios = [
-      {
-        value: { :"some-key" => 'value' },
-        expected: { :someKey => 'value' }
-      },
-      {
-        value: { :SomeKey => 'value' },
-        expected: { :someKey => 'value' }
-      },
-      {
-        value: { :some_key => 'value' },
-        expected: { :someKey => 'value' }
-      },
-      {
-        value: { 'some-key' => 'value' },
-        expected: { 'someKey' => 'value' }
-      },
-      {
-        value: { 'SomeKey' => 'value' },
-        expected: { 'someKey' => 'value' }
-      },
-      {
-        value: { 'some_key' => 'value' },
-        expected: { 'someKey' => 'value' }
-      },
-      {
-        value: :"some-value",
-        expected: :someValue
-      },
-      {
-        value: :SomeValue,
-        expected: :someValue
-      },
-      {
-        value: :some_value,
-        expected: :someValue
-      },
-      {
-        value: 'some-value',
-        expected: 'someValue'
-      },
-      {
-        value: 'SomeValue',
-        expected: 'someValue'
-      },
-      {
-        value: 'some_value',
-        expected: 'someValue'
-      },
-      {
-        value: obj,
-        expected: obj
-      },
-      {
-        value: nil,
-        expected: nil
-      }
-    ]
-    scenarios.each do |s|
-      result = ActiveModelSerializers::KeyTransform.camel_lower(s[:value])
-      assert_equal s[:expected], result
-    end
-  end
-
-  def test_dash
-    obj = Object.new
-    scenarios = [
-      {
-        value: { :some_key => 'value' },
-        expected: { :"some-key" => 'value' }
-      },
-      {
-        value: { 'some_key' => 'value' },
-        expected: { 'some-key' => 'value' }
-      },
-      {
-        value: { :SomeKey => 'value' },
-        expected: { :"some-key" => 'value' }
-      },
-      {
-        value: { 'SomeKey' => 'value' },
-        expected: { 'some-key' => 'value' }
-      },
-      {
-        value: { :someKey => 'value' },
-        expected: { :"some-key" => 'value' }
-      },
-      {
-        value: { 'someKey' => 'value' },
-        expected: { 'some-key' => 'value' }
-      },
-      {
-        value: :some_value,
-        expected: :"some-value"
-      },
-      {
-        value: :SomeValue,
-        expected: :"some-value"
-      },
-      {
-        value: 'SomeValue',
-        expected: 'some-value'
-      },
-      {
-        value: :someValue,
-        expected: :"some-value"
-      },
-      {
-        value: 'someValue',
-        expected: 'some-value'
-      },
-      {
-        value: obj,
-        expected: obj
-      },
-      {
-        value: nil,
-        expected: nil
-      }
-    ]
-    scenarios.each do |s|
-      result = ActiveModelSerializers::KeyTransform.dash(s[:value])
-      assert_equal s[:expected], result
-    end
-  end
-
-  def test_underscore
-    obj = Object.new
-    scenarios = [
-      {
-        value: { :"some-key" => 'value' },
-        expected: { :some_key => 'value' }
-      },
-      {
-        value: { 'some-key' => 'value' },
-        expected: { 'some_key' => 'value' }
-      },
-      {
-        value: { :SomeKey => 'value' },
-        expected: { :some_key => 'value' }
-      },
-      {
-        value: { 'SomeKey' => 'value' },
-        expected: { 'some_key' => 'value' }
-      },
-      {
-        value: { :someKey => 'value' },
-        expected: { :some_key => 'value' }
-      },
-      {
-        value: { 'someKey' => 'value' },
-        expected: { 'some_key' => 'value' }
-      },
-      {
-        value: :"some-value",
-        expected: :some_value
-      },
-      {
-        value: :SomeValue,
-        expected: :some_value
-      },
-      {
-        value: :someValue,
-        expected: :some_value
-      },
-      {
-        value: 'some-value',
-        expected: 'some_value'
-      },
-      {
-        value: 'SomeValue',
-        expected: 'some_value'
-      },
-      {
-        value: 'someValue',
-        expected: 'some_value'
-      },
-      {
-        value: obj,
-        expected: obj
-      },
-      {
-        value: nil,
-        expected: nil
-      }
-    ]
-    scenarios.each do |s|
-      result = ActiveModelSerializers::KeyTransform.underscore(s[:value])
-      assert_equal s[:expected], result
-    end
-  end
-end

data/test/adapter/json_api/relationships_test.rb

@@ -1,199 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    module Adapter
-      class JsonApi
-        class RelationshipTest < ActiveSupport::TestCase
-          RelationshipAuthor = Class.new(::Model)
-          class RelationshipAuthorSerializer < ActiveModel::Serializer
-            has_one :bio do
-              link :self, '//example.com/link_author/relationships/bio'
-            end
-
-            has_one :profile do
-              link :related do
-                "//example.com/profiles/#{object.profile.id}"
-              end
-            end
-
-            has_many :locations do
-              link :related do
-                ids = object.locations.map(&:id).join(',')
-                href "//example.com/locations/#{ids}"
-              end
-            end
-
-            has_many :posts do
-              link :related do
-                ids = object.posts.map(&:id).join(',')
-                href "//example.com/posts/#{ids}"
-                meta ids: ids
-              end
-            end
-
-            has_many :comments do
-              link :self do
-                meta ids: [1]
-              end
-            end
-
-            has_many :roles do |serializer|
-              meta count: object.posts.count
-              serializer.cached_roles
-            end
-
-            has_one :blog do
-              link :self, '//example.com/link_author/relationships/blog'
-              include_data false
-            end
-
-            belongs_to :reviewer do
-              meta name: 'Dan Brown'
-              include_data true
-            end
-
-            has_many :likes do
-              link :related do
-                ids = object.likes.map(&:id).join(',')
-                href "//example.com/likes/#{ids}"
-                meta ids: ids
-              end
-              meta liked: object.likes.any?
-            end
-
-            def cached_roles
-              [
-                Role.new(id: 'from-serializer-method')
-              ]
-            end
-          end
-
-          def setup
-            @post = Post.new(id: 1337, comments: [], author: nil)
-            @blog = Blog.new(id: 1337, name: 'extra')
-            @bio = Bio.new(id: 1337)
-            @like = Like.new(id: 1337)
-            @role = Role.new(id: 'from-record')
-            @profile = Profile.new(id: 1337)
-            @location = Location.new(id: 1337)
-            @reviewer = Author.new(id: 1337)
-            @comment = Comment.new(id: 1337)
-            @author = RelationshipAuthor.new(
-              id: 1337,
-              posts: [@post],
-              blog: @blog,
-              reviewer: @reviewer,
-              bio: @bio,
-              likes: [@like],
-              roles: [@role],
-              locations: [@location],
-              profile: @profile,
-              comments: [@comment]
-            )
-          end
-
-          def test_relationship_simple_link
-            expected = {
-              data: {
-                id: '1337',
-                type: 'bios'
-              },
-              links: {
-                self: '//example.com/link_author/relationships/bio'
-              }
-            }
-            assert_relationship(:bio, expected)
-          end
-
-          def test_relationship_block_link
-            expected = {
-              data: { id: '1337', type: 'profiles' },
-              links: { related: '//example.com/profiles/1337' }
-            }
-            assert_relationship(:profile, expected)
-          end
-
-          def test_relationship_block_link_href
-            expected = {
-              data: [{ id: '1337', type: 'locations' }],
-              links: {
-                related: { href: '//example.com/locations/1337' }
-              }
-            }
-            assert_relationship(:locations, expected)
-          end
-
-          def test_relationship_block_link_href_and_meta
-            expected = {
-              data: [{ id: '1337', type: 'posts' }],
-              links: {
-                related: {
-                  href: '//example.com/posts/1337',
-                  meta: { ids: '1337' }
-                }
-              }
-            }
-            assert_relationship(:posts, expected)
-          end
-
-          def test_relationship_block_link_meta
-            expected = {
-              data: [{ id: '1337', type: 'comments' }],
-              links: {
-                self: {
-                  meta: { ids: [1] }
-                }
-              }
-            }
-            assert_relationship(:comments, expected)
-          end
-
-          def test_relationship_meta
-            expected = {
-              data: [{ id: 'from-serializer-method', type: 'roles' }],
-              meta: { count: 1 }
-            }
-            assert_relationship(:roles, expected)
-          end
-
-          def test_relationship_not_including_data
-            expected = {
-              links: { self: '//example.com/link_author/relationships/blog' }
-            }
-            assert_relationship(:blog, expected)
-          end
-
-          def test_relationship_including_data_explicit
-            expected = {
-              data: { id: '1337', type: 'authors' },
-              meta: { name: 'Dan Brown' }
-            }
-            assert_relationship(:reviewer, expected)
-          end
-
-          def test_relationship_with_everything
-            expected = {
-              data: [{ id: '1337', type: 'likes' }],
-              links: {
-                related: {
-                  href: '//example.com/likes/1337',
-                  meta: { ids: '1337' }
-                }
-              },
-              meta: { liked: true }
-            }
-            assert_relationship(:likes, expected)
-          end
-
-          private
-
-          def assert_relationship(relationship_name, expected)
-            hash = serializable(@author, adapter: :json_api).serializable_hash
-            assert_equal(expected, hash[:data][:relationships][relationship_name])
-          end
-        end
-      end
-    end
-  end
-end

data/test/include_tree/from_include_args_test.rb

@@ -1,26 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    class IncludeTree
-      class FromStringTest < ActiveSupport::TestCase
-        def test_simple_array
-          input = [:comments, :author]
-          actual = ActiveModel::Serializer::IncludeTree.from_include_args(input)
-          assert(actual.key?(:author))
-          assert(actual.key?(:comments))
-        end
-
-        def test_nested_array
-          input = [:comments, posts: [:author, comments: [:author]]]
-          actual = ActiveModel::Serializer::IncludeTree.from_include_args(input)
-          assert(actual.key?(:posts))
-          assert(actual[:posts].key?(:author))
-          assert(actual[:posts].key?(:comments))
-          assert(actual[:posts][:comments].key?(:author))
-          assert(actual.key?(:comments))
-        end
-      end
-    end
-  end
-end

data/test/include_tree/from_string_test.rb

@@ -1,94 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    class IncludeTree
-      class FromStringTest < ActiveSupport::TestCase
-        def test_single_string
-          input = 'author'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:author))
-        end
-
-        def test_multiple_strings
-          input = 'author,comments'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:author))
-          assert(actual.key?(:comments))
-        end
-
-        def test_multiple_strings_with_space
-          input = 'author, comments'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:author))
-          assert(actual.key?(:comments))
-        end
-
-        def test_nested_string
-          input = 'posts.author'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:posts))
-          assert(actual[:posts].key?(:author))
-        end
-
-        def test_multiple_nested_string
-          input = 'posts.author,posts.comments.author,comments'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:posts))
-          assert(actual[:posts].key?(:author))
-          assert(actual[:posts].key?(:comments))
-          assert(actual[:posts][:comments].key?(:author))
-          assert(actual.key?(:comments))
-        end
-
-        def test_toplevel_star_string
-          input = '*'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:comments))
-        end
-
-        def test_nested_star_string
-          input = 'posts.*'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:posts))
-          assert(actual[:posts].key?(:comments))
-        end
-
-        def test_nested_star_middle_string
-          input = 'posts.*.author'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:posts))
-          assert(actual[:posts].key?(:comments))
-          assert(actual[:posts][:comments].key?(:author))
-          refute(actual[:posts][:comments].key?(:unspecified))
-        end
-
-        def test_nested_star_lower_precedence_string
-          input = 'posts.comments.author,posts.*'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:posts))
-          assert(actual[:posts].key?(:comments))
-          assert(actual[:posts][:comments].key?(:author))
-        end
-
-        def test_toplevel_double_star_string
-          input = '**'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:posts))
-          assert(actual[:posts].key?(:comments))
-          assert(actual[:posts][:comments].key?(:posts))
-        end
-
-        def test_nested_double_star_string
-          input = 'comments, posts.**'
-          actual = ActiveModel::Serializer::IncludeTree.from_string(input)
-          assert(actual.key?(:comments))
-          refute(actual[:comments].key?(:author))
-          assert(actual.key?(:posts))
-          assert(actual[:posts].key?(:comments))
-          assert(actual[:posts][:comments].key?(:posts))
-        end
-      end
-    end
-  end
-end