Remove stale methods.

lib/active_model/serializer.rb

@@ -170,25 +170,5 @@ def attributes(options = {})
     ActiveModelSerializers.silence_warnings do
       attr_accessor :instance_options
     end
-
-    # Transforms an inclusion hash into an array of corresponding existing associations,
-    # and corresponding inclusion hashes.
-    # @param [Hash] includes
-    # @return [Array] an array of pairs [association, include_hash] for matching associations
-    def expand_includes(includes)
-      if includes.size == 1 && includes.each_key.first == :*
-        associations.map { |assoc| [assoc, includes.each_value.first] }
-      elsif includes.size == 1 && includes.each_key.first == :**
-        associations.map { |assoc| [assoc, { :** => nil }] }
-      else
-        expanded_associations = includes.map do |inc|
-          association = associations.find { |assoc| assoc.key == inc.first }
-          [association, inc.second] if association
-        end
-        expanded_associations.delete(nil)
-
-        expanded_associations
-      end
-    end
   end
 end

lib/active_model/serializer/utils.rb

@@ -1,38 +1,6 @@
 module ActiveModel::Serializer::Utils
   module_function
 
-  # Translates a comma separated list of dot separated paths (JSONAPI 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)
-    included.delete(' ').split(',').inject({}) do |hash, path|
-      hash.deep_merge!(path.split('.').reverse_each.inject({}) { |a, e| { e.to_sym => a } })
-    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: {} } } }`.
-  #
-  # @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({}) { |(key, value), hash| hash[key] = include_args_to_hash(value) }
-    when Array
-      included.inject({}) { |a, e| a.merge!(include_args_to_hash(e)) }
-    when String
-      include_string_to_hash(included)
-    else
-      {}
-    end
-  end
-
   def nested_lookup_paths(klass)
     paths = klass.to_s.split('::').reverse.reduce([]) { |a, e| a + [[e] + Array(a.last)] }.reverse
     paths.map! { |path| "::#{path.join('::')}" }