post_json 1.0.10 → 1.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3ba8f65c7f2db2eec1489a4f4fd47bb44d882a1f
-  data.tar.gz: f40eda3e7b88abaab7ab6789413e28277ce28338
+  metadata.gz: fb5fea92951fd8ec7e82b70905b2ae78c5e28071
+  data.tar.gz: 412eaafc6a0b9c802dd02116898dc173f194d454
 SHA512:
-  metadata.gz: 41dc503b940da4747ee0a6af8bba3481decb1196ace7605c87d89ba4596d2451cb3234506e3908458a39465a7d3b5607db867ed444d9ebd1e3685a5277103a47
-  data.tar.gz: 83d71844541cfae6110fcbaebb480f62e1eaea185da3530eb34d039405941b5d0ce9b905977eed2582a3cb4546823672dea94d5b48a05c9adbea98a3e6863759
+  metadata.gz: 4874f99abaec969d3544de9ad4e1db5f651a16d50625ecb9112e2913b2048e7c6183b5ab154efcec482a1d0a6ab957a37a7a8cb22ec33417db76e548e4f16fe0
+  data.tar.gz: 9fc7845cf1082ed2f0670d43aa8ab07ab27780340122d0f3d139b2e2c9f8a1f8d0aae686f073a4e2f44e8191b05f743cdecf98a8efe94f08ff86462ccc6791ff

data/README.md

@@ -11,15 +11,16 @@ See example of how we use PostJson as part of <a href="https://github.com/webnut
 
 
 ## Getting started
-1. Add the gem to your Ruby on Rails application `Gemfile`:
 
-        gem 'post_json'
+### Add the gem to your Ruby on Rails application `Gemfile`:
+
+    gem 'post_json'
         
-2. At the command prompt, install the gem:
+### At the command prompt, install the gem, run the generator, and migrate the db:
 
-        bundle install
-        rails g post_json:install
-        rake db:migrate
+    bundle install
+    rails g post_json:install
+    rake db:migrate
         
 That's it!
 
@@ -34,99 +35,114 @@ PostJson is all about collections. All models represent a collection.
 
 Also, __notice you don't have to define model attributes anywhere!__
 
-1. Lets create your first model.
+### Lets create your first model.
 
-        class Person < PostJson::Collection["people"]
-        end
+```ruby
+class Person < PostJson::Collection["people"]
+end
         
-        me = Person.create(name: "Jacob")
-
-    As you can see it look the same as ActiveRecord, except you define `PostJson::Collection["people"]` instead of 
-    `ActiveRecord::Base`.
-    
-    `Person` can do the same as any model class inheriting `ActiveRecord::Base`.
+me = Person.create(name: "Jacob")
+```
+        
+As you can see it look the same as ActiveRecord, except you define `PostJson::Collection["people"]` instead of 
+`ActiveRecord::Base`.
     
-    You can also skip the creation of a class:
+`Person` can do the same as any model class inheriting `ActiveRecord::Base`.
     
-        people = PostJson::Collection["people"]
-        me = people.create(name: "Jacob")
+You can also skip the creation of a class:
+
+```ruby    
+people = PostJson::Collection["people"]
+me = people.create(name: "Jacob")
+```
 
-2. Adding some validation:
+### Adding some validation:
 
-        class Person < PostJson::Collection["people"]
-          validates :name, presence: true
-        end
+```ruby
+class Person < PostJson::Collection["people"]
+  validates :name, presence: true
+end
+```
 
-    PostJson::Collection["people"] returns a class, which is based on `PostJson::Base`, which is based on 
-    `ActiveRecord::Base`. So its the exact same validation as you may know.
+PostJson::Collection["people"] returns a class, which is based on `PostJson::Base`, which is based on 
+`ActiveRecord::Base`. So its the exact same validation as you may know.
     
-    Read the <a href="http://guides.rubyonrails.org/active_record_validations.html" target="_blank">Rails guide about validation</a> 
-    if you need more information.
+Read the <a href="http://guides.rubyonrails.org/active_record_validations.html" target="_blank">Rails guide about validation</a> if you need more information.
 
-3. Lets create a more complex document and do a query:
+### Lets create a more complex document and do a query:
 
-        me = Person.create(name: "Jacob", details: {age: 33})
-        
-    Now we can make a query and get the document:
-    
-        also_me_1 = Person.where(details: {age: 33}).first
-        also_me_2 = Person.where("details.age" => 33).first
-        also_me_3 = Person.where("function(doc) { return doc.details.age == 33; }").first
-        also_me_4 = Person.where("json_details.age = ?", 33).first
-        
-   PostJson support filtering on nested attributes as you can see. The two first queries speak for themself.
-   
-   The third query is special and show it is possible to use a pure JavaScript function for selecting documents.
+```ruby
+me = Person.create(name: "Jacob", details: {age: 33})
+```
+
+Now we can make a query and get the document:
 
-   The last query is also special and show it is possible to write real SQL queries. We just need to prefix 
-   the JSON attributes with `json_`.
+```ruby    
+# PostJson supports filtering on nested attributes
+also_me_1 = Person.where(details: {age: 33}).first
+also_me_2 = Person.where("details.age" => 33).first
 
-4. Accessing attributes:
+# It is possible to use a pure JavaScript function for selecting documents
+also_me_3 = Person.where("function(doc) { return doc.details.age == 33; }").first
 
-        person = Person.create(name: "Jacob")
-        puts person.name            # "Jacob"
-        puts person.name_was        # "Jacob"
-        puts person.name_changed?   # false
-        puts person.name_change     # nil
+# It is also possible to write real SQL queries. Just prefix the JSON attributes with `json_`
+also_me_4 = Person.where("json_details.age = ?", 33).first
+```        
 
-        person.name = "Martin"
+### Accessing attributes:
+
+Like you would expect with ActiveRecord:
+
+```ruby
+person = Person.create(name: "Jacob")
+puts person.name            # => "Jacob"
+puts person.name_was        # => "Jacob"
+puts person.name_changed?   # => false
+puts person.name_change     # => nil
+
+person.name = "Martin"
         
-        puts person.name_was        # "Jacob"
-        puts person.name            # "Martin"
-        puts person.name_changed?   # true
-        puts person.name_change     # ["Jacob", "Martin"]
+puts person.name_was        # => "Jacob"
+puts person.name            # => "Martin"
+puts person.name_changed?   # => true
+puts person.name_change     # => ["Jacob", "Martin"]
         
-        person.save
+person.save
 
-        puts person.name            # "Martin"
-        puts person.name_was        # "Martin"
-        puts person.name_changed?   # false
-        puts person.name_change     # nil
-        
-    Like you would expect with ActiveRecord.
+puts person.name            # => "Martin"
+puts person.name_was        # => "Martin"
+puts person.name_changed?   # => false
+puts person.name_change     # => nil
+```
+
+### Introduction to select and selectors.
 
-5. Introduction to select and selectors.
+Sometimes we need a transformed version of documents. This is very easy with `select`
 
-    Sometimes we need a transformed version of documents. This is very easy with `select`
+```ruby
+me = Person.create(name: "Jacob", details: {age: 33})
 
-        me = Person.create(name: "Jacob", details: {age: 33})
+other_me = Person.limit(1).select({name: "name", age: "details.age"}).first
 
-        other_me = Person.limit(1).select({name: "name", age: "details.age"}).first
-        puts other_me               # {name: "Jacob", age: 33}
+puts other_me   
+# => {name: "Jacob", age: 33}
 
-    `select` takes a hash as argument and return an array of hashes. The value of each key/value pair in the hash argument is a selector. Selectors can point at attributes at root level, but also nested attributes. Each level of attributes is seperated with a dot (.).
+```
+`select` takes a hash as argument and return an array of hashes. The value of each key/value pair in the hash argument is a selector. Selectors can point at attributes at root level, but also nested attributes. Each level of attributes is seperated with a dot (.).
 
-6. Check out the initializer at `config/initializers/post_json.rb`
+### Check out the initializer at `config/initializers/post_json.rb`
 
-        PostJson.setup "people" do |collection|
-          collection.record_timestamps = true                           # default is 'true'
-          collection.created_at_attribute_name = "created_at"           # default is 'created_at'
-          collection.updated_at_attribute_name = "updated_at"           # default is 'updated_at'
-          collection.include_version_number = true                      # default is 'true'
-          collection.version_attribute_name = "version"                 # default is 'version'
-          collection.use_dynamic_index = true                           # default is 'true'
-          collection.create_dynamic_index_milliseconds_threshold = 50   # default is '50'
-        end
+```ruby
+PostJson.setup "people" do |collection|
+  collection.record_timestamps = true                           # default is 'true'
+  collection.created_at_attribute_name = "created_at"           # default is 'created_at'
+  collection.updated_at_attribute_name = "updated_at"           # default is 'updated_at'
+  collection.include_version_number = true                      # default is 'true'
+  collection.version_attribute_name = "version"                 # default is 'version'
+  collection.use_dynamic_index = true                           # default is 'true'
+  collection.create_dynamic_index_milliseconds_threshold = 50   # default is '50'
+end
+```
 
 #### All of the following methods are supported
 
@@ -141,12 +157,14 @@ We also added `page(page, per_page)`, which translate into `offset((page-1)*per_
 
 On a virtual machine running on a 3 year old laptop we created 100.000 documents:
 
-        test_model = PostJson::Collection["test"]
-        100000.times { test_model.create(content: SecureRandom.uuid) }
-        content = test_model.last.content
+```ruby
+test_model = PostJson::Collection["test"]
+100000.times { test_model.create(content: SecureRandom.uuid) }
+content = test_model.last.content
         
-        result = test_model.where(content: content).count
-        # Rails debug tells me the duration was 975.5ms
+result = test_model.where(content: content).count
+# Rails debug tells me the duration was 975.5ms
+```
 
 The duration was above 50ms as you can see.
 
@@ -154,8 +172,10 @@ PostJson has a feature called "Dynamic Index". It is enabled by default and work
     
 Now lets see how the performance will be on the second and future queries using 'content':
 
-        result = test_model.where(content: content).count
-        # Rails debug tells me the duration was 1.5ms
+```ruby
+result = test_model.where(content: content).count
+# Rails debug tells me the duration was 1.5ms
+```
 
 It shows PostgreSQL as a document database combined with indexing has great performance out of the box.
 
@@ -183,16 +203,17 @@ you execute a query with `name` the performance will be much improved.
 
 You can adjust the settings:
 
-        class Person < PostJson::Collection["people"]
-          self.create_dynamic_index_milliseconds_threshold = 75
-        end
+```ruby
+class Person < PostJson::Collection["people"]
+  self.create_dynamic_index_milliseconds_threshold = 75
+end
 
-        # Or you can do:
+# Or you can do:
 
-        PostJson::Collection["people"].create_dynamic_index_milliseconds_threshold = 75
-
-        # Now indexes are only created if queries are slower than 75 milliseconds.
+PostJson::Collection["people"].create_dynamic_index_milliseconds_threshold = 75
 
+# Now indexes are only created if queries are slower than 75 milliseconds.
+```
 
 You might already know this about User Interfaces, but it is usual considered good practice if auto-complete responses are served to the user within 100 milliseconds. Other results are usual okay within 500 milliseconds. So leave room for application processing and network delay.
 
@@ -202,23 +223,32 @@ Do not set create_dynamic_index_milliseconds_threshold too low as PostJson will
 
 PostJson assign UUID as primary key (id):
 
-        me = Person.create(name: "Jacob")
-        puts me.id
-        # "297a2500-a456-459b-b3e9-e876f59602c2"
+```ruby
+me = Person.create(name: "Jacob")
+
+puts me.id    
+# => "297a2500-a456-459b-b3e9-e876f59602c2"
+```
 
 But you also set the primary key yourself:
 
-        john_doe = Person.create(id: "John Doe")
+```ruby
+john_doe = Person.create(id: "John Doe")
+```
 
 Notice the primary key is downcased when doing a query or finding records:
 
-        found = Person.where(id: "JOhN DoE").first
-        puts found.attributes
-        # {"id"=>"John Doe", "version"=>1, "created_at"=>"2013-10-22T10:42:26.190Z", "updated_at"=>"2013-10-22T10:42:26.190Z"}
+```ruby
+found = Person.where(id: "JOhN DoE").first
+
+puts found.attributes
+# => {"id"=>"John Doe", "version"=>1, "created_at"=>"2013-10-22T10:42:26.190Z", "updated_at"=>"2013-10-22T10:42:26.190Z"}
         
-        found_again = Person.find("JOhN DoE")
-        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"}
+found_again = Person.find("JOhN DoE")
+
+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"}
+```
 
 ## The future
 

data/lib/post_json/base.rb

@@ -12,11 +12,32 @@ module PostJson
     include Copyable
 
     def initialize(*args)
-      __local__primary_key = self.class.primary_key
-      __local__attrs = (args[0] || {}).with_indifferent_access
-      __local__attrs[__local__primary_key] = __local__attrs[__local__primary_key].to_s if __local__attrs.has_key?(__local__primary_key)
-      args[0] = {__local__primary_key => __local__attrs[__local__primary_key], '__doc__body' => __local__attrs}.with_indifferent_access
-      super
+      if args[0]
+        __local__doc__body = HashWithIndifferentAccess.new
+
+        args[0] = args[0].with_indifferent_access.inject(HashWithIndifferentAccess.new('__doc__body' => {})) do |result, (attribute_name, value)|
+          if self.class.primary_key == attribute_name
+            result[attribute_name] = value
+            result['__doc__body'][attribute_name] = value
+          elsif self.class.column_names.include?(attribute_name)
+            result[attribute_name] = value
+          else
+            __local__doc__body[attribute_name] = value
+          end
+          result
+        end
+
+        super(*args) do |new_record|
+          __local__doc__body.each do |attribute_name, value|
+            new_record.public_send("#{attribute_name}=", value)
+          end
+
+          yield new_record if block_given?
+        end
+      else
+        args[0] = HashWithIndifferentAccess.new('__doc__body' => {})
+        super
+      end
     end
 
     def cache_key
@@ -26,7 +47,11 @@ module PostJson
     end
 
     def attributes
-      read_attribute('__doc__body').try(:with_indifferent_access) || HashWithIndifferentAccess.new
+      if @new_record != nil
+        (read_attribute('__doc__body') || {}).with_indifferent_access
+      else
+        HashWithIndifferentAccess.new
+      end
     end
 
     def to_h
@@ -108,6 +133,8 @@ module PostJson
       self.__doc__body_write_attribute(attribute_name, value)
     end
 
+    alias_method :super_respond_to?, :respond_to?
+
     def respond_to?(method_symbol, include_all = false)
       if super
         true
@@ -121,6 +148,8 @@ module PostJson
                             method_name[0..-2]
                           elsif method_name.end_with?("_change")
                             method_name[0..-8]
+                          elsif method_name.end_with?("_will_change!")
+                            method_name[0..-14]
                           else
                             method_name
                           end
@@ -138,6 +167,8 @@ module PostJson
                           method_name[0..-2]
                         elsif method_name.end_with?("_change")
                           method_name[0..-8]
+                        elsif method_name.end_with?("_will_change!")
+                          method_name[0..-14]
                         else
                           method_name
                         end
@@ -174,10 +205,7 @@ module PostJson
         if @collection_name == nil
           @collection_name = superclass.collection_name rescue nil
         end
-        message = "You need to assign a collection name to class \"#{name}\":
-class #{name}
-  self.collection_name = #{name.underscore.pluralize}
-end"
+        message = "You need to assign a collection name to \"#{name || 'Class'}.collection_name\""
         raise ArgumentError, message unless @collection_name.present?
         @collection_name
       end
@@ -219,6 +247,10 @@ end"
           def #{attribute_name}_change
             __doc__body_attribute_change('#{attribute_name}')
           end
+
+          def #{attribute_name}_will_change!
+            (__doc__body_will_change! || {})['#{attribute_name}']
+          end
         RUBY
       end
     end

data/lib/post_json/version.rb

@@ -1,3 +1,3 @@
 module PostJson
-  VERSION = "1.0.10"
+  VERSION = "1.0.11"
 end

data/spec/models/derived_base_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe "Base model as superclass" do
+  class ChildModel < PostJson::Collection["children"]
+    def name=(value)
+      super(value.to_s.upcase)
+    end
+  end
+
+  subject { ChildModel }
+
+  its(:collection_name) { should == "children" }
+
+  context "document" do
+    let(:name) { "jacob" }
+    subject { ChildModel.create(name: name) }
+    its(:name) { should == name.upcase }
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: post_json
 version: !ruby/object:Gem::Version
-  version: 1.0.10
+  version: 1.0.11
 platform: ruby
 authors:
 - Jacob Madsen and Martin Thoegersen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-23 00:00:00.000000000 Z
+date: 2013-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -80,8 +80,8 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '2.0'
-description: Fast and flexible Document database by combining features of PostgreSQL
-  with PLV8 and Ruby
+description: A Fast and Flexible Document Database by Combining Features of Ruby and
+  PostgreSQL with PLV8
 email:
 - hello@webnuts.com
 executables: []
@@ -112,6 +112,7 @@ files:
 - lib/post_json/base.rb
 - spec/models/base_spec.rb
 - spec/models/queries_spec.rb
+- spec/models/derived_base_spec.rb
 - spec/models/collection_spec.rb
 - spec/spec_helper.rb
 - spec/dummy/app/helpers/application_helper.rb