cdq 0.1.1

data/motion/cdq/context.rb

@@ -0,0 +1,190 @@
+
+module CDQ
+
+  class CDQContextManager
+
+    BACKGROUND_SAVE_NOTIFICATION = 'com.infinitered.cdq.context.background_save_completed'
+
+    def initialize(opts = {})
+      @store_manager = opts[:store_manager]
+    end
+
+    # Push a new context onto the stack for the current thread, making that context the
+    # default. If a block is supplied, push for the duration of the block and then
+    # return to the previous state.
+    #
+    def push(context, &block)
+      if block_given?
+        save_stack do
+          push_to_stack(context)
+          block.call
+        end
+      else
+        push_to_stack(context)
+      end
+    end
+
+    # Pop the top context off the stack.  If a block is supplied, pop for the
+    # duration of the block and then return to the previous state.
+    #
+    def pop(&block)
+      if block_given?
+        save_stack do
+          rval = pop_from_stack
+          block.call
+        end
+      else
+        pop_from_stack
+      end
+    end
+
+    # The current context at the top of the stack.
+    #
+    def current
+      stack.last
+    end
+
+    # An array of all contexts, from bottom to top of the stack.
+    #
+    def all
+      stack.dup
+    end
+
+    # Remove all contexts.
+    #
+    def reset!
+      self.stack = []
+    end
+
+    # Create and push a new context with the specified concurrency type.  Its parent
+    # 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.
+    #
+    def new(concurrency_type, &block)
+      context = NSManagedObjectContext.alloc.initWithConcurrencyType(concurrency_type)
+      if current
+        context.parentContext = current
+      else
+        if @store_manager.invalid?
+          raise "store coordinator not found. Cannot create the first context without one."
+        else
+          context.persistentStoreCoordinator = @store_manager.current
+        end
+      end
+      push(context, &block)
+    end
+
+    # Save all contexts in the stack, starting with the current and working down.
+    #
+    def save(options = {})
+      always_wait = options[:always_wait]
+      stack.reverse.each do |context|
+        if always_wait || context.concurrencyType == NSMainQueueConcurrencyType
+          context.performBlockAndWait( -> {
+
+            with_error_object do |error|
+              context.save(error)
+            end
+
+          } )
+        elsif context.concurrencyType == NSPrivateQueueConcurrencyType
+          task_id = UIApplication.sharedApplication.beginBackgroundTaskWithExpirationHandler( -> { NSLog "CDQ Save Timed Out" } )
+
+          if task_id == UIBackgroundTaskInvalid
+            context.performBlockAndWait( -> {
+
+              with_error_object do |error|
+                context.save(error)
+              end
+
+            } )
+          else
+            context.performBlock( -> {
+
+              # Let the application know we're doing something important
+              with_error_object do |error|
+                context.save(error)
+              end
+
+              UIApplication.sharedApplication.endBackgroundTask(task_id)
+
+              NSNotificationCenter.defaultCenter.postNotificationName(BACKGROUND_SAVE_NOTIFICATION, object: context)
+
+            } )
+          end
+        else
+          with_error_object do |error|
+            context.save(error)
+          end
+        end
+      end
+      true
+    end
+
+    private
+
+    def push_to_stack(value)
+      lstack = stack
+      lstack << value
+      self.stack = lstack
+      value
+    end
+
+    def pop_from_stack
+      lstack = stack
+      value = lstack.pop
+      self.stack = lstack
+      value
+    end
+
+    def save_stack(&block)
+      begin
+        saved_stack = all
+        block.call
+      ensure
+        self.stack = saved_stack
+      end
+    end
+
+    def stack
+      Thread.current[:"cdq.context.stack.#{object_id}"] || []
+    end
+
+    def stack=(value)
+      Thread.current[:"cdq.context.stack.#{object_id}"] = value
+    end
+
+    def with_error_object(default = nil, &block)
+      error = Pointer.new(:object)
+      result = block.call(error)
+      if error[0]
+        print_error("Error while fetching", error[0])
+        raise "Error while fetching: #{error[0].debugDescription}"
+      end
+      result || default
+    end
+
+    def print_error(message, error, indent = "")
+      puts indent + message + error.localizedDescription
+      if error.userInfo['reason']
+        puts indent + error.userInfo['reason']
+      end
+      if error.userInfo['metadata']
+        error.userInfo['metadata'].each do |key, value|
+          puts indent + "#{key}: #{value}"
+        end
+      end
+      if !error.userInfo[NSDetailedErrorsKey].nil?
+        error.userInfo[NSDetailedErrorsKey].each do |key, value|
+          if key.instance_of? NSError
+            print_error("Sub-Error: ", key, indent + "   ")
+          else
+            puts indent + "#{key}: #{value}"
+          end
+        end
+      end
+    end
+
+end
+
+end

data/motion/cdq/model.rb

@@ -0,0 +1,32 @@
+
+module CDQ
+
+  class CDQModelManager
+
+    attr_writer :current
+
+    def initialize(opts = {})
+      @config = opts[:config] || CDQConfig.default
+    end
+
+    def current
+      @current ||= load_model
+    end
+
+    def invalid?
+      !@current && @config.model_url.nil?
+    end
+
+    private
+
+    def load_model
+      if invalid?
+        raise "No model file.  Cannot create an NSManagedObjectModel without one."
+      else
+        NSManagedObjectModel.alloc.initWithContentsOfURL(@config.model_url)
+      end
+    end
+
+  end
+
+end

data/motion/cdq/object.rb

@@ -0,0 +1,83 @@
+
+module CDQ
+
+  class CDQObject
+
+    include CDQ
+
+    def contexts
+      @@context_manager ||= CDQContextManager.new(store_manager: stores)
+    end
+
+    def stores
+      @@store_manager ||= CDQStoreManager.new(model_manager: models)
+    end
+
+    def models
+      @@model_manager ||= CDQModelManager.new
+    end
+
+    def reset!(opts = {})
+      @@context_manager.reset!
+      @@context_manager = nil
+      @@store_manager.reset!
+      @@store_manager = nil
+    end
+
+    def setup(opts = {})
+      if opts[:context]
+        contexts.push(opts[:context])
+        return true
+      elsif opts[:store]
+        stores.current = opts[:store]
+      elsif opts[:model]
+        models.current = opts[:model]
+      end
+      contexts.new(NSMainQueueConcurrencyType)
+      true
+    end
+
+    def save(*args)
+      contexts.save(*args)
+    end
+
+    protected
+
+    def with_error_object(default, &block)
+      error = Pointer.new(:object)
+      result = block.call(error)
+      if error[0]
+        raise "Error while fetching: #{error[0].debugDescription}"
+      end
+      result || default
+    end
+
+    def constantize(camel_cased_word)
+      names = camel_cased_word.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      names.inject(Object) do |constant, name|
+        if constant == Object
+          constant.const_get(name)
+        else
+          candidate = constant.const_get(name)
+          next candidate if constant.const_defined?(name, false)
+          next candidate unless Object.const_defined?(name)
+
+          # Go down the ancestors to check it it's owned
+          # directly before we reach Object or the end of ancestors.
+          constant = constant.ancestors.inject do |const, ancestor|
+            break const    if ancestor == Object
+            break ancestor if ancestor.const_defined?(name, false)
+            const
+          end
+
+          # owner is in Object, so raise
+          constant.const_get(name, false)
+        end
+      end
+    end
+  end
+
+end
+

data/motion/cdq/object_proxy.rb

@@ -0,0 +1,30 @@
+
+module CDQ
+  class CDQObjectProxy < CDQObject
+
+    def initialize(object)
+      @object = object
+    end
+
+    def get
+      @object
+    end
+
+    def respond_to?(method)
+      super(method) || @object.entity.relationshipsByName[method]
+    end
+
+    def method_missing(*args)
+      if @object.entity.relationshipsByName[args.first]
+        CDQRelationshipQuery.new(@object, args.first)
+      else
+        super(*args)
+      end
+    end
+
+    def destroy
+      @object.managedObjectContext.deleteObject(@object)
+    end
+  end
+end
+

data/motion/cdq/partial_predicate.rb

@@ -0,0 +1,53 @@
+
+module CDQ
+  class CDQPartialPredicate < CDQObject
+
+    attr_reader :key, :scope, :operation
+
+    OPERATORS = {
+      :eq => [NSEqualToPredicateOperatorType, :equal],
+      :ne => [NSNotEqualToPredicateOperatorType, :not_equal],
+      :lt => [NSLessThanPredicateOperatorType, :less_than],
+      :le => [NSLessThanOrEqualToPredicateOperatorType, :less_than_or_equal],
+      :gt => [NSGreaterThanPredicateOperatorType, :greater_than],
+      :ge => [NSGreaterThanOrEqualToPredicateOperatorType, :greater_than_or_equal],
+      :contains => [NSContainsPredicateOperatorType, :include],
+      :matches => [NSMatchesPredicateOperatorType],
+      :in => [NSInPredicateOperatorType],
+      :begins_with => [NSBeginsWithPredicateOperatorType],
+      :ends_with => [NSEndsWithPredicateOperatorType]
+    }
+      
+    def initialize(key, scope, operation = :and)
+      @key = key
+      @scope = scope
+      @operation = operation
+    end
+
+    OPERATORS.each do |op, (type, synonym)|
+      define_method(op) do |value, options = 0| 
+        make_scope(type, value, options)
+      end
+      alias_method synonym, op if synonym
+    end
+
+    def between(min, max);   make_scope(NSBetweenPredicateOperatorType, [min, max]); end
+      
+    private
+
+    def make_pred(key, type, value, options = 0)
+      NSComparisonPredicate.predicateWithLeftExpression(
+        NSExpression.expressionForKeyPath(key.to_s),
+        rightExpression:NSExpression.expressionForConstantValue(value),
+        modifier:NSDirectPredicateModifier,
+        type:type,
+        options:options)
+    end
+
+    def make_scope(type, value, options = 0)
+      scope.send(operation, make_pred(key, type, value, options), key)
+    end
+
+  end
+end
+

data/motion/cdq/query.rb

@@ -0,0 +1,128 @@
+
+module CDQ
+  class CDQQuery < CDQObject
+
+    EMPTY = Object.new
+
+    attr_reader :predicate, :sort_descriptors
+
+    def initialize(opts = {})
+      @predicate = opts[:predicate]
+      @limit = opts[:limit]
+      @offset = opts[:offset]
+      @sort_descriptors = opts[:sort_descriptors] || []
+      @saved_key = opts[:saved_key]
+    end
+
+    def limit(value = EMPTY)
+      if value == EMPTY
+        @limit
+      else
+        clone(limit: value)
+      end
+    end
+
+    def offset(value = EMPTY)
+      if value == EMPTY
+        @offset
+      else
+        clone(offset: value)
+      end
+    end
+
+    # Combine this query with others in an intersection ("and") relationship
+    def and(query = nil, *args)
+      merge_query(query, :and, *args) do |left, right|
+        NSCompoundPredicate.andPredicateWithSubpredicates([left, right])
+      end
+    end
+    alias_method :where, :and
+
+    # Combine this query with others in a union ("or") relationship
+    def or(query = nil, *args)
+      merge_query(query, :or, *args) do |left, right|
+        NSCompoundPredicate.orPredicateWithSubpredicates([left, right])
+      end
+    end
+
+    # Create a new query with the same values as this one, optionally overriding
+    # any of them in the options
+    def clone(opts = {})
+      self.class.new(locals.merge(opts))
+    end
+
+    def locals
+      { sort_descriptors: sort_descriptors,
+        predicate: predicate,
+        limit: limit,
+        offset: offset }
+    end
+
+    def sort_by(key, dir = :ascending)
+      if dir.to_s[0,4].downcase == 'desc'
+        ascending = false
+      else 
+        ascending = true
+      end
+
+      clone(sort_descriptors: @sort_descriptors + [NSSortDescriptor.sortDescriptorWithKey(key, ascending: ascending)])
+    end
+
+    def fetch_request
+      NSFetchRequest.new.tap do |req|
+        req.predicate = predicate
+        req.fetchLimit = limit if limit
+        req.fetchOffset = offset if offset
+        req.sortDescriptors = sort_descriptors unless sort_descriptors.empty?
+      end
+    end
+
+    private
+
+    def merge_query(query, operation, *args, &block)
+      key_to_save = nil
+      case query
+      when Hash
+        subquery = query.inject(CDQQuery.new) do |memo, (key, value)|
+          memo.and(key).eq(value)
+        end
+        other_predicate = subquery.predicate
+        new_limit = limit
+        new_offset = offset
+        new_sort_descriptors = sort_descriptors
+      when Symbol
+        return CDQPartialPredicate.new(query, self, operation)
+      when NilClass
+        if @saved_key
+          return CDQPartialPredicate.new(@saved_key, self, operation)
+        else
+          raise "Zero-argument 'and' and 'or' can only be used if there is a key in the preceding predicate"
+        end
+      when CDQQuery
+        new_limit = [limit, query.limit].compact.last
+        new_offset = [offset, query.offset].compact.last
+        new_sort_descriptors = sort_descriptors + query.sort_descriptors
+        other_predicate = query.predicate
+      when NSPredicate
+        other_predicate = query
+        new_limit = limit
+        new_offset = offset
+        new_sort_descriptors = sort_descriptors
+        key_to_save = args.first
+      when String
+        other_predicate = NSPredicate.predicateWithFormat(query, argumentArray: args)
+        new_limit = limit
+        new_offset = offset
+        new_sort_descriptors = sort_descriptors
+      end
+      if predicate
+        new_predicate = block.call(predicate, other_predicate)
+      else
+        new_predicate = other_predicate
+      end
+      clone(predicate: new_predicate, limit: new_limit, offset: new_offset, sort_descriptors: new_sort_descriptors, saved_key: key_to_save)
+    end
+
+  end
+end
+