active_model_serializers 0.10.0 → 0.10.1

data/lib/active_model/serializer/include_tree.rb

@@ -1,111 +0,0 @@
-module ActiveModel
-  class Serializer
-    # TODO: description of this class, and overview of how it's used
-    class IncludeTree
-      module Parsing
-        module_function
-
-        # Translates a comma separated list of dot separated paths (JSON API format) into a Hash.
-        #
-        # @example
-        #   `'posts.author, posts.comments.upvotes, posts.comments.author'`
-        #
-        #   would become
-        #
-        #   `{ posts: { author: {}, comments: { author: {}, upvotes: {} } } }`.
-        #
-        # @param [String] included
-        # @return [Hash] a Hash representing the same tree structure
-        def include_string_to_hash(included)
-          # TODO: Needs comment walking through the process of what all this is doing.
-          included.delete(' ').split(',').reduce({}) do |hash, path|
-            include_tree = path.split('.').reverse_each.reduce({}) { |a, e| { e.to_sym => a } }
-            hash.deep_merge!(include_tree)
-          end
-        end
-
-        # Translates the arguments passed to the include option into a Hash. The format can be either
-        # a String (see #include_string_to_hash), an Array of Symbols and Hashes, or a mix of both.
-        #
-        # @example
-        #  `posts: [:author, comments: [:author, :upvotes]]`
-        #
-        #  would become
-        #
-        #   `{ posts: { author: {}, comments: { author: {}, upvotes: {} } } }`.
-        #
-        # @example
-        #  `[:author, :comments => [:author]]`
-        #
-        #   would become
-        #
-        #   `{:author => {}, :comments => { author: {} } }`
-        #
-        # @param [Symbol, Hash, Array, String] included
-        # @return [Hash] a Hash representing the same tree structure
-        def include_args_to_hash(included)
-          case included
-          when Symbol
-            { included => {} }
-          when Hash
-            included.each_with_object({}) do |(key, value), hash|
-              hash[key] = include_args_to_hash(value)
-            end
-          when Array
-            included.reduce({}) { |a, e| a.deep_merge!(include_args_to_hash(e)) }
-          when String
-            include_string_to_hash(included)
-          else
-            {}
-          end
-        end
-      end
-
-      # Builds an IncludeTree from a comma separated list of dot separated paths (JSON API format).
-      # @example `'posts.author, posts.comments.upvotes, posts.comments.author'`
-      #
-      # @param [String] included
-      # @return [IncludeTree]
-      #
-      def self.from_string(included)
-        new(Parsing.include_string_to_hash(included))
-      end
-
-      # Translates the arguments passed to the include option into an IncludeTree.
-      # The format can be either a String (see #from_string), an Array of Symbols and Hashes, or a mix of both.
-      # @example `posts: [:author, comments: [:author, :upvotes]]`
-      #
-      # @param [Symbol, Hash, Array, String] included
-      # @return [IncludeTree]
-      #
-      def self.from_include_args(included)
-        return included if included.is_a?(IncludeTree)
-
-        new(Parsing.include_args_to_hash(included))
-      end
-
-      # @param [Hash] hash
-      def initialize(hash = {})
-        @hash = hash
-      end
-
-      def key?(key)
-        @hash.key?(key) || @hash.key?(:*) || @hash.key?(:**)
-      end
-
-      def [](key)
-        # TODO(beauby): Adopt a lazy caching strategy for generating subtrees.
-        case
-        when @hash.key?(key)
-          self.class.new(@hash[key])
-        when @hash.key?(:*)
-          self.class.new(@hash[:*])
-        when @hash.key?(:**)
-          self.class.new(:** => {})
-        else
-          nil
-        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

data/test/include_tree/include_args_to_hash_test.rb

@@ -1,64 +0,0 @@
-require 'test_helper'
-
-module ActiveModel
-  class Serializer
-    class IncludeTree
-      module Parsing
-        class IncludeArgsToHashTest < MiniTest::Test
-          def test_include_args_to_hash_from_symbol
-            expected = { author: {} }
-            input = :author
-            actual = Parsing.include_args_to_hash(input)
-
-            assert_equal(expected, actual)
-          end
-
-          def test_include_args_to_hash_from_array
-            expected = { author: {}, comments: {} }
-            input = [:author, :comments]
-            actual = Parsing.include_args_to_hash(input)
-
-            assert_equal(expected, actual)
-          end
-
-          def test_include_args_to_hash_from_nested_array
-            expected = { author: {}, comments: { author: {} } }
-            input = [:author, comments: [:author]]
-            actual = Parsing.include_args_to_hash(input)
-
-            assert_equal(expected, actual)
-          end
-
-          def test_include_args_to_hash_from_array_of_hashes
-            expected = {
-              author: {},
-              blogs: { posts: { contributors: {} } },
-              comments: { author: { blogs: { posts: {} } } }
-            }
-            input = [
-              :author,
-              blogs: [posts: :contributors],
-              comments: { author: { blogs: :posts } }
-            ]
-            actual = Parsing.include_args_to_hash(input)
-
-            assert_equal(expected, actual)
-          end
-
-          def test_array_of_string
-            expected = {
-              comments: { author: {}, attachment: {} }
-            }
-            input = [
-              'comments.author',
-              'comments.attachment'
-            ]
-            actual = Parsing.include_args_to_hash(input)
-
-            assert_equal(expected, actual)
-          end
-        end
-      end
-    end
-  end
-end