curator 0.8.0 → 0.8.1

data/lib/curator/memory/configuration.rb

@@ -3,7 +3,7 @@ module Curator::Memory
     include Curator::Configuration
 
     def data_store
-      Curator::Memory::DataStore
+      Curator::Memory::DataStore.new
     end
   end
 end

data/lib/curator/memory/data_store.rb

@@ -3,14 +3,15 @@ require 'ostruct'
 module Curator
   module Memory
     class DataStore
-      def self.remove_all_keys
+      def remove_all_keys
         @data = {}
       end
-      class << self
-        alias :reset! :remove_all_keys
+
+      def reset!
+        remove_all_keys
       end
 
-      def self.save(options)
+      def save(options)
         bucket = _bucket_name(options[:collection_name])
         object = options[:value]
         key = options[:key]
@@ -31,7 +32,7 @@ module Curator
         key
       end
 
-      def self.delete(collection_name, key)
+      def delete(collection_name, key)
         bucket = _bucket_name(collection_name)
         _records(bucket).delete(key)
         _indices(bucket).each_key do |name|
@@ -44,17 +45,17 @@ module Curator
         end
       end
 
-      def self.find_by_key(collection_name, key)
+      def find_by_key(collection_name, key)
         bucket = _bucket_name(collection_name)
         value = _records(bucket).fetch(key, nil)
         return if value.nil?
         {:key => key, :data => value}
       end
 
-      def self.find_by_index(collection_name, index_name, query)
+      def find_by_attribute(collection_name, attribute, query)
         return [] if query.nil?
         bucket = _bucket_name(collection_name)
-        index = _index(bucket, index_name)
+        index = _index(bucket, attribute)
         keys = case query
                when Range
                  keys = index.keys.select do |key|
@@ -69,27 +70,27 @@ module Curator
         end
       end
 
-      def self._data
+      def _data
         @data ||= {}
       end
 
-      def self._bucket(bucket)
+      def _bucket(bucket)
         _data[bucket] ||= {}
       end
 
-      def self._records(bucket)
+      def _records(bucket)
         _bucket(bucket)[:records] ||= {}
       end
 
-      def self._indices(bucket)
+      def _indices(bucket)
         _bucket(bucket)[:indices] ||= {}
       end
 
-      def self._index(bucket, index_name)
+      def _index(bucket, index_name)
         _indices(bucket)[index_name] ||= {}
       end
 
-      def self._normalized_index_values(indexed_data)
+      def _normalized_index_values(indexed_data)
         if indexed_data.is_a?(Array)
           indexed_data
         else
@@ -97,13 +98,13 @@ module Curator
         end
       end
 
-      def self._generate_key(bucket)
+      def _generate_key(bucket)
         keys = _records(bucket).keys
         keys = [0] if keys.empty?
         keys.max.next
       end
 
-      def self._bucket_name(name)
+      def _bucket_name(name)
         "#{Curator.config.environment}:#{name}"
       end
     end

data/lib/curator/mongo/configuration.rb

@@ -5,7 +5,7 @@ module Curator::Mongo
     attr_accessor :database, :mongo_config_file
 
     def data_store
-      Curator::Mongo::DataStore
+      Curator::Mongo::DataStore.new
     end
   end
 end

data/lib/curator/mongo/data_store.rb

@@ -4,23 +4,28 @@ require 'yaml'
 module Curator
   module Mongo
     class DataStore
-      def self.client
+      def client
         return @client if @client
         config = YAML.load(File.read(Curator.config.mongo_config_file))[Curator.config.environment]
         host = config.delete(:host)
         port = config.delete(:port)
+        password = config.delete(:password)
+        username = config.delete(:username)
+        @database_name = config.delete(:database) || default_db_name
         @client = ::Mongo::Connection.new(host, port, config)
+        @client.add_auth(@database_name, username, password) if username and password
+        @client
       end
 
-      def self.remove_all_keys
+      def remove_all_keys
         self.reset!
       end
 
-      def self.reset!
+      def reset!
         _db.collections.each {|coll| coll.drop unless coll.name =~ /system/ }
       end
 
-      def self.save(options)
+      def save(options)
         collection = _collection options[:collection_name]
         key = options.delete(:key)
         document = options[:value]
@@ -31,12 +36,12 @@ module Curator
         collection.save document
       end
 
-      def self.delete(collection_name, id)
+      def delete(collection_name, id)
         collection = _collection(collection_name)
         collection.remove(:_id => id)
       end
 
-      def self.find_by_index(collection_name, field, query)
+      def find_by_attribute(collection_name, field, query)
         return [] if query.nil?
 
         exp = {}
@@ -46,34 +51,34 @@ module Curator
         documents.map {|doc| normalize_document(doc) }
       end
 
-      def self.find_by_key(collection_name, id)
+      def find_by_key(collection_name, id)
         collection = _collection(collection_name)
         document = collection.find_one({:_id => id})
         normalize_document(document) unless document.nil?
       end
 
-      def self._collection(name)
+      def _collection(name)
         _db.collection(name)
       end
 
-      def self._collection_name(name)
-        _db.collection(name).name
-      end
-
-      def self._db
+      def _db
         client.db(_db_name)
       end
 
-      def self._db_name
+      def default_db_name
         "#{Curator.config.database}:#{Curator.config.environment}"
       end
 
-      def self.normalize_document(doc)
+      def _db_name
+        @database_name
+      end
+
+      def normalize_document(doc)
         key = doc.delete '_id'
         Hash[:key => key, :data => doc]
       end
 
-      def self._normalize_query(query)
+      def _normalize_query(query)
         query.inject({}) do |hash, (key, value)|
           case value
           when Range

data/lib/curator/repository.rb

@@ -34,15 +34,15 @@ module Curator
       end
 
       def find_by_created_at(start_time, end_time)
-        _find_by_index(collection_name, :created_at, _format_time_for_index(start_time).._format_time_for_index(end_time))
+        _find_by_attribute(:created_at, _format_time_for_index(start_time).._format_time_for_index(end_time))
       end
 
       def find_by_updated_at(start_time, end_time)
-        _find_by_index(collection_name, :updated_at, _format_time_for_index(start_time).._format_time_for_index(end_time))
+        _find_by_attribute(:updated_at, _format_time_for_index(start_time).._format_time_for_index(end_time))
       end
 
       def find_by_version(version)
-        _find_by_index(collection_name, :version, version)
+        _find_by_attribute(:version, version)
       end
 
       def find_by_id(id)
@@ -93,20 +93,20 @@ module Curator
         object.instance_values
       end
 
-      def _build_finder_methods(field_name)
+      def _build_finder_methods(attribute)
         eigenclass = class << self; self; end
         eigenclass.class_eval do
-          define_method("find_by_#{field_name}") do |value|
-            _find_by_index(collection_name, field_name, value)
+          define_method("find_by_#{attribute}") do |value|
+            _find_by_attribute(attribute, value)
           end
-          define_method("find_first_by_#{field_name}") do |value|
-            _find_by_index(collection_name, field_name, value).first
+          define_method("find_first_by_#{attribute}") do |value|
+            _find_by_attribute(attribute, value).first
           end
         end
       end
 
-      def _find_by_index(collection_name, field_name, value)
-        if results = data_store.find_by_index(collection_name, field_name, value)
+      def _find_by_attribute(attribute, value)
+        if results = data_store.find_by_attribute(collection_name, attribute, value)
           results.map do |hash|
             _deserialize(hash[:key], hash[:data])
           end
@@ -121,8 +121,6 @@ module Curator
         attributes = data.with_indifferent_access
         migrated_attributes = migrator.migrate(attributes)
         migrated_attributes[:id] = id
-        migrated_attributes[:created_at] = Time.parse(migrated_attributes[:created_at]) if migrated_attributes[:created_at]
-        migrated_attributes[:updated_at] = Time.parse(migrated_attributes[:updated_at]) if migrated_attributes[:updated_at]
         deserialize(migrated_attributes)
       end
 

data/lib/curator/resettable_riak/configuration.rb

@@ -1,7 +1,9 @@
+require File.expand_path(File.dirname(__FILE__) + '/../riak/configuration')
+
 module Curator::ResettableRiak
   class Configuration < Curator::Riak::Configuration
     def data_store
-      Curator::ResettableRiak::DataStore
+      Curator::ResettableRiak::DataStore.new
     end
   end
 end

data/lib/curator/resettable_riak/data_store.rb

@@ -1,22 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + '/../riak/data_store')
 require 'active_support/core_ext/kernel/reporting'
 
 module Curator
   module ResettableRiak
     class DataStore < Riak::DataStore
-      def self.bucket_prefix
+      def bucket_prefix
         job = "#{ENV['JOB_NAME'].gsub(/[^[:alnum:]]/, '_')}" if ENV['JOB_NAME'].present?
         [Curator.config.bucket_prefix, job, Curator.config.environment].compact.join(':')
       end
 
-      def self.exclude_from_reset
+      def exclude_from_reset(&block)
         @exclude_from_reset = true
         yield
+      ensure
         @exclude_from_reset = false
       end
 
-      def self.remove_all_keys
+      def remove_all_keys
         silence_warnings do
-          buckets = client.buckets.select { |bucket| bucket.name.start_with?(DataStore.bucket_prefix) }
+          buckets = client.buckets.select { |bucket| bucket.name.start_with?(bucket_prefix) }
           buckets.each do |bucket|
             bucket.keys do |keys|
               keys.each { |key| bucket.delete(key) }
@@ -25,7 +27,7 @@ module Curator
         end
       end
 
-      def self.reset!
+      def reset!
         @bucket_names ||= {}
         deletable_buckets = @bucket_names.each do |bucket_name, keys|
           bucket = _bucket(bucket_name)
@@ -34,7 +36,7 @@ module Curator
         @bucket_names = {}
       end
 
-      def self.save(options)
+      def save(options)
         key = super
 
         unless @exclude_from_reset

data/lib/curator/riak/configuration.rb

@@ -11,7 +11,7 @@ module Curator::Riak
     end
 
     def data_store
-      Curator::Riak::DataStore
+      Curator::Riak::DataStore.new
     end
   end
 end

data/lib/curator/riak/data_store.rb

@@ -4,23 +4,27 @@ require 'yaml'
 module Curator
   module Riak
     class DataStore
-      def self.client
+      def client
         return @client if @client
         yml_config = YAML.load(File.read(Curator.config.riak_config_file))[Curator.config.environment]
         @client = ::Riak::Client.new(yml_config)
       end
 
-      def self.delete(bucket_name, key)
+      def bucket_prefix
+        "#{Curator.config.bucket_prefix}:#{Curator.config.environment}"
+      end
+
+      def delete(bucket_name, key)
         bucket = _bucket(bucket_name)
         object = bucket.get(key)
         object.delete
       end
 
-      def self.ping
+      def ping
         client.ping
       end
 
-      def self.save(options)
+      def save(options)
         bucket = _bucket(options[:collection_name])
         object = ::Riak::RObject.new(bucket, options[:key])
         object.content_type = options.fetch(:content_type, "application/json")
@@ -32,17 +36,17 @@ module Curator
         result.key
       end
 
-      def self.find_by_key(bucket_name, key)
+      def find_by_key(bucket_name, key)
         bucket = _bucket(bucket_name)
         begin
           object = bucket.get(key)
-          { :key => object.key, :data => object.data } unless object.data.empty?
+          { :key => object.key, :data => _deserialize(object.data) } unless object.data.empty?
         rescue ::Riak::HTTPFailedRequest => failed_request
           raise failed_request unless failed_request.not_found?
         end
       end
 
-      def self.find_by_index(bucket_name, index_name, query)
+      def find_by_attribute(bucket_name, index_name, query)
         return [] if query.nil?
 
         bucket = _bucket(bucket_name)
@@ -54,23 +58,26 @@ module Curator
         end
       end
 
-      def self._bucket(name)
+      def _bucket(name)
         client.bucket(_bucket_name(name))
       end
 
-      def self._bucket_name(name)
+      def _bucket_name(name)
         bucket_prefix + ":" + name
       end
 
-      def self.bucket_prefix
-        "#{Curator.config.bucket_prefix}:#{Curator.config.environment}"
+      def _deserialize(data)
+        deserialized_data = data.dup
+        deserialized_data["created_at"] = Time.parse(data["created_at"]) if data["created_at"]
+        deserialized_data["updated_at"] = Time.parse(data["updated_at"]) if data["updated_at"]
+        deserialized_data
       end
 
-      def self._find_key_by_index(bucket, index_name, query)
+      def _find_key_by_index(bucket, index_name, query)
         bucket.get_index("#{index_name}_bin", query)
       end
 
-      def self._normalized_index_data(index_data)
+      def _normalized_index_data(index_data)
         if index_data.is_a?(Array)
           index_data.join(", ")
         else

data/lib/curator.rb

@@ -21,13 +21,6 @@ module Curator
   end
 
   def self.data_store
-    config.data_store
-  end
-
-  self.configure(:riak) do |config|
-    config.environment = 'development'
-    config.migrations_path = File.expand_path(File.dirname(__FILE__) + "/../db/migrate")
-    config.bucket_prefix = 'curator'
-    config.riak_config_file = File.expand_path(File.dirname(__FILE__) + "/../config/riak.yml")
+    @data_store ||= config.data_store
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: curator
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-08 00:00:00.000000000 Z
+date: 2012-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport