class Paradocs::Extensions::Structure

Constants

DEFAULT

Attributes

ignore_transparent[RW]
root[R]
schema[R]

Public Class Methods

new(schema, ignore_transparent=true, root="") click to toggle source
# File lib/paradocs/extensions/structure.rb, line 11
def initialize(schema, ignore_transparent=true, root="")
  @schema             = schema
  @ignore_transparent = ignore_transparent
  @root               = root
end

Public Instance Methods

all_flatten(schema_structure=nil, &block) click to toggle source
# File lib/paradocs/extensions/structure.rb, line 61
def all_flatten(schema_structure=nil, &block)
  schema_structure ||= flatten(&block)
  if schema_structure[subschemes].empty?
    schema_structure.delete(subschemes) # don't include redundant key
    return {DEFAULT => schema_structure}
  end
  schema_structure[subschemes].each_with_object({}) do |(name, subschema), result|
    if subschema[subschemes].empty?
      result[name] = schema_structure.merge(subschema)
      result[name][errors] += schema_structure[errors]
      result[name][errors].uniq!
      result[name].delete(subschemes)
      next result[name]
    end

    all_flatten(subschema).each do |sub_name, schema|
      result["#{name}_#{sub_name}".to_sym] = schema_structure.merge(schema)
    end
  end
end
all_nested(&block) click to toggle source
# File lib/paradocs/extensions/structure.rb, line 39
def all_nested(&block)
  all_flatten(&block).each_with_object({}) do |(name, struct), obj|
    obj[name] = {}
    # sort the flatten struct to have iterated 1lvl keys before 2lvl and so on...
    struct.sort_by { |k, v| k.to_s.count(".") }.each do |key, value|
      target = obj[name]
      key, value = key.to_s, value.clone # clone the values, because we do mutation below
      value.merge!(nested_name: key) if value.respond_to?(:merge) # it can be array (_errors)
      next target[key.to_sym] = value if key.start_with?(Paradocs.config.meta_prefix) # copy meta fields

      parts = key.split(".")
      next target[key] ||= value if parts.size == 1 # copy 1lvl key
      parts.each.with_index do |subkey, index|
        target[subkey] ||= value
        next if parts.size == index + 1
        target[subkey][:structure] ||= {}
        target = target[subkey][:structure] # target goes deeper for each part
      end
    end
  end
end
flatten() { |humanized_name, meta| ... } click to toggle source
# File lib/paradocs/extensions/structure.rb, line 82
def flatten(&block)
  schema.fields.each_with_object({errors => [], subschemes => {}}) do |(_, field), obj|
    meta, sc = collect_meta(field, root)
    humanized_name = meta.delete(:nested_name)
    obj[humanized_name] = meta unless ignore_transparent && field.transparent?

    if sc
      deep_result = self.class.new(sc, ignore_transparent, meta[:json_path]).flatten(&block)
      obj[errors] += deep_result.delete(errors)
      obj[subschemes].merge!(deep_result.delete(subschemes))
      obj.merge!(deep_result)
    else
      obj[errors] += field.possible_errors
    end
    yield(humanized_name, meta) if block_given?
    next unless field.mutates_schema?
    schema.subschemes.each do |name, subschema|
      obj[subschemes][name] ||= self.class.new(subschema, ignore_transparent, root).flatten(&block)
      obj[errors] += obj[subschemes][name][errors]
    end
  end
end
nested() { |field_key, meta| ... } click to toggle source
# File lib/paradocs/extensions/structure.rb, line 17
def nested(&block)
  schema.fields.each_with_object({errors => [], subschemes => {}}) do |(_, field), result|
    meta, sc = collect_meta(field, root)
    if sc
      meta[:structure] = self.class.new(sc, ignore_transparent, meta[:json_path]).nested(&block)
      result[errors] += meta[:structure].delete(errors)
    else
      result[errors] += field.possible_errors
    end

    field_key = field.meta_data[:alias] || field.key
    result[field_key] = meta unless ignore_transparent && field.transparent?
    yield(field_key, meta) if block_given?

    next unless field.mutates_schema?
    schema.subschemes.each do |name, subschema|
      result[subschemes][name] = self.class.new(subschema, ignore_transparent, root).nested(&block)
      result[errors] += result[subschemes][name][errors]
    end
  end
end

Private Instance Methods

collect_meta(field, root) click to toggle source
# File lib/paradocs/extensions/structure.rb, line 107
def collect_meta(field, root)
  field_key = field.meta_data[:alias] || field.key
  json_path = root.empty? ? "$.#{field_key}" : "#{root}.#{field_key}"
  meta = field.meta_data.merge(json_path: json_path)
  sc = meta.delete(:schema)
  meta[:mutates_schema] = true if meta.delete(:mutates_schema)
  json_path << "[]" if meta[:type] == :array
  meta[:nested_name] = json_path.gsub("[]", "")[2..-1]
  [meta, sc]
end