riagent 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 189f3608c683deba5f7d5396006eca9567270aef
-  data.tar.gz: 92e10aef1130cbf20a18f5796659f1ea7e6ced30
+  metadata.gz: 27288ed232ba0816f1d3801edbb0d254f9afddf3
+  data.tar.gz: 734ec9dcfb6fc9816660d911e0cfd93a348b3e0a
 SHA512:
-  metadata.gz: c6246e9dfff27679cd03f175fd0500fe67f8ad7b410eff03a3b421dccb5b589cf5554464ada2dffa5e3f8828657c1bc36ace4bc431c7a91360325672865fb7d8
-  data.tar.gz: a028746246a003269eaf376248b64713415e25d1279a1f6c1ed2dfc6ca6a4d6dd2b52c6ec55a53e382d98540b747c30aaa0c296b21bf5fdcd0580633b5733c98
+  metadata.gz: dcc0206d55b66b3db10d0ed0fd1131232fd5979bbf61a60d177850198d30a20a8d6b3a658d7c72790bf054cf470e6aeb6d2b57c34d7abbb2d31d1d66fc56ce8e
+  data.tar.gz: e834529f89a4755b803b926055565e1345f8a57c4529973e5e7acef529825e321138662ec65c1f3e64ddc4d76d8c02fd42757e744016d78a771a984037fe8fd8

data/Gemfile.lock

@@ -5,16 +5,16 @@ PATH
       activemodel (~> 4.0)
       activesupport (~> 4.0)
       riagent-document
-      riak-client
+      riak-client (~> 2.0.0.rc1)
       riak_json
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (4.0.5)
-      activesupport (= 4.0.5)
+    activemodel (4.0.9)
+      activesupport (= 4.0.9)
       builder (~> 3.1.0)
-    activesupport (4.0.5)
+    activesupport (4.0.9)
       i18n (~> 0.6, >= 0.6.9)
       minitest (~> 4.2)
       multi_json (~> 1.3)
@@ -24,50 +24,55 @@ GEM
       descendants_tracker (~> 0.0.4)
       ice_nine (~> 0.11.0)
       thread_safe (~> 0.3, >= 0.3.1)
-    beefcake (0.3.7)
+    beefcake (1.0.0.pre2)
     builder (3.1.4)
     coercible (1.0.0)
       descendants_tracker (~> 0.0.1)
     descendants_tracker (0.0.4)
       thread_safe (~> 0.3, >= 0.3.1)
     equalizer (0.0.9)
-    i18n (0.6.9)
+    i18n (0.6.11)
     ice_nine (0.11.0)
     innertube (1.0.2)
     json (1.8.1)
     mime-types (2.3)
-    minitest (4.7.5)
+    minitest (4.7.0)
     minitest-spec-context (0.0.3)
     multi_json (1.10.1)
+    netrc (0.7.7)
+    r509 (0.10.0)
+    r509-cert-validator (0.0.4)
+      r509 (~> 0.10.0)
     rake (10.3.2)
-    rest-client (1.6.7)
-      mime-types (>= 1.16)
+    rest-client (1.7.2)
+      mime-types (>= 1.16, < 3.0)
+      netrc (~> 0.7)
     riagent-document (0.0.1)
       activesupport (~> 4.0)
       virtus
-    riak-client (1.4.4.1)
-      beefcake (~> 0.3.7)
-      builder (>= 2.1.2)
+    riak-client (2.0.0.rc1)
+      beefcake (>= 1.0.0.pre1)
       i18n (>= 0.4.0)
       innertube (~> 1.0.2)
       multi_json (~> 1.0)
+      r509-cert-validator (~> 0.0.4)
     riak_json (0.0.4)
       json
       rest-client
     thread_safe (0.3.4)
-    tzinfo (0.3.39)
-    virtus (1.0.2)
+    tzinfo (0.3.41)
+    virtus (1.0.3)
       axiom-types (~> 0.1)
       coercible (~> 1.0)
-      descendants_tracker (~> 0.0.3)
-      equalizer (~> 0.0.9)
+      descendants_tracker (~> 0.0, >= 0.0.3)
+      equalizer (~> 0.0, >= 0.0.9)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   bundler
-  minitest (~> 4.2)
+  minitest (~> 4.7)
   minitest-spec-context
   rake
   riagent!

data/README.md

@@ -1,90 +1,111 @@
 # riagent
 
-Object Document Mapper for RiakJson (Riak + Solr), for use with Ruby on Rails 4 and Sinatra.
+Object Document Mapper for [Riak](http://basho.com/products/riak-kv/)
+(including integration with Solr search), for use with Ruby on Rails 4 and
+Sinatra.
 
 ## Requirements
  - Ruby 1.9+
- - Riak build with [Riak Json](https://github.com/basho-labs/riak_json) and Solr/Yokozuna enabled 
-   (see [Setup](https://github.com/basho-labs/riak_json#setup) section for instructions)
- - [RiakJson](https://github.com/basho-labs/riak_json_ruby_client) Ruby Client gem installed locally
- - [riagent-document](https://github.com/dmitrizagidulin/riagent-document) gem installed locally
+ - [Riak](http://basho.com/products/riak-kv/) version 2.0 or later
+ - [RiakJson](https://github.com/basho-labs/riak_json_ruby_client) Ruby Client
+    gem installed locally
+ - [riagent-document](https://github.com/dmitrizagidulin/riagent-document) gem
+    installed locally
 
 ## Motivation
-*a.k.a. Why not just use a plain [riak_json client](https://github.com/basho-labs/riak_json_ruby_client) or a 
+*a.k.a. Why not just use a plain
+[riak_json client](https://github.com/basho-labs/riak_json_ruby_client) or a
 [riak-ruby-client](https://github.com/basho/riak-ruby-client)?*
 
-A RiakJson or Riak client just answers the question "How do I store stuff in Riak?". 
-In order to develop any non-toy application using Riak as a persistence layer, a developer must answer further questions:
+A Riak client just answers the question "How do I store stuff in Riak?".
+In order to develop any non-toy application using Riak as a persistence layer,
+a developer must answer further questions:
 
- - How do I define my model objects, and how do I serialize them so I can store them in Riak?
- - What will my access patterns be? Plain Key/Value reads and writes, or will I need to perform queries?
- - How do I integrate painlessly with my framework of choice? (Ruby on Rails, Sinatra)
+ - How do I define my model objects, and how do I serialize them so I can store
+    them in Riak?
+ - What will my access patterns be? Plain Key/Value reads and writes, or will I
+    need to perform queries?
+ - How do I integrate painlessly with my framework of choice? (Ruby on Rails,
+     Sinatra)
 
-Riagent attempts to provide answers to those questions, to encode recommended best-practice Riak query patterns,
-and in general to aid rapid application development by working with Riak's strenghts while respecting its limitations. 
-It is intended as a spiritual successor to [Ripple](https://github.com/basho-labs/ripple).
+Riagent attempts to provide answers to those questions, to encode recommended
+best-practice Riak query patterns, and in general to aid rapid application
+development by working with Riak's strenghts while respecting its limitations.
+It is intended as a spiritual successor to
+[Ripple](https://github.com/basho-labs/ripple).
 
 #### Model Definition and Serialization
-Riagent provides a model definition language that will be familiar to most Rails developers, via 
-the [riagent-document](https://github.com/dmitrizagidulin/riagent-document) gem.
+Riagent provides a model definition language that will be familiar to most Rails
+developers, via the
+[riagent-document](https://github.com/dmitrizagidulin/riagent-document) gem.
 
 ```ruby
 include 'riagent-document'
 
 class User
   include Riagent::ActiveDocument
-  
+
   attribute :username, String
   attribute :email, String
   attribute :country, String, default: 'USA'
 end
 ```
 
-Riagent::ActiveDocument instances provide a rich set of functionality including attribute defaults, type coercions, 
-conversion to and from JSON, search schema creation, easy persistence to Riak,
-document embedding, and more. See the [riagent-document README](https://github.com/dmitrizagidulin/riagent-document)
+Riagent::ActiveDocument instances provide a rich set of functionality including
+attribute defaults, type coercions, conversion to and from JSON, search schema
+creation, easy persistence to Riak, document embedding, and more. See the
+[riagent-document README](https://github.com/dmitrizagidulin/riagent-document)
 for more details.
 
 #### Advanced Riak K/V and Query Support
-Reads and writes of single objects into Riak are easy (and have the benefit of being massively scalable, highly concurrent, and fault-tolerant).
-But what about listing and querying? Every developer that gets past a Hello World get/put tutorial on Riak is soon faced with questions
-about more advanced access patterns. How do I implement collections, and list things? How do I search or query on various attributes?
-Should I use Secondary Indexes? What about Search/Solr integration? 
-
-Riagent provides a set of high-level notations and functionality that allows developers create collections and associations on Riak,
-either via plain K/V operations when possible, or via advanced mechanisms such as Solr/[RiakJson](https://github.com/basho-labs/riak_json)
-queries when necessary.
+Reads and writes of single objects into Riak are easy (and have the benefit of
+being massively scalable, highly concurrent, and fault-tolerant). But what about
+listing and querying? Every developer that gets past a Hello World get/put
+tutorial on Riak is soon faced with questions about more advanced access
+patterns. How do I implement collections, and list things? How do I search or
+query on various attributes? Should I use Secondary Indexes? What about
+Search/Solr integration?
+
+Riagent provides a set of high-level notations and functionality that allows
+developers create collections and associations on Riak, either via plain K/V
+operations when possible, or via advanced mechanisms such as
+Solr/[RiakJson](https://github.com/basho-labs/riak_json) queries when necessary.
 
 ```ruby
 class User
   include Riagent::ActiveDocument
-  
+
   collection_type :riak_json  # Persist to a RiakJson::Collection
-  
+
   attribute :username, String, search_index: { as: :text }
   attribute :email, String, search_index: { as: :string }
   attribute :language, String, default: 'en'
-  
+
   # Associations
   has_one :email_preference, :class => EmailPreference
   has_many :posts, :class => BlogPost, :using => :solr
-  
+
   # Validations
   validates_presence_of :username
 end
 ```
 
 #### Rails and Sinatra integration
-Riagent and ActiveDocuments are integrated into the usual Rails workflow. 
+Riagent and ActiveDocuments are integrated into the usual Rails workflow.
 
- - Riagent provides client configuration and initialization, via the ```config/riak.yml``` file
- - Provides a simple Key/Value persistence layer with ```save()```, ```find()```, ```update()``` and ```destroy()``` methods.
+ - Riagent provides client configuration and initialization, via the
+    ```config/riak.yml``` file
+ - Provides a simple Key/Value persistence layer with ```save()```,
+    ```find()```, ```update()``` and ```destroy()``` methods.
  - ActiveDocument implements the ActiveModel API.
-   (Specifically, passes the [ActiveModel Lint Test suite](http://api.rubyonrails.org/classes/ActiveModel/Lint/Tests.html))
+   (Specifically, passes the [ActiveModel Lint Test
+    suite](http://api.rubyonrails.org/classes/ActiveModel/Lint/Tests.html))
  - Provides a full range of validations for each attribute.
  - Provides ```before_save``` / ```after_save``` type Callback functionality
- - Provides a custom Query capability (to Riak/Solr), for searches, range queries, aggregations and more
- - Derives RiakJson/Solr search schemas from annotated document attributes (see Schemas below)
+ - Provides a custom Query capability (to Riak/Solr), for searches, range
+    queries, aggregations and more
+ - Derives RiakJson/Solr search schemas from annotated document attributes (see
+    Schemas below)
 
 ## Usage
 ### Adding Riagent to a Rails App
@@ -99,11 +120,13 @@ Run the install generator:
 rails generate riagent:install
 ```
 
-This creates a ```config/riak.yml``` file. Edit it to point to your running Riak instance.
+This creates a ```config/riak.yml``` file. Edit it to point to your running Riak
+instance.
 
 ### Controller and View helpers
-Since they implement the ActiveModel API, when you use ActiveDocuments in 
+Since they implement the ActiveModel API, when you use ActiveDocuments in
 a Rails model, the usual ```link_to```/route-based helpers work:
+
 ```erb
 # In a user view file
 <%= link_to @user.username, @user %> # => <a href="/users/EmuVX4kFHxxvlUVJj5TmPGgGPjP">HieronymusBosch</a>
@@ -131,12 +154,13 @@ new_user.key  # => 'EmuVX4kFHxxvlUVJj5TmPGgGPjP'
 ```
 
 ### Key/Value Persistence
-The usual array of CRUD type k/v operations is available to an ActiveDocument model.
+The usual array of CRUD type k/v operations is available to an ActiveDocument
+model.
 
 Create documents via ```save()``` and ```save!()```
 ```ruby
 user = User.new({username: 'John', email: 'john@doe.com'})
-# If you save without specifying a key, RiakJson generates a UUID type key automatically
+# If you save without specifying a key, it generates a UUID key automatically
 user.save  # => 'EmuVX4kFHxxvlUVJj5TmPGgGPjP'
 ```
 
@@ -154,7 +178,7 @@ user.destroy  # deletes the document
 ```
 
 ### Callbacks
-ActiveDocument currently supports ```before_*``` and ```after_*``` [callbacks](http://api.rubyonrails.org/classes/ActiveSupport/Callbacks.html) 
+ActiveDocument currently supports ```before_*``` and ```after_*``` [callbacks](http://api.rubyonrails.org/classes/ActiveSupport/Callbacks.html)
 for the following events:
 ```[:create, :update, :save, :destroy]```
 
@@ -169,23 +193,28 @@ user = User.find_one({ username: 'HieronymusBosch' })
 ```
 
 ## Search Schema Definition
-RiakJson uses Solr/Yokozuna to provide indexing and search capability for its collections. 
-If you do not specify a collection schema explicitly, RiakJson creates one when you insert the first document to that collection 
-(it [infers the schema](https://github.com/basho-labs/riak_json/blob/master/docs/architecture.md#inferred-schemas) 
-based on the basic data types of the field values in the JSON).
-However, if you do not want to use this default schema behavior (for example, because RJ tries to index all of the fields), 
-you can define and set a collection schema yourself, using RJ Ruby Client's [schema administration](https://github.com/basho-labs/riak_json_ruby_client#schema-administration) 
+RiakJson uses Solr/Yokozuna to provide indexing and search capability for its
+collections. If you do not specify a collection schema explicitly, RiakJson
+creates one when you insert the first document to that collection (it [infers
+the
+schema](https://github.com/basho-labs/riak_json/blob/master/docs/architecture.md#inferred-schemas)
+based on the basic data types of the field values in the JSON). However, if you
+do not want to use this default schema behavior (for example, because RJ tries
+to index all of the fields), you can define and set a collection schema
+yourself, using RJ Ruby Client's [schema
+administration](https://github.com/basho-labs/riak_json_ruby_client#schema-administration)
 API.
 
-To make the process of schema definition even easier for developers, ActiveDocument provides the ```search_index``` attribute
-option. This annotation allows you to specify which document fields you want added to your search schema, as well as the 
-Solr field type that will be used to index it.
+To make the process of schema definition even easier for developers,
+ActiveDocument provides the ```search_index``` attribute option. This annotation
+allows you to specify which document fields you want added to your search
+schema, as well as the Solr field type that will be used to index it.
 
 For example, the following model:
 ```ruby
 class User
   include Riagent::ActiveDocument
-  
+
   attribute :username, String, required: true, search_index: { :as => :text }
   attribute :email, String, search_index: { :as => :string }
   attribute :country, String, default: 'USA'
@@ -208,23 +237,32 @@ User.schema   # =>
 ```
 
 ### Schema Administration
-Note that if you use the ```search_index``` attribute annotations above, you will have to explicitly 
-notify RiakJson of your intent to save the schema. You will have to call the ```set_schema()``` collection
-method before you start inserting documents (for example, in a ```db:setup``` Rake task).
+Note that if you use the ```search_index``` attribute annotations above, you
+will have to explicitly notify RiakJson of your intent to save the schema. You
+will have to call the ```set_schema()``` collection method before you start
+inserting documents (for example, in a ```db:setup``` Rake task).
 
 ```ruby
 User.collection.set_schema(User.schema)
 ```
 
 ## Testing the Riagent gem
-First, set up the Riak config file for (and make sure it's pointing to a running Riak instance)
+First, set up the Riak config file for (and make sure it's pointing to a running
+Riak instance)
 
 ```
 cp test/config/riak.yml.example test/config/riak.yml
 ```
 
+The integration tests require that a Set bucket type be created, named `sets`:
+
+```
+riak-admin bucket-type create sets '{"props":{"datatype":"set"}}'
+riak-admin bucket-type activate sets
+```
+
 To run the tests:
 
 ```
 bundle exec rake test
-```
+```

data/lib/riagent/configuration.rb

@@ -55,7 +55,8 @@ module Riagent
 
     # @param [Hash] env_config Configuration hash for a given environment
     def init_riak_client(env_config)
-      client = Riak::Client.new host: env_config['host'], pb_port: env_config['pb_port'], protocol: 'pbc'
+#      client = Riak::Client.new host: env_config['host'], pb_port: env_config['pb_port'], protocol: 'pbc'
+      client = Riak::Client.new host: env_config['host'], pb_port: env_config['pb_port']
       self.riak_client = client
     end
     
@@ -78,7 +79,11 @@ module Riagent
     
     # @return [Riak::Client] The Riak client for the current thread.
     def riak_client
-      Thread.current[:riak_client] ||= nil
+      unless Thread.current[:riak_client]
+        # Re-initialize client
+        self.init_riak_client(self.config_for(Rails.env))
+      end
+      Thread.current[:riak_client]
     end
     
     # Sets the Riak client for the current thread.
@@ -89,7 +94,11 @@ module Riagent
     
     # @return [RiakJson::Client] The RiakJson client for the current thread.
     def riak_json_client
-      Thread.current[:riak_json_client] ||= nil
+      unless Thread.current[:riak_json_client]
+        # Re-initialize client
+        self.init_riak_json_client(self.config_for(Rails.env))
+      end
+      Thread.current[:riak_json_client]
     end
     
     # Sets the RiakJson client for the current thread.

data/lib/riagent/persistence.rb

@@ -20,6 +20,7 @@
 
 require "active_support/concern"
 require "riagent/persistence/persistence_strategy"
+require "riagent/persistence/riak_dt_set_strategy"
 require "riagent/persistence/riak_json_strategy"
 require "riagent/persistence/riak_no_index_strategy"
 
@@ -30,7 +31,11 @@ module Riagent
   module Persistence
     extend ActiveSupport::Concern
     
-    COLLECTION_TYPES = [:riak_json, :riak_no_index]
+    COLLECTION_TYPES = [:riak_json, :riak_kv]
+    
+    # Key Listing strategies for +:riak_kv+ collections 
+    # (the :riak_json collection type uses an implied solr query strategy)
+    VALID_KEY_LISTS = [:streaming_list_keys, :riak_dt_set]
     
     included do
       extend ActiveModel::Callbacks
@@ -111,7 +116,7 @@ module Riagent
       #   collection_type :riak_json  # persist to a RiakJson::Collection
       # end
       # </code>
-      def collection_type(coll_type)
+      def collection_type(coll_type, options={})
         unless COLLECTION_TYPES.include? coll_type
           raise ArgumentError, "Invalid collection type: #{coll_type.to_s}"
         end
@@ -119,8 +124,15 @@ module Riagent
         case @collection_type
         when :riak_json
           self.persistence = Riagent::Persistence::RiakJsonStrategy.new(self)
-        when :riak_no_index
-          self.persistence = Riagent::Persistence::RiakNoIndexStrategy.new(self)
+        when :riak_kv
+          self.persistence = Riagent::Persistence::RiakKVStrategy.new(self)
+          if options.has_key? :list_keys_using
+            if options[:list_keys_using] == :streaming_list_keys
+              self.persistence = Riagent::Persistence::RiakNoIndexStrategy.new(self)
+            elsif options[:list_keys_using] == :riak_dt_set
+              self.persistence = Riagent::Persistence::RiakDTSetStrategy.new(self)
+            end
+          end
         end
       end