post_json 1.0.13 → 1.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9d00197439ef2828a5a9f92f800c029d8a396134
-  data.tar.gz: 59223ff032a986b240b83d0557f53c36aabcf708
+  metadata.gz: a4e515a137dc47d28656df5a0cb6221765eb2d1e
+  data.tar.gz: 4c00c5e67ce84f313e93d34114962b13098dcdc8
 SHA512:
-  metadata.gz: fa5492848c38164755418dc96b8c3e13ff97032e8d9d7f0b4f377b2ca72b86a7c381db5a47004cde68abb12c1b4aa8d1f63df90de287549d6bd7fa085c9a2610
-  data.tar.gz: 5d55d2a5331b57b5d12abe3b4cac590765f50ee116bc55db28b313c64f4b1cad11b3e2c49598cea7dca1b8b20182df5997c6f07886ca9991792a543f7b4a907e
+  metadata.gz: eff7e305c189675ee80be4df40ec658b905e8f91479ec5fb2913162d042a6221717874dc43dcdaaba038a8895d14945083bdfb3479cf898a4bf8fb60cf70cfb3
+  data.tar.gz: 0efb647508cad8ace9357d41405577a0c11c83d6de0a863a24cecbb0875139b878d4de2a83e8e45e84ef172cd8a3fb7b7e7765fc026235c9deb58ee6fd169b2e

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright 2013 Webnuts (www.webnuts.com / hello@webnuts.com)
+Copyright 2014 Webnuts (www.webnuts.com / hello@webnuts.com)
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -17,4 +17,4 @@ 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.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,11 +1,45 @@
 # Welcome to PostJson
 
-PostJson is everything you expect of ActiveRecord and PostgreSQL, with the added power and dynamic nature of a document database (Free as a bird! No schemas!). 
+PostJson is everything you expect from ActiveRecord and PostgreSQL with the added power and dynamic nature of a document database (Free as a bird! No schemas!). 
 
 PostJson combines features of Ruby, ActiveRecord and PostgreSQL to provide a great document database by taking advantage of PostgreSQL 9.2+ support for JavaScript (Google's V8 engine). We started the work on PostJson, because we love document databases **and** PostgreSQL. 
 
-See the example of how we use PostJson as part of [Jumpstarter](https://github.com/webnuts/jumpstarter).
-
+## README contents
+
+- [Installation](#installation)
+- [Usage](#usage)
+    - [Model](#model)
+    - [Validations](#validations)
+    - [Querying](#querying)
+    - [Accessing attributes](#accessing-attributes)
+    - [Transformation with select](#transformation-with-select)
+    - [Dates](#dates)
+    - [Supported methods](#supported-methods)
+- [Configuration Options](#configuration-options)
+- [Performance](#performance)
+- [Dynamic Indexes](#dynamic-indexes)
+    - [Example](#example)
+    - [Index configuration](#index-configuration)
+        - [Warning](#warning)
+    - [Manual creation of index](#manual-creation-of-index)
+    - [List existing indexes](#list-existing-indexes)
+    - [Destroying an index](#destroying-an-index)
+- [Primary Keys](#primary-keys)
+- [Migrating to PostJson](#migrating-to-postjson)
+- [Roadmap](#roadmap)
+  - [Version 2.0: Reboot - Close To The Metal](#version-20-reboot--close-to-the-metal)
+  - [Version 2.1: JavaScript Bindings](#version-21-javascript-bindings)
+  - [Version 2.2: Relations](#version-22-relations)
+  - [Version 2.3: Versioning](#version-23-versioning)
+  - [Version 2.4: Bulk Import](#version-24-bulk-import)
+  - [Version 2.5: Export CSV and HTML](#version-25-export-csv-and-html)
+  - [Version 2.6: File Attachments](#version-26-file-attachments)
+  - [Version 2.7: Unused Index Deletion](#version-27-unused-index-deletion)
+  - [Version 3.x: Full Text Search](#version-3x-full-text-search)
+- [The future](#the-future)
+- [Requirements](#requirements)
+- [License](#license)
+- [Want to contribute?](#want-to-contribute)
 
 ## Installation
 
@@ -123,25 +157,24 @@ puts other_me
 
 ### Dates
 
-Dates are not natively supported by JSON. This is why dates are persisted as strings.
+JSON does not natively support dates so Time and DateTime values are serialized as strings with the format of `strftime('%Y-%m-%dT%H:%M:%S.%LZ')`. PostJson will parse an attribute's value to a `DateTime` object if the value is a string and matches the serialization format.
+
 
 ```ruby
 me = Person.create(name: "Jacob", nested: {now: Time.now})
+
+# `now` is a regular Time instance before being saved
 puts me.attributes
 # => {"name"=>"Jacob", "nested"=>{"now"=>2013-10-24 16:15:05 +0200}, "id"=>"fb9ef4bb-1441-4392-a95d-6402f72829db", "version"=>1, "created_at"=>Thu, 24 Oct 2013 14:15:05 UTC +00:00, "updated_at"=>Thu, 24 Oct 2013 14:15:05 UTC +00:00}
-```
 
-Lets reload it and see how it is stored:
-
-```ruby
+me.save
 me.reload
+
+# after save `now` is the formatted string
 puts me.attributes
 # => {"name"=>"Jacob", "nested"=>{"now"=>"2013-10-24T14:15:05.783Z"}, "id"=>"fb9ef4bb-1441-4392-a95d-6402f72829db", "version"=>1, "created_at"=>"2013-10-24T14:15:05.831Z", "updated_at"=>"2013-10-24T14:15:05.831Z"}
 ```
 
-PostJson will serialize Time and DateTime to format `strftime('%Y-%m-%dT%H:%M:%S.%LZ')` when persisting documents.
-
-PostJson will also parse an attribute's value to a `DateTime` object, if the value is a string and matches the format.
 
 ### Supported methods
 
@@ -170,7 +203,7 @@ For a Rails project this configuration could go in an initializer (`config/initi
 
 ## Performance
 
-On a virtual machine running on a 3 year old laptop we created 100.000 documents:
+As an example of PostJson performance we created 100,000 documents on a virtual machine running on a 3 year old laptop:
 
 ```ruby
 test_model = PostJson::Collection["test"]
@@ -181,26 +214,18 @@ result = test_model.where(content: content).count
 # Rails debug duration was 975.5ms
 ```
 
-The duration was above 50ms as you can see.
-
-PostJson has a feature called "Dynamic Index". It is enabled by default and works automatic behind the scene. It has now created an index on 'content'.
-    
-Now lets see how the performance will be on the second and future queries using 'content':
+Not bad but we know it can get better with some very specific indexing. After an index is created on `test.content` the performance is greatly improved:
 
 ```ruby
 result = test_model.where(content: content).count
 # Rails debug duration was 1.5ms
 ```
 
-It shows PostgreSQL as a document database combined with indexing has great performance out of the box.
-
-See the next section about "Dynamic Indexes" for details.
+You *could* create this index manually but PostJson has a feature called `Dynamic Index` that is enabled by default to work behind the scenes automatically creating indexes on slow queries.
 
 ## Dynamic Indexes
 
-PostJson will measure the duration of each `SELECT` query and instruct PostgreSQL to create an index, 
-if the query duration is above a specified threshold. This feature is called `Dynamic Index`. Since most 
-applications perform the same queries over and over again we think you'll find this useful.
+`Dynamic Index` is a feature of PostJson that will measure the duration of each `SELECT` query and instruct PostgreSQL to create an index if the query duration is above a specified threshold. Since most applications perform the same queries over and over again we think you'll find this useful.
 
 Each collection (like `PostJson::Collection["people"]` above) has two index attributes:
 
@@ -231,10 +256,49 @@ or:
 PostJson::Collection["people"].create_dynamic_index_milliseconds_threshold = 75
 ```
 
-### WARNING
+###### WARNING
 
 Do not set the dynamic index threshold too low as PostJson will try to create an index for every query. A threshold of 1 millisecond would be less than the duration of almost all queries.
 
+### Manual creation of index
+
+```ruby
+class Person < PostJson::Collection["people"]
+  self.ensure_dynamic_index("name", "details.age")
+end
+```
+ or:
+
+```ruby
+PostJson::Collection["people"].ensure_dynamic_index("name", "details.age")
+```
+
+### List existing indexes
+
+```ruby
+puts Person.existing_dynamic_indexes
+# => ["name", "details.age"]
+```
+
+or:
+
+```ruby
+puts PostJson::Collection["people"].existing_dynamic_indexes
+# => ["name", "details.age"]
+```
+
+### Destroying an index
+
+```ruby
+Person.destroy_dynamic_index("name")
+```
+
+or:
+
+```ruby
+PostJson::Collection["people"].destroy_dynamic_index("name")
+```
+
 ## Primary Keys
 
 PostJson assigns UUID as primary key (id):
@@ -266,22 +330,169 @@ puts found_again.attributes
 # => {"id"=>"John Doe", "version"=>1, "created_at"=>"2013-10-22T10:42:26.190Z", "updated_at"=>"2013-10-22T10:42:26.190Z"}
 ```
 
+## Migrating to PostJson
+
+Given a `User` model:
+
+```ruby
+class User < ActiveRecord::Base
+  ...
+end
+```
+
+Add each user to the new `users` collection:
+
+```ruby
+PostJson::Collection["users"].transaction do
+  User.all.find_each do |user|
+    PostJson::Collection["users"].create(user.attributes)
+  end
+end
+```
+
+Then replace `ActiveRecord::Base` with the `PostJson::Collection` class:
+
+```ruby
+class User < PostJson::Collection["users"]
+  ...
+end
+```
+
+Users will have the exact same content, including their primary keys (id).
+
+## Roadmap
+
+> Please note the roadmap might change as we move forward.
+
+### Version 2.0: Reboot – Close To The Metal
+
+#### Components
+PostJson should be an add-on to your Rails project and not a replacement for ActiveRecord models. To accomplish this, we plan to split the implementation into components and concerns. This will make it possible to include as much (or as little) of PostJson into your ActiveRecord models as you like.
+
+For example, perhaps you want `PostJson::Attributes`:
+
+```ruby
+class Person < ActiveRecord::Base
+  # PostJson::Attributes hides the column assigned to `document_hash_column` and includes the dynamic attributes in results like `to_json`.  
+
+  include PostJson::Attributes
+  self.document_hash_column = "__dynamic_attributes"
+end
+```
+
+We're excited to see how far we can take it to make everything re-usable in existing applications!
+
+#### Collection tables
+Version 1.x stores all documents in a table called `post_json_documents`. In Version 2, each collection will have its own table with the same name as the collection. Each collection's metadata (title, settings etc.) will be stored as a record in the dedicated table.
+
+### Version 2.1: JavaScript Bindings
+
+PostJson should support JavaScript bindings to its collection methods for query and find. We plan to integrate the `therubyracer` gem to translate JavaScript queries to ActiveRecord queries allowing seamless integration with rich JavaScript clients.
+
+Imagine a Rails controller's index method:
+
+```ruby
+def index
+  js_query = params[:query]
+  puts js_query
+  # => function(people) { return people.limit(10).where({'gender': 'male'}); }
+
+  result = PostJson::Collection['people'].eval_js_query(js_query)
+  render json: result
+end
+```
+
+### Version 2.2: Relations
+
+PostJson should support relations between collections like `has_many`, `has_one`, and `belongs_to` as persistable queries being able to work as dependent associations. Relations should not be tied to class definitions. This will allow the creation of relations from client software and enable relations to be copied / included in backups and migrations.
+
+Imagine we have two collection: `customers` and `orders`.
+
+#### has_one
+
+```ruby
+class Customer < PostJson::Collection["customers"]
+  has_one :order  
+end   
+```
+
+The order relation will use the `order_id` attribute from the customer, look-up the `orders` collection, and find the correct document using that id.
+
+`has_one` will support override of the `foreign_key` ('order_id'), `collection_name` ('orders'), and mark dependent as `:delete` or `:destroy`. It will also support alias with `:as`, `:readonly` and a `-> { ... }` block for specializing.
+
+#### has_many
+
+```ruby
+class Customer < PostJson::Collection["customers"]
+  has_many :orders
+end
+```
+
+The order relation will use the `order_ids` attribute from the customer, look-up the `orders` collection, and find all related order documents using `where(id: order_ids)`.
+
+`has_many` will support override of `foreign_keys` ('order_ids'), `collection_name` ('orders') and mark dependent as `:delete_all` or `:destroy_all`. It will also support alias with `:as`, `:readonly` and a `-> { ... }` block for specializing.
+
+```ruby
+class Order < PostJson::Collection["orders"]
+  belongs_to :customer
+end
+```
+
+The customer relation will look-up a collection named `customers` and find a customer with the `order_id` attribute set to the current order primary key value.
+
+`belongs_to` will support override of `foreign_key` ('order_id'), `collection_name` ('customers') and mark dependent as `:delete` or `:destroy`. It will also support alias with `:as`, `:readonly`, and a `-> { ... }` block for specializing.
+
+PostJson will use ActiveSupport::Inflector to implement the naming conventions.
+
+PostJson will serialize lambda (-> { ... } block for specializing) as part of the collection definitions.
+
+### Version 2.3: Versioning
+
+The history of data has great potential. It should be as easy as possible to get a view of the past. PostJson should be able to store the history of each document, including the possibility of restoring a document's previous state as a new document, roll back a document to its previous state, and view the changes for each version of a document.
+
+This should also work for an entire collection. PostJson should be able to create a new collection from an existing collection's previous state. It should also be possible to query and view the previous state of a collection without restoring it to a new collection first.
+
+### Version 2.4: Bulk Import
+
+Importing data can often be boring and troublesome. PostJson should make it easy to setup a data transformation and use bulk inserts to improve performance.
+
+### Version 2.5: Export CSV and HTML
+
+PostJson already supports transformation with `select`. PostJson should be able to return results as CSV and HTML.
+
+#### CSV
+
+CSV stores tabular data and is not compatible with JSON. PostJson will flatten the data: 
+
+```json
+{ parent: {child: 123} }
+```
+
+will be converted to 
+
+```json
+{ "parent.child" => 123 }
+```
+
+#### HTML
+
+HTML will be rendered by templates. PostJson will support Mustache and store templates in the database. This will allow PostgreSQL to do the rendering and return results as strings.
+
+### Version 2.6: File Attachments
+
+PostJson should be able to store files in a specialized `files` collection when it makes sense to store files in the database. Files can be attached to other collections by using a `has_one` or `has_many` relation.
+
+### Version 2.7: Unused Index Deletion
+
+PostJson should provide automatic deletion of unused dynamic indexes as an optional feature.
+
+### version 3.x: Full Text Search
+
+PostgreSQL has many great features to support Full Text Search and PostJson should take advantage of these.
+
 ## The future
 
-A few things we will be working on:
-- Versioning of documents with support for history, restore and rollback.
-- Restore a copy of entire collection at a specific date.
-- Copy a collection.
-- Automatic deletion of dynamic indexes when unused for a period of time.
-- Full text search. PostgreSQL has many great features.
-- Bulk import.
-- Whitelisting of attributes for models (strong attributes).
-- Whitelisting of collection names.
-- Support for files. Maybe as attachments to documents.
-- Keep the similarities with ActiveRecord API, but it shouldn't depend on Rails or ActiveRecord. 
-- Better performance and less complex code.
-
-And please let us know what you think and what you need. 
+We would love to hear new ideas or random thoughts about PostJson.
 
 ## Requirements
 

data/lib/core_ext/abstract_adapter_extend.rb

@@ -2,15 +2,14 @@ ActiveRecord::ConnectionAdapters::AbstractAdapter.class_eval do
 
   attr_accessor :last_select_query, :last_select_query_duration
   
-  def measure_select_all(arel, name = nil, binds = [])
+  def select_all_with_measure_duration(arel, name = nil, binds = [])
     result = nil
     @last_select_query_duration = Benchmark.realtime do
-      result = original_select_all(arel, name, binds)
+      result = select_all_without_measure_duration(arel, name, binds)
     end
     @last_select_query = to_sql(arel, binds.dup).strip
     result
   end
 
-  alias_method :original_select_all, :select_all
-  alias_method :select_all, :measure_select_all
+  alias_method_chain :select_all, :measure_duration
 end

data/lib/core_ext/active_record_relation_extend.rb

@@ -5,12 +5,11 @@
 # The override below can be removed in the future
 
 ActiveRecord::Relation.class_eval do
-  def exec_queries_without_implicit_readonly
-    records = original_exec_queries
+  def exec_queries_with_disable_implicit_readonly
+    records = exec_queries_without_disable_implicit_readonly
     records.each { |r| r.instance_variable_set(:@readonly, false) } unless self.readonly_value == true
     records
   end
 
-  alias_method :original_exec_queries, :exec_queries
-  alias_method :exec_queries, :exec_queries_without_implicit_readonly
+  alias_method_chain :exec_queries, :disable_implicit_readonly
 end

data/lib/post_json/base.rb

@@ -186,21 +186,21 @@ module PostJson
     end
 
     class << self
-      def post_json_all
-        QueryTranslator.new(original_all)
+      def all_with_query_translator
+        QueryTranslator.new(all_without_query_translator)
       end
 
-      alias_method :original_all, :all
-      alias_method :all, :post_json_all
+      alias_method_chain :all, :query_translator
 
       def page(*args)
         all.page(*args)
       end
 
       def default_scopes
-        # query = original_all.where("\"#{table_name}\".__doc__model_settings_id = ?", settings_id)
+        # query = query.where("\"#{table_name}\".__doc__model_settings_id = ?", settings_id)
         model_settings = ModelSettings.table_name
-        query = original_all.joins("INNER JOIN \"#{model_settings}\" ON lower(\"#{model_settings}\".collection_name) = '#{collection_name.downcase}'")
+        query = all_without_query_translator
+        query = query.joins("INNER JOIN \"#{model_settings}\" ON lower(\"#{model_settings}\".collection_name) = '#{collection_name.downcase}'")
         query = query.where("\"#{table_name}\".__doc__model_settings_id = \"#{model_settings}\".id")
         super + [Proc.new { query }]
       end

data/lib/post_json/concerns/copyable.rb

@@ -10,7 +10,7 @@ module PostJson
 
           if destination.persisted?
             dest_id = destination.persisted_settings.id
-            query = original_all
+            query = all_without_query_translator
             query = query.joins("INNER JOIN #{table_name} as dest ON dest.id = #{table_name}.id")
             query = query.where("dest.__doc__model_settings_id = '#{dest_id}'")
             query = query.where("\"#{table_name}\".__doc__model_settings_id = '#{src_id}'")

data/lib/post_json/concerns/dynamic_index_methods.rb

@@ -3,7 +3,7 @@ module PostJson
     extend ActiveSupport::Concern
 
     module ClassMethods
-      def dynamic_indexes
+      def existing_dynamic_indexes
         if settings.new_record?
           []
         else
@@ -11,11 +11,7 @@ module PostJson
         end
       end
 
-      def create_dynamic_index(selector)
-        create_dynamic_indexes(selector)
-      end
-
-      def create_dynamic_indexes(*selectors)
+      def ensure_dynamic_index(*selectors)
         DynamicIndex.ensure_index(persisted_settings.id, *selectors).count
       end
 

data/lib/post_json/query_translator.rb

@@ -33,7 +33,7 @@ module PostJson
         if model_class.use_dynamic_index == true &&
            model_class.create_dynamic_index_milliseconds_threshold < select_duration
           selectors = select_query.scan(/.*?json_selector\('(.*?)', \"post_json_documents\"\.__doc__body\)/).flatten.uniq
-          model_class.create_dynamic_indexes(selectors)
+          model_class.ensure_dynamic_index(*selectors)
         end
         result
       end

data/lib/post_json/version.rb

@@ -1,3 +1,3 @@
 module PostJson
-  VERSION = "1.0.13"
+  VERSION = "1.0.14"
 end

data/spec/models/base_spec.rb

@@ -365,20 +365,20 @@ describe "Base model" do
   context "dynamic indexes" do
     subject { PostJson::Collection['Customer'] }
 
-    its(:dynamic_indexes) { should == [] }
+    its(:existing_dynamic_indexes) { should == [] }
 
     context "create index" do
       let(:selector) { "name" }
       before do
-        subject.create_dynamic_index(selector)
+        subject.ensure_dynamic_index(selector)
       end
-      its(:dynamic_indexes) { should == [selector] }
+      its(:existing_dynamic_indexes) { should == [selector] }
 
       context "and destroy index" do
         before do
           subject.destroy_dynamic_index(selector)
         end
-        its(:dynamic_indexes) { should == [] }
+        its(:existing_dynamic_indexes) { should == [] }
       end
     end
   end

metadata

@@ -1,83 +1,84 @@
 --- !ruby/object:Gem::Specification
 name: post_json
 version: !ruby/object:Gem::Version
-  version: 1.0.13
+  version: 1.0.14
 platform: ruby
 authors:
-- Jacob Madsen and Martin Thoegersen
+- Jacob Madsen
+- Martin Thoegersen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-24 00:00:00.000000000 Z
+date: 2014-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
         version: 4.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
         version: 4.0.0
 - !ruby/object:Gem::Dependency
   name: uuidtools
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 2.1.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 2.1.4
 - !ruby/object:Gem::Dependency
   name: hashie
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 2.0.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 2.0.5
 - !ruby/object:Gem::Dependency
   name: pg
   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: rspec-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
 description: A Fast and Flexible Document Database by Combining Features of Ruby and
@@ -88,73 +89,73 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/core_ext/hash_extend.rb
-- lib/core_ext/active_record_relation_extend.rb
-- lib/core_ext/abstract_adapter_extend.rb
 - lib/post_json.rb
-- lib/generators/post_json/install/templates/create_procedures.rb
-- lib/generators/post_json/install/templates/create_post_json_documents.rb
-- lib/generators/post_json/install/templates/initializer.rb
-- lib/generators/post_json/install/templates/create_post_json_model_settings.rb
-- lib/generators/post_json/install/templates/create_post_json_dynamic_indexes.rb
-- lib/generators/post_json/install/templates/enable_extensions.rb
-- lib/generators/post_json/install/install_generator.rb
 - lib/post_json/model_settings.rb
-- lib/post_json/concerns/settings_methods.rb
-- lib/post_json/concerns/query_methods.rb
 - lib/post_json/concerns/argument_methods.rb
-- lib/post_json/concerns/copyable.rb
 - lib/post_json/concerns/finder_methods.rb
+- lib/post_json/concerns/copyable.rb
 - lib/post_json/concerns/dynamic_index_methods.rb
+- lib/post_json/concerns/query_methods.rb
+- lib/post_json/concerns/settings_methods.rb
 - lib/post_json/version.rb
 - lib/post_json/dynamic_index.rb
 - lib/post_json/query_translator.rb
 - lib/post_json/base.rb
-- spec/models/base_spec.rb
-- spec/models/queries_spec.rb
+- lib/generators/post_json/install/templates/create_post_json_model_settings.rb
+- lib/generators/post_json/install/templates/create_post_json_documents.rb
+- lib/generators/post_json/install/templates/initializer.rb
+- lib/generators/post_json/install/templates/create_procedures.rb
+- lib/generators/post_json/install/templates/create_post_json_dynamic_indexes.rb
+- lib/generators/post_json/install/templates/enable_extensions.rb
+- lib/generators/post_json/install/install_generator.rb
+- lib/core_ext/abstract_adapter_extend.rb
+- lib/core_ext/hash_extend.rb
+- lib/core_ext/active_record_relation_extend.rb
 - spec/models/derived_base_spec.rb
+- spec/models/base_spec.rb
 - spec/models/collection_spec.rb
+- spec/models/queries_spec.rb
+- spec/modules/argument_methods_spec.rb
+- spec/modules/query_methods_spec.rb
 - spec/spec_helper.rb
-- spec/dummy/app/helpers/application_helper.rb
-- spec/dummy/app/assets/javascripts/application.js
-- spec/dummy/app/assets/stylesheets/scaffold.css
-- spec/dummy/app/assets/stylesheets/application.css
-- spec/dummy/app/views/layouts/application.html.erb
-- spec/dummy/app/controllers/application_controller.rb
+- spec/dummy/bin/rake
 - spec/dummy/bin/rails
 - spec/dummy/bin/bundle
-- spec/dummy/bin/rake
-- spec/dummy/config.ru
-- spec/dummy/Rakefile
-- spec/dummy/config/environment.rb
-- spec/dummy/config/environments/development.rb
 - spec/dummy/config/environments/test.rb
+- spec/dummy/config/environments/development.rb
 - spec/dummy/config/environments/production.rb
-- spec/dummy/config/application.rb
-- spec/dummy/config/initializers/inflections.rb
-- spec/dummy/config/initializers/mime_types.rb
-- spec/dummy/config/initializers/backtrace_silencers.rb
-- spec/dummy/config/initializers/filter_parameter_logging.rb
+- spec/dummy/config/locales/en.yml
+- spec/dummy/config/routes.rb
+- spec/dummy/config/database.yml
 - spec/dummy/config/initializers/post_json.rb
 - spec/dummy/config/initializers/session_store.rb
+- spec/dummy/config/initializers/mime_types.rb
 - spec/dummy/config/initializers/wrap_parameters.rb
+- spec/dummy/config/initializers/filter_parameter_logging.rb
+- spec/dummy/config/initializers/inflections.rb
 - spec/dummy/config/initializers/secret_token.rb
-- spec/dummy/config/routes.rb
-- spec/dummy/config/locales/en.yml
-- spec/dummy/config/database.yml
+- spec/dummy/config/initializers/backtrace_silencers.rb
+- spec/dummy/config/application.rb
+- spec/dummy/config/environment.rb
 - spec/dummy/config/boot.rb
-- spec/dummy/public/favicon.ico
-- spec/dummy/public/404.html
-- spec/dummy/public/500.html
-- spec/dummy/public/422.html
 - spec/dummy/db/structure.sql
 - spec/dummy/db/migrate/20131018135641_create_post_json_model_settings.rb
-- spec/dummy/db/migrate/20131018135643_create_post_json_dynamic_indexes.rb
-- spec/dummy/db/migrate/20131018135639_enable_extensions.rb
 - spec/dummy/db/migrate/20131018135640_create_procedures.rb
+- spec/dummy/db/migrate/20131018135639_enable_extensions.rb
+- spec/dummy/db/migrate/20131018135643_create_post_json_dynamic_indexes.rb
 - spec/dummy/db/migrate/20131018135642_create_post_json_documents.rb
-- spec/modules/query_methods_spec.rb
-- spec/modules/argument_methods_spec.rb
+- spec/dummy/public/500.html
+- spec/dummy/public/404.html
+- spec/dummy/public/favicon.ico
+- spec/dummy/public/422.html
+- spec/dummy/app/views/layouts/application.html.erb
+- spec/dummy/app/controllers/application_controller.rb
+- spec/dummy/app/assets/stylesheets/scaffold.css
+- spec/dummy/app/assets/stylesheets/application.css
+- spec/dummy/app/assets/javascripts/application.js
+- spec/dummy/app/helpers/application_helper.rb
+- spec/dummy/Rakefile
+- spec/dummy/config.ru
 - MIT-LICENSE
 - Rakefile
 - README.md
@@ -168,17 +169,17 @@ 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.1.9
+rubygems_version: 2.1.10
 signing_key: 
 specification_version: 4
 summary: PostgreSQL as Document database