curator 0.1.0

data/lib/curator/migration.rb

@@ -0,0 +1,9 @@
+module Curator
+  class Migration
+    attr_accessor :version
+
+    def initialize(version)
+      @version = version
+    end
+  end
+end

data/lib/curator/migrator.rb

@@ -0,0 +1,29 @@
+module Curator
+  class Migrator
+    def initialize(collection_name)
+      @collection_name = collection_name
+    end
+
+    def migrate(attributes)
+      migrations = _applicable_migrations(attributes["version"].to_i)
+      migrations.inject(attributes) do |migrated_attributes, migration|
+        migration.migrate(migrated_attributes).merge("version" => migration.version)
+      end
+    end
+
+    def _applicable_migrations(current_version)
+      @applicable_migrations ||= _all_migrations.select { |migration| migration.version > current_version }.sort_by(&:version)
+    end
+
+    def _all_migrations
+      files = Dir.glob("#{File.join(Curator.migrations_path, @collection_name)}/*.rb")
+
+      files.map do |file|
+        load file
+        migration_version, name = file.scan(/([0-9]+)_([_a-z0-9]*).rb/).first
+        klass = name.camelize.constantize
+        klass.new(migration_version.to_i)
+      end
+    end
+  end
+end

data/lib/curator/model.rb

@@ -0,0 +1,44 @@
+require 'active_support'
+require 'active_model'
+
+module Curator
+  module Model
+    extend ActiveSupport::Concern
+    include ActiveModel::Conversion
+
+    included do
+      attr_accessor :created_at, :updated_at
+      attr_writer :version
+    end
+
+    def initialize(args = {})
+      args.each do |attribute, value|
+        send("#{attribute}=", value) if respond_to?("#{attribute}=")
+      end
+    end
+
+    def persisted?
+      id.present?
+    end
+
+    def version
+      @version || self.class.version
+    end
+
+    def ==(other)
+      self.id == other.id
+    end
+
+    module ClassMethods
+      include ActiveModel::Naming
+
+      def current_version(number)
+        @version = number
+      end
+
+      def version
+        @version || 0
+      end
+    end
+  end
+end

data/lib/curator/railtie.rb

@@ -0,0 +1,9 @@
+module Curator
+  class Railtie < Rails::Railtie
+    initializer "railtie.configure_rails_initialization" do
+      Curator.environment = Rails.env
+      Curator.riak_config_file = Rails.root.join('config', 'riak.yml')
+      Curator.migrations_path = Rails.root.join('db', 'migrate')
+    end
+  end
+end

data/lib/curator/repository.rb

@@ -0,0 +1,163 @@
+require 'active_support/inflector'
+require 'active_support/core_ext/object/instance_variables'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'json'
+
+module Curator
+  module Repository
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def collection_name
+        ActiveSupport::Inflector.tableize(klass)
+      end
+
+      def data_store
+        @data_store ||= Riak::DataStore
+      end
+
+      def data_store=(store)
+        @data_store = store
+      end
+
+      def delete(object)
+        data_store.delete(collection_name, object.id)
+      end
+
+      def encrypted_entity
+        @encrypted_entity = true
+      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))
+      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))
+      end
+
+      def find_by_id(id)
+        if hash = data_store.find_by_key(collection_name, id)
+          _deserialize(hash[:key], hash[:data])
+        end
+      end
+
+      def indexed_fields(*fields)
+        @indexed_fields = fields
+
+        @indexed_fields.each do |field_name|
+          _build_finder_methods(field_name)
+        end
+      end
+
+      def klass
+        name.to_s.gsub("Repository", "").constantize
+      end
+
+      def migrator
+        @migrator ||= Curator::Migrator.new(collection_name)
+      end
+
+      def save(object)
+        hash = {
+          :collection_name => collection_name,
+          :value => _serialize(object),
+          :index => _indexes(object)
+        }
+
+        if object.id
+          hash[:key] = object.id
+          data_store.save(hash)
+        else
+          object.id = data_store.save(hash).key
+        end
+      end
+
+      def serialize(object)
+        object.instance_values
+      end
+
+      def _build_finder_methods(field_name)
+        singleton_class.class_eval do
+          define_method("find_by_#{field_name}") do |value|
+            _find_by_index(collection_name, field_name, value)
+          end
+          define_method("find_first_by_#{field_name}") do |value|
+            _find_by_index(collection_name, field_name, 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)
+          results.map do |hash|
+            _deserialize(hash[:key], hash[:data])
+          end
+        end
+      end
+
+      def deserialize(attributes)
+        klass.new(attributes)
+      end
+
+      def _deserialize(id, data)
+        attributes = data.with_indifferent_access
+        migrated_attributes = migrator.migrate(attributes)
+        object = deserialize(migrated_attributes)
+        object.id = id
+        object.created_at = Time.parse(attributes[:created_at]) if attributes[:created_at].present?
+        object.updated_at = Time.parse(attributes[:updated_at]) if attributes[:updated_at].present?
+        object
+      end
+
+      def _encrypted_attributes(object, attributes)
+        return attributes unless _encrypted_entity?
+
+        encryption_key = EncryptionKeyRepository.find_active
+        plaintext = attributes.to_json
+        ciphertext = encryption_key.encrypt(plaintext)
+        {
+          :encryption_key_id => encryption_key.id,
+          :encrypted_data => Base64.encode64(ciphertext)
+        }
+      end
+
+      def _encrypted_entity?
+        @encrypted_entity == true
+      end
+
+      def _format_time_for_index(time)
+        time.to_json.gsub('"', '')
+      end
+
+      def _indexed_fields
+        @indexed_fields || []
+      end
+
+      def _indexes(object)
+        index_values = _indexed_fields.map { |field| [field, object.send(field)] }
+        index_values += [
+          [:created_at, _format_time_for_index(object.send(:created_at))],
+          [:updated_at, _format_time_for_index(object.send(:updated_at))]
+        ]
+        Hash[index_values]
+      end
+
+      def _serialize(object)
+        attributes = serialize(object).reject { |key, val| val.nil? }
+
+        timestamp = Time.now.utc
+
+        updated_at = timestamp
+        created_at = object.created_at || timestamp
+
+        object.created_at = created_at
+        object.updated_at = updated_at
+        attributes[:created_at] = created_at
+        attributes[:updated_at] = updated_at
+
+        _encrypted_attributes(object, attributes)
+      end
+    end
+  end
+end

data/lib/curator/riak/data_store.rb

@@ -0,0 +1,73 @@
+require 'riak'
+require 'yaml'
+
+module Riak
+  class DataStore
+    BUCKET_PREFIX = "curator"
+
+    def self.client
+      return @client if @client
+      yml_config = YAML.load(File.read(Curator.riak_config_file))[Curator.environment]
+      @client = Riak::Client.new(yml_config)
+    end
+
+    def self.delete(bucket_name, key)
+      bucket = _bucket(bucket_name)
+      object = bucket.get(key)
+      object.delete
+    end
+
+    def self.ping
+      client.ping
+    end
+
+    def self.save(options)
+      bucket = _bucket(options[:collection_name])
+      object = Riak::RObject.new(bucket, options[:key])
+      object.content_type = "application/json"
+      object.data = options[:value]
+      options.fetch(:index, {}).each do |index_name, index_value|
+        object.indexes["#{index_name}_bin"] << index_value
+      end
+      object.store
+    end
+
+    def self.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?
+      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)
+      return [] if query.nil?
+
+      bucket = _bucket(bucket_name)
+      begin
+        keys = _find_key_by_index(bucket, index_name.to_s, query)
+        keys.map { |key| find_by_key(bucket_name, key) }
+      rescue Riak::HTTPFailedRequest => failed_request
+        raise failed_request unless failed_request.not_found?
+      end
+    end
+
+    def self._bucket(name)
+      client.bucket(_bucket_name(name))
+    end
+
+    def self._bucket_name(name)
+      bucket_prefix + ":" + name
+    end
+
+    def self.bucket_prefix
+      "#{BUCKET_PREFIX}:#{Curator.environment}"
+    end
+
+    def self._find_key_by_index(bucket, index_name, query)
+      bucket.get_index("#{index_name}_bin", query)
+    end
+  end
+end

data/lib/curator.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+
+require 'curator/migration'
+require 'curator/migrator'
+require 'curator/model'
+require 'curator/repository'
+require 'curator/riak/data_store'
+require 'curator/railtie' if defined?(Rails)
+
+module Curator
+  class << self
+    attr_accessor :environment, :migrations_path, :riak_config_file
+  end
+
+  self.environment = "development"
+  self.riak_config_file = File.expand_path(File.dirname(__FILE__) + "/../config/riak.yml")
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: curator
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Braintree
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70110328955160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70110328955160
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: &70110328954240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70110328954240
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &70110328953820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70110328953820
+- !ruby/object:Gem::Dependency
+  name: riak-client
+  requirement: &70110328952900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70110328952900
+description: Model and repository framework
+email: code@getbraintree.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/curator/migration.rb
+- lib/curator/migrator.rb
+- lib/curator/model.rb
+- lib/curator/railtie.rb
+- lib/curator/repository.rb
+- lib/curator/riak/data_store.rb
+- lib/curator.rb
+homepage: http://github.com/braintree/curator
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Model and repository framework
+test_files: []