rom-cassandra 0.0.1

data/lib/rom/cassandra/migrations/migrator.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+
+module ROM::Cassandra
+
+  module Migrations
+
+    # Class Migrator finds the migration files and migrates Cassandra cluster
+    # to the required version using method [#apply].
+    #
+    # The class is responcible for searching files and deciding,
+    # which of them should be runned up and down. Every single migration
+    # is applied or rolled back using `RunnerUp` and `RunnerDown` classes.
+    #
+    # @example
+    #   migrator = Migrator.new(hosts: ["127.0.0.1"], port: 9042)
+    #
+    #   # Applies all migrations
+    #   migrator.apply
+    #
+    #   # Rolls back all migrations
+    #   migrator.apply version: 0
+    #
+    #   # Moves to the required version (before the year 2016)
+    #   migrator.apply version: 20151231235959
+    #
+    class Migrator
+
+      # @!attribute [r] session
+      #
+      # @return [ROM::Cassandra::Session] The session to the Cassandra cluster
+      #
+      attr_reader :session
+
+      # @!attribute [r] logger
+      #
+      # @return [::Logger] The logger used by the migrator
+      #
+      attr_reader :logger
+
+      # @!attribute [r] root
+      #
+      # @return [Array<String>] The root path for migrations
+      #
+      attr_reader :root
+
+      # @!attribute [r] paths
+      #
+      # @return [Array<String>] The list of paths to migration files
+      #
+      attr_reader :paths
+
+      # Initializes a migrator with Cassandra uri settings.
+      #
+      # Can specify logger and path as well.
+      #
+      # @param [ROM::Cassandra::Session] session
+      # @option options [::Logger] :logger
+      # @option options [String] :path
+      #
+      # See [ROM::Cassandra::Session] for other avaliable options for URI
+      #
+      def initialize(session, options = {})
+        @session = session
+        @logger  = options.fetch(:logger) { Logger.new }
+        @root    = options.fetch(:path) { DEFAULT_PATH }
+        @paths   = Dir[File.join(root, "*.rb")].sort
+      end
+
+      # Migrates the Cassandra cluster to selected version
+      #
+      # Applies all migrations if a version is skipped.
+      # Rolls all migrations back if a version is set to 0.
+      #
+      # @option options [Integer, nil] :version
+      #
+      # @return [undefined]
+      #
+      def apply(options = {})
+        version = options.fetch(:version) { ALL_VERSIONS }
+
+        migrate_to version
+        rollback_to version
+      end
+
+      private
+
+      def migrate_to(version)
+        paths
+          .reject { |path| GET_VERSION[path] > version }
+          .each { |path| RunnerUp.apply(session, logger, path) }
+      end
+
+      def rollback_to(version)
+        paths
+          .select { |path| GET_VERSION[path] > version }
+          .reverse_each { |path| RunnerDown.apply(session, logger, path) }
+      end
+
+    end # class Migrator
+
+  end # module Migrations
+
+end # module ROM::Cassandra

data/lib/rom/cassandra/migrations/runner.rb

@@ -0,0 +1,119 @@
+# encoding: utf-8
+
+require "inflecto"
+
+module ROM::Cassandra
+
+  module Migrations
+
+    # Base class that loads and runs the migration, registers it in
+    # the Cassandra 'rom.migrations' table, and logs the result.
+    #
+    # As a base class uses the Command pattern to define a sequence of
+    # actions, that should be implemented by the subclasses:
+    # `RunnerUp`, and `RunnderDown`.
+    #
+    # @api private
+    #
+    class Runner
+
+      # @!attribute [r] session
+      #
+      # @return [ROM::Cassandra::Session]
+      #   The session for sending requests to Cassandra
+      #
+      attr_reader :session
+
+      # @!attribute [r] logger
+      #
+      # @return [::Logger] The logger to report results
+      #
+      attr_reader :logger
+
+      # @!attribute [r] version
+      #
+      # @return [Integer] The number of migration
+      #
+      attr_reader :version
+
+      # @!attribute [r] path
+      #
+      # @return [String] The path to the migration file
+      #
+      attr_reader :path
+
+      # @!attribute [r] migration
+      #
+      # @return [ROM::Cassandra::Migrations::Migration]
+      #   The migration class
+      #
+      attr_reader :migration
+
+      # Applies the runner to session, logger and migration path
+      #
+      # @param (see #initialize)
+      #
+      # @return (see #call)
+      #
+      def self.apply(session, logger, path)
+        new(session, logger, path).call
+      end
+
+      # Initializes the runner for the session, logger and migration path
+      #
+      # @param [ROM::Cassandra::Session] session
+      # @param [Logger] logger
+      # @param [String] path
+      #
+      def initialize(session, logger, path)
+        @session   = session
+        @logger    = logger
+        @path      = path
+        @version   = extract_version
+        @migration = extract_migration if migrate? # defined in a subclass
+      end
+
+      # Runs the sequence of commands to provide migration
+      #
+      # @return [undefined]
+      #
+      def call
+        return unless migration
+        apply    # defined in a subclass
+        register # defined in a subclass
+        log      # defined in a subclass
+      end
+
+      # Prepares the table and selects version
+      #
+      # @return [Array<Hash>] list of rows with the selected version
+      #
+      def select_version
+        session.call "CREATE KEYSPACE IF NOT EXISTS rom WITH" \
+          " REPLICATION = {'class': 'SimpleStrategy', 'replication_factor': 3};"
+        session.call "CREATE TABLE IF NOT EXISTS rom.migrations" \
+          " (version text, PRIMARY KEY (version));"
+        session.call "SELECT * FROM rom.migrations WHERE" \
+          " version = '#{version}';"
+      end
+
+      private
+
+      def extract_version
+        version = GET_VERSION[path]
+        return version unless version.equal? 0
+        fail NameError.new "invalid version number: '#{path}'"
+      end
+
+      def extract_migration
+        require path
+        basename   = File.basename(path, ".rb")
+        class_name = Inflecto.camelize basename[/_.+/][1..-1]
+        Inflecto.constantize(class_name).new(session)
+      end
+
+    end # class Runner
+
+  end # module Migrations
+
+end # module ROM::Cassandra

data/lib/rom/cassandra/migrations/runner_down.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+module ROM::Cassandra
+
+  module Migrations
+
+    # Runs migration up, registers it in Cassandra table and logs the change.
+    #
+    # @api private
+    #
+    class RunnerDown < Runner
+
+      # Checks if the version hasn't been registered yet
+      #
+      # @return [Boolean]
+      #
+      def migrate?
+        select_version.any?
+      end
+
+      # Rolls back the migration
+      #
+      # @return [undefined]
+      #
+      def apply
+        migration.down
+      end
+
+      # Removes the version from Cassandra db
+      #
+      # @return [Array] an empty array
+      #
+      def register
+        session.call "DELETE FROM rom.migrations WHERE version = '#{version}';"
+      end
+
+      # Logs the result of the operation
+      #
+      # @return [undefined]
+      #
+      def log
+        logger.info "Roll back migration #{version}\n"
+      end
+
+    end # class RunnerDown
+
+  end # module Migrations
+
+end # module ROM::Cassandra

data/lib/rom/cassandra/migrations/runner_up.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+module ROM::Cassandra
+
+  module Migrations
+
+    # Runs migration up, registers it in Cassandra table and logs the change.
+    #
+    # @api private
+    #
+    class RunnerUp < Runner
+
+      # Checks if the version has been registered yet
+      #
+      # @return [Boolean]
+      #
+      def migrate?
+        select_version.empty?
+      end
+
+      # Moves the migration forward
+      #
+      # @return [undefined]
+      #
+      def apply
+        migration.up
+      end
+
+      # Registers the version in Cassandra db
+      #
+      # @return [Array] an empty array
+      #
+      def register
+        session.call "INSERT INTO rom.migrations (version)" \
+          " VALUES ('#{version}');"
+      end
+
+      # Logs the result of the operation
+      #
+      # @return [undefined]
+      #
+      def log
+        logger.info "Apply migration #{version}\n"
+      end
+
+    end # class RunnerUp
+
+  end # module Migrations
+
+end # module ROM::Cassandra

data/lib/rom/cassandra/query.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+require "query_builder"
+
+module ROM::Cassandra
+
+  # Wraps the external CQL query builder
+  #
+  class Query
+
+    # Default CQL statements builder
+    DEFAULT_BUILDER = QueryBuilder::CQL
+
+    # Initializes the object carrying the lazy query
+    #
+    # @param [ROM::Cassandra::Query] query
+    #
+    def initialize(query = nil)
+      @query = query || DEFAULT_BUILDER
+    end
+
+    # Builds the Query statement from the wrapped query
+    #
+    # @return [String]
+    #
+    def to_s
+      @query.to_s
+    end
+
+    private
+
+    def respond_to_missing?(name, *)
+      @query.respond_to? name
+    end
+
+    def method_missing(name, *args)
+      updated_query = @query.public_send(name, *args)
+      self.class.new(updated_query)
+    end
+
+  end # class Query
+
+end # module ROM::Cassandra

data/lib/rom/cassandra/relation.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+
+module ROM::Cassandra
+
+  # Relation subclass of Cassandra adapter
+  #
+  # @example
+  #   class Users < ROM::Relation[:cassandra]
+  #     def last_ten_admins
+  #       select(:id, :name)
+  #         .where(role: "admin")
+  #         .using(consistency: :quorum)
+  #         .order(:name, :desc)
+  #         .limit(10)
+  #     end
+  #   end
+  #
+  # @api public
+  #
+  class Relation < ROM::Relation
+
+    adapter :cassandra
+    option  :source
+
+    # @!attribute [r] source
+    #
+    # @return [ROM::Cassandra::Dataset]
+    #   The source dataset before `get` method has been applied
+    #
+    attr_reader :source
+
+    # @private
+    def initialize(*)
+      super
+      return if (@source = options[:source])
+      @source  = dataset
+      @dataset = dataset.get
+    end
+
+    # Returns the relation whose source is restricted by `#insert` lazy query
+    #
+    # @return [ROM::Cassandra::Relation]
+    #
+    def insert_query
+      reload source.insert
+    end
+
+    # Returns the relation whose source is restricted by `#update` lazy query
+    #
+    # @return [ROM::Cassandra::Relation]
+    #
+    def update_query
+      reload source.update
+    end
+
+    # Returns the relation whose source is restricted by `#delete` lazy query
+    #
+    # @return [ROM::Cassandra::Relation]
+    #
+    def delete_query
+      reload source.delete
+    end
+
+    # Returns the relation whose source is restricted by `#delete` lazy query
+    #
+    # @return [ROM::Cassandra::Relation]
+    #
+    def batch_query
+      reload source.batch
+    end
+
+    private
+
+    def respond_to_missing?(name, *)
+      dataset.respond_to? name
+    end
+
+    def method_missing(name, *args)
+      reload dataset.public_send(name, *args)
+    end
+
+    def reload(dataset)
+      Relation.new dataset, source: source
+    end
+
+  end # class Relation
+
+end # module ROM::Cassandra