cdq 0.1.11 → 1.0.0

data/README.md

@@ -17,7 +17,8 @@ XCode, or you can use [ruby-xcdm](https://github.com/infinitered/ruby-xcdm).
 
 ## Introducing CDQ
 
-CDQ began its life as a fork of [MotionData](https://github.com/alloy/MotionData), but it became obvious I
+CDQ began its life as a fork of
+[MotionData](https://github.com/alloy/MotionData), but it became obvious I
 wanted to take things in a different direction, so I cut loose and ended up
 rewriting almost everything.  If you pay attention, you can still find the
 genetic traces, so thanks to @alloy for sharing his work and letting me learn
@@ -28,7 +29,7 @@ avoiding too much abstraction or method pollution on top of the SDK.  While it
 borrows many ideas from ActiveRecord (especially AREL), it is designed to
 harmonize with Core Data's way of doing things first.
 
-I am actively developing and improving CDQ (updated September 2014) so if you have
+I am actively developing and improving CDQ (updated February 2015) so if you have
 trouble or find a bug, please open a ticket!
 
 ### Why use a static Data Model?
@@ -46,14 +47,14 @@ $ cd my_app
 $ cdq init
 ```
 
-This way assumes you want to use ruby-xcdm.  Run ```cdq -h``` for list of more generators.
+This way assumes you want to use ruby-xcdm.  Run `cdq -h` for list of more generators.
 
 ### Using Bundler:
 
 ```ruby
 gem 'cdq'
 ```
-<br />
+
 If you want to see bleeding-edge changes, point Bundler at the git repo:
 
 ```ruby
@@ -67,7 +68,7 @@ it to your resources file and make sure it's named the same as your RubyMotion
 project.  If you're using `ruby-xcdm` (which I highly recommend) then it will
 create the datamodel file automatically and put it in the right place.
 
-Now include the setup code in your ```app_delegate.rb``` file:
+Now include the setup code in your `app_delegate.rb` file:
 
 ```ruby
 class AppDelegate
@@ -129,22 +130,25 @@ about contexts at all.
 For a great discussion of why you might want to use nested contexts, see [here](http://www.cocoanetics.com/2012/07/multi-context-coredata/).
 
 CDQ maintains a stack of contexts (one stack per thread), and by default, all
-operations on objects use the topmost context.  You just call ```cdq.save```
+operations on objects use the topmost context.  You just call `cdq.save`
 and it saves the whole stack.  Or you can get a list of all the contexts in
-order with ```cdq.contexts.all``` and do more precise work.
+order with `cdq.contexts.all` and do more precise work.
 
 Settings things up the way you want is easy.  Here's how you'd set it up for asynchronous
 saves:
 
 ```ruby
-  cdq.contexts.new(NSPrivateQueueConcurrencyType)
-  cdq.contexts.new(NSMainQueueConcurrencyType)
+  cdq.contexts.push(:root)
+  cdq.contexts.push(:main)
 ```
 
 This pushes a private queue context onto the bottom of the stack, then a main queue context on top of it.
-Since the main queue is on top, all your data operations will use that.  ```cdq.save``` then saves the
+Since the main queue is on top, all your data operations will use that.  `cdq.save` then saves the
 main context, and schedules a save on the root context.
 
+In addition, since these two contexts are globally important, it makes them available at `cdq.contexts.main` and
+`cdq.contexts.root`.
+
 ### Temporary Contexts
 
 From time to time, you may need to use a temporary context.  For example, on
@@ -153,8 +157,11 @@ load into a temporary context (possibly in a background thread) and then move
 all the data over to your main context all at once.  CDQ makes that easy too:
 
 ```ruby
-  cdq.contexts.new(NSConfinementConcurrencyType) do
+  cdq.background do
+
     # Your work here
+
+    cdq.save
   end
 ```
 
@@ -247,12 +254,12 @@ Here are some examples.  **See the [cheat sheet](https://github.com/infinitered/
 Like ActiveRecord, CDQ will not run a fetch until you actually request specific
 objects.  There are several methods for getting at the data:
 
- * ```array```
- * ```first```
- * ```each```
- * ```[]```
- * ```map```
- * Anything else in ```Enumerable```
+ * `array`
+ * `first`
+ * `each`
+ * `[]`
+ * `map`
+ * Anything else in `Enumerable`
 
 ## Dedicated Models
 
@@ -299,12 +306,12 @@ name, You'll need to use a <tt>cdq.yml</tt> config file.  See
 ### Working without model classes using the master method
 
 If you need or want to work without using CDQManagedObject as your base class,
-you can use the ```cdq()``` master method.  This is a "magic" method, like
-```rmq()``` in [RubyMotionQuery](http://github.com/infinitered/rmq) or
-```$()``` in jQuery, which will lift whatever you pass into it into the CDQ
+you can use the `cdq()`master method.  This is a "magic" method, like
+`rmq()` in [RubyMotionQuery](http://github.com/infinitered/rmq) or
+`$()` in jQuery, which will lift whatever you pass into it into the CDQ
 universe. The method is available inside all UIResponder classes (so, views and
 controllers) as well as in the console.  You can use it anywhere else by
-including the model ```CDQ``` into your classes.  To use an entity without a
+including the model `CDQ` into your classes.  To use an entity without a
 model class, just pass its name as a string into the master method, like so
 
 ```ruby

data/lib/cdq/version.rb

@@ -1,4 +1,4 @@
 
 module CDQ
-  VERSION = '0.1.11'
+  VERSION = '1.0.0'
 end

data/motion/cdq/context.rb

@@ -2,13 +2,15 @@ module CDQ
 
   class CDQContextManager
 
+    include Deprecation
+
     BACKGROUND_SAVE_NOTIFICATION = 'com.infinitered.cdq.context.background_save_completed'
     DID_FINISH_IMPORT_NOTIFICATION = 'com.infinitered.cdq.context.did_finish_import'
 
     def initialize(opts = {})
       @store_manager = opts[:store_manager]
     end
-    
+
     def dealloc
       NSNotificationCenter.defaultCenter.removeObserver(self) if @observed_context
       super
@@ -18,12 +20,18 @@ module CDQ
     # default. If a block is supplied, push for the duration of the block and then
     # return to the previous state.
     #
-    def push(context, &block)
+    def push(context, options = {}, &block)
       @has_been_set_up = true
+
+      unless context.is_a? NSManagedObjectContext
+        context = create(context, options)
+      end
+
       if block_given?
         save_stack do
-          push_to_stack(context)
+          context = push_to_stack(context)
           block.call
+          context
         end
       else
         push_to_stack(context)
@@ -38,6 +46,7 @@ module CDQ
         save_stack do
           rval = pop_from_stack
           block.call
+          rval
         end
       else
         pop_from_stack
@@ -48,7 +57,7 @@ module CDQ
     #
     def current
       if stack.empty? && !@has_been_set_up
-        new(NSMainQueueConcurrencyType)
+        push(NSMainQueueConcurrencyType)
       end
       stack.last
     end
@@ -69,13 +78,41 @@ module CDQ
     # will be set to the previous head context.  If a block is supplied, the new context
     # will exist for the duration of the block and then the previous state will be restore_managerd.
     #
+    # REMOVE1.1
+    #
     def new(concurrency_type, &block)
+      deprecate "cdq.contexts.new() is deprecated.  Use push() or create()"
+      context = create(concurrency_type)
+      push(context, {}, &block)
+    end
+
+    # Create a new context by type, setting upstream to the topmost context if available,
+    # or to the persistent store coordinator if not.  Return the context but do NOT push it
+    # onto the stack.
+    #
+    # Options:
+    #
+    #   :named - Assign the context a name, making it available as cdq.contexts.<name>.  The
+    #     name is permanent, and should only be used for contexts that are intended to be global,
+    #     since the object will never get released.
+    #
+    def create(concurrency_type, options = {}, &block)
       @has_been_set_up = true
-      
-      context = NSManagedObjectContext.alloc.initWithConcurrencyType(concurrency_type)
-      if current
-        context.parentContext = current
+
+      case concurrency_type
+      when :main
+        context = NSManagedObjectContext.alloc.initWithConcurrencyType(NSMainQueueConcurrencyType)
+        options[:named] = :main unless options.has_key?(:named)
+      when :private_queue, :private
+        context = NSManagedObjectContext.alloc.initWithConcurrencyType(NSPrivateQueueConcurrencyType)
+      when :root
+        context = NSManagedObjectContext.alloc.initWithConcurrencyType(NSPrivateQueueConcurrencyType)
+        options[:named] = :root unless options.has_key?(:named)
       else
+        context = NSManagedObjectContext.alloc.initWithConcurrencyType(concurrency_type)
+      end
+
+      if stack.empty?
         if @store_manager.invalid?
           raise "store coordinator not found. Cannot create the first context without one."
         else
@@ -89,17 +126,62 @@ module CDQ
             #}
           }
         end
+      else
+        context.parentContext = stack.last
       end
-      push(context, &block)
+
+      if options[:named]
+        if respond_to?(options[:named])
+          raise "Cannot name a context '#{options[:named]}': conflicts with existing method"
+        end
+        self.class.send(:define_method, options[:named]) do
+          context
+        end
+      end
+      context
     end
 
-    # Save all contexts in the stack, starting with the current and working down.
+    # Save all passed contexts in order.  If none are supplied, save all
+    # contexts in the stack, starting with the current and working down.  If
+    # you pass a symbol instead of a context, it will look up context with
+    # that name.
     #
-    def save(options = {})
+    # Options:
+    #
+    #   always_wait: If true, force use of performBlockAndWait for synchronous
+    #     saves.  By default, private queue saves are performed asynchronously.
+    #     Main queue saves are always synchronous if performed from the main
+    #     queue.
+    #
+    def save(*contexts_and_options)
+
+      if contexts_and_options.last.is_a? Hash
+        options = contexts_and_options.pop
+      else
+        options = {}
+      end
+
+      if contexts_and_options.empty?
+        contexts = stack.reverse
+      else
+        # resolve named contexts
+        contexts = contexts_and_options.map do |c|
+          if c.is_a? Symbol
+            send(c)
+          else
+            c
+          end
+        end
+      end
+
       set_timestamps
       always_wait = options[:always_wait]
-      stack.reverse.each do |context|
-        if always_wait || context.concurrencyType == NSMainQueueConcurrencyType
+      contexts.each do |context|
+        if context.concurrencyType == NSMainQueueConcurrencyType && NSThread.isMainThread
+          with_error_object do |error|
+            context.save(error)
+          end
+        elsif always_wait
           context.performBlockAndWait( -> {
 
             with_error_object do |error|
@@ -140,7 +222,51 @@ module CDQ
       end
       true
     end
-    
+
+    # Run the supplied block in a new context with a private queue.  Once the
+    # block exits, the context will be forgotten, so any changes made must be
+    # saved within the block.
+    #
+    # Note that the CDQ context stack, which is used when deciding what to save
+    # with `cdq.save` is stored per-thread, so the stack inside the block is
+    # different from the stack outside the block. If you push any more contexts
+    # inside, they will also disappear when the thread terminates.
+    #
+    # The thread is also unique.  If you call `background` multiple times, it will
+    # be a different thread each time with no persisted state.
+    #
+    # Options:
+    #   wait: If true, run the block synchronously
+    #
+    def background(options = {}, &block)
+      # Create a new private queue context with the main context as its parent
+      context = create(NSPrivateQueueConcurrencyType)
+
+      on(context, options) do
+        push(context, {}, &block)
+      end
+
+    end
+
+    # Run a block on the supplied context using performBlock.  If context is a
+    # symbol, it will look up the corresponding named context and use that
+    # instead.
+    #
+    # Options:
+    #   wait: If true, run the block synchronously
+    #
+    def on(context, options = {}, &block)
+
+      if context.is_a? Symbol
+        context = send(context)
+      end
+
+      if options[:wait]
+        context.performBlockAndWait(block)
+      else
+        context.performBlock(block)
+      end
+    end
 
     def did_finish_import(notification)
       @observed_context.performBlockAndWait ->{
@@ -213,14 +339,19 @@ module CDQ
         end
       end
     end
-    
+
     def set_timestamps
       now = Time.now
-      eos = current.insertedObjects.allObjects + current.updatedObjects.allObjects
-      eos.each do |e|
-        e.created_at ||= now if e.respond_to? :created_at=
+
+      current.insertedObjects.allObjects.each do |e|
+        e.created_at = now if e.respond_to? :created_at=
         e.updated_at = now if e.respond_to? :updated_at=
       end
+
+      current.updatedObjects.allObjects.each do |e|
+        e.updated_at = now if e.respond_to? :updated_at=
+      end
+
     end
 
   end

data/motion/cdq/deprecation.rb

@@ -0,0 +1,13 @@
+
+module CDQ
+  module Deprecation
+
+    class << self
+      attr_accessor :silence_deprecation
+    end
+
+    def deprecate(message)
+      puts message unless CDQ::Deprecation.silence_deprecation
+    end
+  end
+end

data/motion/cdq/object.rb

@@ -33,7 +33,7 @@ module CDQ
       elsif opts[:model]
         models.current = opts[:model]
       end
-      contexts.new(NSMainQueueConcurrencyType)
+      contexts.push(NSMainQueueConcurrencyType)
       true
     end
 
@@ -41,6 +41,10 @@ module CDQ
       contexts.save(*args)
     end
 
+    def background(*args, &block)
+      contexts.background(*args, &block)
+    end
+
     def find(oid)
       url = NSURL.URLWithString(oid)
       object_id = stores.current.managedObjectIDForURIRepresentation(url)

data/motion/cdq/observer.rb

@@ -0,0 +1,52 @@
+
+module CDQ
+  class CDQObserver
+
+    include CDQ
+
+    def initialize(actions, klass_or_object, &block)
+      actions = Array(actions)
+      keys = actions.map { |a| key_for_action(a) }
+
+      if klass_or_object.is_a?(Class)
+        test = proc { |obj| obj.is_a?(klass_or_object) }
+      else
+        test = proc { |obj| obj == klass_or_object }
+      end
+
+      @ns_observer = App.notification_center.observe NSManagedObjectContextDidSaveNotification, cdq.contexts.current do |notif|
+
+        actions.zip(keys).each do |action, key|
+
+          objects = notif.userInfo[key]
+          if objects
+            objects.allObjects.select(&test).each do |obj|
+              if block.arity == 2
+                block.call(obj, action)
+              else
+                block.call(obj)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def ns_observer
+      @ns_observer
+    end
+
+    def key_for_action(action)
+      case action
+      when :insert
+        NSInsertedObjectsKey
+      when :update
+        NSUpdatedObjectsKey
+      when :delete
+        NSDeletedObjectsKey
+      else
+        raise ArgumentError.new("No such action #{action.inspect}")
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: cdq
 version: !ruby/object:Gem::Version
-  version: 0.1.11
+  version: 1.0.0
+  prerelease: 
 platform: ruby
 authors:
 - infinitered
@@ -9,11 +10,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-22 00:00:00.000000000 Z
+date: 2015-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-xcdm
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -24,6 +26,7 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -34,6 +37,7 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: motion-yaml
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -41,6 +45,7 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -62,9 +67,11 @@ files:
 - motion/cdq/collection_proxy.rb
 - motion/cdq/config.rb
 - motion/cdq/context.rb
+- motion/cdq/deprecation.rb
 - motion/cdq/model.rb
 - motion/cdq/object.rb
 - motion/cdq/object_proxy.rb
+- motion/cdq/observer.rb
 - motion/cdq/partial_predicate.rb
 - motion/cdq/query.rb
 - motion/cdq/relationship_query.rb
@@ -82,25 +89,32 @@ files:
 homepage: http://infinitered.com/cdq
 licenses:
 - MIT
-metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -1573090934011425202
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -1573090934011425202
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.5
+rubygems_version: 1.8.23
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: A streamlined library for working with Core Data outside XCode
 test_files: []

checksums.yaml

@@ -1,15 +0,0 @@
----
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    MzdmYTFjN2U5ZTg1ZmExOTM3ODM3NGU0MDE3M2E3NTBmYjNmNTU5NQ==
-  data.tar.gz: !binary |-
-    YTA3Nzc3YmFiZGZkNjE0Njk2NGFkNmUwOTU5OWFiZjFiNTY3Y2IzMw==
-SHA512:
-  metadata.gz: !binary |-
-    Y2FkMTlkNmNmZGRiZjc2Y2ViNjlhOTBhY2I5YjA5MDFhZGQ5YjMxYmMxMTVj
-    MWRjZGE5NmVjOGUzNzE5YWFkODhjNjAxNDVhOWEwZDQwMGVmY2E2NDVlNTVl
-    YWM2Y2EzYzU4MzA3MmY0YTliODhkNTdhYWJkNDhlYjdhNjMwYzE=
-  data.tar.gz: !binary |-
-    ZDM3Y2Y2MWQwZTRhYWIzMWEyZjZjZTFjMzI2MmM1ZmM0MjliYzU3YjQwYWZk
-    NDM3MTFhZDIxYzNjNmRhNmZiYTA3MzE4ZjA0YmJlOTY0MTMxNDZhMzU5Yjdk
-    MzkwYjU5OGQ1YzM3MDM3OWI2YmRhMjQ1ZjAwNTUzMmI1YjQ3NGQ=