tarantool-schema 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 431a9d499bae2bc10348a4780b10ea5793e4debd8b021357f5f0a9edca753e00
-  data.tar.gz: 899bfb866f10c504ba4198899d2a42f850ae0b4a2fdb4c87a920f7c029097591
+  metadata.gz: b3260cbb85da71cf020abb9e22fabfb4feb286ecd95a8b6c4b6547208f7f6f06
+  data.tar.gz: 40d311e9036ffcacd2c65d5968d27f07ea33b3d49ebc643366d72f07e1d00d00
 SHA512:
-  metadata.gz: d07771270e5545f01d696e9600de60b09c861f87e134feaad9e566ad42ee679bed2a512a302b28387bd44a219ef32d518c0a87d245af30088e2da1cc5fb2360a
-  data.tar.gz: df474e074921d8678a7c55f976de5e661dd9eba828591a4247cc6a30c2ef95c1d75b245df42fa567fa4e846cd29085487194c6cf8b7af6d1f041213f3b2499de
+  metadata.gz: e4eb8745bb8495e4a66a51c07fe8b734de1054b5dae1691fe27a465173d3be8511e113c5c56a9ac037f42fe1de1926caac599a200148517ab371cefe96e032f3
+  data.tar.gz: b59ea715167985b0f98f989a026f56941a5633e8a8de283e311acbf2652e51f8a0338b903465bdcea58cca0d917eb8dc822c46fc0eb205c32278b5daa00cdeae

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.2.0 (2026-10-17)
+
+- `Definition.from_live(client, only:)`: the live user spaces as a definition, for bootstrapping an existing
+  database; `Definition#to_ruby` renders a definition as DSL source.
+- `plan`/`apply` take `alter: [:add_field]` to append nullable fields to the end of a live format. Without it a
+  longer declared format stays a mismatch, as before.
+
 ## 0.1.0 (2026-10-17)
 
 First release.

data/README.md

@@ -2,8 +2,9 @@
 
 Idempotent schema declaration for Tarantool 2.11+ and 3.x, meant for deploys. You declare spaces, indexes and
 primary key sequences in Ruby; `apply` creates whatever is missing and checks everything that already exists.
-If the live schema differs from the declaration, it raises an error with a diff and creates nothing. It never
-alters or drops anything: changing a field type or rebuilding an index is a migration and is out of scope.
+If the live schema differs from the declaration, it raises an error with a diff and creates nothing. It alters
+only what you allow (appending nullable fields) and never drops anything: changing a field type or rebuilding an
+index is a migration and is out of scope. An existing database can be read back into the DSL with `from_live`.
 
 ## Installation
 
@@ -95,7 +96,7 @@ Connect to the read-write instance. `apply`:
 2. compares it with the declaration and collects the differences across all spaces;
 3. if there are any, raises `Tarantool::Schema::MismatchError` and creates nothing;
 4. creates the missing spaces and indexes in declaration order, with `if_not_exists` so two deploys racing each
-   other do not fail;
+   other do not fail (and sets the format of spaces that get new fields, see Altering);
 5. reads everything again and raises `MismatchError` if something is still missing or differs, for example
    when another deploy created the space differently in the meantime. Racing another deploy can also surface
    as `Tarantool::ServerError` raised directly from `create_index`, before this re-verification runs.
@@ -119,6 +120,64 @@ schema mismatch:
 
 `MismatchError#mismatches` returns the same lines as an Array, each prefixed with `space <name>: `.
 
+## Altering
+
+Appending nullable fields to the end of a live format is the one change `apply` makes to an existing space, and
+only when asked:
+
+```ruby
+MyApp::SCHEMA.plan(client, alter: [:add_field])   # => ["format codes: add phone, archived_at"]
+MyApp::SCHEMA.apply(client, alter: [:add_field])  # => ["format codes: add phone, archived_at"]
+MyApp::SCHEMA.apply(client, alter: [:add_field])  # => []
+```
+
+`alter:` takes `:add_field` only; anything else raises `ArgumentError`. It applies when the live format is a
+prefix of the declared one (same names, types and nullability) and every field past it is `is_nullable: true`,
+which is what Tarantool requires while the space holds tuples. The whole declared format is sent with
+`box.space[name]:format(...)`, before any new index of that space, so an index on a new field works. Existing
+tuples read the new fields as nil.
+
+Everything else stays a mismatch: a field that is not nullable (`field 4 flag: must be is_nullable: true to be
+added`), a live format longer than the declared one, a field differing inside the prefix. Nothing is ever
+dropped.
+
+## Bootstrapping from a live schema
+
+```ruby
+definition = Tarantool::Schema::Definition.from_live(client)                      # every user space
+definition = Tarantool::Schema::Definition.from_live(client, only: %i[codes users])
+definition.plan(client)  # => []
+File.write('config/tarantool_schema.rb', definition.to_ruby)
+```
+
+`from_live` reads the spaces with ids past the system range whose names do not start with `_` (vshard's
+`_bucket` and crud's `_ddl_*` stay out); `only:` names the spaces to read instead, with or without a leading
+underscore, and raises `ArgumentError` for a name that does not exist. Each space is read as `ensure_space`
+would declare it: engine, format, indexes in id order with their parts. A part that inherits its type and
+nullability from the field is a bare field name; a JSON path part keeps its type. Index options the DSL does not
+know (`hint`, collations, `exclude_null`, vinyl tuning) are not read, as `plan` ignores them anyway. A
+functional index, or a part pointing past the format, raises `ArgumentError` naming the space and index: the
+DSL cannot express them.
+
+`to_ruby` renders a definition as source for a `Tarantool::Schema::Definition.new do ... end` block, defaults
+left out, one space per `ensure_space`, `ensure_index` entries after them; it evaluates back to the same `to_h`:
+
+```ruby
+Tarantool::Schema::Definition.new do
+  ensure_space :codes,
+               format: [
+                 { name: :id, type: :unsigned },
+                 { name: :code, type: :string },
+                 { name: :expires_at, type: :unsigned, is_nullable: true }
+               ],
+               indexes: [
+                 { name: :primary, parts: [:id], sequence: true },
+                 { name: :by_code, parts: [:code] },
+                 { name: :by_expiry, parts: [:expires_at], unique: false }
+               ]
+end
+```
+
 ## Rake
 
 ```ruby
@@ -138,9 +197,9 @@ namespace :tarantool do
       with_schema_client { |client| puts MyApp::SCHEMA.plan(client) }
     end
 
-    desc 'Create missing Tarantool spaces and indexes; fail on drift'
+    desc 'Create missing Tarantool spaces and indexes, append nullable fields; fail on drift'
     task :apply do
-      with_schema_client { |client| puts MyApp::SCHEMA.apply(client) }
+      with_schema_client { |client| puts MyApp::SCHEMA.apply(client, alter: [:add_field]) }
     end
   end
 end
@@ -218,7 +277,8 @@ INTEGRATION=1 TARANTOOL_URI=tcp://app:secret@localhost:3302 bundle exec rspec
 
 ## Public API
 
-`Tarantool::Schema::Definition` and the error classes above.
+`Tarantool::Schema::Definition` (`new`, `from_live`, `ensure_space`, `ensure_index`, `plan`, `apply`, `to_h`,
+`to_ruby`) and the error classes above.
 
 Everything else, including anything tagged `@api private` in its source comment, is an implementation detail
 and may change in any release.

data/lib/tarantool/schema/alter.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Schema
+    # What plan and apply may change on a live space besides creating what is missing. Each entry is opted into
+    # by name; nothing here ever drops or rewrites a field or an index.
+    # @api private
+    module Alter
+      ALLOWED = %i[add_field].freeze
+
+      def self.check(list)
+        list = Array(list).map(&:to_sym)
+        unknown = list - ALLOWED
+        return list.freeze if unknown.empty?
+
+        raise ArgumentError, "alter: unknown #{unknown.map(&:inspect).join(', ')}; allowed: #{ALLOWED.join(', ')}"
+      end
+    end
+  end
+end

data/lib/tarantool/schema/comparison.rb

@@ -7,14 +7,16 @@ module Tarantool
     # from the live format.
     # @api private
     class Comparison
-      attr_reader :name, :space, :mismatches, :missing_indexes
+      attr_reader :name, :space, :mismatches, :missing_indexes, :format_additions
 
-      def initialize(name:, indexes:, live:, space: nil)
+      def initialize(name:, indexes:, live:, space: nil, alter: [])
         @name = name
         @space = space
         @live = live
+        @alter = alter
         @mismatches = []
         @missing_indexes = []
+        @format_additions = []
         live ? compare(indexes) : absent(indexes)
       end
 
@@ -37,7 +39,9 @@ module Tarantool
 
       def compare_space
         @mismatches << "engine: declared #{@space.engine}, actual #{@live.engine}" if @space.engine != @live.engine
-        @mismatches.concat(FormatComparison.new(@space.format, @live.format).mismatches)
+        format = FormatComparison.new(@space.format, @live.format, add_field: @alter.include?(:add_field))
+        @mismatches.concat(format.mismatches)
+        @format_additions = format.additions
         compare_primary
       end
 

data/lib/tarantool/schema/creation.rb

@@ -16,6 +16,11 @@ module Tarantool
         box.space[space]:create_index(name, options)
       LUA
 
+      FORMAT_LUA = <<~LUA
+        local name, format = ...
+        box.space[name]:format(format)
+      LUA
+
       Space = Data.define(:spec) do
         def apply(client)
           client.eval(SPACE_LUA, [spec.name.to_s, spec.to_lua.merge('if_not_exists' => true)])
@@ -24,6 +29,15 @@ module Tarantool
         def to_s = "space #{spec.name}"
       end
 
+      # The whole declared format goes out: the live one is a prefix of it, verified before apply.
+      Format = Data.define(:space, :fields) do
+        def apply(client)
+          client.eval(FORMAT_LUA, [space.name.to_s, space.format.map(&:to_lua)])
+        end
+
+        def to_s = "format #{space.name}: add #{fields.map(&:name).join(', ')}"
+      end
+
       Index = Data.define(:space, :spec) do
         def apply(client)
           client.eval(INDEX_LUA, [space.to_s, spec.name.to_s, spec.to_lua.merge('if_not_exists' => true)])

data/lib/tarantool/schema/definition.rb

@@ -14,6 +14,17 @@ module Tarantool
         freeze
       end
 
+      # Every user space as the server has it, or only the named ones. A space the DSL cannot express raises.
+      def self.from_live(client, only: nil)
+        arguments = SpaceLister.call(client, only:).to_h do |name|
+          live = Inspector.call(client, name) || raise(ArgumentError, "space #{name}: not found")
+
+          [name, LiveDefinition.arguments(name, live)]
+        end
+
+        new { arguments.each { |name, space| ensure_space(name, **space) } }
+      end
+
       def ensure_space(name, format:, indexes:, engine: :memtx)
         raise ArgumentError, 'space without name' if name.nil?
 
@@ -40,21 +51,25 @@ module Tarantool
 
       def to_h = @spaces.transform_values(&:to_h)
 
-      def plan(client) = build_plan(client).verify.creations.map(&:to_s)
+      def to_ruby = Source.render(to_h, @external.transform_values { |indexes| indexes.map(&:to_h) })
+
+      # alter: lists the changes to live spaces that are allowed besides creating what is missing, see Alter.
+      def plan(client, alter: []) = build_plan(client, Alter.check(alter)).verify.creations.map(&:to_s)
 
       # The second plan re-reads everything, so a space another deploy created differently in the meantime fails
       # here instead of being reported as created.
-      def apply(client)
-        creations = build_plan(client).verify.creations
+      def apply(client, alter: [])
+        alter = Alter.check(alter)
+        creations = build_plan(client, alter).verify.creations
         creations.each { |creation| creation.apply(client) }
-        build_plan(client).verify(complete: true)
+        build_plan(client, alter).verify(complete: true)
 
         creations.map(&:to_s)
       end
 
       private
 
-      def build_plan(client) = Plan.new(spaces: @spaces, external: @external, client:)
+      def build_plan(client, alter) = Plan.new(spaces: @spaces, external: @external, client:, alter:)
 
       # A space declared elsewhere already has its primary key, so an index added here never gets a sequence.
       def add_external(space, index)

data/lib/tarantool/schema/format_comparison.rb

@@ -2,14 +2,17 @@
 
 module Tarantool
   module Schema
-    # Differences between a declared format and the live one, field by field in order.
+    # Differences between a declared format and the live one, field by field in order. With add_field, declared
+    # fields past the end of a matching live format are additions instead of a mismatch, as long as they are
+    # nullable: Tarantool rejects a longer format otherwise while the space holds tuples.
     # @api private
     class FormatComparison
       ATTRIBUTES = %i[name type is_nullable].freeze
 
-      def initialize(declared, live)
+      def initialize(declared, live, add_field: false)
         @declared = declared
         @live = live
+        @add_field = add_field
       end
 
       def mismatches
@@ -17,15 +20,33 @@ module Tarantool
           live ? field_mismatches(index + 1, declared, live) : []
         end
 
-        count_mismatch + fields
+        count_mismatch(fields.empty?) + fields
+      end
+
+      # The declared fields to append, when that is allowed and the live format is a matching prefix.
+      def additions
+        return [] unless @add_field && mismatches.empty? && @live.size < @declared.size
+
+        extra
       end
 
       private
 
-      def count_mismatch
+      def extra = @declared.drop(@live.size)
+
+      def count_mismatch(prefix_matches)
         return [] if @declared.size == @live.size
+        return [] if prefix_matches && @add_field && @live.size < @declared.size && extra.all?(&:is_nullable)
 
-        ["format: declared #{@declared.size} fields, actual #{@live.size}"]
+        ["format: declared #{@declared.size} fields, actual #{@live.size}"] + addition_hints
+      end
+
+      def addition_hints
+        return [] unless @add_field && @live.size < @declared.size
+
+        extra.reject(&:is_nullable).map do |field|
+          "field #{@declared.index(field) + 1} #{field.name}: must be is_nullable: true to be added"
+        end
       end
 
       def field_mismatches(number, declared, live)

data/lib/tarantool/schema/inspector.rb

@@ -17,7 +17,7 @@ module Tarantool
                                    path = part.path})
             end
             table.insert(indexes, {id = id, name = index.name, type = index.type, unique = index.unique,
-                                   parts = parts, sequence = index.sequence_id ~= nil})
+                                   parts = parts, sequence = index.sequence_id ~= nil, func = index.func ~= nil})
           end
         end
         return {engine = space.engine, format = space:format(), indexes = indexes}

data/lib/tarantool/schema/live_definition.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Schema
+    # The ensure_space arguments that declare a live space as it is. A part is written as a bare field name when
+    # it inherits everything from the field, so the result reads like a hand-written declaration.
+    # @api private
+    module LiveDefinition
+      module_function
+
+      def arguments(name, live)
+        fields = live.fields
+
+        { engine: live.engine, format: live.format.map(&:to_h),
+          indexes: live.indexes.map { |index| index_arguments(name, index, fields) } }
+      end
+
+      def index_arguments(space, index, fields)
+        raise ArgumentError, "space #{space}: index #{index.name} is functional, not supported" if index.func
+
+        { name: index.name, type: index.type, unique: index.unique, sequence: index.sequence,
+          parts: index.parts.map { |part| part_argument(space, index, part, fields) } }
+      end
+
+      def part_argument(space, index, part, fields)
+        field = fields[part.field]
+        raise ArgumentError, "space #{space}: index #{index.name}: part #{part.field} is beyond the format" unless field
+
+        part.path ? path_part(part, field) : plain_part(part, field)
+      end
+
+      def plain_part(part, field)
+        differing = { type: part.type, is_nullable: part.is_nullable }.reject { |key, value| field.send(key) == value }
+
+        differing.empty? ? part.field : { field: part.field, **differing }
+      end
+
+      # A path part always declares its type; nullability still inherits from the field.
+      def path_part(part, field)
+        nullable = part.is_nullable == field.is_nullable ? {} : { is_nullable: part.is_nullable }
+
+        { field: part.field, type: part.type, **nullable, path: part.path }
+      end
+    end
+  end
+end

data/lib/tarantool/schema/live_space.rb

@@ -23,10 +23,10 @@ module Tarantool
       def fields = format.to_h { |field| [field.name, field] }
     end
 
-    LiveSpace::Index = Data.define(:id, :name, :type, :unique, :parts, :sequence) do
+    LiveSpace::Index = Data.define(:id, :name, :type, :unique, :parts, :sequence, :func) do
       def self.from_eval(raw, format)
         new(id: raw.fetch('id'), name: raw.fetch('name').to_sym, type: raw.fetch('type').downcase,
-            unique: raw.fetch('unique'), sequence: raw.fetch('sequence'),
+            unique: raw.fetch('unique'), sequence: raw.fetch('sequence'), func: raw.fetch('func', false),
             parts: Array(raw['parts']).map { |part| part_from_eval(part, format) })
       end
 

data/lib/tarantool/schema/plan.rb

@@ -5,7 +5,8 @@ module Tarantool
     # The live state of everything a definition declares, compared with it, and what is left to create.
     # @api private
     class Plan
-      def initialize(spaces:, external:, client:)
+      def initialize(spaces:, external:, client:, alter: [])
+        @alter = alter
         @comparisons = spaces.values.map { |space| compare(client, space.name, space.indexes, space) } +
                        external.map { |name, indexes| compare(client, name, indexes) }
       end
@@ -21,24 +22,33 @@ module Tarantool
         self
       end
 
+      # Per space: the space itself or its format change, then its indexes, so an index on a new field works.
       def creations
         @comparisons.flat_map do |comparison|
-          space = comparison.missing_space? ? [Creation::Space.new(spec: comparison.space)] : []
-
-          space + comparison.missing_indexes.map { |index| Creation::Index.new(space: comparison.name, spec: index) }
+          space_creation(comparison) +
+            comparison.missing_indexes.map { |index| Creation::Index.new(space: comparison.name, spec: index) }
         end
       end
 
       private
 
+      def space_creation(comparison)
+        return [Creation::Space.new(spec: comparison.space)] if comparison.missing_space?
+        return [] if comparison.format_additions.empty?
+
+        [Creation::Format.new(space: comparison.space, fields: comparison.format_additions)]
+      end
+
       def compare(client, name, indexes, space = nil)
-        Comparison.new(name:, indexes:, live: Inspector.call(client, name), space:)
+        Comparison.new(name:, indexes:, live: Inspector.call(client, name), space:, alter: @alter)
       end
 
       def still_missing(comparison)
         return ['missing after apply'] if comparison.missing_space?
 
-        comparison.missing_indexes.map { |index| "index #{index.name}: missing after apply" }
+        format = comparison.format_additions.empty? ? [] : ['format: fields missing after apply']
+
+        format + comparison.missing_indexes.map { |index| "index #{index.name}: missing after apply" }
       end
     end
   end

data/lib/tarantool/schema/source.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Schema
+    # Ruby source of a definition, from its normalized Hash: a Definition.new block with one ensure_space per
+    # space and one ensure_index per index on a space declared elsewhere. Defaults are left out and a part that
+    # inherits everything from its field is a bare name, so the result reads like a hand-written declaration.
+    # @api private
+    module Source
+      WIDTH = 120
+      ARGUMENT_INDENT = ' ' * 15
+      ENTRY_INDENT = ' ' * 17
+
+      module_function
+
+      def render(spaces, external)
+        entries = spaces.map { |name, space| space(name, space) }
+        entries += external.map { |name, indexes| indexes(name, indexes) }
+
+        "Tarantool::Schema::Definition.new do\n#{entries.join("\n\n")}#{"\n" if entries.any?}end\n"
+      end
+
+      def space(name, space)
+        fields = space[:format].to_h { |field| [field[:name], field] }
+        format = list('format', space[:format].map { |field| field(field) })
+        indexes = list('indexes', space[:indexes].map { |index| index(index, fields) })
+
+        "  ensure_space #{symbol(name)},\n#{engine(space)}#{format},\n#{indexes}"
+      end
+
+      def engine(space) = space[:engine] == 'memtx' ? '' : "#{ARGUMENT_INDENT}engine: #{symbol(space[:engine])},\n"
+
+      def indexes(space, indexes)
+        indexes.map { |index| "  ensure_index #{symbol(space)}, #{symbol(index[:name])}, #{options(index, {})}" }
+               .join("\n")
+      end
+
+      def list(key, entries)
+        "#{ARGUMENT_INDENT}#{key}: [\n#{entries.map { |entry| ENTRY_INDENT + entry }.join(",\n")}\n#{ARGUMENT_INDENT}]"
+      end
+
+      def field(field)
+        nullable = field[:is_nullable] ? ', is_nullable: true' : ''
+
+        "{ name: #{symbol(field[:name])}, type: #{symbol(field[:type])}#{nullable} }"
+      end
+
+      def index(index, fields)
+        line = "{ name: #{symbol(index[:name])}, #{options(index, fields)} }"
+        return line if ENTRY_INDENT.size + line.size <= WIDTH
+
+        wrapped_index(index, fields)
+      end
+
+      def wrapped_index(index, fields)
+        indent = "#{ENTRY_INDENT}  "
+        parts = index[:parts].map { |part| "#{indent}  #{part(part, fields)}" }.join(",\n")
+        head = "{ name: #{symbol(index[:name])},#{type_option(index).rstrip}"
+        tail = [unique_option(index), sequence_option(index)].join
+
+        "#{head}\n#{indent}parts: [\n#{parts}\n#{indent}]#{tail} }"
+      end
+
+      def options(index, fields)
+        parts = index[:parts].map { |part| part(part, fields) }.join(', ')
+
+        "#{type_option(index).lstrip}parts: [#{parts}]#{unique_option(index)}#{sequence_option(index)}"
+      end
+
+      def type_option(index) = index[:type] == 'tree' ? ' ' : " type: #{symbol(index[:type])}, "
+
+      def unique_option(index) = index[:unique] ? '' : ', unique: false'
+
+      def sequence_option(index) = index[:sequence] ? ', sequence: true' : ''
+
+      # Unresolved parts (external indexes) carry nil for what they inherit; resolved ones repeat the field.
+      def part(part, fields)
+        options = part_options(part, fields[part[:field]])
+        return symbol(part[:field]) if options.empty? && part[:path].nil?
+
+        "{ field: #{symbol(part[:field])}, #{options.map { |key, value| "#{key}: #{value}" }.join(', ')} }"
+      end
+
+      # A path part always declares its type; everything else is written only when it differs from the field.
+      def part_options(part, field)
+        options = differing(part, field)
+        options[:type] = part[:type] if part[:path]
+        options = options.sort_by { |key, _| key == :type ? 0 : 1 }.to_h { |key, value| [key, literal(value)] }
+        options[:path] = string(part[:path]) if part[:path]
+
+        options
+      end
+
+      def differing(part, field)
+        options = { type: part[:type], is_nullable: part[:is_nullable] }.compact
+        return options unless field
+
+        options.reject { |key, value| field[key] == value }
+      end
+
+      def literal(value) = value.is_a?(String) ? symbol(value) : value.to_s
+
+      def symbol(name) = name.to_sym.inspect
+
+      def string(value) = value.match?(/['\\]/) ? value.inspect : "'#{value}'"
+    end
+  end
+end

data/lib/tarantool/schema/space_lister.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Tarantool
+  module Schema
+    # Names of the spaces an application owns: ids past the system range, names without a leading underscore
+    # (vshard's _bucket, crud's _ddl_* stay out). An explicit list skips the server.
+    # @api private
+    module SpaceLister
+      LUA = <<~LUA
+        local names = {}
+        for _, space in box.space._space:pairs(box.schema.SYSTEM_ID_MAX + 1, {iterator = 'GE'}) do
+          if not space.name:match('^_') then table.insert(names, space.name) end
+        end
+        return names
+      LUA
+
+      def self.call(client, only: nil)
+        return only.map(&:to_sym) if only
+
+        Array(client.eval(LUA).first).map(&:to_sym)
+      end
+    end
+  end
+end

data/lib/tarantool/schema/version.rb

@@ -2,6 +2,6 @@
 
 module Tarantool
   module Schema
-    VERSION = '0.1.0'
+    VERSION = '0.2.0'
   end
 end

data/lib/tarantool/schema.rb

@@ -5,6 +5,7 @@ require 'tarantool/client'
 require_relative 'schema/version'
 require_relative 'schema/errors'
 require_relative 'schema/options'
+require_relative 'schema/alter'
 require_relative 'schema/types'
 require_relative 'schema/key_rules'
 require_relative 'schema/field_spec'
@@ -16,6 +17,9 @@ require_relative 'schema/plan'
 require_relative 'schema/definition'
 require_relative 'schema/live_space'
 require_relative 'schema/inspector'
+require_relative 'schema/space_lister'
+require_relative 'schema/live_definition'
+require_relative 'schema/source'
 require_relative 'schema/format_comparison'
 require_relative 'schema/index_comparison'
 require_relative 'schema/comparison'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tarantool-schema
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Starlexxx
@@ -37,6 +37,7 @@ files:
 - LICENSE
 - README.md
 - lib/tarantool/schema.rb
+- lib/tarantool/schema/alter.rb
 - lib/tarantool/schema/comparison.rb
 - lib/tarantool/schema/creation.rb
 - lib/tarantool/schema/definition.rb
@@ -47,10 +48,13 @@ files:
 - lib/tarantool/schema/index_spec.rb
 - lib/tarantool/schema/inspector.rb
 - lib/tarantool/schema/key_rules.rb
+- lib/tarantool/schema/live_definition.rb
 - lib/tarantool/schema/live_space.rb
 - lib/tarantool/schema/options.rb
 - lib/tarantool/schema/part_spec.rb
 - lib/tarantool/schema/plan.rb
+- lib/tarantool/schema/source.rb
+- lib/tarantool/schema/space_lister.rb
 - lib/tarantool/schema/space_rules.rb
 - lib/tarantool/schema/space_spec.rb
 - lib/tarantool/schema/types.rb