risky 1.0.1 → 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 365f66d97a0adebc22c466d92764fd1a7f16bef2
+  data.tar.gz: e57eb61d6dcb1a58b4899f123388acab66c9b7da
+SHA512:
+  metadata.gz: 3686bd912cab327d870870ec35661259e6360aa6e1b3c87ac44ab256c2ca22b651edb768394a9236160344c557ae83c4555bf79b2efbfb8e38c6067c8056d042
+  data.tar.gz: 7f948333bb7d410c949d6ec40dd8a0875e440e67dedcc2274b256dffe5479b06a2342d68812f41b7cccffdb8eebf321fb8a79a426b0e597535a8af34c5e4020e

data/.gitignore

@@ -0,0 +1,8 @@
+pkg/
+._*
+*~
+.DS_Store
+.*.swp
+.rvmrc
+.ruby-version
+.ruby-gemset

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,38 @@
+PATH
+  remote: .
+  specs:
+    risky (1.1.0)
+      riak-client (~> 1.4.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    beefcake (0.3.7)
+    builder (3.2.2)
+    diff-lcs (1.2.4)
+    excon (0.25.3)
+    i18n (0.6.5)
+    innertube (1.0.2)
+    multi_json (1.7.9)
+    riak-client (1.4.0)
+      beefcake (~> 0.3.7)
+      builder (>= 2.1.2)
+      i18n (>= 0.4.0)
+      innertube (~> 1.0.2)
+      multi_json (~> 1.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.5)
+    rspec-expectations (2.14.2)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  excon
+  risky!
+  rspec

data/README.markdown

@@ -1,8 +1,6 @@
 Risky
 =====
 
-(Hey guys, I'll be porting over tests from our internal suite in the next few evenings. --Kyle)
-
 A simple, lightweight object layer for Riak.
 
     $ gem install risky
@@ -14,11 +12,11 @@ A simple, lightweight object layer for Riak.
     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
+Built on top of basho's excellent riak-client, Risky provides basic
 infrastructure for designing models with attributes (including defaults and
 casting to/from JSON), conflict resolution, validation, lifecycle callbacks,
 link-walking, mapreduce, and more. Modules are available for timestamps,
-chronologically ordered lists, and basic secondary indexes.
+chronologically ordered lists, and secondary indexes (2i).
 
 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
@@ -56,6 +54,12 @@ Show me the code!
       links :followers
     end
 
+Contributors
+------------
+
+Dalibor Nasevic ([@dalibor](https://github.com/dalibor))
+Marc Heiligers ([@marcheiligers](https://github.com/marcheiligers))
+
 License
 -------
 

data/Rakefile.rb

@@ -0,0 +1,31 @@
+require "bundler/gem_tasks"
+
+namespace :test do
+  desc "Delete test buckets"
+  task :delete_buckets do
+    require 'riak'
+    Riak.disable_list_keys_warnings = true
+    client = Riak::Client.new(:host => '127.0.0.1', :protocol => 'pbc')
+    bucket_names = [
+      'risky_enum',
+      'risky_indexes',
+      'risky_crud',
+      'risky_items',
+      'risky_users',
+      'risky_mult',
+      'risky_concurrent',
+      'risky_cron_list',
+      'risky_albums',
+      'risky_artists',
+      'risky_labels',
+      'risky_cities',
+      'risky_indexes_by_unique',
+      'risky_indexes_by_value'
+    ]
+    bucket_names.each do |bucket_name|
+      bucket = client.bucket(bucket_name)
+      puts "Deleting keys in #{bucket_name}"
+      bucket.keys.map { |k| bucket.delete(k) }
+    end
+  end
+end

data/lib/risky.rb

@@ -1,302 +1,279 @@
+require 'set'
+require 'riak'
+require 'multi_json'
+
 class Risky
-  require 'set'
-  require 'riak'
-  require 'multi_json'
+  autoload :Invalid,                'risky/invalid'
+  autoload :NotFound,               'risky/not_found'
+  autoload :ListKeys,               'risky/list_keys'
+  autoload :CronList,               'risky/cron_list'
+  autoload :Indexes,                'risky/indexes'
+  autoload :SecondaryIndexes,       'risky/secondary_indexes'
+  autoload :Timestamps,             'risky/timestamps'
+  autoload :Inflector,              'risky/inflector'
+  autoload :PaginatedCollection,    'risky/paginated_collection'
+  autoload :GZip,                   'risky/gzip'
 
-  $LOAD_PATH << File.expand_path(File.dirname(__FILE__))
+  extend Enumerable
 
-  # Exceptions
-  require 'risky/invalid'
-  require 'risky/not_found'
+  class << self
+    # Get a model by key. Returns nil if not found. You can also pass opts to
+    # #reload (e.g. :r, :merge => false).
+    def [](key, opts = {})
+      return nil unless key
 
-  # Fix threading autoload bugs
-  require 'risky/threadsafe'
-  
-  # Default plugins
-  require 'risky/cron_list'
-  require 'risky/indexes'
-  require 'risky/timestamps'
+      begin
+        new(key).reload(opts)
+      rescue Riak::FailedRequest => e
+        raise e unless e.not_found?
+        nil
+      end
+    end
 
-  extend Enumerable
+    def find(key, opts = {})
+      self[key.to_s, opts]
+    end
 
-  # 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
+    def find_all_by_key(keys)
+      return [] if keys.blank?
 
-    begin
-      new(key).reload(opts)
-    rescue Riak::FailedRequest => e
-      raise e unless e.not_found?
-      nil
+      keys.map!(&:to_s)
+      results = bucket.get_many(keys)
+      keys.map { |key| from_riak_object(results[key]) }.compact
     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]
+    def create(key = nil, values = {}, opts = {})
+      new(key, values).save(opts)
     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)
+    # Indicates that this model may be multivalued; in which case .merge should
+    # also be defined.
+    def allow_mult
+      unless bucket.props['allow_mult']
+        bucket.props = bucket.props.merge('allow_mult' => true)
+      end
     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
+    # The Riak::Bucket backing this model.
+    # If name is passed, *sets* the bucket name.
+    def bucket(name = nil)
+      if name
+        @bucket_name = name.to_s
+      end
+
+      riak.bucket(@bucket_name)
     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
+    # The string name of the bucket used for storing instances of this model.
+    def bucket_name
+      @bucket_name
+    end
 
-  def self.bucket_name=(bucket)
-    @bucket_name = name.to_s
-  end
+    def 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
+    def content_type
+      "application/json"
+    end
+
+    # Casts data to appropriate types for values.
+    def 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
-      rescue
-        v
       end
+      casted
     end
-    casted
-  end
 
-  # Counts the number of values in the bucket via key streaming
-  def self.count
-    count = 0
-    bucket.keys do |keys|
-      count += keys.length
+    # Returns true when record deleted.
+    # Returns nil when record was not present to begin with.
+    def delete(key, opts = {})
+      return if key.nil?
+      bucket.delete(key.to_s, opts)
     end
-    count
-  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 do |keys|
-      keys.each do |key|
-        if x = self[key]
-          yield x
-        end
-      end
+    # Does the given key exist in our bucket?
+    def exists?(key)
+      return if key.nil?
+      bucket.exists? key.to_s
     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 from_riak_object(riak_object)
+      return nil if riak_object.nil?
 
-  # 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
 
-    n = new.load_riak_object riak_object
+      # Callback
+      n.after_load
+      n
+    end
 
-    # 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
-  
-  # Iterate over all keys.
-  def self.keys(*a)
-    if block_given?
-      bucket.keys(*a) do |keys|
-        # This API is currently inconsistent from protobuffs to http 
-        if keys.kind_of? Array
-          keys.each do |key|
-            yield key
+    # Gets an existing record or creates one.
+    def get_or_new(*args)
+      self[*args] or new(args.first)
+    end
+
+    # Establishes methods for manipulating a single link with a given tag.
+    def link(tag)
+      tag = tag.to_s
+      class_eval %Q{
+        def #{tag}
+          begin
+            @riak_object.links.find do |l|
+              l.tag == #{tag.inspect}
+            end.key
+          rescue NoMethodError
+            nil
           end
-        else
-          yield keys
         end
-      end
-    else
-      bucket.keys(*a)
-    end
-  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|
+        def #{tag}=(link)
+          @riak_object.links.reject! do |l|
             l.tag == #{tag.inspect}
-          end.key
-        rescue NoMethodError
-          nil
+          end
+          if link
+            @riak_object.links << link.to_link(#{tag.inspect})
+          end
         end
-      end
+      }
+    end
 
-      def #{tag}=(link)
-        @riak_object.links.reject! do |l|
-          l.tag == #{tag.inspect}
+    # Establishes methods for manipulating a set of links with a given tag.
+    def links(tag)
+      tag = tag.to_s
+      class_eval %Q{
+        def #{tag}
+          @riak_object.links.select do |l|
+            l.tag == #{tag.inspect}
+          end.map do |l|
+            l.key
+          end
         end
-        if link
+
+        def add_#{tag}(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
+
+        def remove_#{tag}(link)
+          @riak_object.links.delete link.to_link(#{tag.inspect})
         end
-      end
 
-      def add_#{tag}(link)
-        @riak_object.links << link.to_link(#{tag.inspect})
-      end
+        def clear_#{tag}
+          @riak_object.links.delete_if do |l|
+            l.tag == #{tag.inspect}
+          end
+        end
 
-      def remove_#{tag}(link)
-        @riak_object.links.delete link.to_link(#{tag.inspect})
-      end
+        def #{tag}_count
+          @riak_object.links.select{|l| l.tag == #{tag.inspect}}.length
+        end
+      }
+    end
 
-      def clear_#{tag}
-        @riak_object.links.delete_if do |l|
-          l.tag == #{tag.inspect}
+    # Mapreduce helper
+    def map(*args)
+      mr.map(*args)
+    end
+
+    # Merges n versions of a record together, for read-repair.
+    # Returns the merged record.
+    def 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 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
-      
-      def #{tag}_count
-        @riak_object.links.select{|l| l.tag == #{tag.inspect}}.length
-      end
-    "
-  end
+    end
 
-  # Mapreduce helper
-  def self.map(*args)
-    mr.map(*args)
-  end
+    # MR helper.
+    def reduce(*args)
+      mr.reduce(*args)
+    end
 
-  # Merges n versions of a record together, for read-repair.
-  # Returns the merged record.
-  def self.merge(versions)
-    versions.first
-  end
+    # The Riak::Client backing this model class.
+    def riak
+      Thread.current[:riak_client] ||=
+        if @riak and @riak.respond_to?(:call)
+          @riak.call(self)
+        elsif @riak
+          @riak
+        else
+          superclass.riak
+        end
+    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)
+    # Forces Riak client for this thread to be reset.
+    # If your @riak proc can choose between multiple hosts, calling this on
+    # failure will allow subsequent requests to proceed on another host.
+    def riak!
+      Thread.current[:riak_client] = nil
+      riak
+    end
 
-    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
+    # Sets the Riak Client backing this model class. If client is a lambda (or
+    # anything responding to #call), it will be invoked to generate a new client
+    # every time Risky feels it is appropriate.
+    def riak=(client)
+      @riak = client
     end
-  end
 
-  # MR helper.
-  def self.reduce(*args)
-    mr.reduce(*args)
-  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 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)
 
-  # The Riak::Client backing this model class.
-  def self.riak
-    if @riak_client
-      @riak_client
-    elsif @riak and @riak.respond_to? :call
-      @riak_client = @riak.call(self)
-    elsif @riak
-      @riak_client = @riak
-    else
-      superclass.riak
-    end
-  end
-
-  # Forces this model's Riak client to be reset.
-  # If your @riak proc can choose between multiple hosts, calling this on
-  # failure will allow subsequent requests to proceed on another host.
-  def self.riak!
-    @riak_client = nil
-    riak
-  end
-
-  # Sets the Riak Client backing this model class. If client is a lambda (or
-  # anything responding to #call), it will be invoked to generate a new client
-  # every time Risky feels it is appropriate.
-  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
+      class_eval %Q{
+        def #{value}
+          @values[#{value.inspect}]
+        end
+
+        def #{value}=(value)
+          @values[#{value.inspect}] = value
+        end
+      }
     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 ||= {}
+    # A list of all values we track.
+    def values
+      @values ||= {}
+    end
   end
 
 
@@ -317,7 +294,7 @@ class Risky
     key = key.to_s unless key.nil?
 
     @riak_object ||= Riak::RObject.new(self.class.bucket, key)
-    @riak_object.content_type = 'application/json'
+    @riak_object.content_type = self.class.content_type
 
     @new = true
     @merged = false
@@ -337,22 +314,27 @@ class Risky
       if self[k].nil?
         self[k] = (v[:default].clone rescue v[:default])
       end
-    end 
+    end
+  end
+
+  def ==(object)
+    object.class == self.class &&
+      (object.key.present? && object.key == self.key || object.object_id == self.object_id)
   end
+  alias :eql? :==
 
-  # 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
+  def ===(object)
+    object.is_a?(self.class)
   end
 
   # Access the values hash.
   def [](k)
-    @values[k]
+    values[k]
   end
 
   # Access the values hash.
   def []=(k, v)
-    @values[k] = v
+    values[k] = v
   end
 
   def after_create
@@ -371,7 +353,7 @@ class Risky
   def as_json(opts = {})
     h = @values.merge(:key => key)
     h[:errors] = errors unless errors.empty?
-    h 
+    h
   end
 
   # Called before creation and validation
@@ -406,7 +388,12 @@ class Risky
       # Engage conflict resolution mode
       final = self.class.merge(
         siblings.map do |sibling|
-          self.class.new.load_riak_object(sibling, :merge => false)
+          robject = Riak::RObject.new(sibling.bucket, sibling.key)
+          robject.raw_data = sibling.raw_data
+          robject.content_type = sibling.content_type
+          # robject.siblings = [sibling]
+          robject.vclock = sibling.vclock
+          self.class.new.load_riak_object(robject, :merge => false)
         end
       )
 
@@ -418,7 +405,7 @@ class Risky
       self.merged = true
     else
       # Not merging
-      self.values = self.class.cast(MultiJson.load(riak_object.raw_data)) rescue {}
+      self.values = self.class.cast(riak_object.data) rescue {}
       self.class.values.each do |k, v|
         if values[k].nil?
           values[k] = (v[:default].clone rescue v[:default])
@@ -428,7 +415,7 @@ class Risky
       self.new = false
       self.merged = false
     end
-    
+
     self
   end
 
@@ -441,13 +428,23 @@ class Risky
       @riak_object.key = nil
     else
       @riak_object.key = key.to_s
-    end 
+    end
   end
 
   def key
     @riak_object.key
   end
 
+  def id
+    Integer(key)
+  rescue ArgumentError
+    key
+  end
+
+  def id=(value)
+    self.key = value
+  end
+
   def merged=(merged)
     @merged = !!merged
   end
@@ -481,7 +478,7 @@ class Risky
   end
 
   # Saves this model.
-  # 
+  #
   # Calls #validate and #valid? unless :validate is false.
   #
   # Converts @values to_json and saves it to riak.
@@ -495,9 +492,9 @@ class Risky
       return false unless valid?
     end
 
-    @riak_object.raw_data = MultiJson.dump @values
-	  @riak_object.content_type = "application/json"
-    
+    @riak_object.data = @values
+    @riak_object.content_type = self.class.content_type
+
     store_opts = {}
     store_opts[:w] = opts[:w] if opts[:w]
     store_opts[:dw] = opts[:dw] if opts[:dw]
@@ -511,6 +508,18 @@ class Risky
     self
   end
 
+  def update_attribute(attribute, value)
+    self.send("#{attribute}=", value)
+    self.save
+  end
+
+  def update_attributes(attributes)
+    attributes.each do |attribute, value|
+      self.send("#{attribute}=", value)
+    end
+    self.save
+  end
+
   # This is provided for convenience; #save does *not* use this method, and you
   # are free to override it.
   def to_json(*a)
@@ -527,10 +536,10 @@ class Risky
     @errors = {}
     validate
     @errors.empty?
-  end  
- 
+  end
+
   # Determines whether the model is valid. Sets the contents of #errors if
-  # invalid. 
+  # invalid.
   def validate
     if key.blank?
       errors[:key] = 'is missing'