class ActiveFacet::Helper

Public Class Methods

attribute_serializer_class_for(resource_class, attribute_name, options) click to toggle source

Fetches the attribute serializer registered for the given resource_class @param resource_class [Object] to find attribute serializer class for @param attribute_class_name [String] to find attribute serializer class for @param options [Hash] context @return [Class]

# File lib/active_facet/helper.rb, line 90
def self.attribute_serializer_class_for(resource_class, attribute_name, options)
  fetch_serializer(resource_class, attribute_name.to_s.camelcase, :attribute_serializer, options)
end
default_resource_mapper(resource_class) click to toggle source

Default resource mapping scheme, can be replaced with a custom implementation @param resource_class [Class] @return [Array] of Strings for use by filters and field configurations

# File lib/active_facet/helper.rb, line 15
def self.default_resource_mapper(resource_class)
  map = []
  until(resource_class.superclass == BasicObject) do
    map << resource_class.name.tableize
    resource_class = resource_class.superclass
  end
  map
end
default_serializer_mapper(resource_class, serializer, type, version, options) click to toggle source

Default serializer mapping scheme, can be overrided with config Memoized @param resource_class [Class] @return [Serializer::Base | Class]

# File lib/active_facet/helper.rb, line 42
def self.default_serializer_mapper(resource_class, serializer, type, version, options)
  key = [resource_class.name, serializer.to_s, type.to_s.camelcase, version].join(".")
  return memoized_serializers[key] if memoized_serializers.key?(key)
  memoized_serializers[key] = internal_serializer_mapper(resource_class, serializer, type, version, options)
end
extract_version_from_opts(options) click to toggle source

Safely extracts version from options hash @return [Numeric]

# File lib/active_facet/helper.rb, line 112
def self.extract_version_from_opts(options)
  ((options.try(:[], ActiveFacet.opts_key) || {})[ActiveFacet.version_key] || ActiveFacet.default_version).to_f
end
fetch_serializer(resource_class, serializer, type, options) click to toggle source

Retrieves the first serializer successfully described by the parameters @param resource_class [Class] the class of the resource to serialize @param serializer [String] name of the base_class of the resource to serialize @param type [String] type of serializer to look for (attribute vs. resource) @param options [Hash] context @return [Serializer::Base | Class]

# File lib/active_facet/helper.rb, line 100
def self.fetch_serializer(resource_class, serializer, type, options)
  version = extract_version_from_opts(options)
  unless result = serializer_mapper.call(resource_class, serializer, type, version, options)
    error_message = "Unable to locate serializer for:: " + [resource_class.name, serializer, type, version].to_s
    Rails.logger.debug error_message
    raise ActiveFacet::Errors::LookupError.new(error_message) if ActiveFacet.strict_lookups
  end
  result
end
internal_serializer_mapper(resource_class, serializer, type, version, options) click to toggle source

TODO –jdc implement recursive superclass/parentclass lookup Default serializer mapping scheme, can be overrided with config @param resource_class [Class] @return [Serializer::Base | Class]

# File lib/active_facet/helper.rb, line 56
def self.internal_serializer_mapper(resource_class, serializer, type, version, options)
  case type
  when :serializer
    [
      'V' + version.to_i.to_s + '::' + resource_class.name.camelcase + '::' + resource_class.name.camelcase + type.to_s.camelcase,
      'V' + version.to_i.to_s + '::' + resource_class.name.camelcase + type.to_s.camelcase,
    ].each { |name|
      klass = name.safe_constantize
      return klass.new if klass.present?
    }
  else
    [
      'V' + version.to_i.to_s + '::' + resource_class.name.camelcase + '::' + serializer + type.to_s.camelcase,
      'V' + version.to_i.to_s + '::' + serializer + type.to_s.camelcase,
    ].find { |name|
      klass = name.safe_constantize
      return klass if klass.present?
    }
  end
end
resource_map(resource_class) click to toggle source

Fetches the set of keys the resource_class might appear as for Filters and Fields Memoized @param resource_class [Object] @return [Array] of Strings

# File lib/active_facet/helper.rb, line 32
def self.resource_map(resource_class)
  memoized_resource_map[resource_class] ||= begin
    resource_mapper.call(resource_class)
  end
end
serializer_for(resource_class, options) click to toggle source

Fetches the serializer registered for a resource_class @param resource_class [Object] to find serializer for @param options [Hash] context @return [Serializer::Base]

# File lib/active_facet/helper.rb, line 81
def self.serializer_for(resource_class, options)
  fetch_serializer(resource_class, resource_class.name.demodulize.to_s.camelcase, :serializer, options)
end