class Japin::Normalizer

Attributes

input[R]
keys_case[R]
types_case[R]

Public Class Methods

new(input, keys_case: nil, types_case: nil) click to toggle source
# File lib/japin/normalizer.rb, line 5
def initialize(input, keys_case: nil, types_case: nil)
    @input = deep_transform_keys(input, &:to_s)
    @keys_case = keys_case
    @types_case = types_case
end

Public Instance Methods

normalize() click to toggle source
# File lib/japin/normalizer.rb, line 11
def normalize
    return @output if @output

    @output = {}
    input.slice('data', 'included').each_value { |entities| extract_entities(entities) }
    @output
end
Also aliased as: to_h
to_h()
Alias for: normalize

Private Instance Methods

deep_transform_keys(object) { |key| ... } click to toggle source
# File lib/japin/normalizer.rb, line 67
def deep_transform_keys(object, &block)
    case object
    when Hash
    object.each_with_object({}) do |(key, value), result|
        result[yield(key)] = deep_transform_keys(value, &block)
    end
    when Array then object.map { |element| deep_transform_keys(element, &block) }
    else object
    end
end
extract_entities(json) click to toggle source
# File lib/japin/normalizer.rb, line 23
def extract_entities(json)
    json.is_a?(Array) ? json.each { |record| extract_entity(record) } : extract_entity(json)
end
extract_entity(record) click to toggle source
# File lib/japin/normalizer.rb, line 27
def extract_entity(record)
    type = transform_type_case(record['type'])
    @output[type] ||= {}
    data = record.slice('id', 'attributes', 'links', 'meta').merge('type' => type)

    data['relationships'] = extract_relationships(record['relationships']) if record.key?('relationships')

    @output[type][record['id']] ||= process_entity_data(data)
end
extract_relationships(relationships) click to toggle source
# File lib/japin/normalizer.rb, line 37
def extract_relationships(relationships)
    relationships.transform_values do |relationship|
    data = case relationship['data']
            when Array then relationship['data'].map { |record| process_relationship_data(record) }
            when Hash then process_relationship_data(relationship['data'])
            end
    relationship.slice('links', 'meta').merge('data' => data)
    end
end
process_entity_data(data) click to toggle source
# File lib/japin/normalizer.rb, line 47
def process_entity_data(data)
    @keys_case ? deep_transform_keys(data) { |key| transform_key_case(key) } : data
end
process_relationship_data(data) click to toggle source
# File lib/japin/normalizer.rb, line 51
def process_relationship_data(data)
    data.slice('id').merge('type' => transform_type_case(data['type']))
end
transform_case(string, to_case) click to toggle source
# File lib/japin/normalizer.rb, line 63
def transform_case(string, to_case)
    LuckyCase.convert_case(string, to_case)
end
transform_key_case(key) click to toggle source
# File lib/japin/normalizer.rb, line 59
def transform_key_case(key)
    transform_case(key, @keys_case)
end
transform_type_case(key) click to toggle source
# File lib/japin/normalizer.rb, line 55
def transform_type_case(key)
    @types_case ? transform_case(key, @types_case) : key
end