rom-cassandra 0.0.1

data/lib/rom/cassandra/dataset.rb

@@ -0,0 +1,102 @@
+# encoding: utf-8
+
+module ROM::Cassandra
+
+  # The dataset describes a table of the Cassandra cluster
+  #
+  # @api private
+  #
+  class Dataset
+
+    include Enumerable
+    include Equalizer.new(:session, :keyspace, :table, :query)
+
+    # @!attribute [r] session
+    #
+    # @return [ROM::Cassandra::Session] The open session to a Cassandra cluster
+    #
+    attr_reader :session
+
+    # @!attribute [r] keyspace
+    #
+    # @return [Symbol] The name of the current keyspace
+    #
+    attr_reader :keyspace
+
+    # @!attribute [r] table
+    #
+    # @return [Symbol] The name of the current table
+    #
+    attr_reader :table
+
+    # @!attribute [r] query
+    #
+    # @return [QueryBuilder::Statement] The lazy query to the current table
+    #
+    attr_reader :query
+
+    # Initializes the dataset for given column family and command options
+    #
+    # @param [ROM::Cassandra::Session] session
+    # @param [#to_sym] keyspace
+    # @param [#to_sym] table
+    # @param [ROM::Cassandra::Query] query
+    #
+    # @api private
+    #
+    def initialize(session, keyspace, table, query = nil)
+      @session  = session
+      @keyspace = keyspace.to_sym if keyspace
+      @table    = table.to_sym if table
+      @query    = query || Query.new.keyspace(keyspace).table(table)
+    end
+
+    # Returns the new dataset carriyng the batch query
+    #
+    # The batch query doesn't restricted by any table or keyspace
+    #
+    # @return [ROM::Relation::Dataset]
+    #
+    def batch
+      reload nil, nil, Query.new.batch
+    end
+
+    # Returns new dataset with `select` method applied to the [#query]
+    #
+    # @param [Array, Hash, nil] args
+    #
+    # @return [ROM::Relation::Dataset]
+    #
+    def get(*args)
+      reload keyspace, table, query.select(*args)
+    end
+
+    # Sends the [#query] to Cassandra and iterates through results
+    #
+    # @return [Enumerator]
+    #
+    # @yieldparam [Hash] tuples from the dataset
+    # @yieldreturn [self] itself
+    #
+    def each
+      return to_enum unless block_given?
+      session.call(query).each { |item| yield(item) }
+    end
+
+    private
+
+    def reload(*args)
+      self.class.new(session, *args)
+    end
+
+    def method_missing(name, *args)
+      reload keyspace, table, query.public_send(name, *args)
+    end
+
+    def respond_to_missing?(name, *)
+      query.respond_to?(name)
+    end
+
+  end # class Dataset
+
+end # module ROM::Cassandra

data/lib/rom/cassandra/gateway.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+
+module ROM::Cassandra
+
+  # The gateway to the keyspace of the Cassandra cluster
+  #
+  # @api public
+  #
+  class Gateway < ROM::Gateway
+
+    include Equalizer.new(:options, :datasets)
+
+    # @!attribute [r] session
+    #
+    # @return [ROM::Cassandra::Session] The current session
+    #
+    attr_reader :session
+
+    # @!attribute [r] datasets
+    #
+    # @return [Hash] The list of registered datasets
+    #
+    attr_reader :datasets
+
+    # Initializes the ROM gateway to the Cassandra cluster
+    #
+    # @example
+    #   ROM::Cassandra::Gateway.new(
+    #     hosts:    ["10.0.1.1", "10.0.1.2"],
+    #     port:     9042,
+    #     username: "admin",
+    #     password: "foo"
+    #   )
+    #
+    # @example
+    #   ROM::Cassandra::Gateway.new(
+    #     "http://10.0.1.1:9042",
+    #     username: "admin",
+    #     password: "foo"
+    #   )
+    #
+    # @param [Hash] options
+    #
+    def initialize(*options)
+      @session  = Session.new(*options)
+      @datasets = {}
+    end
+
+    # The options of the initialized session
+    #
+    # @return [Hash]
+    #
+    def options
+      session.uri
+    end
+
+    # Registers a new dataset
+    #
+    # @example
+    #   dataset "foo.bar"
+    #
+    # @param [#to_sym] name The full name of the table
+    #
+    # @return [ROM::Cassandra::Dataset]
+    #
+    def dataset(name)
+      @datasets[name.to_sym] = Dataset.new(session, *split(name))
+    end
+
+    # Returns the registered dataset
+    #
+    # @param (see #dataset)
+    #
+    # @return (see #dataset)
+    #
+    def [](name)
+      datasets[name.to_sym]
+    end
+
+    # Checks whether the dataset is registered
+    #
+    # @param (see #dataset)
+    #
+    # @return [Boolean]
+    #
+    def dataset?(name)
+      self[name] ? true : false
+    end
+
+    # Migrates the Cassandra cluster to given version
+    #
+    # @option (see ROM::Cassandra::Migrations::Migrator#new)
+    # @option options [Integer, nil] :version
+    #
+    # @return [undefined]
+    #
+    def migrate(options = {})
+      settings = options.select { |key| [:path, :logger].include? key }
+      target   = options.select { |key| key.equal? :version }
+
+      Migrations::Migrator.new(session, settings).apply(target)
+    end
+
+    private
+
+    def split(name)
+      list = name.to_s.split(".")
+      return list if 2.equal? list.count
+      fail ArgumentError.new "'#{name}' is not a valid full name of a table. " \
+        "Use format 'keyspace.table' with both keyspace and table parts."
+    end
+
+  end # class Gateway
+
+end # module ROM::Cassandra

data/lib/rom/cassandra/migrations.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require "logger"
+
+module ROM::Cassandra
+
+  # Migrations features for the Cassandra cluster
+  #
+  module Migrations
+
+    # The procedure that extracts version number from a migration filename
+    GET_VERSION  = -> name { File.basename(name, ".rb")[/\d{14}/].to_i }
+
+    # The default path for migrations
+    DEFAULT_PATH = "db/migrate".freeze
+
+    # The biggest possible version for migrations
+    ALL_VERSIONS = ("9" * 14).to_i
+
+    require_relative "migrations/logger"
+    require_relative "migrations/migration"
+    require_relative "migrations/runner"
+    require_relative "migrations/runner_up"
+    require_relative "migrations/runner_down"
+    require_relative "migrations/migrator"
+    require_relative "migrations/generator"
+
+  end # module Migrations
+
+end # module ROM::Cassandra

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

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+module ROM::Cassandra
+
+  module Migrations
+
+    # Generates the migration with given name at the target folder
+    #
+    # @example
+    #   ROM::Cassandra::Migrations::Generator.call "create_users", "/db/migrate"
+    #   # => "/db/migrate/20150827133303_create_users.rb"
+    #
+    class Generator
+
+      # Initializes and calls the generator at once
+      #
+      # @param (see #initialize)
+      #
+      # @return (see #call)
+      #
+      def self.call(name, path)
+        new(name, path).call
+      end
+
+      # Initializes the generator with path to target folder and migration name
+      #
+      # @param [String] path
+      # @param [String] name
+      #
+      def initialize(name, path)
+        @path    = path
+        @name    = Inflecto.underscore(name)
+        @klass   = Inflecto.camelize(name)
+        @version = Time.new.strftime "%Y%m%d%H%M%S"
+      end
+
+      # Generates the migration
+      #
+      # @return [String] the full path to the migration
+      #
+      def call
+        FileUtils.mkdir_p path
+        File.write target, content
+
+        target
+      end
+
+      private
+
+      attr_reader :name, :path, :version
+
+      def content
+        ERB.new(File.read source).result(binding)
+      end
+
+      def source
+        File.expand_path("../generator/migration.erb", __FILE__)
+      end
+
+      def target
+        File.join(path, "#{version}_#{name}.rb")
+      end
+
+    end # class Generator
+
+  end # module Migrations
+
+end # module ROM::Cassandra

data/lib/rom/cassandra/migrations/generator/migration.erb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+# ==============================================================================
+# Define `up` and `down` methods, using `call` and `timestamp` helpers.
+#
+# @see http://rom-rb.org/guides/adapters/cassandra#migrations
+#   the example in the Cassandra Adapter Guide
+# ==============================================================================
+
+# Adds/discards changes to the Cassandra cluster and registers the migration
+# at the rom.migrations table of the cluster.
+#
+# @example
+#   migration = <%= @klass %>.new(session)
+#   migration.up
+#   migration.down
+#
+class <%= @klass %> < ROM::Cassandra::Migrations::Migration
+  # Adds necessary changes to the Cassandra cluster
+  #
+  # @return [undefined]
+  #
+  def up
+  end
+
+  # Rolls back the changes to the Cassandra cluster
+  #
+  # @return [undefined]
+  #
+  def down
+  end
+end # class ROM::Cassandra::Migrations::Migration

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

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require "logger"
+
+module ROM::Cassandra
+
+  module Migrations
+
+    # Default Logger for the migrator
+    #
+    # @example
+    #   logger = Logger.new
+    #   logger.info "some text"
+    #   # => some text
+    #
+    class Logger < ::Logger
+
+      # @private
+      def initialize
+        super $stdout
+        self.formatter = proc { |_, _, _, message| "#{message}\n" }
+      end
+
+    end # Logger
+
+  end # module Migrations
+
+end # module ROM::Cassandra

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

@@ -0,0 +1,107 @@
+# encoding: utf-8
+
+module ROM::Cassandra
+
+  module Migrations
+
+    # Base class for migrations, responcible for sending queries to the session
+    #
+    # @example Migration can be created in OOP-style
+    #   class CreateAuthUsers < ROM::Cassandra::Migration
+    #     def up
+    #       call keyspace(:auth).create.if_not_exists
+    #       call keyspace(:auth)
+    #         .table(:users)
+    #         .create(:id, :int)
+    #         .add(:name, :text)
+    #         .primary_key(:id)
+    #         .if_not_exists
+    #     end
+    #
+    #     def down
+    #       call keyspace(:auth).drop.if_exists
+    #     end
+    #   end
+    #
+    # @example The same migration in CQL style
+    #   class CreateAuthUsers < ROM::Cassandra::Migration
+    #     def up
+    #       call "CREATE KEYSPACE IF NOT EXISTS auth;"
+    #       call(
+    #         "CREATE TABLE auth.users (id int, name text, PRIMARY KEY (text));"
+    #       )
+    #     end
+    #
+    #     def down
+    #       call "DROM KEYSPACE IF EXISTS auth;"
+    #     end
+    #   end
+    #
+    class Migration
+
+      # Makes all helper methods private
+      #
+      # @private
+      #
+      def self.inherited(klass)
+        klass.__send__(:private, :call, :keyspace, :up, :down)
+      end
+
+      # Initializes migration with session to the Cassandra cluster
+      #
+      # @param [ROM::Cassandra::Session] session
+      #
+      def initialize(session)
+        @session = session
+        @builder = Query.new
+      end
+
+      # @!attribute [r] session
+      #
+      # @return [ROM::Cassandra::Session] the session to send queries to
+      #
+      attr_reader :session
+
+      # By default does nothing
+      #
+      # @return [undefined]
+      #
+      # @abstract
+      #
+      def up
+      end
+
+      # By default does nothing
+      #
+      # @return [undefined]
+      #
+      # @abstract
+      #
+      def down
+      end
+
+      # Sends the query to Cassandra cluster
+      #
+      # @param [#to_s] query
+      #
+      # @return [Array]
+      #
+      def call(query)
+        session.call query.to_s
+      end
+
+      # Starts building the CQL query in the context of some keyspace
+      #
+      # @param [#to_s] name
+      #
+      # @return [ROM::Cassandra::Query]
+      #
+      def keyspace(name)
+        @builder.keyspace(name)
+      end
+
+    end # class Migration
+
+  end # module Migrations
+
+end # module ROM::Cassandra