risky 0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2011 Kyle Kingsbury
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,58 @@
+Risky
+=====
+
+A simple, lightweight object layer for Riak.
+
+    class User < Risky
+      bucket :users
+    end
+
+    User.new('clu', 'fights' => 'for the users').save
+
+    User['clu']['fights'] #=> 'for the users'
+
+Built on top of seancribb's excellent riak-client, Risky provides basic
+infrastructure for designing models with attributes (including defaults and
+casting to/from JSON), validation, lifecycle callbacks, link-walking,
+mapreduce, and more. Modules are available for timestamps, chronologically ordered lists, and basic secondary indexes.
+
+Risky does not provide the rich API of Ripple, but it also does not require activesupport. It strives to be understandable, minimal, and modular. Magic is avoided in favor of module composition and a compact API.
+
+Risky stores every instance of a model in a given bucket, indexed by key. Objects are stored as JSON hashes.
+
+Show me the code!
+-----------------
+
+    class User < Risky
+      include Risky::Indexes
+      include Risky::Timestamps
+
+      bucket :users
+
+      # Provides user.name instead of user['name']
+      value :name
+      value :twitter, :default => {}
+
+      # :class is used to cast times from JSON back into Time objects.
+      value :updated_at, :class => Time
+      value :created_at, :class => Time
+
+      # Provides User.by_name. Changing the name stores an object in the
+      # users_by_name bucket, with key user.name, linking back to us. A validate
+      # function is used to ensure uniqueness before saving.
+      index :name, :unique => true
+
+      # Here, a custom proc returns the key used for the index.
+      index :twitter_id, :proc => lambda { |user| user.twitter['id'] }
+
+      # Provides user.followers, a list of links with the 'followers' tag.
+      links :followers
+    end
+
+License
+-------
+
+Risky was developed by Kyle Kingsbury <aphyr@aphyr.com> at http://vodpod.com,
+for their iPad social video app "Showyou". Generous thanks to Sean Cribbs, Mark
+Phillips, the Basho team, and all the other #riak'ers. Released under the MIT
+license.

data/lib/risky.rb

@@ -0,0 +1,499 @@
+class Risky
+  require 'riak'
+
+  $LOAD_PATH << File.expand_path(File.dirname(__FILE__))
+ 
+  # Exceptions
+  require 'risky/invalid'
+  require 'risky/not_found'
+  
+  # Plugins
+  require 'risky/cron_list'
+  require 'risky/indexes'
+  require 'risky/timestamps'
+
+  include Enumerable
+
+  # Get a model by key. Returns nil if not found. You can also pass opts to
+  # #reload (e.g. :r, :merge => false).
+  def self.[](key, opts = {})
+    return nil unless key
+
+    begin
+      new(key).reload(opts)
+    rescue Riak::FailedRequest => e
+      raise unless e.code.to_i == 404
+      nil
+    end
+  end
+
+  # Returns all model instances from the bucket. Why yes, this *could* be
+  # expensive, Suzy!
+  def self.all(opts = {:reload => true})
+    bucket.keys(opts).map do |key|
+      self[key]
+    end
+  end
+
+  # Indicates that this model may be multivalued; in which case .merge should
+  # also be defined.
+  def self.allow_mult
+    unless bucket.props['allow_mult']
+      bucket.props = bucket.props.merge('allow_mult' => true)
+    end
+  end
+
+  # The Riak::Bucket backing this model.
+  # If name is passed, *sets* the bucket name.
+  def self.bucket(name = nil)
+    if name
+      @bucket_name = name.to_s
+    end
+  
+    riak.bucket(@bucket_name)
+  end
+
+  # The string name of the bucket used for storing instances of this model.
+  def self.bucket_name
+    @bucket_name
+  end
+
+  def self.bucket_name=(bucket)
+    @bucket_name = name.to_s
+  end
+
+  # Casts data to appropriate types for values.
+  def self.cast(data)
+    casted = {}
+    data.each do |k, v|
+      c = @values[k][:class] rescue nil
+      casted[k] = begin
+        if c == Time
+          Time.iso8601(v)
+        else
+          v
+        end
+      rescue
+        v
+      end
+    end
+    casted
+  end
+
+  # Counts the number of models via MR
+  def self.count
+    map("
+      function(v) {
+         return [1];
+      };
+    ").reduce("
+      function(counts, arg) {
+        return [
+          counts.reduce(
+            function(acc, value) {
+              return acc + value
+            }, 0)
+        ];
+      }
+    ", :keep => true).run.first
+  end
+
+  # Returns true when record deleted.
+  # Returns nil when record was not present to begin with.
+  def self.delete(key, opts = {})
+    return if key.nil?
+    (bucket.delete(key.to_s, opts)[:code] == 204) or nil
+  end
+
+  # Iterate over all items using key streaming.
+  def self.each
+    bucket.keys(:reload => true) do |keys|
+      keys.each do |key|
+        yield self[key]
+      end
+    end
+  end
+
+  # Does the given key exist in our bucket?
+  def self.exists?(key)
+    return if key.nil?
+    bucket.exists? key.to_s
+  end
+
+  # Fills in values from a Riak::RObject
+  def self.from_riak_object(riak_object)
+    return nil if riak_object.nil?
+
+    n = new.load_riak_object riak_object
+
+    # Callback
+    n.after_load
+    n
+  end
+
+  # Gets an existing record or creates one.
+  def self.get_or_new(*args)
+    self[*args] or new(args.first)
+  end
+
+  # Establishes methods for manipulating a single link with a given tag.
+  def self.link(tag)
+    tag = tag.to_s
+    class_eval "
+      def #{tag}
+        begin
+          @riak_object.links.find do |l|
+            l.tag == #{tag.inspect}
+          end.key
+        rescue NoMethodError
+          nil
+        end
+      end
+
+      def #{tag}=(link)
+        @riak_object.links.reject! do |l|
+          l.tag == #{tag.inspect}
+        end
+        if link
+          @riak_object.links << link.to_link(#{tag.inspect})
+        end
+      end
+    "
+  end
+
+  # Establishes methods for manipulating a set of links with a given tag.
+  def self.links(tag)
+    tag = tag.to_s
+    class_eval "
+      def #{tag}
+        @riak_object.links.select do |l|
+          l.tag == #{tag.inspect}
+        end.map do |l|
+          l.key
+        end
+      end
+
+      def add_#{tag}(link)
+        @riak_object.links << link.to_link(#{tag.inspect})
+      end
+
+      def remove_#{tag}(link)
+        @riak_object.links.delete link.to_link(#{tag.inspect})
+      end
+
+      def clear_#{tag}
+        @riak_object.links.delete_if do |l|
+          l.tag == #{tag.inspect}
+        end
+      end
+      
+      def #{tag}_count
+        @riak_object.links.select{|l| l.tag == #{tag.inspect}}.length
+      end
+    "
+  end
+
+  # Mapreduce helper
+  def self.map(*args)
+    mr.map(*args)
+  end
+
+  # Merges n versions of a record together, for read-repair.
+  # Returns the merged record.
+  def self.merge(versions)
+    versions.first
+  end
+
+  # Begins a mapreduce on this model's bucket.
+  # If no keys are given, operates on the entire bucket.
+  # If keys are given, operates on those keys first.
+  def self.mr(keys = nil)
+    mr = Riak::MapReduce.new(riak)
+
+    if keys
+      # Add specific keys
+      [*keys].compact.inject(mr) do |mr, key|
+        mr.add @bucket_name, key.to_s
+      end
+    else
+      # Add whole bucket
+      mr.add @bucket_name
+    end
+  end
+
+  # MR helper.
+  def self.reduce(*args)
+    mr.reduce(*args)
+  end
+
+  # The Riak::Client backing this model class.
+  def self.riak
+    @riak ||= superclass.riak
+  end
+
+  def self.riak=(client)
+    @riak = client
+  end
+ 
+  # Add a new value to this model. Values aren't necessary; you can 
+  # use Risky#[], but if you would like to cast values to/from JSON or
+  # specify defaults, you may: 
+  # 
+  # :default => object (#clone is called for each new instance)
+  # :class => Time, Integer, etc. Inferred from default.class if present.
+  def self.value(value, opts = {})
+    value = value.to_s
+
+    klass = if opts[:class]
+      opts[:class]
+    elsif opts.include? :default
+      opts[:default].class
+    else
+      nil
+    end
+    values[value] = opts.merge(:class => klass)
+    
+    class_eval "
+      def #{value}; @values[#{value.inspect}]; end
+      def #{value}=(value); @values[#{value.inspect}] = value; end
+    "
+  end
+
+  # A list of all values we track.
+  def self.values
+    @values ||= {}
+  end
+
+
+
+  attr_accessor :values
+  attr_accessor :riak_object
+
+  # Create a new instance from a key and a list of values.
+  #
+  # Values will be passed to attr= methods where possible, so you can write
+  # def password=(p)
+  #   self['password'] = md5sum p
+  # end
+  # User.new('me', :password => 'baggins')
+  def initialize(key = nil, values = {})
+    super()
+
+    key = key.to_s unless key.nil?
+
+    @riak_object ||= Riak::RObject.new(self.class.bucket, key)
+    @riak_object.content_type = 'application/javascript'
+
+    @new = true
+    @merged = false
+    @values = {}
+
+    # Load values
+    values.each do |k,v|
+      begin
+        send(k.to_s + '=', v)
+      rescue NoMethodError
+        self[k] = v
+      end
+    end
+
+    # Fill in defults.
+    self.class.values.each do |k,v|
+      self[k] ||= (v[:default].clone rescue v[:default])
+    end 
+  end
+
+  # Two models compare === if they are of matching class and key.
+  def ===(o)
+    o.class == self.class and o.key.to_s == self.key.to_s rescue false
+  end
+
+  # Access the values hash.
+  def [](k)
+    @values[k]
+  end
+
+  # Access the values hash.
+  def []=(k, v)
+    @values[k] = v
+  end
+
+  def after_create
+  end
+
+  def after_delete
+  end
+
+  # Called when a riak object is used to populate the instance.
+  def after_load
+  end
+
+  def after_save
+  end
+
+  def as_json(opts = {})
+    h = @values.merge(:key => key)
+    h[:errors] = errors unless errors.empty?
+    h 
+  end
+
+  # Called before creation and validation
+  def before_create
+  end
+
+  # Called before deletion
+  def before_delete
+  end
+
+  # Called before saving and before validation
+  def before_save
+  end
+
+  # Delete this object in the DB and return self.
+  def delete
+    before_delete
+    @riak_object.delete
+    after_delete
+
+    self
+  end
+
+  # A hash for errors on this object
+  def errors
+    @errors ||= {}
+  end
+
+  # Replaces values and riak_object with data from riak_object.
+  def load_riak_object(riak_object, opts = {:merge => true})
+    if opts[:merge] and riak_object.conflict? and siblings = riak_object.siblings
+      # Engage conflict resolution mode
+      final = self.class.merge(
+        siblings.map do |sibling|
+          self.class.new.load_riak_object(sibling, :merge => false)
+        end
+      )
+
+      # Copy final values to self.
+      final.instance_variables.each do |var|
+        self.instance_variable_set(var, final.instance_variable_get(var))
+      end
+
+      self.merged = true
+    else
+      # Not merging
+      self.values = self.class.cast(JSON.parse(riak_object.raw_data)) rescue {}
+      self.class.values.each do |k, v|
+        values[k] ||= (v[:default].clone rescue v[:default])
+      end
+      self.riak_object = riak_object
+      self.new = false
+      self.merged = false
+    end
+    
+    self
+  end
+
+  def inspect
+    "#<#{self.class} #{key} #{@values.inspect}>"
+  end
+
+  def key=(key)
+    if key.nil?
+      @riak_object.key = nil
+    else
+      @riak_object.key = key.to_s
+    end 
+  end
+
+  def key
+    @riak_object.key
+  end
+
+  def merged=(merged)
+    @merged = !!merged
+  end
+
+  # Has this model been merged from multiple siblings?
+  def merged?
+    @merged
+  end
+
+  def new=(new)
+    @new = !!new
+  end
+
+  # Is this model freshly created; i.e. not saved in the database yet?
+  def new?
+    @new
+  end
+
+  # Reload this model's data from Riak.
+  # opts are passed to Riak::Bucket[]
+  def reload(opts = {})
+    # Get object from riak.
+    riak_object = self.class.bucket[key, opts]
+
+    # Load
+    load_riak_object riak_object
+
+    # Callback
+    after_load
+    self
+  end
+
+  # Saves this model.
+  # 
+  # Calls #validate and #valid? unless :validate is false.
+  #
+  # Converts @values to_json and saves it to riak.
+  #
+  # :w and :dw are also supported.
+  def save(opts = {})
+    before_create if @new
+    before_save
+
+    unless opts[:validate] == false
+      return false unless valid?
+    end
+
+    @riak_object.raw_data = @values.to_json
+    
+    store_opts = {}
+    store_opts[:w] = opts[:w] if opts[:w]
+    store_opts[:dw] = opts[:dw] if opts[:dw]
+    @riak_object.store store_opts
+
+    after_create if @new
+    after_save
+
+    @new = false
+
+    self
+  end
+
+  # This is provided for convenience; #save does *not* use this method, and you
+  # are free to override it.
+  def to_json(*a)
+    as_json.to_json(*a)
+  end
+
+  # Returns a Riak::Link object pointing to this record.
+  def to_link(*a)
+    @riak_object.to_link(*a)
+  end
+
+  # Calls #validate and checks whether the errors hash is empty.
+  def valid?
+    @errors = {}
+    validate
+    @errors.empty?
+  end  
+ 
+  # Determines whether the model is valid. Sets the contents of #errors if
+  # invalid. 
+  def validate
+    if key.blank?
+      errors[:key] = 'is missing'
+    end
+  end
+end

data/lib/risky/cron_list.rb

@@ -0,0 +1,189 @@
+module Risky::CronList
+  # Provides methods which allow a Risky model to act as a chronological list
+  # of references to some other model.
+  
+  module ClassMethods
+    def item_class(klass = nil)
+      if klass
+        @item_class = klass
+      else
+        @item_class or raise "no item class defined for #{self}"
+      end
+    end
+
+    def limit(limit = nil)
+      if limit
+        @limit = limit
+      else
+        @limit
+      end
+    end
+
+    def merge(versions)
+      p = super(versions)
+      items = sort_items(versions.map(&:items).flatten!.uniq)
+
+      if limit = self.limit
+        p.items = items[0...limit]
+        p.removed_items = items[limit..-1] || []
+      else
+        p.items = items
+      end
+
+      p
+    end
+
+    # Sorts a list of items into the appropriate order.
+    def sort_items(items)
+      items.sort { |a,b| b <=> a }
+    end
+  end
+
+  def self.included(base)
+    base.value :items, :default => []
+    base.extend ClassMethods
+  end
+
+  def initialize(*a)
+    super *a
+
+    @added_items ||= []
+    @removed_items ||= []
+  end
+
+  def <<(item)
+    if self.class.item_class === item
+      # Item is already an object; ensure it has a key.
+      item.key ||= new_item_key(item)
+    else
+      # Create a new item with <item> as the data.
+      item = self.class.item_class.new(new_item_key(item), item)
+    end
+
+    add_item item
+
+    trim
+  end
+  alias :add :<<
+
+  def add_item(item)
+    @added_items << item
+    @removed_items.delete item.key 
+
+    unless items.include? item.key
+      items.unshift item.key
+
+      if self.class.sort_items(items[0,2]).first != item.key
+        # We must reorder.
+        self.items = self.class.sort_items(items)
+      end
+    end
+  end
+
+  def added_items
+    @added_items
+  end
+
+  def added_items=(items)
+    @added_items = items
+  end
+
+  def after_delete
+    super
+
+    (@removed_items + items).each do |item|
+      delete_item(item) rescue nil
+    end
+
+    @removed_items.clear
+  end
+
+  def after_save
+    super
+    
+    @removed_items.each do |item|
+      delete_item(item) rescue nil
+    end
+
+    @added_items.clear
+    @removed_items.clear
+  end
+
+  def all
+    items.map { |item| self.class.item_class[item] }
+  end
+
+  def before_save
+    super
+
+    @added_items.each do |item|
+      item.save(:w => :all) or raise "unable to save #{item}"
+    end
+  end
+
+  # Remove all items. Items will actually be deleted on #save
+  def clear
+    @removed_items += items
+    items.clear
+  end
+
+  # Remove dangling references. Items will actually be deleted on #save
+  # TODO...
+  #def cleanup
+  #end
+
+  # Remove an item by key.
+  def remove(item_key)
+    if key = items.delete(item_key)
+      # This item existed.
+      @added_items.reject! do |item|
+        item['key'] == item_key
+      end
+
+      @removed_items << key
+    end
+
+    key
+  end
+
+  # Takes an entry of items and deletes it.
+  def delete_item(item)
+    self.class.item_class.delete item
+  end
+
+  # Generates a key for a newly added item.
+  def new_item_key(item = nil)
+    # Re-use existing time
+    begin
+      t = item['created_at']
+      if t.kind_of? String
+        time = Time.iso8601(t)
+      elsif t.kind_of? Time
+        time = t
+      end
+    rescue
+    end
+    time ||= Time.now
+     
+    "k#{key}_t#{time.to_f}#{rand(10**5)}"
+  end
+
+  def removed_items
+    @removed_items
+  end
+
+  def removed_items=(items)
+    @removed_items = items
+  end
+
+  def trim
+    # Remove expired items
+    if limit = self.class.limit
+      if removed = items.slice!(limit..-1)
+        @removed_items += removed
+      end
+    end
+
+    self
+  end
+end

data/lib/risky/indexes.rb

@@ -0,0 +1,118 @@
+module Risky::Indexes
+  # Provides indexes on an attribute. Mostly.
+
+  def self.included(base)
+    base.instance_eval do
+      @indexes = {}
+     
+      def indexes
+        @indexes
+      end
+
+      # Options:
+      # :proc => Anything responding to #[record]. Returns the key used for the index.
+      # :unique => Perform a unique check to ensure this index does not
+      #            conflict with another record.
+      def index(attribute, opts = {})
+        opts[:bucket] ||= "#{@bucket_name}_by_#{attribute}"
+        @indexes[attribute] = opts
+        
+        class_eval %{
+          def self.by_#{attribute}(value)
+            return nil unless value
+
+            begin
+              from_riak_object(
+                Riak::RObject.new(
+                  riak[#{opts[:bucket].inspect}],
+                  value
+                ).walk(:bucket => #{@bucket_name.inspect}).first.first
+              )
+            rescue Riak::FailedRequest => e
+              raise e unless e.code.to_i == 404
+              nil
+            end
+          end
+        }
+      end
+    end
+  end
+
+  def initialize(*a)
+    @old_indexed_values = {}
+    
+    super *a
+  end
+
+  def after_load
+    super
+
+    self.class.indexes.each do |attr, opts|
+      @old_indexed_values[attr] = opts[:proc][self] rescue self[attr.to_s]
+    end
+  end
+
+  def after_save
+    super
+
+    self.class.indexes.each do |attr, opts|
+      current = opts[:proc][self] rescue self[attr.to_s]
+      old = @old_indexed_values[attr]
+      @old_indexed_values[attr] = current
+      unless old == current
+        # Remove old index
+        if old
+          self.class.riak[opts[:bucket]].delete(old) rescue nil
+        end
+
+        # Create new index
+        unless current.nil?
+          index = Riak::RObject.new(self.class.riak[opts[:bucket]], current)
+          index.content_type = 'text/plain'
+          index.data = ''
+          index.links = Set.new([@riak_robject.to_link('value')])
+          index.store
+        end
+      end
+    end
+  end
+
+  def before_delete
+    super
+
+    self.class.indexes.each do |attr, opts|
+      if key = @old_indexed_values[attr]
+        self.class.riak[opts[:bucket]].delete(key) rescue nil
+      end
+    end
+  end
+
+  def validate
+    super
+
+    # Validate unique indexes
+    self.class.indexes.each do |attr, opts|
+      next unless opts[:unique]
+      
+      current = opts[:proc][self] rescue self[attr.to_s]
+      old = @old_indexed_values[attr]
+
+      next if current.nil?
+      next if current == old
+
+      # Validate that the record belongs to us.
+      begin
+        existing = self.class.riak[opts[:bucket]][current]
+        existing_key = existing.links.find { |l| l.tag == 'value' }.key
+      rescue
+        # Any failure here means no current index exists exists.
+        next
+      end
+
+      if existing_key and (new? or key != existing_key)
+        # Conflicts!
+        errors[attr.to_sym] = 'taken'
+      end
+    end
+  end
+end

data/lib/risky/invalid.rb

@@ -0,0 +1,16 @@
+class Risky::Invalid < RuntimeError
+  attr_accessor :record
+
+  def initialize(record, message = nil)
+    @record = record
+    @message = message || "record invalid"
+  end
+
+  def errors
+    @record.errors
+  end
+
+  def to_s
+    @message
+  end
+end

data/lib/risky/not_found.rb

@@ -0,0 +1,12 @@
+class Risky::NotFound < RuntimeError
+  attr_accessor :key
+
+  def initialize(key, message = nil)
+    @record = key
+    @message = message || "record not found"
+  end
+
+  def to_s
+    @message
+  end
+end

data/lib/risky/timestamps.rb

@@ -0,0 +1,21 @@
+module Risky::Timestamps
+  # If created_at and/or updated_at are present, updates them before creation
+  # and save, respectively.
+
+  def before_save
+    super
+    begin
+      self.updated_at = Time.now
+    rescue
+    end
+  end
+
+  def before_create
+    super
+
+    begin
+      self.created_at ||= Time.now
+    rescue
+    end
+  end
+end

data/lib/risky/version.rb

@@ -0,0 +1,3 @@
+class Risky
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: risky
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Kyle Kingsbury
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-07 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: riak-client
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 8
+        - 2
+        version: 0.8.2
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: aphyr@aphyr.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/risky/invalid.rb
+- lib/risky/not_found.rb
+- lib/risky/version.rb
+- lib/risky/timestamps.rb
+- lib/risky/indexes.rb
+- lib/risky/cron_list.rb
+- lib/risky.rb
+- LICENSE
+- README.markdown
+has_rdoc: true
+homepage: https://github.com/aphyr/risky
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 8
+      - 6
+      version: 1.8.6
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: risky
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A Ruby ORM for the Riak distributed database.
+test_files: []
+