Class: Vk::Schema

Inherits:
Object
  • Object
show all
Defined in:
lib/vk/schema.rb,
lib/vk/schema/method.rb,
lib/vk/schema/object.rb,
lib/vk/schema/response.rb,
lib/vk/schema/generator.rb,
lib/vk/schema/namespace.rb,
lib/vk/schema/definition.rb,
lib/vk/schema/generator/type.rb,
lib/vk/schema/definition/type.rb,
lib/vk/schema/generator/types.rb,
lib/vk/schema/definition/error.rb,
lib/vk/schema/generator/client.rb,
lib/vk/schema/generator/common.rb,
lib/vk/schema/generator/errors.rb,
lib/vk/schema/generator/method.rb,
lib/vk/schema/generator/object.rb,
lib/vk/schema/definition/method.rb,
lib/vk/schema/definition/object.rb,
lib/vk/schema/generator/methods.rb,
lib/vk/schema/generator/objects.rb,
lib/vk/schema/generator/response.rb,
lib/vk/schema/definition/constant.rb,
lib/vk/schema/definition/response.rb,
lib/vk/schema/generator/responses.rb,
lib/vk/schema/definition/attribute.rb,
lib/vk/schema/definition/has_attributes.rb

Defined Under Namespace

Classes: Definition, Generator, Method, Namespace, Object, Response

objects.json collapse

OBJECTS_DEFINITION =
%r{\A(objects\.json)?#/definitions/}
RESPONSES_DEFINITION =
%r{\Aresponses\.json?#/definitions/}

Instance Attribute Summary collapse

objects.json collapse

methods.json collapse

responses.json collapse

schema.json collapse

Client collapse

Instance Method Summary collapse

Constructor Details

#initialize(path: 'data/schema') ⇒ Schema

Returns a new instance of Schema.

Parameters:

  • path (String) (defaults to: 'data/schema')

16
17
18
19
20
21
22
# File 'lib/vk/schema.rb', line 16

def initialize(path: 'data/schema')
  @path = Pathname.new(path)
  @methods = JSON.parse(File.read(@path / 'methods.json'))
  @objects = JSON.parse(File.read(@path / 'objects.json'))
  @responses = JSON.parse(File.read(@path / 'responses.json'))
  @schema = JSON.parse(File.read(@path / 'responses.json'))
end

Instance Attribute Details

#pathPathname (readonly)

Returns:

  • (Pathname)

25
26
27
# File 'lib/vk/schema.rb', line 25

def path
  @path
end

Instance Method Details

#definition_of(ref) ⇒ Definition

Parameters:

  • ref (String)

Returns:


66
67
68
69
70
71
72
73
# File 'lib/vk/schema.rb', line 66

def definition_of(ref)
  case ref
  when OBJECTS_DEFINITION
    objects_reference[ref.sub(OBJECTS_DEFINITION, '')]
  else
    raise "Unknown reference: #{ref.inspect}"
  end
end

#errors<Vk::Definition::Error>

Returns:

  • (<Vk::Definition::Error>)

92
93
94
95
96
# File 'lib/vk/schema.rb', line 92

def errors
  @methods['errors'].map do |error|
    Vk::Schema::Definition::Error.new(error['name'], error, self)
  end
end

#methods<Vk::Definition::Error>

Returns:

  • (<Vk::Definition::Error>)

99
100
101
102
103
# File 'lib/vk/schema.rb', line 99

def methods
  @methods['methods'].map do |method|
    Definition::Method.new(method['name'], method, self)
  end
end

#namespaced_methods{String => Definition::methods}

Returns:

  • ({String => Definition::methods})

106
107
108
109
110
111
112
113
# File 'lib/vk/schema.rb', line 106

def namespaced_methods
  @namespaced_methods ||=
    methods.each_with_object({}) do |value, memo|
      next unless value.is_a?(Definition::Method)
      memo[value.namespace] ||= []
      memo[value.namespace] << value
    end
end

#namespaced_objects{String => Definition::Object}

Returns:


44
45
46
47
48
49
50
# File 'lib/vk/schema.rb', line 44

def namespaced_objects
  @namespaced_objects ||= objects_reference.values.each_with_object({}) do |value, memo|
    next unless value.is_a?(Definition::Object)
    memo[value.namespace] ||= []
    memo[value.namespace] << value
  end
end

#namespaced_types{String => Definition::Type}

Returns:


53
54
55
56
57
58
59
# File 'lib/vk/schema.rb', line 53

def namespaced_types
  @namespaced_types ||= objects_reference.values.each_with_object({}) do |value, memo|
    next unless value.is_a?(Definition::Type)
    memo[value.namespace] ||= []
    memo[value.namespace] << value
  end
end

#namespaces<String>

Returns:

  • (<String>)

136
137
138
139
140
141
142
# File 'lib/vk/schema.rb', line 136

def namespaces
  @namespaces ||= (
    namespaced_methods.keys |
      namespaced_objects.keys |
      namespaced_types.keys
  ).map(&:underscore)
end

#objects<Definition::Object>

Returns:


30
31
32
33
34
# File 'lib/vk/schema.rb', line 30

def objects
  objects_reference.values.select do |value|
    value.is_a?(Definition::Object)
  end
end

#objects_reference{String => Definition::Object, Definition::Type}

Returns:


76
77
78
79
80
81
82
83
84
85
86
87
# File 'lib/vk/schema.rb', line 76

def objects_reference
  @objects_reference ||=
    @objects['definitions'].each_with_object({}) do |(name, definition), memo|
      memo[name] = if object?(definition)
                     Definition::Object.new(name, definition, self)
                   elsif definition['type']
                     Definition::Type.new(name, definition, self)
                   else
                     raise "What is #{name}, #{definition.inspect}?"
                   end
    end
end

#responses<Definition::Error>

Returns:


118
119
120
121
122
# File 'lib/vk/schema.rb', line 118

def responses
  @responses['definitions'].map do |name, response|
    Definition::Response.new(name, response, self)
  end
end

#schemas<Definition::Error>

Returns:


127
128
129
130
131
# File 'lib/vk/schema.rb', line 127

def schemas
  @schema['definitions'].map do |name, response|
    Definition::Response.new(name, response, self)
  end
end

#types<Definition::Type>

Returns:


37
38
39
40
41
# File 'lib/vk/schema.rb', line 37

def types
  objects_reference.values.select do |value|
    value.is_a?(Definition::Type)
  end
end