ork 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d614293fd63e1d8d2a8de96cfb92ad40c09ebdc5
+  data.tar.gz: f487220a7969011adfe79399feb8ddcecc0d7187
+SHA512:
+  metadata.gz: 39953ee12661946b11f55e278253d8726871ff9b8d3eb3c389e9d2ba447460f8c959048c99b9d6ade5a7992974297bc7bc78d8b55ba0e7c9366c82b6492fb9ba
+  data.tar.gz: 7b565b3a8ff7901cc7457464a335a54b0c5c1a1f53cf159f87815e4402a250d168bbd275da6f7a4a12a8621c59be86e53e08cf5066e10c9eb5428ea632a6cc03

data/README.md

@@ -0,0 +1,45 @@
+# `ork`
+[![Gem Version](https://badge.fury.io/rb/ork.png)](http://badge.fury.io/rb/ork)
+[![Build Status](https://secure.travis-ci.org/eMancu/ork.png)](http://travis-ci.org/eMancu/ork)
+[![Code Climate](https://codeclimate.com/github/eMancu/ork.png)](https://codeclimate.com/github/eMancu/ork)
+[![Coverage Status](https://coveralls.io/repos/eMancu/ork/badge.png)](https://coveralls.io/r/eMancu/ork)
+[![Dependency Status](https://gemnasium.com/eMancu/ork.png)](https://gemnasium.com/eMancu/ork)
+
+`ork` is a small Ruby modeling layer for **Riak**, Basho's distributed database inspired by [Ohm](http://ohm.keyvalue.org).
+
+## Dependencies
+
+`ork` requires Ruby 1.9 or later and the `riak-client` gem to connect to **Riak**.
+
+## Getting started
+
+## Attributes
+
+Ork::Model provides one attribute type:
+
+- Ork::Model.attribute attribute
+
+And three meta types:
+
+- Ork::Model.reference  reference
+- Ork::Model.referenced referenced
+- Ork::Model.collection collection
+
+### attribute
+
+An `attribute` is just any value that can be stored.
+
+### reference
+
+It's a special kind of attribute that references another model.
+Internally, Ork will keep a pointer to the model (its ID), but you get
+accessors that give you real instances. You can think of it as the model
+containing the foreign key to another model.
+
+### referenced
+
+Provides an accessor to search for _one_ model that `reference` the current model.
+
+### collection
+
+Provides an accessor to search for _all_ models that `reference` the current model.

data/lib/ork/connection.rb

@@ -0,0 +1,28 @@
+module Ork
+  class Connection
+    attr_accessor :context, :options
+
+    def initialize(context = :main, options = {})
+      @context = context
+      @options = options
+    end
+
+    def reset!
+      threaded[context] = nil
+    end
+
+    def start(context, options = {})
+      self.context = context
+      self.options = options
+      self.reset!
+    end
+
+    def riak
+      threaded[context] ||= Riak::Client.new(options)
+    end
+
+    def threaded
+      Thread.current[:ork] ||= {}
+    end
+  end
+end

data/lib/ork/model/associations.rb

@@ -0,0 +1,138 @@
+module Ork::Model
+  module Associations
+    # A macro for defining an attribute, an index, and an accessor
+    # for a given model.
+    #
+    # Example:
+    #
+    #   class Post
+    #     include Ork::Model
+    #
+    #     reference :user, :User
+    #   end
+    #
+    #   # It's the same as:
+    #
+    #   class Post
+    #     include Ork::Model
+    #
+    #     attribute :user_id
+    #     index :user_id
+    #
+    #     def user
+    #       @_memo[:user] ||= User[user_id]
+    #     end
+    #
+    #     def user=(user)
+    #       self.user_id = user.id
+    #       @_memo[:user] = user
+    #     end
+    #
+    #     def user_id=(user_id)
+    #       @_memo.delete(:user_id)
+    #       self.user_id = user_id
+    #     end
+    #   end
+    #
+    def reference(name, model)
+      reader = :"#{name}_id"
+      writer = :"#{name}_id="
+
+      index reader
+
+      define_method(reader) do
+        @attributes[reader]
+      end
+
+      define_method(writer) do |value|
+        @_memo.delete(name)
+        @attributes[reader] = value
+      end
+
+      define_method(:"#{name}=") do |value|
+        @_memo.delete(name)
+        send(writer, value ? value.id : nil)
+      end
+
+      define_method(name) do
+        @_memo[name] ||= begin
+                           model = Ork::Utils.const(self.class, model)
+                           model[send(reader)]
+                         end
+      end
+    end
+
+    # A macro for defining a method which basically does a find.
+    #
+    # Example:
+    #   class Post
+    #     include Ork::Model
+    #
+    #     reference :user, :User
+    #   end
+    #
+    #   class User
+    #     include Ork::Model
+    #
+    #     referenced :post, :Post
+    #   end
+    #
+    #   # is the same as
+    #
+    #   class User
+    #     include Ork::Model
+    #
+    #     def post
+    #       Post.find(:user_id => self.id)
+    #     end
+    #   end
+    #
+    def referenced(name, model, reference = to_reference)
+      define_method name do
+        model = Ork::Utils.const(self.class, model)
+        model.find(:"#{reference}_id" => id).first
+      end
+    end
+
+    # A macro for defining a method which basically does a find.
+    #
+    # Example:
+    #   class Post
+    #     include Ork::Model
+    #
+    #     reference :user, :User
+    #   end
+    #
+    #   class User
+    #     include Ork::Model
+    #
+    #     collection :posts, :Post
+    #   end
+    #
+    #   # is the same as
+    #
+    #   class User
+    #     include Ork::Model
+    #
+    #     def posts
+    #       Post.find(:user_id => self.id)
+    #     end
+    #   end
+    #
+    def collection(name, model, reference = to_reference)
+      define_method name do
+        model = Ork::Utils.const(self.class, model)
+        model.find(:"#{reference}_id" => id)
+      end
+    end
+
+    private
+
+    def to_reference
+      name.to_s.
+        match(/^(?:.*::)*(.*)$/)[1].
+        gsub(/([a-z\d])([A-Z])/, '\1_\2').
+        downcase.to_sym
+    end
+  end
+end

data/lib/ork/model/class_methods.rb

@@ -0,0 +1,89 @@
+module Ork::Model
+  module ClassMethods
+    attr_writer :bucket_name
+
+    # Syntactic sugar for Model.new(atts).save
+    def create(atts = {})
+      new(atts).save
+    end
+
+    def attributes
+      @attributes ||= []
+    end
+
+    def bucket
+      Ork.riak.bucket(bucket_name)
+    end
+
+    def bucket_name
+      @bucket_name ||= self.to_s.downcase
+    end
+
+    def indices
+      @indices ||= []
+    end
+
+    def uniques
+      @uniques ||= []
+    end
+
+    protected
+
+    # Declares persisted attributes.
+    # All attributes are stored on the Riak hash.
+    #
+    # Example:
+    #   class User
+    #     include Ork::Model
+    #
+    #     attribute :name
+    #   end
+    #
+    #   # It's the same as:
+    #
+    #   class User
+    #     include Ork::Model
+    #
+    #     def name
+    #       @attributes[:name]
+    #     end
+    #
+    #     def name=(name)
+    #       @attributes[:name] = name
+    #     end
+    #   end
+    #
+    def attribute(name, cast = nil)
+      attributes << name unless attributes.include?(name)
+
+      if cast
+        define_method(name) do
+          cast[@attributes[name]]
+        end
+      else
+        define_method(name) do
+          @attributes[name]
+        end
+      end
+
+      define_method(:"#{name}=") do |value|
+        @attributes[name] = value
+      end
+    end
+
+    # Index any method on your model. Once you index a method, you can
+    # use it in `find` statements.
+    def index(attribute)
+      indices << attribute unless indices.include?(attribute)
+    end
+
+    # Create a unique index for any method on your model.
+    #
+    # Note: if there is a conflict while saving, an
+    # `Ork::UniqueIndexViolation` violation is raised.
+    #
+    def unique(attribute)
+      uniques << attribute unless uniques.include?(attribute)
+    end
+  end
+end

data/lib/ork/model/finders.rb

@@ -0,0 +1,44 @@
+module Ork::Model
+  module Finders
+
+    # Retrieve a record by ID.
+    #
+    # Example:
+    #
+    #   u = User.create
+    #   u == User[u.id]
+    #   # =>  true
+    #
+    def [](id)
+      new.send(:load!, id) if exist?(id)
+    rescue Riak::FailedRequest => e
+      raise e unless e.not_found?
+      nil
+    end
+
+    # Check if the ID exists.
+    def exist?(id)
+      !id.nil? && bucket.exists?(id)
+    end
+    alias :exists? :exist?
+
+    # Find all documents in the Document's bucket and return them.
+    # @overload list()
+    #   Get all documents and return them in an array.
+    #   @param [Hash] options options to be passed to the
+    #     underlying {Bucket#keys} method.
+    #   @return [Array<Document>] all found documents in the bucket
+    #
+    # @Note: This operation is incredibly expensive and should not
+    #   be used in production applications.
+    #
+    def all
+      bucket.keys.inject([]) do |acc, k|
+        obj = self[k]
+        obj ? acc << obj : acc
+      end
+    end
+    alias :list :all
+
+  end
+end

data/lib/ork/model.rb

@@ -0,0 +1,154 @@
+require_relative 'model/class_methods'
+require_relative 'model/associations'
+require_relative 'model/finders'
+
+module Ork
+  module Model
+    attr_reader :attributes, :id
+    attr_writer :id
+
+    def self.included(klass)
+      klass.extend(Ork::Model::ClassMethods)
+      klass.extend(Ork::Model::Associations)
+      klass.extend(Ork::Model::Finders)
+    end
+
+    # Initialize a model using a dictionary of attributes.
+    #
+    # Example:
+    #
+    #   u = User.new(:name => "John")
+    #
+    def initialize(atts = {})
+      @attributes = {}
+      @_memo = {}
+      update_attributes(atts)
+    end
+
+    # Check for equality by doing the following assertions:
+    #
+    # 1. That the passed model is of the same type.
+    # 2. That they represent the same RObject id.
+    #
+    def ==(other)
+      other.kind_of?(model) && other.id == id
+    end
+
+    alias :eql? :==
+
+    def new?
+      !id
+    end
+
+    # Pretty print for the model
+    #
+    #  Example:
+    #
+    #    User.new(name: 'John').inspect
+    #    # => #<User:6kS5VHNbaed9h7gFLnVg5lmO4U7 {:name=>"John"}>
+    def inspect
+      "#<#{model}:#{id || 'nil'} #{attributes.inspect}>"
+    end
+
+    # Update the model attributes and call save.
+    #
+    # Example:
+    #
+    #   User[1].update(:name => "John")
+    #
+    #   # It's the same as:
+    #
+    #   u = User[1]
+    #   u.update_attributes(:name => "John")
+    #   u.save
+    #
+    def update(attributes)
+      update_attributes(attributes)
+      save
+    end
+
+    # Write the dictionary of key-value pairs to the model.
+    #
+    def update_attributes(atts)
+      atts.delete('_type')
+      atts.each { |att, val| send(:"#{att}=", val) }
+    end
+
+    # Delete the model
+    def delete
+      __robject.delete unless new?
+      freeze
+    rescue Riak::FailedRequest
+      false
+    end
+
+    # Persist the model attributes and update indices and unique
+    # indices.
+    #
+    # If the model is not valid, nil is returned. Otherwise, the
+    # persisted model is returned.
+    #
+    # Example:
+    #
+    #   class User
+    #     include Ork::Model
+    #
+    #     attribute :name
+    #
+    #     def validate
+    #       assert_present :name
+    #     end
+    #   end
+    #
+    #   User.new(:name => nil).save
+    #   # => nil
+    #
+    #   u = User.new(:name => "John").save
+    #   # => #<User:6kS5VHNbaed9h7gFLnVg5lmO4U7 {:name=>"John"}>
+    #
+    def save
+      # FIXME: Work with validations, scrivener or hatch?
+      # save! if valid?
+      save!
+    end
+
+    # Saves the model without checking for validity. Refer to
+    # `Model#save` for more details.
+    def save!
+      __save__
+    end
+
+    # Preload all the attributes of this model from Riak.
+    def reload
+      new? ? self : self.load!(@id)
+    end
+
+    protected
+
+    def load!(id)
+      @id = self.__robject.key = id
+      @__robject = @__robject.reload(force: true)
+      update_attributes(@__robject.data)
+
+      self
+    end
+
+    # Persist the object in Riak database
+    def __save__
+      __robject.content_type = 'application/json'
+      __robject.data = @attributes.merge('_type' => model.name)
+      __robject.store
+      @id = __robject.key
+
+      self
+    end
+
+    def __robject
+      @__robject ||= model.bucket.new
+    end
+
+    def model
+      self.class
+    end
+  end
+end

data/lib/ork/utils.rb

@@ -0,0 +1,35 @@
+module Ork
+  # Instead of monkey patching Kernel or trying to be clever, it's
+  # best to confine all the helper methods in a Utils module.
+  module Utils
+
+    # Used by: `attribute`, `reference`, `collection`.
+    #
+    # Employed as a solution to avoid `NameError` problems when trying
+    # to load models referring to other models not yet loaded.
+    #
+    # Example:
+    #
+    #   class Comment
+    #     include Ork::Model
+    #
+    #     reference :user, User # NameError undefined constant User.
+    #   end
+    #
+    #   Instead of relying on some clever `const_missing` hack, we can
+    #   simply use a Symbol.
+    #
+    #   class Comment
+    #     include Ork::Model
+    #
+    #     reference :user, :User
+    #   end
+    #
+    def self.const(context, name)
+      case name
+      when Symbol then context.const_get(name)
+      else name
+      end
+    end
+  end
+end

data/lib/ork/version.rb

@@ -0,0 +1,3 @@
+class Ork
+  VERSION = "0.0.1"
+end

data/lib/ork.rb

@@ -0,0 +1,36 @@
+require 'ork/connection'
+require 'ork/model'
+require 'ork/utils'
+require "riak"
+
+module Ork
+  class Error < StandardError; end
+
+  def self.conn
+    @conn ||= Ork::Connection.new
+  end
+
+  # Stores the connection options for the Riak instance.
+  #
+  # Examples:
+  #
+  #   Ork.connect(:http_port => 6380, :pb_port => 15000)
+  #
+  # All of the options are simply passed on to `Riak::Client.new`.
+  #
+  def self.connect(context = :main, options = {})
+    conn.start(context, options)
+  end
+
+  # Use this if you want to do quick ad hoc riak commands against the
+  # defined Ork connection.
+  #
+  # Examples:
+  #
+  #   Ork.riak.buckets
+  #   Ork.riak.bucket('foo').keys
+  #
+  def self.riak
+    conn.riak
+  end
+end

data/ork.gemspec

@@ -0,0 +1,24 @@
+Gem::Specification.new do |s|
+  s.name        = 'ork'
+  s.version     = '0.0.1'
+  s.date        = Time.now.strftime('%Y-%m-%d')
+  s.summary     = 'Ruby modeling layer for Riak.'
+  s.description = 'Ork is a small Ruby modeling layer for Riak, inspired by Ohm.'
+  s.authors     = ['Emiliano Mancuso']
+  s.email       = ['emiliano.mancuso@gmail.com']
+  s.homepage    = 'http://github.com/eMancu/ork'
+  s.license     = 'MIT'
+
+  s.files = Dir[
+    'README.md',
+    'rakefile',
+    'lib/**/*.rb',
+    '*.gemspec'
+  ]
+  s.test_files = Dir['test/*.*']
+
+  s.add_dependency 'riak-client'
+  s.add_development_dependency 'protest'
+  s.add_development_dependency 'toml-rb'
+end
+

data/rakefile

@@ -0,0 +1,31 @@
+require "rake/testtask"
+
+task :default => :test
+
+desc 'Start riak test server'
+task :start do
+  require File.expand_path("./test/helper", File.dirname(__FILE__))
+  puts '..:: Starting riak test server ::..'
+  test_server.start
+end
+
+desc 'Run tests'
+task :test => [:start] do
+  Dir["test/*.rb"].each { |file| load file unless file =~ /helper.rb/ }
+end
+
+desc 'Stop riak test server'
+task :stop => [:start] do
+  puts '..:: Stop riak test server ::..'
+
+  flush_db!
+  test_server.stop
+end
+
+at_exit do
+  puts '..:: Stop riak test server ::..'
+  sleep 1
+
+  flush_db!
+  test_server.stop
+end

data/test/finders.rb

@@ -0,0 +1,43 @@
+require_relative 'helper'
+
+class Human
+  include Ork::Model
+
+  attribute :name
+  attribute :last_name
+
+  unique :name
+  index :last_name
+end
+
+Protest.describe 'Finders' do
+  setup do
+    @human1 = Human.create(name: 'Tony',  last_name: 'Montana')
+    @human2 = Human.create(name: 'Cacho', last_name: 'Castaña')
+  end
+
+  teardown do
+    flush_db!
+  end
+
+  test 'retrieve an object by id' do
+    assert_equal @human1, Human[@human1.id]
+  end
+
+  test 'return nil when the id does not belong to an object of this bucket' do
+    assert_equal nil, Human['not_an_id']
+  end
+
+  test 'if exist an object with the id' do
+    assert !Human.exist?(nil)
+    assert !Human.exist?('not_an_id')
+    assert Human.exist?(@human1.id)
+  end
+
+  test 'list all the objects' do
+    assert_equal 2, Human.list.size
+    assert Human.list.include?(@human1)
+    assert Human.list.include?(@human2)
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,41 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib"))
+
+require "rubygems"
+require "protest"
+require "ork"
+
+# require 'coveralls'
+# Coveralls.wear!
+
+Riak.disable_list_keys_warnings = true
+
+require 'riak/test_server'
+
+def test_server
+  $test_server ||= begin
+     require 'toml'
+     path = File.expand_path("../test_riak_server.toml", __FILE__)
+     config = TOML.load_file(path, symbolize_keys: true)
+
+
+     server = Riak::TestServer.create(root: config[:root],
+                                      source: config[:source],
+                                      min_port: config[:min_port])
+
+
+     Ork.connect(:test, {
+      http_port: server.http_port,
+      pb_port:   server.pb_port
+     })
+
+     server
+   rescue => e
+     puts ("Can't run Ork tests without the test server.\n" +
+             "Specify the location of your Riak installation in test/test_riak_server.toml\n" +
+             e.inspect)
+   end
+end
+
+def flush_db!
+  test_server.drop
+end

data/test/model.rb

@@ -0,0 +1,139 @@
+# encoding: UTF-8
+require_relative 'helper'
+
+class Event
+  include Ork::Model
+
+  attribute :name
+  attribute :location
+
+  unique :name
+  index :location
+end
+
+Protest.describe 'Ork::Model' do
+  context 'Definition' do
+    test 'have an attributes list' do
+      assert_equal [:name, :location], Event.attributes
+    end
+
+    test 'have a uniques list' do
+      assert_equal [:name], Event.uniques
+    end
+
+    test 'have an indices list' do
+      assert_equal [:location], Event.indices
+    end
+
+    test 'model owns a bucket name by default' do
+      assert_equal 'event', Event.bucket_name
+    end
+
+    test 'generate accessors for attributes' do
+      event = Event.new
+
+      assert event.respond_to? :name
+      assert event.respond_to? :name=
+      assert event.respond_to? :location
+      assert event.respond_to? :location=
+    end
+
+    test 'cast to different types' do
+      pending 'Define how to cast objects'
+    end
+
+    test 'model can change bucket name' do
+      Event.bucket_name= 'other_bucket_for_event'
+      assert_equal 'other_bucket_for_event', Event.bucket_name
+    end
+
+    test 'there is a Riak::Bucket corresponding to the model' do
+      assert_equal Riak::Bucket, Event.bucket.class
+    end
+  end
+
+  context 'Instance' do
+    setup do
+      @event = Event.new(name: 'Ruby')
+    end
+
+    test 'determine if it is a new instance or it was saved' do
+      assert @event.new?
+      @event.save
+      assert !@event.new?
+    end
+
+    test 'assign attributes from the hash' do
+      assert_equal 'Ruby', @event.name
+    end
+
+    test 'inspect a new object shows the class, attributes with id nil' do
+      assert_equal '#<Event:nil {:name=>"Ruby"}>', @event.inspect
+    end
+
+    test 'inspect a saved object shows the class, attributes with id nil' do
+      @event.save
+      assert_equal '#<Event:' + @event.id + ' {:name=>"Ruby"}>', @event.inspect
+    end
+
+    test 'assign an ID and save the object' do
+      event = Event.create(name: 'Ruby')
+
+      assert !event.new?
+      assert !event.id.nil?
+    end
+
+    test 'update and save the attributes in UTF8' do
+      @event.update(name: '32° Kisei-sen')
+      assert_equal '32° Kisei-sen', Event[@event.id].name
+    end
+
+    test 'update_attributes changes attributes but does not save the object' do
+      assert @event.new?
+      assert_equal 'Ruby', @event.name
+
+      @event.update_attributes(name: 'Emerald', location: 4)
+
+      assert @event.new?
+      assert_equal 'Emerald', @event.name
+      assert_equal 4, @event.location
+    end
+
+    context 'Deletion' do
+      test 'freeze the object' do
+        assert !@event.frozen?
+        @event.delete
+        assert @event.frozen?
+      end
+
+      test 'delete the object from the bucket' do
+        @event.save
+        assert Event.bucket.exist?(@event.id)
+        @event.delete
+        assert !Event.bucket.exist?(@event.id)
+      end
+    end
+  end
+
+  context "Equality" do
+    setup do
+      @event = Event.new(name: 'Ruby')
+      @other = Event.new(name: 'Emerald')
+    end
+
+    test 'different types' do
+      assert @event != 'Not an event'
+    end
+
+    test 'saved instances with different ids' do
+      @event.save
+      @other.save
+
+      assert @event != @other
+    end
+
+    test 'unsaved intances' do
+      pending 'Define how equality will be'
+    end
+  end
+end

data/test/reference.rb

@@ -0,0 +1,73 @@
+require_relative 'helper'
+
+class Post
+  include Ork::Model
+  attribute :name
+end
+
+class Comment
+  include Ork::Model
+  attribute :text
+
+  reference :post, :Post
+  reference :weird_post, :Post
+end
+
+Protest.describe 'reference' do
+  teardown do
+    flush_db!
+  end
+
+  should 'return nil when there is no reference object' do
+    comment = Comment.new
+
+    assert comment.post.nil?
+  end
+
+  should 'raise an exception assigning an object of the wrong type' do
+    pending 'Not sure to support this'
+    assert_raise(Error) do
+      Comment.new post: 'Not a post'
+    end
+  end
+
+  should 'return the object referenced' do
+    post = Post.create name: 'New'
+    comment = Comment.new post: post
+
+    assert_equal post, comment.post
+    assert_equal post.id, comment.post_id
+  end
+
+  test 'object reference with not default key' do
+    post = Post.create name: 'New'
+    comment = Comment.new weird_post: post
+
+    assert_equal post, comment.weird_post
+    assert_equal post.id, comment.weird_post_id
+  end
+
+  should 'update reference to an object given the id or object' do
+    post = Post.create name: 'New'
+    comment = Comment.new
+
+    assert comment.post.nil?
+    assert comment.post_id.nil?
+
+    comment.post = post
+
+    assert_equal post, comment.post
+    assert_equal post.id, comment.post_id
+
+    post = Post.create name: 'Other'
+    comment.post_id = post.id
+
+    assert_equal post, comment.post
+    assert_equal post.id, comment.post_id
+  end
+
+  context 'Deletion' do
+    # Discuss if we want cascade all deletetion and that sort of things
+  end
+
+end

data/test/test_riak_server.toml

@@ -0,0 +1,15 @@
+# This is where the test server node will be generated. Something on
+# /tmp is usually ok.
+root = "/tmp/.ork_node"
+min_port = 15000
+
+# This is where Riak is installed on your system, that is, the path to
+# the 'riak' and 'riak-admin' scripts. I use a self-built node, but
+# here's where it will generally be on various platforms:
+#
+#                Linux:  /usr/sbin
+#  Solaris/OpenSolaris:  /opt/riak/bin
+#  Mac OS/X (Homebrew):  /usr/local/bin
+#    Source/Self built:  /path/to/your/install/rel/riak/bin
+#
+source = "/usr/local/bin"

data/test/test_riak_server.toml.example

@@ -0,0 +1,15 @@
+# This is where the test server node will be generated. Something on
+# /tmp is usually ok.
+root = "/tmp/.ork_node"
+min_port = 15000
+
+# This is where Riak is installed on your system, that is, the path to
+# the 'riak' and 'riak-admin' scripts. I use a self-built node, but
+# here's where it will generally be on various platforms:
+#
+#                Linux:  /usr/sbin
+#  Solaris/OpenSolaris:  /opt/riak/bin
+#  Mac OS/X (Homebrew):  /usr/local/bin
+#    Source/Self built:  /path/to/your/install/rel/riak/bin
+#
+source = "/usr/local/bin"

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: ork
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Emiliano Mancuso
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: riak-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: protest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: toml-rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ork is a small Ruby modeling layer for Riak, inspired by Ohm.
+email:
+- emiliano.mancuso@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- rakefile
+- lib/ork/connection.rb
+- lib/ork/model/associations.rb
+- lib/ork/model/class_methods.rb
+- lib/ork/model/finders.rb
+- lib/ork/model.rb
+- lib/ork/utils.rb
+- lib/ork/version.rb
+- lib/ork.rb
+- ork.gemspec
+- test/finders.rb
+- test/helper.rb
+- test/model.rb
+- test/reference.rb
+- test/test_riak_server.toml
+- test/test_riak_server.toml.example
+homepage: http://github.com/eMancu/ork
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Ruby modeling layer for Riak.
+test_files:
+- test/finders.rb
+- test/helper.rb
+- test/model.rb
+- test/reference.rb
+- test/test_riak_server.toml
+- test/test_riak_server.toml.example