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.

Yield Parameters:

  • yields —

    each element of enum for preprocessing into a Schema

Yield Returns:

Raises:



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

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 {|Enumerator::Yielder| ... } ⇒ SchemaSet

Builds a SchemaSet, yielding a yielder to be called with each schema of the SchemaSet.

Yields:

  • (Enumerator::Yielder) 


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

def build(&block)
  new(Enumerator.new(&block))
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.

Raises:

  • (ArgumentError) —

    when the schemas param is not an Enumerable

  • (Schema::NotASchemaError) —

    when the schemas param contains objects which are not Schemas



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

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)



168
169
170
 
# File 'lib/jsi/schema_set.rb', line 168

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.

Yields:



178
179
180
181
182
183
184
185
186
 
# File 'lib/jsi/schema_set.rb', line 178

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.

Yields:



152
153
154
155
156
157
158
159
160
 
# File 'lib/jsi/schema_set.rb', line 152

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)



143
144
145
 
# File 'lib/jsi/schema_set.rb', line 143

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

#inspect ⇒ String 



206
207
208
 
# File 'lib/jsi/schema_set.rb', line 206

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

#instance_valid?(instance) ⇒ Boolean

whether the given instance is valid against our schemas



201
202
203
 
# File 'lib/jsi/schema_set.rb', line 201

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

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

validates the given instance against our schemas



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

def instance_validate(instance)
  inject(Validation::FullResult.new) do |result, schema|
    result.merge(schema.instance_validate(instance))
  end.freeze
end

#new_jsi(instance, uri: nil, register: false, schema_registry: JSI.schema_registry, stringify_symbol_keys: false, to_immutable: DEFAULT_CONTENT_TO_IMMUTABLE, mutable: 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.



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
130
131
132
133
134
135
136
 
# File 'lib/jsi/schema_set.rb', line 98

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

  instance = to_immutable.call(instance) if !mutable && to_immutable

  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),
    mutable: mutable,
  )
  jsi = jsi_class.new(instance,
    jsi_indicated_schemas: self,
    jsi_schema_base_uri: uri,
    jsi_schema_registry: schema_registry,
    jsi_content_to_immutable: to_immutable,
  )

  schema_registry.register(jsi) if register && schema_registry

  jsi
end

#pretty_print(q) ⇒ Object 



214
215
216
217
218
219
220
221
222
223
224
225
 
# File 'lib/jsi/schema_set.rb', line 214

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

#to_s ⇒ Object 



210
211
212
 
# File 'lib/jsi/schema_set.rb', line 210

def to_s
  inspect
end