cassie 1.0.6.pre2 → 1.1.0.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e87e9f31fbcda1c157ea0ab6ab1448979b4c4fdc
-  data.tar.gz: 8d502e415d094a962000ef91d2d1b01a7372e6cd
+  metadata.gz: 16ae8e8e9728e84b78a102b1a42937d89ee9249f
+  data.tar.gz: 72e87ae44eab6a96c566af3c1835beaa35c194f3
 SHA512:
-  metadata.gz: b4f85555049d4ee14ca32bd328f58be26ae9a8e65a076087818076f17c78700db94f2a52570f96a8d07465dc57336945825958c40e030cd09e47440afe03370d
-  data.tar.gz: b9a2c4dd0851603c55f0e1aa7ebe083a13ab3d1d6f0f6b6172a92f3ac2fd4b68ad3ec3bd84f697327cc07bfdaae4058a377f30e8db7de88cdf8a954689c99240
+  metadata.gz: 994a3b26d1093f06a7004d74f75936e77a56fd34eba323891b6e5e6637a620fcd26bb50bfb128b1cd9e24fea61603b82d391a101b54118203ae4a47883034420
+  data.tar.gz: c4fa532a24ad9b1c9149c03394e66bc6e1fc1ef1738f57a6d43e6d13ebad5741e046bb4ebd197a5d81cbe8ce2090a16e4a23c084ff8481e03b779ac7af3abc52

data/lib/cassie/schema/README.md

@@ -65,7 +65,7 @@ cassie migrations:import
    - done
 -- done
 -- Dumping Cassandra schema (version 0.0.0.1)
-   - Writing to db/cassandra/schema.cql
+   - Writing to db/cassandra/schema.rb
    - done
 -- done
 ```
@@ -93,11 +93,35 @@ cassie schema:import
    - done
 -- done
 -- Dumping Cassandra schema (version 0.0.1.0)
-   - Writing to db/cassandra/schema.cql
+   - Writing to db/cassandra/schema.rb
    - done
 -- done
 ```
 
+##### Initializing versioning
+
+Locally, these import tasks will also initialiaze the local version tracking to have all migration versions recorded.
+
+However, another developer's or environment's database does not have this schema metadata. Syncronize version tracking by initializing cassie schema with the version of the current in-database schema.
+
+```
+cassie schema:init -v 0.0.2.0
+```
+
+```
+-- Initializing Cassie Versioning
+-- done
+-- Fast-forwarding to version 0.0.2.0
+   > Recorded version 0.0.0.1
+   > Recorded version 0.0.1.0
+   > Recorded version 0.0.2.0
+-- done
+-- Initializing 'cassie_development' Keyspace
+-- done
+```
+
+This does not run any migrations, but rather updates schema version metadata, so future migrations begin after the provided version.
+
 #### Creating a migration
 
 ```
@@ -180,36 +204,40 @@ cassie schema:history
 ```
 
 #### Reporting the version status
+
+Display all applied and unapplied migrations.
+
 ```
 cassie schema:status
 ```
 ```
-+-----------+----------------+-------------+---------------------------+
-|  Version  | Description    |   Status    | Migration File            |
-+-----------+----------------+-------------+---------------------------+
-| * 0.2.0.0 |  create users  | serverbot   | 2016-09-08 10:23:54 -0500 |
-|   0.1.0.0 | initial schema | eprothro    | 2016-09-08 09:23:54 -0500 |
-+-----------+----------------+-------------+---------------------------+
++-----------+----------------+--------+---------------------------------------------------------------+
+| Number    | Description    | Status | Migration File                                                |
++-----------+----------------+--------+---------------------------------------------------------------+
+|   0.0.3.0 | create friends |  DOWN  | db/cassandra/migrations/0000_0000_0003_0000_create_friends.rb |
+| * 0.0.2.0 | create users   |   UP   | db/cassandra/migrations/0000_0000_0002_0000_create_users.rb   |
+|   0.1.0.0 | initial schema |   UP   | db/cassandra/migrations/0000_0000_0001_0000_initial_schema.rb |
++-----------+----------------+--------+---------------------------------------------------------------+
 ```
 
 ### Schema Management
 
-The full schema is stored in `schema.cql`, this is recommended to be checked into source control.
+The full schema is stored in `schema.rb`, this is recommended to be checked into source control.
 It is updated (with a full dump) after each migration, to maintain a truth-store for the schema when used with multiple developers.
 
-### Dump the schema
+#### Dump the schema
 
 ```
 cassie schema:dump
 ```
 ```
 -- Dumping Cassandra schema (version 0.2.0.0)
-   - Writing to db/cassandra/schema.cql
+   - Writing to db/cassandra/schema.rb
    - done
 -- done
 ```
 
-### Drop the schema
+#### Drop the schema
 ```
 cassie schema:drop
 ```
@@ -222,17 +250,17 @@ cassie schema:drop
 -- done
 ```
 
-### Load the schema
+#### Load the schema
 ```
 cassie schema:load
 ```
 ```
--- Loading Schema from db/cassandra/schema.cql
+-- Loading Schema from db/cassandra/schema.rb
    > Schema is now at version 0.2.0.0
 -- done
 ```
 
-### Reset the schema
+#### Reset the schema
 
 ```
 cassie schema:reset
@@ -244,12 +272,12 @@ cassie schema:reset
    - Dropping 'cassie_schema'
    - done
 -- done
--- Loading Schema from db/cassandra/schema.cql
+-- Loading Schema from db/cassandra/schema.rb
    > Schema is now at version 0.2.0.0
 -- done
 ```
 
-### Reset the schema and migrate
+#### Reset the schema and migrate
 
 This task reload the schema from the schema file, and then proceeds with incremental migrations up to the latest migration.
 
@@ -263,7 +291,7 @@ cassie migrate:reset
    - Dropping 'cassie_schema'
    - done
 -- done
--- Loading Schema from db/cassandra/schema.cql
+-- Loading Schema from db/cassandra/schema.rb
    > Schema is now at version 0.2.0.0
 -- done
 -- Migrating to version 0.2.1.0
@@ -271,12 +299,25 @@ cassie migrate:reset
    - done (4.89 ms)
 -- done
 -- Dumping Cassandra schema (version 0.2.1.0)
-   - Writing to db/cassandra/schema.cql
+   - Writing to db/cassandra/schema.rb
    - done
 -- done
 ```
 
-### Architecture (`cassie` developers)
+### Multiple Envrionments
+
+Set the environment with `RACK_ENV`, `CASSANDRA_ENV` or the `--env`(`-e`) switch for `cassie` commands:
+
+```
+RACK_ENV=test cassie migrate:reset
+```
+is equivalent to
+```
+cassie migrate:reset -e test
+```
+
+
+### Version / Migration Architecture (`cassie` developers)
 
 #### Versions
 

data/lib/cassie/schema/configuration.rb

@@ -11,7 +11,7 @@ module Cassie::Schema
 
     # @!visibility private
     def self.extended(extender)
-      extender.paths["schema_file"] = "db/cassandra/schema.cql"
+      extender.paths[:schema_file] = "db/cassandra/schema.rb"
       extender.paths[:migrations_directory] = "db/cassandra/migrations"
       extender.schema_keyspace = "cassie_schema"
       extender.versions_table = "versions"
@@ -20,7 +20,7 @@ module Cassie::Schema
     # Paths used for configuration loading.
     #
     # @return [Hash]
-    #   * +:schema_file+ - The .cql file defining the current schema structure
+    #   * +:schema_file+ - The .rb file defining the current schema structure
     #   * +:migrations_directory+ - The directory containing the versioned schema migration .rb files
     def paths
       @paths ||= {}.with_indifferent_access

data/lib/cassie/schema/definition/dsl.rb

@@ -0,0 +1,43 @@
+module Cassie::Schema
+  module Definition
+
+    # DSL for Cassie::Schema Defintion
+    # these methods can be called in a schema.rb
+    # file to define keyspace agnostic schema.
+    # When executed, they will then create that schema
+    # for the currently defined default keyspace found
+    # in +Cassie.configuration[:keyspace]+.
+    class DSL
+      class << self
+
+        # The default keyspace according to the
+        # cluster configuration in +Cassie.configuration[:keyspace]+
+        # @return [String] the keyspace name
+        def default_keyspace
+          Cassie.configuration[:keyspace]
+        end
+
+        # Execute the given CQL on the current cluster, using an
+        # unscoped session. CQL should be keyspace agnostic, where
+        # keyspace names are interpolated with the +#{default_keyspace}+.
+        # Table names must be fully qualified.
+        # @return [Cassandra::Result] the result of execution
+        def create_schema(cql)
+          cql.strip.split(";").each do |statement|
+            Cassie.session(nil).execute("#{statement.strip};")
+          end
+        end
+
+        def record_version(number, description, uuid, executor, executed_at_utc)
+          id = Cassandra::TimeUuid.new(uuid)
+          executed_at = DateTime.parse(executed_at_utc) rescue nil
+          version = Version.new(number, description, id, executor, executed_at)
+
+          Cassie::Schema.initialize_versioning
+
+          Cassie::Schema.record_version(version)
+        end
+      end
+    end
+  end
+end

data/lib/cassie/schema/definition.rb

@@ -0,0 +1,14 @@
+module Cassie::Schema
+
+  # Extend Defintion to get the +define+ class method
+  # used to define schema for a cassandra cluster
+  module Definition
+    require_relative 'definition/dsl'
+
+    def define(&block)
+      raise "block required to define schema." unless block_given?
+
+      DSL.instance_eval(&block)
+    end
+  end
+end

data/lib/cassie/schema/migrator.rb

@@ -11,6 +11,7 @@ module Cassie::Schema
 
 
     def initialize(target)
+      puts target
       @target_version   = build_target_version(target)
       @current_version  = Cassie::Schema.version
       @direction        = build_direction
@@ -60,6 +61,9 @@ module Cassie::Schema
         duration = Benchmark.realtime do
           yield(command)
         end
+        # Sleep for 50ms to ensure TimeUuid generation jitter
+        # doesn't cause out-of-order records
+        sleep(0.050)
         after_each.call(command.version, (duration*1000).round(2))
       end
     end

data/lib/cassie/schema/queries/create_versions_table_query.rb

@@ -4,14 +4,15 @@ module Cassie::Schema
 
     def statement
       %(
-         CREATE TABLE #{Cassie::Schema.versions_table} (
-           bucket int,
+         CREATE TABLE IF NOT EXISTS #{Cassie::Schema.versions_table} (
+           application text,
+           env text,
            id timeuuid,
            number text,
            description text,
            executor text,
            executed_at timestamp,
-           PRIMARY KEY (bucket, id)
+           PRIMARY KEY ((application, env), id)
          ) WITH CLUSTERING ORDER BY (id DESC);
         )
     end

data/lib/cassie/schema/queries/delete_version_query.rb

@@ -1,13 +1,26 @@
 module Cassie::Schema
   class DeleteVersionQuery < Cassie::Modification
-
+    attr
     delete_from Cassie::Schema.versions_table
 
-    where :id, :eq
-    where :bucket, :eq
+    where :id, :eq, if: :id?
+    where :env, :eq
+    where :application, :eq
+
+    def id?
+      !!self.id
+    end
+
+    def env
+      #setting #env should win
+      return @env if defined?(@env)
+      Cassie.env
+    end
 
-    def bucket
-      0
+    def application
+      #setting #env should win
+      return @application if defined?(@application)
+      Cassie::Schema.application
     end
 
     def keyspace

data/lib/cassie/schema/queries/insert_version_query.rb

@@ -7,7 +7,8 @@ module Cassie::Schema
 
     insert_into "#{Cassie::Schema.schema_keyspace}.#{Cassie::Schema.versions_table}"
 
-    set :bucket
+    set :application
+    set :env
     set :id
     set :number
     set :description
@@ -16,8 +17,12 @@ module Cassie::Schema
 
     map_from :version
 
-    def bucket
-      0
+    def env
+      Cassie.env
+    end
+
+    def application
+      Cassie::Schema.application
     end
 
     def executed_at?

data/lib/cassie/schema/queries/select_versions_query.rb

@@ -3,6 +3,17 @@ module Cassie::Schema
 
     select_from Cassie::Schema.versions_table
 
+    where :application, :eq
+    where :env, :eq
+
+    def env
+      Cassie.env
+    end
+
+    def application
+      Cassie::Schema.application
+    end
+
     def build_result(row)
       Version.new(row["number"],
                   row["description"],

data/lib/cassie/schema/schema_dumper.rb

@@ -0,0 +1,125 @@
+module Cassie::Schema
+  require_relative 'queries'
+
+  class SchemaDumper
+    # The location to dump the ruby file
+    attr_reader :destination_path
+
+    # The keyspace that will be extracted
+    # and replaced with +#{default_keyspace}+ upon dumping
+    attr_reader :keyspace
+
+    def initialize(opts={})
+      @destination_path = opts[:destination_path] || default_destination_path
+      @keyspace = Cassie.configuration[:keyspace]
+    end
+
+    # The stream to dump the source to
+    def stream
+      @stream ||= begin
+        prepare_stream
+        File.open(destination_path, "w+")
+      end
+    end
+
+    # Dump the CQL for the current environment's keyspace,
+    # the schema metadata keyspace, and the versions rows
+    # that are currently in the schema versions table.
+    def dump
+      stream << <<-EOS
+# This file describes the keyspace-agnostic schema
+# for this application's environments.
+#
+# It is the definitive source of the current state
+# of the schema and should not be modified directly.
+#
+# It is strongly recommened that this schema file be checked into source control.
+#
+# Use `cassie` commands to apply this schema to a particular environment:
+# * Load this schema with `cassie schema:load`
+# * Reset the schema to this definition with `cassie schema:reset`
+Cassie::Schema.define do
+
+EOS
+      stream << "  create_schema <<-EOS\n"
+      stream << "#{keyspace_agnostic_cql}\n"
+      stream << "EOS\n"
+      stream << "\n\n"
+      versions.each do |v|
+        stream << "  record_version #{version_arg_str(v)}\n"
+      end
+      stream << "end\n"
+
+      close_stream
+    end
+
+    def versions_table_name
+      "#{Cassie::Schema.schema_keyspace}.#{Cassie::Schema.versions_table}"
+    end
+
+    def destination_path
+      @destination_path || raise("Unconfigured schema file path: `Cassie::Schema.paths[:schema_file]` is empty")
+    end
+
+    protected
+
+    # Fetch the keyspace agnostic CQL ruby string that can be used to
+    # recreate the keyspace. The keyspace value is replaced
+    # with +#{default_keyspace}+
+    # @return [String] A ruby string with keyspace interpolated CQL commands
+    # @raise [RuntimeError] if the {Cassie.configuration[:keyspace]} keyspace could not be described.
+    def keyspace_agnostic_cql
+      @keyspace_structure ||= begin
+        args = ["-e", "'DESCRIBE KEYSPACE #{keyspace}'"]
+        runner = Cassie::Support::SystemCommand.new("cqlsh", args)
+        runner.succeed
+
+        runner.output.gsub(keyspace, '#{default_keyspace}').strip
+      end
+    end
+
+    def versions
+      @versions ||= begin
+        versions_query.fetch
+      rescue Cassandra::Errors::InvalidError => e
+        log_versions_not_found(e)
+        []
+      end
+    end
+
+    def versions_query
+      SelectVersionsQuery.new
+    end
+
+    def default_destination_path
+      Cassie::Schema.paths[:schema_file]
+    end
+
+    def prepare_stream
+      dir = File.dirname(destination_path)
+      Dir.mkdir(dir) unless File.directory?(dir)
+    end
+
+    def close_stream
+      stream.close
+      @stream = nil
+    end
+
+    def log_versions_not_found(error)
+      msg = "WARNING: Cassie Schema Versions table not found at '#{versions_table_name}'. Initialize your schema with `cassie schema:init` or `cassie:migrations:import` for versioned migration support."
+      msg << "\n\t- "
+      msg << error.message.split("\n").join("\n\t- ")
+      logger.warn(msg)
+    end
+
+    def logger
+      Cassie.logger
+    end
+
+    def version_arg_str(version)
+      <<-EOS.strip
+"#{version}", "#{version.description}", "#{version.id}", "#{version.executor}", "#{version.executed_at.try(:iso8601, 6)}"
+EOS
+    end
+  end
+end

data/lib/cassie/schema/schema_loader.rb

@@ -0,0 +1,20 @@
+module Cassie::Schema
+ class SchemaLoader
+   attr_reader :source_path
+
+
+  def initialize(opts={})
+    @source_path = opts[:source_path] || default_source_path
+  end
+
+  def load
+    Kernel.load File.absolute_path(source_path)
+  end
+
+  protected
+
+  def default_source_path
+    Cassie::Schema.paths[:schema_file]
+  end
+ end
+end

data/lib/cassie/schema/structure_dumper.rb

@@ -33,17 +33,7 @@ module Cassie::Schema
     # an empty string is returned.
     # @return [String] CQL commands
     def schema_meta_structure
-      @schema_meta_structure ||= begin
-        args = ["-e", "'DESCRIBE KEYSPACE #{Cassie::Schema.schema_keyspace}'"]
-        runner = Cassie::Support::SystemCommand.new("cqlsh", args)
-        runner.run
-
-        if runner.success?
-          runner.output
-        else
-          ""
-        end
-      end
+      CreateVersionsTableQuery.new.to_cql
     end
 
     def versions

data/lib/cassie/schema/versioning.rb

@@ -30,11 +30,10 @@ module Cassie::Schema
     end
 
     # Create the keyspace and table for tracking schema versions
-    # in the Cassandra database
+    # in the Cassandra database if they don't already exist
     # @return [void]
     def initialize_versioning
       create_schema_keyspace unless keyspace_exists?
-      raise Cassie::Schema::AlreadyInitiailizedError if version_exists?
       create_versions_table unless versions_table_exists?
     end
 
@@ -119,7 +118,7 @@ module Cassie::Schema
       database_versions.tap do |versions|
         versions.each{|v| VersionObjectLoader.new(v).load }
       end
-    rescue Cassandra::Errors::InvalidError
+    rescue Cassandra::Errors::InvalidError => e
       raise uninitialized_error
     end
 

data/lib/cassie/schema.rb

@@ -14,11 +14,28 @@ module Cassie
   module Schema
     require_relative 'schema/configuration'
     require_relative 'schema/versioning'
+    require_relative 'schema/definition'
 
     extend Configuration
     extend Versioning
+    extend Definition
+
+    # The application namespace. Only applicaple
+    # When cassie manages multiple applicaiton
+    # schemas within the same cluster.
+    # @return [String] the application namespace
+    def self.application
+      return @application if defined?(@application)
+      "global"
+    end
+
+    def self.application=(app_name)
+      @application = app_name
+    end
   end
 
   require_relative 'schema/structure_dumper'
   require_relative 'schema/structure_loader'
+  require_relative 'schema/schema_loader'
+  require_relative 'schema/schema_dumper'
 end

data/lib/cassie/tasks/schema/drop.rake

@@ -5,19 +5,24 @@ namespace :cassie do
       include Cassie::Tasks::IO
       begin
         query = Cassie::Schema::DropKeyspaceQuery.new
-        keyspaces = [Cassie.configuration[:keyspace], Cassie::Schema.schema_keyspace]
+        keyspaces = [Cassie.configuration[:keyspace]]
 
-        puts "-- Dropping #{keyspaces.count} keyspaces"
+        puts "-- Dropping '#{Cassie.env}' schema"
         keyspaces.each do |keyspace|
           query.keyspace = keyspace
           puts "   - Dropping '#{keyspace}'"
           if Cassie.keyspace_exists?(keyspace)
-            query.execute
+            query.execute!
           else
             puts "     > '#{keyspace}' does not exist"
           end
           puts "   - done"
         end
+        puts "   - Clearning schema version metadata"
+          count = Cassie::Schema.applied_versions.count
+          Cassie::Schema::DeleteVersionQuery.new.execute!
+          puts "     > removed #{count} #{'version'.pluralize(count)}"
+        puts "   - done"
         puts "-- done"
       rescue => e
         output_error(e)

data/lib/cassie/tasks/schema/dump.rake

@@ -1,12 +1,12 @@
 namespace :cassie do
   namespace :schema do
-    desc "Dumps the schema for all non-system keyspaces in CQL format (`db/cassandra/schema.cql` by default)"
+    desc "Dumps the schema for configured keyspace into schema file (`db/cassandra/schema.rb` by default)"
     task :dump do
       include Cassie::Tasks::IO
 
       begin
-        puts "-- Dumping Cassandra schema (version #{Cassie::Schema.version})"
-        dumper = Cassie::Schema::StructureDumper.new
+        puts "-- Dumping '#{Cassie.env}' schema (version #{Cassie::Schema.version})"
+        dumper = Cassie::Schema::SchemaDumper.new
         puts "   - Writing to #{dumper.destination_path}"
         dumper.dump
         puts "   - done"

data/lib/cassie/tasks/schema/load.rake

@@ -1,14 +1,14 @@
 namespace :cassie do
   namespace :schema do
-    desc "Creates the schema by executing the CQL in the schema file (`db/cassandra/schema.cql` by default)"
+    desc "Creates the schema by executing the schema file (`db/cassandra/schema.rb` by default)"
     task :load do
       include Cassie::Tasks::IO
 
       begin
-        loader = Cassie::Schema::StructureLoader.new
-        puts "-- Loading Schema from #{loader.source_path}"
+        loader = Cassie::Schema::SchemaLoader.new
+        puts "-- Loading '#{Cassie.env}' Schema from #{loader.source_path}"
         loader.load
-        puts "   > Schema is now at version #{Cassie::Schema.version}"
+        puts "   > '#{Cassie.env}' schema is now at version #{Cassie::Schema.version}"
         puts "-- done"
       rescue => e
         output_error(e)

data/lib/cassie/tasks/schema/migrate.rake

@@ -8,7 +8,7 @@ namespace :cassie do
         version = argv[0]
 
         migrator = Cassie::Schema::Migrator.new(version)
-        puts "-- Migrating to version #{migrator.target_version}"
+        puts "-- Migrating '#{Cassie.env}' schema to version #{migrator.target_version}"
 
         if migrator.commands.count == 0
           if migrator.target_version == migrator.current_version

data/lib/cassie/tasks/schema/reset.rake

@@ -1,6 +1,6 @@
 namespace :cassie do
   namespace :schema do
-    desc "Creates the schema by executing the CQL in the schema file (`db/cassandra/schema.cql` by default)"
+    desc "Creates the schema by executing the schema file (`db/cassandra/schema.rb` by default)"
     task :reset => [:drop, :load]
   end
 end

data/lib/cassie/tasks/schema/version_display.rb

@@ -9,8 +9,9 @@ module Cassie::Tasks
         # Note: if we end up using this elsewhere, move to Version::VersionList
         # or something simliar, and have version collection methods return that
         members = [:number, :description, :executor, :executed_at]
-        titles  = ['Number', 'Description', 'Migrated by', 'Migrated at']
-        table = Terminal::Table.new(headings:  titles)
+        headings  = ['Number', 'Description', 'Migrated by', 'Migrated at']
+        title = "Environment: #{Cassie.env}"
+        table = Terminal::Table.new(headings:  headings, title: title)
         current_version = Cassie::Schema.version
 
         versions.each.with_index do |v|
@@ -19,6 +20,7 @@ module Cassie::Tasks
           row[0] = "* #{row[0]}" if v == current_version
           row[1] = v.description
           row[2] = v.executor
+          row[3] = v.executed_at
           row[3] ||= "Unknown"
           table.add_row(row)
         end
@@ -30,8 +32,9 @@ module Cassie::Tasks
       def print_statuses(versions)
         # Note: if we end up using this elsewhere, move to Version::VersionList
         # or something simliar, and have version collection methods return that
-        titles  = ['Number', 'Description', 'Status', 'Migration File']
-        table = Terminal::Table.new(headings:  titles)
+        headings  = ['Number', 'Description', 'Status', 'Migration File']
+        title = "Environment: #{Cassie.env}"
+        table = Terminal::Table.new(headings:  headings, title: title)
         current_version = Cassie::Schema.version
 
         versions.each.with_index do |v|

data/lib/cassie/tasks.rb

@@ -1,4 +1,5 @@
 require 'rake'
+require 'active_support/core_ext/string'
 
 require_relative "tasks/task_runner"
 require_relative "tasks/io"

data/lib/cassie/version.rb

@@ -1,3 +1,3 @@
 module Cassie
-  VERSION = "1.0.6.pre2"
+  VERSION = "1.1.0.pre2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cassie
 version: !ruby/object:Gem::Version
-  version: 1.0.6.pre2
+  version: 1.1.0.pre2
 platform: ruby
 authors:
 - Evan Prothro
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-17 00:00:00.000000000 Z
+date: 2017-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cassandra-driver
@@ -133,6 +133,8 @@ files:
 - lib/cassie/schema/cassandra_migrations/importer.rb
 - lib/cassie/schema/cassandra_migrations/migration_file.rb
 - lib/cassie/schema/configuration.rb
+- lib/cassie/schema/definition.rb
+- lib/cassie/schema/definition/dsl.rb
 - lib/cassie/schema/migration.rb
 - lib/cassie/schema/migration/cassandra_support.rb
 - lib/cassie/schema/migration/dsl.rb
@@ -149,6 +151,8 @@ files:
 - lib/cassie/schema/queries/insert_version_query.rb
 - lib/cassie/schema/queries/select_versions_query.rb
 - lib/cassie/schema/rollback_command.rb
+- lib/cassie/schema/schema_dumper.rb
+- lib/cassie/schema/schema_loader.rb
 - lib/cassie/schema/structure_dumper.rb
 - lib/cassie/schema/structure_loader.rb
 - lib/cassie/schema/version.rb