rrod 0.0.1 → 1.0.0.alpha.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 483487fdba1ca64ce64a80010c2c9381ae9e471a
-  data.tar.gz: b6be998e8cbbcd06e65ed0b89b7114465d00727c
+  metadata.gz: 54fca12a0dd242e700196f2689c7e0c10b20f238
+  data.tar.gz: a218efee402307b755b0e681d1872d231d619771
 SHA512:
-  metadata.gz: f2a3a7e0d98d410a876392c8121f9b5a3ec5537b2a6a265ed159ebb88a438275f22b44296f5ec6c076b309683672641568461baf6ca07ff44a6de3adae3cb6b7
-  data.tar.gz: c29f1826f9aaf76b048cbe286e2c3434c48f38b955f6ae3030735a7b2422c06d178a1145547be4f62cce952940c4efd8b4acfdc8a59d36ce08e3021557bfad92
+  metadata.gz: e4d07847ef76659034a92ca8dcc2711dd47af332dd8e525a411a226885df9fc6de90542fb155d289a941fd89236d6d14bf7466a852db9f5d347d0c8096584abc
+  data.tar.gz: 48e8aca8812277c91321f8120785d399a2c9d3a8c4cbca7732c24ad8a0cff4abab4a9a75af0f395b1414af69f813c7ebf2f1d88faf9ad46663e9fef84223b9e4

data/.gitignore

@@ -4,6 +4,7 @@
 .config
 .ruby-gemset
 .ruby-version
+.tmp
 .yardoc
 Gemfile.lock
 InstalledFiles
@@ -14,6 +15,7 @@ lib/bundler/man
 pkg
 rdoc
 spec/reports
+spec/support/test_server.yml
 test/tmp
 test/version_tmp
 tmp

data/README.md

@@ -1,36 +1,51 @@
+<!--- TODO use consistent capitalization with Rrod and Riak as well as backticks-->
 # Rrod
 ### Riak ruby object database.
 Rrod lets you use the super awesome database, riak, to model and persist your
 ruby objects.
 
-# Riak
-First, you must make sure you have Riak installed. See:
-http://docs.basho.com/riak/latest/quickstart/#Install-Riak.
-These guys have extremely good docs 
-and will usually answer your questions in IRC #riak.  
+## Riak Installation
+First, you must make sure you 
+[have Riak installed](http://docs.basho.com/riak/latest/quickstart/#Install-Riak).
+These guys have extremely good docs and will usually answer your questions 
+in freenode IRC #riak.  You must also make sure you have 
+[enabled search](http://docs.basho.com/riak/latest/ops/advanced/configs/search/) 
+for your Riak installation.  
 
-## Installation
+## Rrod Installation
 Add `rrod` to your Gemfile and run `bundle` or execute `gem install rrod`.
 
-# Usage
-Once you have riak and rrod installed, make sure you know the port of one of your
-riak nodes.  Usually `8098`.
+## Usage
+Once you have Riak and Rrod installed you can begin to play.  `Rrod` will
+connect to Riak on localhost using protocol buffers on port 8087.  What you
+say? Don't worry about it.  
 
-In terminal, run:
+Next, if you installed Rrod by adding it to your Gemfile, run
 
-  $ rrod irb
+```
+$ bundle exec rrod pry
+```
 
-This will set you up with an irb environment with rrod loaded.  Then run the
-following commands.
+Otherwise, if you installed using `gem install rrod`, run:
+
+```
+$ rrod pry
+```
+
+This will set you up with an pry environment with `Rrod` loaded.  
+Next you will wave your magic wand and enter the following incantations:
 
 ```ruby
-Car = Class.new(Rrod::Document)
-car = {wheels: 4, color: :black, make: 'Jeep'}
-Car.persist(car)
-@car = Car.first
-@car.color
+Car = Class.new { include Rrod::Model }
+car = Car.new(wheels: 5, color: 'black', make: 'Jeep')
+car.save
+@car = Car.find_first_by make: 'Jeep'
+@car.wheels # => 5
 ```
 
+`Rrod` lets you have arbitrary attributes on your ruby objects and persist and
+retreive them from Riak.
+
 ## Contributing
 
 1. Fork it

data/lib/rrod/all.rb

@@ -1 +1,24 @@
-require 'rrod/version'
+require 'active_model'
+require 'active_support/concern'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/string/conversions'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/string/starts_ends_with'
+require 'american_date'
+require 'bigdecimal'
+require 'riak'
+
+require 'rrod/version' # first
+require 'rrod/configuration'
+require 'rrod/caster'
+require 'rrod/caster/nested_model'
+require 'rrod/model/attribute'
+require 'rrod/model/attribute_methods'
+require 'rrod/model/collection'
+require 'rrod/model/finders'
+require 'rrod/model/persistence'
+require 'rrod/model/schema'
+require 'rrod/model/serialization'
+require 'rrod/model'
+require 'rrod/query'

data/lib/rrod/caster/nested_model.rb

@@ -0,0 +1,16 @@
+module Rrod
+  class Caster
+    module NestedModel
+
+      def rrod_cast(values)
+        return if values.nil?
+        Rrod::Model::Collection.new(values.map { |value| model.rrod_cast(value) })
+      end
+
+      def model
+        first
+      end
+
+    end
+  end
+end

data/lib/rrod/caster.rb

@@ -0,0 +1,34 @@
+module Rrod
+  class Caster
+
+    def initialize(&casting)
+      @casting = casting
+    end
+
+    def rrod_cast(value)
+      return if value.nil?
+      @casting.(value)
+    end
+            
+    module Boolean
+      extend self
+      def rrod_cast(value)
+        [nil, false, 'false', 0, '0'].include?(value) ? false : true
+      end
+    end
+
+    BigDecimal = new { |value| ::BigDecimal.new(value.to_s) } 
+    Date       = new { |value| value.to_date }
+    DateTime   = new { |value| value.to_datetime }
+    Float      = new { |value| value.to_f }
+    Integer    = new { |value| value.to_i }
+    Numeric    = new { |value| 
+      float_value = value.to_f
+      int_value   = value.to_i
+      float_value == int_value ? int_value : float_value
+    }
+    String     = new { |value| value.to_s }
+    Symbol     = new { |value| value.to_sym }
+    Time       = new { |value| value.to_time }
+  end
+end

data/lib/rrod/cli.rb

@@ -1,16 +1,23 @@
 require 'thor'
+require 'rrod'
 
 module Rrod
   class Cli < Thor
     package_name "Rrod"
   
     map "-i" => :pry
+    map "-t" => :test
 
     desc "pry", "start an interactive ruby session with Rrod loaded"
     def pry
       require 'pry'
-      require 'rrod'
-      Class.new { pry }
+      TOPLEVEL_BINDING.pry
+    end
+
+    desc "test", "start the Rrod::TestServer"
+    def test
+      require 'rrod/test_server/runner'
+      Rrod::TestServer::Runner.run
     end
   end
 end

data/lib/rrod/configuration.rb

@@ -0,0 +1,40 @@
+module Rrod
+  module Config
+    def configure
+      yield configuration if block_given?
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+  end
+
+  extend Config
+
+  class Configuration
+    attr_accessor :client, :http_port, :pb_port, :protocol, 
+      :test_server_yml, :test_server_search_startup_timeout, :nodes
+
+    def initialize
+      @protocol        = 'pbc'
+      @test_server_yml = File.expand_path('spec/support/test_server.yml', '.')
+      @test_server_search_startup_timeout = 40 # because it's a test
+    end
+
+    def client
+      @client ||= Riak::Client.new(client_options)
+    end
+
+    private
+
+    def client_options
+      attributes = %w[http_port pb_port protocol nodes]
+      attributes.inject({}) do |acc, method|
+        acc.tap { |hash|
+          value = public_send(method)
+          hash[method.to_sym] = value unless value.nil?
+        }
+      end
+    end
+  end
+end

data/lib/rrod/model/attribute.rb

@@ -0,0 +1,80 @@
+module Rrod
+  module Model
+    class Attribute
+
+      def self.reader_definition(name)
+        -> { read_attribute name }
+      end
+
+      def self.writer_definition(name)
+        ->(value) { write_attribute name, value }
+      end
+       
+      attr_accessor :model, :name, :type, :options, :default
+
+      # @param [Class] The class that is declaring the attribute
+      # @param [Symbol] The name of the attribute
+      # @param [Class] The type of the attribute for marshalling
+      # @param [Hash] Options for the attribute (they are optional).
+      def initialize(model, name, type, options={})
+        self.model   = model
+        self.name    = name.to_sym
+        self.type    = type
+        self.default = options.delete(:default)
+        self.options = options
+      end
+
+      # @return [Object] default value or result of call on default value
+      def default
+        @default.respond_to?(:call) ? @default.call : @default
+      end
+
+      def define
+        define_reader
+        define_writer
+        apply_validators
+        self
+      end
+
+      def cast(value)
+        caster = type.respond_to?(:rrod_cast) ? type : rrod_caster
+        caster ? caster.rrod_cast(value) : value
+      end
+
+      private
+
+      def name=(value)
+        @name = value.to_sym
+      end
+
+      def type=(value)
+        @type = value
+        @type.extend(Rrod::Caster::NestedModel) if nested_model?
+      end
+
+      def nested_model?
+        type.is_a?(Array) and type.first.ancestors.include?(Rrod::Model)
+      end
+
+      def define_reader
+        model.send :define_method, name, self.class.reader_definition(name)
+      end
+
+      def define_writer
+        model.send :define_method, "#{name}=", self.class.writer_definition(name)
+      end
+
+      def apply_validators
+        model.validates name, options if options.present?
+      end
+
+      def rrod_caster
+        "Rrod::Caster::#{type}".constantize
+      rescue NameError
+      end
+    end
+  end
+end
+
+# stand-in for true/false attribute types
+Boolean = Module.new unless defined? ::Boolean

data/lib/rrod/model/attribute_methods.rb

@@ -0,0 +1,85 @@
+module Rrod
+  module Model
+    module AttributeMethods
+
+      def initialize(attributes = {})
+        @attributes        = {}
+        self.magic_methods = attributes.keys
+        self.attributes    = attributes
+      end
+
+      def id
+        read_attribute :id
+      end
+
+      def id=(value)
+        write_attribute :id, value
+      end
+
+      # Returns a new hash with all of the object's attributes.
+      # @return [Hash] the object's attributes
+      def attributes
+        @attributes.keys.inject({}) { |acc, key|
+          acc.tap { |hash| hash[key] = respond_to?(key) ? public_send(key) : nil }
+        }
+      end
+
+      # Mass assign the attributes of the object.
+      # @param [Hash] the attributes to mass assign
+      def attributes=(attrs)
+        attrs.each do |key, value|
+          public_send "#{key}=", value
+        end
+      end
+
+      # Read a single attribute of the object.
+      # @param [Symbol, String] the key of the attribute to read
+      # @return the attribute at the given key
+      def read_attribute(key)
+        @attributes[key.to_s]
+      end
+      alias :[] :read_attribute
+
+      # Write a given value to the attributes for a given key.
+      # @param [Symbol, String] the key of the attribute to write
+      # @param the value to write to attributes
+      def write_attribute(key, value)
+        @attributes[key.to_s] = self.class.cast_attribute(key, value)
+      end
+      alias :[]= :write_attribute
+
+      private
+
+      def magic_methods=(keys)
+        return if self.class.schema? # classes with attributes don't get magic methods
+        @magic_methods = keys.inject([]) { |acc, k| acc << k.to_s << "#{k}=" }
+      end
+
+      def magic_methods
+        @magic_methods || []
+      end
+
+      def define_singleton_reader(attribute)
+        define_singleton_method attribute, Attribute.reader_definition(attribute)
+      end
+
+      def define_singleton_writer(attribute)
+        define_singleton_method "#{attribute}=", Attribute.writer_definition(attribute)
+      end
+
+      def method_missing(method_id, *args, &block)
+        method = method_id.to_s
+        return super unless magic_methods.include?(method)
+
+        accessor = method.ends_with?('=') ? :writer : :reader
+        send "define_singleton_#{accessor}", method.chomp('=')
+        send method_id, *args
+      end
+
+      def respond_to_missing?(*args)
+        magic_methods.include? args.first.to_s
+      end
+
+    end
+  end
+end

data/lib/rrod/model/collection.rb

@@ -0,0 +1,37 @@
+module Rrod
+  module Model
+    class Collection
+      include Enumerable
+
+      delegate(*%w[clear count each length size], to: :collection)
+
+      def initialize(collection=[])
+        self.collection = collection
+      end
+
+      def collection=(collection)
+        raise InvalidCollectionTypeError.new unless collection.respond_to?(:each)
+        collection.map { |member| push member }
+      rescue InvalidMemberTypeError => e
+        clear and raise e
+      end
+
+      def collection
+        @collection ||= []
+      end
+
+      def push(value)
+        raise InvalidMemberTypeError.new unless Rrod::Model === (value)
+        collection.push(value)
+      end
+      alias :<< :push
+
+      def serializable_hash(*)
+        collection.map(&:serializable_hash)
+      end
+
+      InvalidCollectionTypeError = Class.new(StandardError)
+      InvalidMemberTypeError     = Class.new(StandardError)
+    end
+  end
+end

data/lib/rrod/model/finders.rb

@@ -0,0 +1,59 @@
+module Rrod
+  module Model
+    module Finders
+
+      def find(id)
+        find_one(id).tap { |found| raise NotFound.new if found.nil? }
+      end
+
+      def find_one(id)
+        robject = bucket.get(id) 
+        found(id, robject.data, robject) 
+      rescue Riak::FailedRequest => e 
+        raise e unless e.not_found?
+      end
+
+      def find_first_by(attributes)
+        query = Query.new(attributes)
+
+        if query.using_id?
+          find_one(query.id)
+        else
+          docs = search(query)
+          docs.any? ? found(nil, docs.first) : nil
+        end
+      end
+
+      def find_first_by!(attributes)
+        find_first_by(attributes).tap { |model| raise NotFound.new if model.nil? }
+      end
+
+      def find_all_by(attributes)
+        query = Query.new(attributes)
+        raise ArgumentError.new('Cannot pass id to find_all_by') if query.using_id?
+        search(query).map { |doc| found(nil, doc) }
+      end
+
+      def find_all_by!(attributes)
+        find_all_by(attributes).tap { |models| raise NotFound.new if models.empty? }
+      end
+
+      private
+
+      def search(query)
+        client.search(bucket_name, query.to_s)['docs']
+      end
+
+      def found(key, data, robject=nil)
+        new(data).tap { |instance| 
+          instance.id      = key
+          instance.robject = robject
+          instance.instance_variable_set(:@persisted, true)
+        }
+      end
+
+    end
+
+    NotFound = Class.new(StandardError)
+  end
+end

data/lib/rrod/model/persistence.rb

@@ -0,0 +1,35 @@
+module Rrod
+  module Model
+    module Persistence
+      attr_accessor :robject
+
+      def persisted?
+        @persisted
+      end
+
+      def new?
+        !persisted?
+      end
+      alias :new_record? :new?
+
+      def save(options={})
+        options.fetch(:validate, true) ? 
+          (valid? and persist) : persist
+      end
+
+      def persist
+        bucket.enable_index!
+        robject.raw_data = to_json
+        robject.key = id unless id.nil?
+        robject.store
+        self.id = robject.key
+        @persisted = true
+      end
+
+      def robject
+        @robject ||= bucket.new
+      end
+    end
+  end
+end
+

data/lib/rrod/model/schema.rb

@@ -0,0 +1,30 @@
+module Rrod
+  module Model
+    module Schema
+
+      def attributes
+        @attributes ||= {}
+      end
+
+      def attribute(name, type, options={})
+        attributes[name.to_sym] = Attribute.new(self, name, type, options).define
+      end
+
+      def cast_attribute(key, value)
+        attribute = attributes[key.to_sym]
+        attribute ? attribute.cast(value) : value
+      end
+
+      def schema?
+        attributes.any?
+      end
+
+      def rrod_cast(value)
+        return       if value.nil?
+        return value if value.is_a?(Rrod::Model)
+        found(nil, value)
+      end
+
+    end
+  end
+end

data/lib/rrod/model/serialization.rb

@@ -0,0 +1,12 @@
+module Rrod
+  module Model
+    module Serialization
+
+      def read_attribute_for_serialization(key)
+        value = read_attribute(key)
+        value.respond_to?(:serializable_hash) ? value.serializable_hash : value
+      end
+
+    end
+  end
+end

data/lib/rrod/model.rb

@@ -0,0 +1,38 @@
+module Rrod
+  module Model
+    extend  ActiveSupport::Concern
+
+    include AttributeMethods
+    include Persistence
+    include Serialization
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+    include ActiveModel::Validations
+
+    module ClassMethods
+      include Finders
+      include Schema
+
+      def client
+        Rrod.configuration.client
+      end
+
+      def bucket
+        @bucket ||= client[bucket_name]
+      end
+
+      # TODO make class attribute
+      def bucket_name
+        name.tableize
+      end
+    end
+
+    def client
+      self.class.client
+    end
+
+    def bucket
+      self.class.bucket
+    end
+  end
+end

data/lib/rrod/query.rb

@@ -0,0 +1,30 @@
+module Rrod
+  class Query
+    attr_accessor :options
+
+    def initialize(options)
+      self.options = options
+    end
+
+    def id
+      options[:id]
+    end
+
+    def using_id?
+      id.present?
+    end
+
+    def to_s
+      options.map { |key, value| "#{key}:#{value}" }.join(" AND ")
+    end
+
+    def options=(options)
+      @options = options.with_indifferent_access
+      raise ArgumentError.new("no search options") if options.blank?
+      raise ArgumentError.new("cannot mix id with other options") if using_id? and options.keys.count > 1
+    rescue => e
+      @options.clear and raise e
+    end
+
+  end
+end