Class: JSI::SchemaSet

Inherits:
Set
  • Object
show all
Defined in:
lib/jsi/schema_set.rb

Overview

a Set of JSI Schemas. always frozen.

any schema instance is described by a set of schemas.

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(enum) {|yields| ... } ⇒ SchemaSet

initializes a SchemaSet from the given enum and freezes it.

if a block is given, each element of the enum is passed to it, and the result must be a Schema. if no block is given, the enum must contain only Schemas.

Parameters:

  • enum (#each) —

    the schemas to be included in the SchemaSet, or items to be passed to the block

Yield Parameters:

  • yields —

    each element of enum for preprocessing into a Schema

Yield Returns:

Raises:



44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/jsi/schema_set.rb', line 44

def initialize(enum, &block)
  if enum.is_a?(Schema)
    raise(ArgumentError, [
      "#{SchemaSet} initialized with a #{Schema}",
      "you probably meant to pass that to #{SchemaSet}[]",
      "or to wrap that schema in a Set or Array for #{SchemaSet}.new",
      "given: #{enum.pretty_inspect.chomp}",
    ].join("\n"))
  end

  unless enum.is_a?(Enumerable)
    raise(ArgumentError, "#{SchemaSet} initialized with non-Enumerable: #{enum.pretty_inspect.chomp}")
  end

  super

  not_schemas = reject { |s| s.is_a?(Schema) }
  if !not_schemas.empty?
    raise(Schema::NotASchemaError, [
      "#{SchemaSet} initialized with non-schema objects:",
      *not_schemas.map { |ns| ns.pretty_inspect.chomp },
    ].join("\n"))
  end

  freeze
end

Class Method Details

.build {|Set| ... } ⇒ SchemaSet

builds a SchemaSet from a mutable Set which is added to by the given block

Yields:

  • (Set) —

    a Set to which the block may add schemas

Returns:



13
14
15
16
17
 
# File 'lib/jsi/schema_set.rb', line 13

def build
  mutable_set = Set.new
  yield mutable_set
  new(mutable_set)
end

.ensure_schema_set(schemas) ⇒ SchemaSet

ensures the given param becomes a SchemaSet. returns the param if it is already SchemaSet, otherwise initializes a SchemaSet from it.

Parameters:

  • schemas (SchemaSet, Enumerable) —

    the object to ensure becomes a SchemaSet

Returns:

  • (SchemaSet) —

    the given SchemaSet, or a SchemaSet initialized from the given Enumerable

Raises:

  • (ArgumentError) —

    when the schemas param is not an Enumerable

  • (Schema::NotASchemaError) —

    when the schemas param contains objects which are not Schemas



26
27
28
29
30
31
32
 
# File 'lib/jsi/schema_set.rb', line 26

def ensure_schema_set(schemas)
  if schemas.is_a?(SchemaSet)
    schemas
  else
    new(schemas)
  end
end

Instance Method Details

#child_applicator_schemas(token, instance) ⇒ JSI::SchemaSet

a set of child applicator subschemas of each schema in this set which apply to the child of the given instance on the given token. (see JSI::Schema#child_applicator_schemas)

Parameters:

  • instance (Object) —

    the instance to check any child applicators against

Returns:



161
162
163
 
# File 'lib/jsi/schema_set.rb', line 161

def child_applicator_schemas(token, instance)
  SchemaSet.new(each_child_applicator_schema(token, instance))
end

#each_child_applicator_schema(token, instance) {|JSI::Schema| ... } ⇒ nil, Enumerator

yields each child applicator schema which applies to the child of the given instance on the given token.

Parameters:

  • token (Object) —

    the array index or object property name for the child instance

  • instance (Object) —

    the instance to check any child applicators against

Yields:

Returns:

  • (nil, Enumerator) —

    an Enumerator if invoked without a block; otherwise nil



171
172
173
174
175
176
177
178
179
 
# File 'lib/jsi/schema_set.rb', line 171

def each_child_applicator_schema(token, instance, &block)
  return to_enum(__method__, token, instance) unless block

  each do |schema|
    schema.each_child_applicator_schema(token, instance, &block)
  end

  nil
end

#each_inplace_applicator_schema(instance) {|JSI::Schema| ... } ⇒ nil, Enumerator

yields each inplace applicator schema which applies to the given instance.

Parameters:

  • instance (Object) —

    the instance to check any applicators against

Yields:

Returns:

  • (nil, Enumerator) —

    an Enumerator if invoked without a block; otherwise nil



145
146
147
148
149
150
151
152
153
 
# File 'lib/jsi/schema_set.rb', line 145

def each_inplace_applicator_schema(instance, &block)
  return to_enum(__method__, instance) unless block

  each do |schema|
    schema.each_inplace_applicator_schema(instance, &block)
  end

  nil
end

#inplace_applicator_schemas(instance) ⇒ JSI::SchemaSet

a set of inplace applicator schemas of each schema in this set which apply to the given instance. (see JSI::Schema#inplace_applicator_schemas)

Parameters:

  • instance (Object) —

    the instance to check any applicators against

Returns:



136
137
138
 
# File 'lib/jsi/schema_set.rb', line 136

def inplace_applicator_schemas(instance)
  SchemaSet.new(each_inplace_applicator_schema(instance))
end

#inspect ⇒ String Also known as: to_s

Returns:

  • (String) 


198
199
200
 
# File 'lib/jsi/schema_set.rb', line 198

def inspect
  -"#{self.class}[#{map(&:inspect).join(", ")}]"
end

#instance_valid?(instance) ⇒ Boolean

whether the given instance is valid against our schemas

Parameters:

  • instance (Object) —

    the instance to validate against our schemas

Returns:

  • (Boolean) 


193
194
195
 
# File 'lib/jsi/schema_set.rb', line 193

def instance_valid?(instance)
  all? { |schema| schema.instance_valid?(instance) }
end

#instance_validate(instance) ⇒ JSI::Validation::Result

validates the given instance against our schemas

Parameters:

  • instance (Object) —

    the instance to validate against our schemas

Returns:



185
186
187
188
 
# File 'lib/jsi/schema_set.rb', line 185

def instance_validate(instance)
  results = map { |schema| schema.instance_validate(instance) }
  results.inject(Validation::FullResult.new, &:merge).freeze
end

#new_jsi(instance, uri: nil, register: false, schema_registry: JSI.schema_registry, stringify_symbol_keys: false) ⇒ JSI::Base subclass

Instantiates a new JSI whose content comes from the given instance param. This SchemaSet indicates the schemas of the JSI - its schemas are inplace applicators of this set's schemas which apply to the given instance.

Parameters:

  • instance (Object) —

    the instance to be represented as a JSI

  • uri (#to_str, Addressable::URI) (defaults to: nil) —

    The retrieval URI of the instance.

    It is rare that this needs to be specified, and only useful for instances which contain schemas. See JSI::Schema::DescribesSchema#new_schema's uri param documentation.

  • register (Boolean) (defaults to: false) —

    Whether schema resources in the instantiated JSI will be registered in the schema registry indicated by param schema_registry. This is only useful when the JSI is a schema or contains schemas. The JSI's root will be registered with the uri param, if specified, whether or not the root is a schema.

  • schema_registry (SchemaRegistry, nil) (defaults to: JSI.schema_registry) —

    The registry to use for references to other schemas and, depending on register and uri params, to register this JSI and/or any contained schemas with declared URIs.

  • stringify_symbol_keys (Boolean) (defaults to: false) —

    Whether the instance content will have any Symbol keys of Hashes replaced with Strings (recursively through the document). Replacement is done on a copy; the given instance is not modified.

Returns:

  • (JSI::Base subclass) —

    a JSI whose content comes from the given instance and whose schemas are inplace applicators of the schemas in this set.



93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
# File 'lib/jsi/schema_set.rb', line 93

def new_jsi(instance,
    uri: nil,
    register: false,
    schema_registry: JSI.schema_registry,
    stringify_symbol_keys: false
)
  if stringify_symbol_keys
    instance = Util.deep_stringify_symbol_keys(instance)
  end

  applied_schemas = inplace_applicator_schemas(instance)

  if uri
    unless uri.respond_to?(:to_str)
      raise(TypeError, "uri must be string or Addressable::URI; got: #{uri.inspect}")
    end
    uri = Util.uri(uri)
    unless uri.absolute? && !uri.fragment
      raise(ArgumentError, "uri must be an absolute URI with no fragment; got: #{uri.inspect}")
    end
  end

  jsi_class = JSI::SchemaClasses.class_for_schemas(applied_schemas,
    includes: SchemaClasses.includes_for(instance),
  )
  jsi = jsi_class.new(instance,
    jsi_indicated_schemas: self,
    jsi_schema_base_uri: uri,
    jsi_schema_registry: schema_registry,
  )

  if register && schema_registry
    schema_registry.register(jsi)
  end

  jsi
end

#pretty_print(q) ⇒ Object 



204
205
206
207
208
209
210
211
212
213
214
215
216
217
 
# File 'lib/jsi/schema_set.rb', line 204

def pretty_print(q)
  q.text self.class.to_s
  q.text '['
  q.group_sub {
    q.nest(2) {
      q.breakable('')
      q.seplist(self, nil, :each) { |e|
        q.pp e
      }
    }
  }
  q.breakable ''
  q.text ']'
end