quandl_cassandra 1.3.1 → 1.4.0

data/.gitignore

@@ -4,4 +4,7 @@
 .rvmrc
 *.gem
 *.log
-log/*
+log/*
+.vagrant/*
+berks-cookbooks/*
+Berksfile.lock

data/Berksfile

@@ -0,0 +1,4 @@
+source 'https://api.berkshelf.com'
+
+cookbook 'apt'
+cookbook 'cassandra'

data/README.md

@@ -1,7 +1,13 @@
-# Installation
+# NOTE
 
-```ruby
+This project is deprecated. See: [Cequel](https://github.com/cequel/cequel) for an alternative.
+
+## Installation
 
+```ruby
 gem 'quandl_cassandra'
+```
+
+## Development
 
-```
+Install cookbooks with 'berks vendor'.  Run Vagrant with 'vagrant up'.

data/Rakefile

@@ -9,11 +9,3 @@ desc "Run all specs"
 RSpec::Core::RakeTask.new(:spec) do |task|
   task.pattern = "spec/**/*_spec.rb"
 end
-
-require 'quandl/utility/rake_tasks'
-Quandl::Utility::Tasks.configure do |c|
-  c.name              = 'quandl_cassandra'
-  c.version_path      = 'VERSION'
-  c.changelog_path    = 'UPGRADE.md'
-  c.changelog_matching  = ['^QUGC','^WIKI','^CASS']
-end

data/UPGRADE.md

@@ -1,7 +1,11 @@
-## 1.3.0 
-
+## 1.4.0
 
+* Don't allow invalid values of columns, column_names and column_types. Always fetch or recalculate if invalid.
+* Stop using Quandl Utility.
+* Create self contained development environment.
+* Add more verbose logging.
 
+## 1.3.0
 
 
 ## 1.2.5

data/Vagrantfile

@@ -0,0 +1,43 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :"
+
+Vagrant.configure('2') do |config|
+  # All Vagrant configuration is done here. The most common configuration
+  # options are documented and commented below. For a complete reference,
+  # please see the online documentation at vagrantup.com.
+
+  # Every Vagrant virtual environment requires a box to build off of.
+  config.vm.box     = "ubuntu-precise64"
+  config.vm.box_url = "http://files.vagrantup.com/precise64.box"
+  config.omnibus.chef_version = '11.8.0'
+
+  config.vm.provider :virtualbox do |v|
+    v.memory = '2048'
+  end
+
+  config.vm.network :private_network, ip: "192.168.50.4"
+
+  config.vm.provision "chef_solo" do |chef|
+
+    chef.cookbooks_path = 'berks-cookbooks'
+
+    chef.add_recipe 'apt'
+    chef.add_recipe 'cassandra::datastax'
+
+    chef.json = {
+      cassandra: {
+        version: '1.2.16',
+        listen_address: '192.168.50.4',
+        rpc_address: '0.0.0.0'
+      },
+      java: {
+        install_flavor: 'oracle',
+        jdk_version: '7',
+        oracle: {
+          accept_oracle_download_terms: true
+        }
+      }
+    }
+  end
+
+end

data/examples/connect.rb

@@ -9,9 +9,47 @@ require "quandl/fabricate"
 Quandl::Logger.use Quandl::Logger::Outputs
 
 Quandl::Cassandra.configure do |c|
-  c.hosts         = ['localhost','192.168.33.10']
+  c.hosts         = ['localhost','192.168.50.4']
   c.consistency   = :one
-  c.keyspace      = 'wikiposit'
 end
 
-binding.pry
+# Create development keyspace if it does not already exists
+keyspace_name = 'quandl_development'
+columnfamily_name = 'posts'
+
+if Quandl::Cassandra::Base.execute("SELECT * FROM system.schema_keyspaces WHERE keyspace_name = '#{keyspace_name}';", 'one').empty?
+  Quandl::Cassandra::Base.execute("CREATE KEYSPACE #{keyspace_name} WITH REPLICATION = {'class' : 'SimpleStrategy', 'replication_factor': 1};", 'one')
+end
+
+results = Quandl::Cassandra::Base.execute("SELECT * FROM system.schema_columnfamilies WHERE keyspace_name = '#{keyspace_name}';")
+
+# Create column family if it does not exist
+if results.empty? or results.none? { |r| r['columnfamily_name'] == columnfamily_name }
+  Quandl::Cassandra.configuration.keyspace = keyspace_name
+  Quandl::Cassandra::Base.reset_connection
+  Quandl::Cassandra::Base.execute("CREATE TABLE #{columnfamily_name} (
+  id uuid PRIMARY KEY,
+  content text,
+  author varchar,
+  updated_at timestamp );", 'one')
+else
+  puts "The column family #{columnfamily_name} already exists in keyspace #{keyspace_name}!"
+end
+
+Quandl::Cassandra.configuration.keyspace = keyspace_name
+Quandl::Cassandra::Base.reset_connection
+
+class Post < Quandl::Cassandra::Base
+
+  table_name :posts
+
+  after_initialize :default_attributes
+
+  def default_attributes
+    self.id = Cql::Uuid.new(SecureRandom.uuid) unless id.present?
+  end
+
+end
+
+binding.pry
+

data/lib/quandl/cassandra.rb

@@ -21,6 +21,6 @@ require 'quandl/cassandra/configuration'
 require 'quandl/cassandra/batch'
 
 module Quandl
-module Cassandra
-end
+  module Cassandra
+  end
 end

data/lib/quandl/cassandra/base/attributes.rb

@@ -1,112 +1,113 @@
 module Quandl
-module Cassandra
-class Base
-  
-module Attributes
-  
-  extend ActiveSupport::Concern
-  
-  included do
-    include ActiveModel::AttributeMethods
-    include ActiveModel::Dirty
-  end
-  
-  module ClassMethods
-  
-    def define_attributes(*names)
-      Array(names).each{|name| define_attribute(name) }
-    end
-    
-    def define_attribute(name)
-      name = name.to_sym
-      self.class_eval do
-        define_attribute_methods [name.to_sym]
+  module Cassandra
+    class Base
+
+    module Attributes
+
+      extend ActiveSupport::Concern
+
+      included do
+        include ActiveModel::AttributeMethods
+        include ActiveModel::Dirty
       end
-      define_method(name) do
-        read_attribute(name)
+
+      module ClassMethods
+
+        def define_attributes(*names)
+          Array(names).each{|name| define_attribute(name) }
+          Quandl::Logger.info("The attributes for #{self.to_s} are #{Array(names).join(', ')}")
+        end
+
+        def define_attribute(name)
+          name = name.to_sym
+          self.class_eval do
+            define_attribute_methods [name.to_sym]
+          end
+          define_method(name) do
+            read_attribute(name)
+          end
+          define_method("#{name}=") do |value|
+            write_attribute(name, value)
+          end
+          define_method("#{name}?") do
+            read_attribute(name).present?
+          end
+          # store an array of defined attriubte names
+          attribute_names << name unless attribute_names.include?(name)
+        end
+
+        def attribute_names
+          @attribute_names ||= []
+        end
+
       end
-      define_method("#{name}=") do |value|
-        write_attribute(name, value)
+
+      def initialize(*args)
+        attrs = args.extract_options!
+        @attributes = {}
+        # result set attributes?
+        result_set = attrs.delete(:_result_set) if attrs.has_key?(:_result_set)
+        # assign
+        if result_set.present? && result_set.is_a?(Hash)
+          @attributes = result_set.symbolize_keys!
+          self.new_record = false
+        end
+        # assign attributes
+        self.assign_attributes(attrs)
       end
-      define_method("#{name}?") do
-        read_attribute(name).present?
+
+      def inspect
+        "#{self.class.name} " + attributes.inspect
       end
-      # store an array of defined attriubte names
-      attribute_names << name unless attribute_names.include?(name)
-    end
-    
-    def attribute_names
-      @attribute_names ||= []
-    end
-    
-  end
-  
-  def initialize(*args)
-    attrs = args.extract_options!
-    @attributes = {}
-    # result set attributes?
-    result_set = attrs.delete(:_result_set) if attrs.has_key?(:_result_set)
-    # assign
-    if result_set.present? && result_set.is_a?(Hash)
-      @attributes = result_set.symbolize_keys!
-      self.new_record = false
+
+      def assign_attributes(hash)
+        hash.each do |k,v|
+          send("#{k}=", v) if self.class.attribute_names.include?(k) && respond_to?("#{k}=")
+        end
+      end
+
+      def attributes
+        @attributes ||= self.class.attribute_names.inject({}){|m,k| m[k] ||= nil; m }
+      end
+
+      def attributes=(value)
+        @attributes = value.symbolize_keys! if value.is_a?(Hash)
+      end
+
+      def reload
+        return false unless primary_key?
+        clear_changes!
+        reload_attributes
+        true
+      end
+
+      protected
+
+      def write_attribute(attribute, value)
+        self.send(:"#{attribute}_will_change!") if self.attributes[:"#{attribute}"] != value
+        @attributes[:"#{attribute}"] = value
+      end
+
+      def read_attribute(attribute)
+        @attributes[:"#{attribute}"]
+      end
+
+      def attribute_changed?(attribute)
+        !changes[attribute.to_s].nil?
+      end
+
+      def clear_changes!
+        @previously_changed = {}
+        @changed_attributes.clear
+      end
+
+      def cycle_changes!
+        @previously_changed = changes
+        @changed_attributes.clear
+      end
+
     end
-    # assign attributes
-    self.assign_attributes(attrs)
-  end
 
-  def inspect
-    "#{self.class.name} " + attributes.inspect
-  end
-  
-  def assign_attributes(hash)
-    hash.each do |k,v|
-      send("#{k}=", v) if self.class.attribute_names.include?(k) && respond_to?("#{k}=")
     end
   end
-  
-  def attributes
-    @attributes ||= self.class.attribute_names.inject({}){|m,k| m[k] ||= nil; m }
-  end
-  
-  def attributes=(value)
-    @attributes = value.symbolize_keys! if value.is_a?(Hash)
-  end
-  
-  def reload
-    return false unless primary_key?
-    clear_changes!
-    reload_attributes
-    true
-  end
-  
-  protected
-  
-  def write_attribute(attribute, value)
-    self.send(:"#{attribute}_will_change!") if self.attributes[:"#{attribute}"] != value
-    @attributes[:"#{attribute}"] = value
-  end
-  
-  def read_attribute(attribute)
-    @attributes[:"#{attribute}"]
-  end
-  
-  def attribute_changed?(attribute)
-    !changes[attribute.to_s].nil?
-  end
-  
-  def clear_changes!
-    @previously_changed = {}
-    @changed_attributes.clear
-  end
-  
-  def cycle_changes!
-    @previously_changed = changes
-    @changed_attributes.clear
-  end
-  
-end
-
-end
-end
 end

data/lib/quandl/cassandra/base/logging.rb

@@ -1,36 +1,32 @@
 require 'colorize'
 
 module Quandl
-module Cassandra
-class Base
-module Logging
-  
-  extend ActiveSupport::Concern
-  
-  module ClassMethods
-    
-    def prepare(*args, &block)
-      statement = args.first.to_s
-      statement = "#{statement[0..200]} ... #{statement.length} chars" if statement.length > 200
-      Logger.debug(statement)
-      super if defined?(super)
-    end
+  module Cassandra
+    class Base
+      module Logging
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def prepare(*args, &block)
+            statement = args.first.to_s
+            statement = "#{statement[0..200]} ... #{statement.length} chars" if statement.length > 200
+            Logger.debug(statement)
+            super if defined?(super)
+          end
 
-    def execute(*args, &block)
-      statement = args.first.to_s
-      statement = "#{statement[0..200]} ... #{statement.length} chars" if statement.length > 200
-      t1 = Time.now
-      begin
-        r = super if defined?(super)
-      ensure
-        Logger.debug("(#{t1.elapsed_ms}) ".blue + " #{statement}")
+          def execute(*args, &block)
+            statement = args.first.to_s
+            statement = "#{statement[0..200]} ... #{statement.length} chars" if statement.length > 200
+            t1 = Time.now
+            begin
+              r = super if defined?(super)
+            ensure
+              Logger.debug("(#{t1.elapsed_ms}) ".blue + " #{statement}")
+            end
+            r
+          end
+        end
       end
-      r
     end
-    
-  end  
-  
-end
-end
-end
+  end
 end

data/lib/quandl/cassandra/base/sanitization.rb

@@ -1,15 +1,13 @@
 module Quandl::Cassandra::Base::Sanitization
-  
   extend ActiveSupport::Concern
-  
+
   module ClassMethods
-    
     def bind_primary_key(*args)
       attrs = {}
       primary_key.each_with_index { |k, i| attrs[k] = args[i] if args[i].present? }
       attrs
     end
-    
+
     def sanitize_attributes(attrs)
       values = {}
       attrs.each do |attribute, value|
@@ -20,18 +18,16 @@ module Quandl::Cassandra::Base::Sanitization
       end
       values
     end
-  
+
     def sanitize_attribute(attribute, value)
       # process each value
-      return value.collect{|val| column_type(attribute).sanitize_for_cql( val ) } if value.is_a?(Array)
+      return value.map { |val| column_type(attribute).sanitize_for_cql(val) } if value.is_a?(Array)
       # process value
-      column_type(attribute).sanitize_for_cql( value )
+      column_type(attribute).sanitize_for_cql(value)
     end
-    
   end
-  
+
   def sanitized_attribute(attribute)
     self.class.sanitize_attribute(attribute, read_attribute(attribute))
   end
-  
-end
+end