class ActiveModelSerializers::Adapter::Base

def self.inherited(subclass)
  ActiveModelSerializers::Adapter.register(subclass)
end

def as_json(options = nil)
  hash = serializable_hash(options)
  include_meta(hash)
  hash
end

def cache_check(serializer)
  CachedSerializer.new(serializer).cache_check(self) do
    yield
  end
end

def cached_name
  @cached_name ||= self.class.name.demodulize.underscore
end

def default_key_transform
  :unaltered
end

def fragment_cache(cached_hash, non_cached_hash)
  non_cached_hash.merge cached_hash
end

def include_meta(json)
  json[meta_key] = meta unless meta.blank?
  json
end

def initialize(serializer, options = {})
  @serializer = serializer
  @instance_options = options
end

def meta
  instance_options.fetch(:meta, nil)
end

def meta_key
  instance_options.fetch(:meta_key, 'meta'.freeze)
end

def root
  serializer.json_key.to_sym if serializer.json_key
end

def serializable_hash(_options = nil)
  fail NotImplementedError, 'This is an abstract method. Should be implemented at the concrete adapter.'
end

def transform(options)
  return options[:key_transform] if options && options[:key_transform]
  ActiveModelSerializers.config.key_transform || default_key_transform
end

def transform_key_casing!(value, options)
  KeyTransform.send(transform(options), value)
end