risky 1.0.1 → 1.1.0

data/lib/risky/paginated_collection.rb

@@ -0,0 +1,11 @@
+class Risky::PaginatedCollection < Array
+
+  attr_reader :keys, :continuation
+
+  def initialize(collection, paginated_keys)
+    @keys = paginated_keys
+    @continuation = paginated_keys.continuation
+
+    super(collection)
+  end
+end

data/lib/risky/secondary_indexes.rb

@@ -0,0 +1,196 @@
+module Risky::SecondaryIndexes
+
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    # Add a new secondary index to this model.
+    # Default option is :type => :int, can also be :bin
+    # Default option is :multi => false, can also be true
+    # Option :map can be used to map the index to a model (see map_model).
+    #   This assumes by default that the index name ends in _id (use :map => true)
+    #   If it ends in something else, use :map => '_suffix'
+    def index2i(name, opts = {})
+      name = name.to_s
+
+      opts.replace({:type => :int, :multi => false, :finder => :find}.merge(opts))
+      indexes2i[name] = opts
+
+      class_eval %Q{
+        def #{name}
+          @indexes2i['#{name}']
+        end
+
+        def #{name}=(value)
+          @indexes2i['#{name}'] = value
+        end
+      }
+
+      if opts[:map]
+        if opts[:map] === true # assume that it ends in _id
+          model_name = name[0..-4]
+          map_model(model_name, opts)
+        else
+          model_name = name[0..-(opts[:map].length + 1)]
+          map_model(model_name, opts.merge(:suffix => opts[:map]))
+        end
+      end
+    end
+
+    # A list of all secondary indexes
+    def indexes2i
+      @indexes2i ||= {}
+    end
+
+    def find_by_index(index2i, value)
+      index = "#{index2i}_#{indexes2i[index2i.to_s][:type]}"
+      key = bucket.get_index(index, value).first
+      return nil if key.nil?
+
+      find(key)
+    end
+
+    def find_all_by_index(index2i, value)
+      index = "#{index2i}_#{indexes2i[index2i.to_s][:type]}"
+      keys = bucket.get_index(index, value)
+
+      find_all_by_key(keys)
+    end
+
+    def find_all_keys_by_index(index2i, value)
+      index = "#{index2i}_#{indexes2i[index2i.to_s][:type]}"
+      bucket.get_index(index, value)
+    end
+
+    def paginate_by_index(index2i, value, opts = {})
+      keys = paginate_keys_by_index(index2i, value, opts)
+      Risky::PaginatedCollection.new(find_all_by_key(keys), keys)
+    end
+
+    def paginate_keys_by_index(index2i, value, opts = {})
+      opts.reject! { |k, v| v.nil? }
+
+      index = "#{index2i}_#{indexes2i[index2i.to_s][:type]}"
+      bucket.get_index(index, value, opts)
+    end
+
+    def create(key, values = {}, indexes2i = {}, opts = {})
+      obj = new key, values, indexes2i
+      obj.save(opts)
+    end
+
+    # The map_model method is a convenience method to map the model_id to getters and setters.
+    # The assumption is that you have a value or index2i for model_id.
+    # The default suffix is '_id', so map_model :promotion implies that promotion_id is the index2i.
+    #
+    # For example, map_model :promotion will create these three methods
+    # ```ruby
+    # def promotion
+    #   @promotion ||= Promotion.find_by_id promotion_id
+    # end
+    #
+    # def promotion=(value)
+    #   @promotion = promotion
+    #   self.promotion_id = value.nil? ? nil : value.id
+    # end
+    #
+    # def promotion_id=(value)
+    #   @promotion = nil if self.promotion_id != value
+    #   indexes2i['promotion_id'] = value
+    # end
+    # ```
+    def map_model(model_name, opts = {})
+      model_name = model_name.to_s
+      class_name = Risky::Inflector.classify(model_name)
+
+      opts.replace({:type => :index2i, :suffix => '_id'}.merge(opts))
+
+      class_eval %Q{
+        def #{model_name}
+          @#{model_name} ||= #{class_name}.#{opts[:finder]} #{model_name}#{opts[:suffix]}
+        end
+
+        def #{model_name}=(value)
+          @#{model_name} = value
+          self.#{model_name}#{opts[:suffix]} = value.nil? ? nil : value.id
+        end
+
+        def #{model_name}_id=(value)
+          @#{model_name} = nil if self.#{model_name}_id != value
+          indexes2i['#{model_name}#{opts[:suffix]}'] = value
+        end
+      }
+    end
+  end
+
+
+  ### Instance methods
+  def initialize(key = nil, values = {}, indexes2i = {})
+    super((key.nil? ? nil : key.to_s), values)
+
+    # Parse anything not parsed correctly by Yajl (no support for json_create)
+    self.class.values.each do |k,v|
+      if self[k].is_a?(Hash) && self[k]['json_class']
+        klass = Risky::Inflector.constantize(self[k]['json_class'])
+        self[k] = klass.send(:json_create, self[k])
+      end
+    end
+
+    @indexes2i = {}
+
+    indexes2i.each do |k,v|
+      send(k.to_s + '=', v)
+    end
+  end
+
+  def save(opts = {})
+    self.class.indexes2i.each do |k, v|
+      raise ArgumentError, "Nil for index #{k} on #{self.class.name}" if (v[:multi] ? @indexes2i[k].nil? : @indexes2i[k].blank?) && !v[:allow_nil]
+
+      case v[:type]
+      when :int
+        @riak_object.indexes["#{k}_int"] = v[:multi] && @indexes2i[k].respond_to?(:map) ? @indexes2i[k].map(&:to_i) : [ @indexes2i[k].to_i ]
+      when :bin
+        @riak_object.indexes["#{k}_bin"] = v[:multi] && @indexes2i[k].respond_to?(:map) ? @indexes2i[k].map(&:to_s) : [ @indexes2i[k].to_s ]
+      else
+        raise TypeError, "Invalid 2i type '#{v[:type]}' for index #{k} on #{self.class.name}"
+      end
+    end
+
+    super(opts)
+  end
+
+  def load_riak_object(riak_object, opts = {:merge => true})
+    super(riak_object, opts)
+
+    # Parse anything not parsed correctly by Yajl (no support for json_create)
+    self.class.values.each do |k,v|
+      if self[k].is_a?(Hash) && self[k]['json_class']
+        klass = Risky::Inflector.constantize(self[k]['json_class'])
+        self[k] = klass.send(:json_create, self[k])
+      end
+    end
+
+    self.class.indexes2i.each do |k, v|
+      case v[:type]
+      when :int
+        @indexes2i[k] = v[:multi] ? @riak_object.indexes["#{k}_int"].map(&:to_i) : @riak_object.indexes["#{k}_int"].first.to_i
+      when :bin
+        @indexes2i[k] = v[:multi] ? @riak_object.indexes["#{k}_bin"].map(&:to_s) : @riak_object.indexes["#{k}_bin"].first.to_s
+      else
+        raise TypeError, "Invalid 2i type '#{v[:type]}' for index #{k} on #{self.class.name}"
+      end
+    end
+
+    self
+  end
+
+  def indexes2i
+    @indexes2i
+  end
+
+  def inspect
+    "#<#{self.class} #{key} #{@indexes2i.inspect} #{@values.inspect}>"
+  end
+end

data/lib/risky/version.rb

@@ -1,3 +1,3 @@
 class Risky
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
 end

data/risky.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/risky/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Kyle Kingsbury"]
+  gem.email         = ["aphyr@aphyr.com"]
+  gem.description   = %q{A lightweight Ruby ORM for Riak.}
+  gem.summary       = %q{A Ruby ORM for the Riak distributed database.}
+  gem.homepage      = "https://github.com/aphyr/risky"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "risky"
+  gem.require_paths = ["lib"]
+  gem.version       = Risky::VERSION
+  gem.license       = "MIT"
+
+  gem.add_dependency "riak-client", "~> 1.4.0"
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "excon"
+end

data/spec/risky/cron_list_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+class Item < Risky
+  include Risky::ListKeys
+
+  bucket :risky_items
+  value :v
+end
+
+class CronList < Risky
+  include Risky::ListKeys
+  include Risky::CronList
+
+  bucket :risky_cron_list
+
+  item_class Item
+  limit 5
+end
+
+
+describe Risky::CronList do
+  before :all do
+    CronList.delete_all
+    @l = CronList.new 'test'
+  end
+
+  it 'stores an item' do
+    @l << {:v => 1}
+    @l.items.first.should be_kind_of String
+    Item[@l.items.first].should be_nil
+    @l.save.should_not be_false
+
+    @l.reload
+    @l.items.size.should == 1
+    @l.items.first.should be_kind_of String
+    i = Item[@l.items.first]
+    i.should be_kind_of Item
+    i.v.should == 1
+  end
+
+  it 'limits items' do
+    10.times do |i|
+      @l << {:v => i}
+    end
+    @l.save.should_not be_false
+    @l.reload
+    @l.items.size.should == 5
+    @l.items.map { |k|
+      Item[k].v
+    }.sort.should == (5...10).to_a
+  end
+end

data/spec/risky/crud_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+class Crud < Risky
+  include Risky::ListKeys
+
+  bucket :risky_crud
+  value :value
+end
+
+
+describe 'CRUD' do
+  it 'can create a new, blank object' do
+    c = Crud.new
+    c.key.should be_nil
+    c.value.should be_nil
+    c.save.should be_false
+    c.errors[:key].should == 'is missing'
+  end
+
+  it 'can create and save a named object with a value' do
+    # To be serialized in your best Nazgul voice
+    c = Crud.new 'baggins', :value => 'shire!'
+    c.key.should == 'baggins'
+    c.value.should == 'shire!'
+    c.save.should == c
+  end
+
+  it 'can read objects' do
+    Crud['mary_poppins'].should be_nil
+
+    # This rspec clone *IS* named after Francis Bacon, after all.
+    c = Crud.new 'superstition', :value => 'confusion of many states'
+    c.save.should_not be_false
+
+    c2 = Crud['superstition']
+    c2.should === c
+    c2.value.should == 'confusion of many states'
+  end
+
+  it 'can test for existence' do
+    Crud.exists?('russells_lagrangian_teapot').should be_false
+    Crud.exists?('superstition').should be_true
+  end
+
+  it 'deletes an unfetched object' do
+    Crud.delete('mary_poppins').should be_true
+    Crud.delete('superstition').should be_true
+  end
+
+  it 'can delete a fetched object' do
+    v = Crud.new('victim').save
+    v.should_not be_false
+    v.delete.should === v
+    Crud.exists?(v).should be_false
+  end
+
+  it 'checks objects equality by keys' do
+    Crud.new('superstition', 'value' => 'witches').should == Crud.new('superstition', 'value' => 'warlocks')
+  end
+
+  it 'checks objects equality by object ids when no keys' do
+    object1 = Crud.new(nil, 'value' => 'witches')
+    object2 = Crud.new(nil, 'value' => 'witches')
+
+    object1.should == object1
+    object2.should == object2
+    object1.should_not == object2
+  end
+end

data/spec/risky/enumerable_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+class Enum < Risky
+  include Risky::ListKeys
+
+  bucket :risky_enum
+end
+
+describe 'Enumerable' do
+  before :all do
+    # Wipe bucket and replace with 3 items
+    Enum.delete_all
+
+    @keys = ['hume', 'locke', 'spinoza']
+    @keys.each do |key|
+      Enum.new(key).save or raise
+    end
+  end
+
+  it 'can count' do
+    Enum.count.should == 3
+  end
+
+  it 'can list keys' do
+    Enum.keys.should be_kind_of Array
+    Enum.keys do |key|
+      key.should be_kind_of String
+    end
+  end
+
+  it 'can iterate' do
+    seen = []
+    Enum.each do |obj|
+      obj.should be_kind_of Enum
+      seen << obj.key
+    end
+    seen.sort.should == @keys
+  end
+
+  it 'can inject' do
+    Enum.inject(0) do |count, obj|
+      count + obj.key.size
+    end.should == @keys.join('').size
+  end
+end

data/spec/risky/gzip_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe 'GZip' do
+  class Zippable < Risky
+    include Risky::GZip
+
+    bucket :risky_gzip
+    value :value
+  end
+
+  it 'can create and save a named object with a value' do
+    g = Zippable.new 'pizzazz', :value => 'oomph'
+    g.save.should == g
+  end
+
+  it 'can read objects' do
+    Zippable['zest'].should be_nil
+
+    g = Zippable.new 'zing', :value => 'vigor'
+    g.save.should_not be_false
+
+    g2 = Zippable['zing']
+    g2.should === g
+    g2.value.should == 'vigor'
+  end
+end
+
+describe 'GZip with allow_mult' do
+  class MultiZippable < Risky
+    include Risky::GZip
+
+    bucket :risky_gzip_mult
+    allow_mult
+
+    value :value
+
+    def self.merge(versions)
+      g = super(versions)
+      g.value = versions.map(&:value).sort.join(', ')
+      g
+    end
+  end
+
+  it 'merges' do
+    conflict(MultiZippable, 'value', ['spirit', 'sparkle']).value.should eq('sparkle, spirit')
+  end
+end
+
+describe 'Legacy data not GZipped' do
+  class NoZip < Risky
+    bucket :risky_gzip_legacy
+    value :value
+  end
+
+  class Zip < Risky
+    include Risky::GZip
+
+    bucket :risky_gzip_legacy
+    value :value
+  end
+
+  it 'loads non-zipped legacy data' do
+    g = NoZip.new 'gusto', :value => 'spritely'
+    g.save.should == g
+
+    g1 = Zip['gusto']
+    g1.key.should eq(g.key)
+    g1.value.should eq(g.value)
+  end
+end
+
+
+