Module: SchemaTools::Modules::Read

Included in:
Reader, Reader
Defined in:
lib/schema_tools/modules/read.rb

Overview

Read schemas into a hash

Instance Method Summary collapse

Instance Method Details

#_handle_reference_properties(schema) ⇒ Object

Merge referenced property definitions into the given schema. e.g. each object has an updated_at field which we define in a single location(external file) instead of repeating the property def in each schema.

Parameters:

  • schema (HashWithIndifferentAccess) —

    • single schema



84
85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/schema_tools/modules/read.rb', line 84

def _handle_reference_properties(schema)
  return unless schema["properties"]
  schema["properties"].each { |key, value|
    next unless value["$ref"]

    json_pointer = value["$ref"]
    values_from_pointer = RefResolver.load_json_pointer json_pointer
    schema["properties"][key].merge!(values_from_pointer) {|key, old, new|
      old
    }
    schema["properties"][key].delete("$ref")
  }
end

#read(schema_name, path_or_schema = nil) ⇒ Object

Read a schema and return it as hash. You can supply a path or the global path defined in #SchemaTools.schema_path is used. Schemata are returned from cache(#registry) if present to prevent filesystem round-trips. The cache can be reset with #registry_reset

@return schema as hash

Parameters:

  • schema (String|Symbol) —

    name to be read from schema path directory

  • either (String|Hash) —

    the path to retrieve schema_name from, or a Schema in Ruby hash form



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/schema_tools/modules/read.rb', line 35

def read(schema_name, path_or_schema=nil)
  schema_name = schema_name.to_sym
  return registry[schema_name] if registry[schema_name]

  if path_or_schema.is_a?(::Hash)
    path       = nil
    plain_data = path_or_schema.to_json
  elsif path_or_schema.is_a?(::String) || path_or_schema.nil?
    path       = path_or_schema
    file_path  = File.join(path || SchemaTools.schema_path, "#{schema_name}.json")
  else
    raise ArgumentError, 'Second parameter must be a path or a schema!'
  end

  plain_data ||= File.open(file_path, 'r'){|f| f.read}

  schema = ActiveSupport::JSON.decode(plain_data).with_indifferent_access
  if schema[:extends]
    extends = schema[:extends].is_a?(Array) ? schema[:extends] : [ schema[:extends] ]
    extends.each do |ext_name|
      ext = read(ext_name, path)
      # current schema props win
      schema[:properties] = ext[:properties].merge(schema[:properties])
    end
  end
  _handle_reference_properties schema
  registry[ schema_name ] = schema
end

#read_all(path = nil) ⇒ Array<HashWithIndifferentAccess>

Read all available schemas from a given path(folder) and return them as array

Parameters:

  • path (String) (defaults to: nil) —

    to schema files

Returns:

  • (Array<HashWithIndifferentAccess>) —

    array of schemas as hash



69
70
71
72
73
74
75
76
77
 
# File 'lib/schema_tools/modules/read.rb', line 69

def read_all(path=nil)
  schemas = []
  file_path = File.join(path || SchemaTools.schema_path, '*.json')
  Dir.glob( file_path ).each do |file|
    schema_name = File.basename(file, '.json').to_sym
    schemas << read(schema_name, path)
  end
  schemas
end

#registry ⇒ Hash{String=>Hash{Symbol=>HashWithIndifferentAccess}}

Variable remembering already read-in schema’s 

:invoice =>{schema
:credit_note =>schema
}

}

Returns:

  • (Hash{String=>Hash{Symbol=>HashWithIndifferentAccess}}) 


18
19
20
 
# File 'lib/schema_tools/modules/read.rb', line 18

def registry
  @registry ||= {}
end

#registry_reset ⇒ Object 



22
23
24
 
# File 'lib/schema_tools/modules/read.rb', line 22

def registry_reset
  @registry = nil
end