believer 0.1.2 → 0.1.3

data/README.md

@@ -1,2 +1,132 @@
+# CQL3 Object Relational Mapping
+Believer is an Object Relational Mapping library for CQL3
+
+## Installation
+    gem install believer
+
+## Inspiration
+The Believer library is heavily inspired by ActiveRecord. Most patterns used in this library should be pretty familiar for ActiveRecord users.
+
+## Usage
+
+### Define your class
+An example:
+
+    require 'believer'
+
+    class Artist < Believer::Base
+        column :name
+        column :label
+
+        primary_key :name
+    end
+
+    class Album < Believer::Base
+        column :artist
+        column :name
+        column :release_date, :type => :timestamp
+
+        primary_key :artist, :name
+    end
+
+    class Song < Believer::Base
+        column :artist
+        column :album
+        column :name
+        column :track_number, :type => :integer
+
+        primary_key :artist, :album, :name
+    end
+
+#### The Believer::Base class
+This is the class you should extend from.
+
+#### The column class method
+Defines the mapping between a Ruby object attribute and a Cassandra column. Also defines a getter and setter attribute with the same name.
+The second argument is a Hash, which support the following keys:
+* type: the data type. Supported are: :string, :integer, :float, :timestamp
+
+
+#### The primary_key class method
+Sets the primary key columns of the class.
+In a situation where you're only querying data, you don't need to set this.
+However, if you rely on object equality somewhere in your application, it is advisable to set the primary key, as the primary key values are used in the Believer::Base.eql? method.
+
+### Query your class
+The following methods can be used to query class instances.
+* where: specify query filters
+* select: specify which fields to load. Using none defaults to all fields being loaded.
+* limit: limit the number of results to a maximum
+* order: specify the order of the results
+
+All methods are chainable, meaning you can
+
+#### The where method
+Use the where method to specify filters on the result set. These filters correspond to the expressions in the WHERE clause of a Cassandra query.
+
+    # Using a hash
+    Artist.where(:name => 'James Brown')
+
+    # Using a hash mapping key to an array of possible values. Maps to the CQL IN operator
+    Artist.where(:name => ['Coldplay', 'Depeche Mode', 'Eurythmics'])
+
+    # Using string with interpolation
+    Artist.where('name = ?', 'Foreigner')
+
+#### The select method
+Using the select method you can define the columns loaded in a query. These fields correspond to the expressions in the SELECT clause of a Cassandra query.
+This might be handy in the case you have a table with a lot of columns, but only need a few.
+
+    # Select a single field
+    Artist.select(:name)
+
+    # Select a multiple fields
+    Artist.select(:name, :label)
+
+#### The limit method
+Limits the amount of records returned to the specified maximum
+
+    # Yield at most 20 class instances
+    Artist.limit(20)
+
+#### The order method
+Order the results in using the specified column
+
+    # Order ascending by name
+    Album.order(:name)
+    Album.order(:name, :asc)
+
+    # Order descending by name
+    Album.order(:name, :desc)
+
+#### Method chaining
+All query methods can be chained.
+This is done by creating and returning a clone of the receiver. The clone is the receiver of the query method.
+
+    # 'Echoes'....
+    Song.where(:artist => 'Pink Floyd').where(:album => 'Meddle').order(:track_number, :desc).limit(1)
+
+### Configuration
+If using Rails, place a believer.yml file in the configuration directory of your application.
+The file structure starts with the the environment name, followed by the connection configuration.
+This is the client connection configuration passed to the cql-rb gem.
+
+    development:
+        host: 127.0.0.1
+        port: 9042
+        keyspace: my_keyspace
+
+    staging:
+        host: 'staging.mynetwork.local'
+        port: 9042
+        keyspace: my_keyspace
+        credentials:
+            username: john
+            password: $FDFD%@#&*
+
+
+In other cases, you will have to programatically set the environment:
+
+    Believer::Base.environment = Believer::Environment::BaseEnv.new(:host => '127.0.0.1', :keyspace => 'mykeyspace')
 
 

data/lib/believer/columns.rb

@@ -20,6 +20,28 @@ module Believer
     end
 
     class Column
+      #TYPES = {
+      #    :ascii	strings	US-ASCII character string
+      #bigint	integers	64-bit signed long
+      #blob	blobs	Arbitrary bytes (no validation), expressed as hexadecimal
+      #boolean	booleans	true or false
+      #counter	integers	Distributed counter value (64-bit long)
+      #decimal	integers, floats	Variable-precision decimal
+      #double	integers	64-bit IEEE-754 floating point
+      #float	integers, floats	32-bit IEEE-754 floating point
+      #inet	strings	IP address string in IPv4 or IPv6 format*
+      #                                                     int	integers	32-bit signed integer
+      #list	n/a	A collection of one or more ordered elements
+      #map	n/a	A JSON-style array of literals: { literal : literal, literal : literal ... }
+      #set	n/a	A collection of one or more elements
+      #text	strings	UTF-8 encoded string
+      #timestamp	integers, strings	Date plus time, encoded as 8 bytes since epoch
+      #uuid	uuids	A UUID in standard UUID format
+      #timeuuid	uuids	Type 1 UUID only (CQL 3)
+      #varchar	strings	UTF-8 encoded string
+      #varint	integers	Arbitrary-precision integer
+      #}
+      #
       CQL_COL_TYPES = {
           :integer => 'INT',
           :string => 'VARCHAR',

data/lib/believer/environment.rb

@@ -7,8 +7,11 @@ module Believer
     module ClassMethods
 
       def environment
+
         if @environment.nil?
-          if defined?(::Rails)
+          if self.superclass.respond_to?(:environment)
+            @environment = self.superclass.environment
+          elsif defined?(::Rails)
             @environment = ::Believer::Environment::RailsEnv.new
           end
         end
@@ -26,6 +29,22 @@ module Believer
       #  {:host => '127.0.0.1'}
       #end
 
+      def initialize(config = nil)
+        @configuration = config.dup unless config.nil?
+      end
+
+      def configuration
+        @configuration ||= load_configuration
+      end
+
+      def configuration=(config)
+        @configuration = config
+      end
+
+      def connection_configuration
+        @connection_configuration ||= configuration.reject_if {|k, v| k == :pool}
+      end
+
       def create_connection(options = {})
         cc = connection_configuration
 
@@ -33,20 +52,20 @@ module Believer
           connection = Cql::Client.connect(cc)
           connection.use(cc[:keyspace])
         else
-          connection = Cql::Client.connect(cc.delete_if {|k,v|k==:keyspace})
+          connection = Cql::Client.connect(cc.delete_if {|k,v|k == :keyspace})
         end
         connection
       end
 
       def create_keyspace(connection = nil)
         conn = connection || create_connection
-        ks_def = <<-KSDEF
+        ks_def = <<-KS_DEF
           CREATE KEYSPACE #{connection_configuration[:keyspace]}
           WITH replication = {
             'class': 'SimpleStrategy',
             'replication_factor': 1
           }
-        KSDEF
+        KS_DEF
 
         conn.execute(ks_def)
       end

data/lib/believer/environment/rails_env.rb

@@ -3,16 +3,13 @@ module Believer
   module Environment
     class RailsEnv < Believer::Environment::BaseEnv
 
-      def connection_configuration
-        unless @connection_configuration
-          config_file = Rails.root + "config/cql.yml"
-          #puts "Using CQL connection config file: #{config_file}"
-          config = YAML::load(File.open(config_file.to_s))
-          env_config = config[Rails.env]
-          @connection_configuration = env_config.symbolize_keys
-          @connection_configuration[:logger] = Rails.logger
-        end
-        @connection_configuration
+      def load_configuration
+        config_file = Rails.root + "config/believer.yml"
+        config = YAML::load(File.open(config_file.to_s))
+        env_config = config[Rails.env]
+        env_config = {}.merge(env_config).symbolize_keys
+        env_config[:logger] = Rails.logger
+        env_config
       end
     end
   end

data/lib/believer/version.rb

@@ -1,5 +1,5 @@
 module Believer
   module Version
-    VERSION = '0.1.2'
+    VERSION = '0.1.3'
   end
 end

data/spec/support/test_classes.rb

@@ -51,8 +51,9 @@ module Test
     @env ||= Environment.new
   end
 
+  Believer::Base.environment = test_environment
   CLASSES = [Processor, Computer, Event, Person]
-  CLASSES.each {|cl| cl.environment = test_environment}
+  #CLASSES.each {|cl| cl.environment = test_environment}
 
   def self.classes
     CLASSES

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: believer
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
   prerelease: 
 platform: ruby
 authors: