cdq 0.1.1

data/motion/cdq/relationship_query.rb

@@ -0,0 +1,122 @@
+
+module CDQ
+
+  class CDQRelationshipQuery < CDQTargetedQuery
+
+    def initialize(owner, name, set = nil, opts = {})
+      @owner = owner
+      @relationship_name = name
+      @set = set || @owner.send(name)
+      relationship = owner.entity.relationshipsByName[name]
+      @inverse_rel = relationship.inverseRelationship
+      entity_description = relationship.destinationEntity
+      target_class = constantize(entity_description.managedObjectClassName)
+      super(entity_description, target_class, opts)
+      if @inverse_rel.isToMany
+        @predicate = self.where(@inverse_rel.name.to_sym).contains(@owner).predicate
+      else
+        @predicate = self.where(@inverse_rel.name.to_sym => @owner).predicate
+      end
+    end
+
+    # Creates a new managed object within the target relationship
+    # 
+    def new(opts = {})
+      super(opts).tap do |obj|
+        add(obj)
+      end
+    end
+
+    # Add an existing object to the relationship
+    # 
+    def add(obj)
+      if @inverse_rel.isToMany
+        obj.send(@inverse_rel.name).addObject(@owner)
+      else
+        obj.send("#{@inverse_rel.name}=", @owner)
+      end
+      @set.addObject obj
+    end
+    alias_method :<<, :add
+
+    def self.extend_set(set, owner, name)
+      set.extend SetExt
+      set.extend Enumerable
+      set.__query__ = self.new(owner, name, set)
+      set
+    end
+
+    # A Core Data relationship set is extended with this module to provide
+    # scoping by forwarding messages to a CDQRelationshipQuery instance knows
+    # how to create further queries based on the underlying relationship.
+    module SetExt
+      attr_accessor :__query__
+
+      def set
+        self
+      end
+
+      # This works in a special way.  If we're extending a regular NSSet, it will 
+      # create a new method that calls allObjects.  If we're extending a NSOrderedSet,
+      # the override will not work, and we get the array method already defined on
+      # NSOrderedSet, which is actually exactly what we want.
+      def array
+        self.allObjects
+      end
+
+      def first
+        array.first
+      end
+
+      # duplicating a lot of common methods because it's way faster than using method_missing
+      #
+      def each(*args, &block)
+        array.each(*args, &block)
+      end
+
+      def add(obj)
+        @__query__.add(obj)
+      end
+      alias_method :<<, :add
+
+      def create(opts = {})
+        @__query__.create(opts)
+      end
+
+      def new(opts = {})
+        @__query__.new(opts)
+      end
+
+      def where(*args)
+        @__query__.where(*args)
+      end
+
+      def sort_by(*args)
+        @__query__.sort_by(*args)
+      end
+
+      def limit(*args)
+        @__query__.limit(*args)
+      end
+
+      def offset(*args)
+        @__query__.offset(*args)
+      end
+
+      def respond_to?(method)
+        super(method) || @__query__.respond_to?(method)
+      end
+
+      def method_missing(method, *args, &block)
+        if @__query__.respond_to?(method)
+          @__query__.send(method, *args, &block)
+        else
+          super
+        end
+      end
+
+    end
+
+  end
+
+end

data/motion/cdq/store.rb

@@ -0,0 +1,52 @@
+
+module CDQ
+
+  class CDQStoreManager
+
+    attr_writer :current
+
+    def initialize(opts = {})
+      @config = opts[:config] || CDQConfig.default
+      @model_manager = opts[:model_manager]
+    end
+
+    def current
+      @current ||= create_store
+    end
+
+    def reset!
+      NSFileManager.defaultManager.removeItemAtURL(@config.database_url, error: nil)
+    end
+
+    def invalid?
+      !@current && @model_manager.invalid?
+    end
+
+    private
+
+    def create_store
+      if invalid?
+        raise "No model found.  Can't create a persistent store coordinator without it."
+      else
+        coordinator = NSPersistentStoreCoordinator.alloc.initWithManagedObjectModel(@model_manager.current)
+        error = Pointer.new(:object)
+        options = { NSMigratePersistentStoresAutomaticallyOption => true,
+                    NSInferMappingModelAutomaticallyOption => true }
+        url = @config.database_url
+        store = coordinator.addPersistentStoreWithType(NSSQLiteStoreType,
+                                                       configuration:nil,
+                                                       URL:url,
+                                                       options:options,
+                                                       error:error)
+        if store.nil?
+          error[0].userInfo['metadata'] && error[0].userInfo['metadata'].each do |key, value|
+            NSLog "#{key}: #{value}"
+          end
+          raise error[0].userInfo['reason']
+        end
+        coordinator
+      end
+    end
+  end
+
+end

data/motion/cdq/targeted_query.rb

@@ -0,0 +1,170 @@
+
+module CDQ #:nodoc:
+
+  class CDQTargetedQuery < CDQQuery
+
+    include Enumerable
+
+    attr_reader :entity_description
+
+    # Create a new CDQTargetedContext.  Takes an entity description, an optional
+    # implementation class, and a hash of options that will be passed to the CDQQuery
+    # constructor.
+    #
+    def initialize(entity_description, target_class = nil, opts = {})
+      @entity_description = entity_description
+      @target_class = target_class ||
+        NSClassFromString(entity_description.managedObjectClassName) ||
+        CDQManagedObject
+      @context = opts.delete(:context)
+      super(opts)
+    end
+
+    # The current context, taken from the environment or overriden by <tt>in_context</tt>
+    #
+    def context
+      @context || contexts.current
+    end
+
+    # Return the number of matching entities.
+    #
+    # Causes execution.
+    #
+    def count
+      raise("No context has been set.  Probably need to run cdq.setup") unless context
+      with_error_object(0) do |error|
+        context.countForFetchRequest(fetch_request, error:error)
+      end
+    end
+
+    # Return all matching entities.  
+    #
+    # Causes execution.
+    #
+    def array
+      raise("No context has been set.  Probably need to run cdq.setup") unless context
+      with_error_object([]) do |error|
+        context.executeFetchRequest(fetch_request, error:error)
+      end
+    end
+    alias_method :to_a, :array
+
+    # Convenience method for referring to all matching entities.  No-op.  You must
+    # still call <tt>array</tt> or another executing method
+    #
+    def all
+      self
+    end
+
+    # Return the first entity matching the query.
+    #
+    # Causes execution.  
+    #
+    def first
+      limit(1).array.first
+    end
+
+    # Fetch a single entity from the query by index.  If the optional
+    # <tt>length</tt> parameter is supplied, fetch a range of length <tt>length</tt>
+    # starting at <tt>index</tt>
+    #
+    # Causes execution.  
+    #
+    def [](index, length = nil)
+      if length
+        offset(index).limit(length).array
+      else
+        offset(index).first
+      end
+    end
+
+    # Iterate over each entity matched by the query.  You can also use any method from the
+    # Enumerable module in the standard library that does not depend on ordering.
+    #
+    # Causes execution.  
+    #
+    def each(&block)
+      array.each(&block)
+    end
+
+    # Returns the fully-contstructed fetch request, which can be executed outside of CDQ.
+    #
+    def fetch_request
+      super.tap do |req|
+        req.entity = @entity_description
+        req.predicate ||= NSPredicate.predicateWithValue(true)
+      end
+    end
+
+    # Create a new entity in the current context.  Accepts a hash of attributes that will be assigned to 
+    # the newly-created entity.  Does not save the context.
+    #
+    def new(opts = {})
+      @target_class.alloc.initWithEntity(@entity_description, insertIntoManagedObjectContext: context).tap do |entity|
+        opts.each { |k, v| entity.send("#{k}=", v) }
+      end
+    end
+
+    # Create a new entity in the current context.  Accepts a hash of attributes that will be assigned to 
+    # the newly-created entity.  Does not save the context.
+    #
+    # [TODO: Will apply validation.]
+    #
+    def create(*args)
+      new(*args)
+    end
+
+    # Create a named scope.  The query is any valid CDQ query.
+    #
+    # Example:
+    #   
+    # cdq('Author').scope(:first_published, cdq(:published).eq(true).sort_by(:published_at).limit(1))
+    #
+    # cdq('Author').first_published.first => #<Author>
+    #
+    def scope(name, query = nil, &block)
+      if query.nil? && block_given?
+        named_scopes[name] = block
+      elsif query
+        named_scopes[name] = query
+      else
+        raise ArgumentError.new("You must supply a query OR a block that returns a query to scope")
+      end
+    end
+
+    # Override the context in which to perform this query.  This forever forces the
+    # specified context for this particular query, so if you save the it for later
+    # use (such as defining a scope) bear in mind that changes in the default context
+    # will have no effect when running this. 
+    #
+    def in_context(context)
+      clone(context: context)
+    end
+
+    # Any unknown method will be checked against the list of named scopes.
+    #
+    def method_missing(name, *args)
+      scope = named_scopes[name]
+      case scope
+      when CDQQuery
+        where(scope)
+      when Proc
+        where(scope.call(*args))
+      else
+        super(name, *args)
+      end
+    end
+
+    private
+
+    def named_scopes
+      @@named_scopes ||= {}
+      @@named_scopes[@entity_description] ||= {}
+    end
+
+    def clone(opts = {})
+      CDQTargetedQuery.new(@entity_description, @target_class, locals.merge(opts))
+    end
+
+  end
+end

data/motion/managed_object.rb

@@ -0,0 +1,98 @@
+
+# CDQ Extensions for your custom entity objects.  This is mostly convenience
+# and syntactic sugar -- you can access every feature using the cdq(Class).<em>method</em>
+# syntax, but this enables the nicer-looking and more convenient Class.<em>method</em> style.
+# Any method availble on cdq(Class) is now available directly on Class.
+#
+# If there is a conflict between a CDQ method and one of yours, or one of Core Data's,
+# your code will always win.  In that case you can get at the CDQ method by calling
+# Class.cdq.<em>method</em>.
+#
+# Examples:
+# 
+#   MyEntity.where(:name).eq("John").limit(2)
+#   MyEntity.first
+#   MyEntity.create(name: "John")
+#   MyEntity.sort_by(:title)[4]
+#
+#   class MyEntity < CDQManagedObject
+#     scope :last_week, where(:created_at).ge(date.delta(weeks: -2)).and.lt(date.delta(weeks: -1))
+#   end
+#
+#   MyEntity.last_week.where(:created_by => john)
+#
+class CDQManagedObject < CoreDataQueryManagedObjectBase
+
+  extend CDQ
+  include CDQ
+
+  class << self
+
+    def inherited(klass) #:nodoc:
+      cdq(klass).entity_description.relationshipsByName.each do |name, rdesc|
+        if rdesc.isToMany
+          klass.defineRelationshipMethod(name)
+        end
+      end
+    end
+
+    # Shortcut to look up the entity description for this class
+    #
+    def entity_description
+      cdq.models.current.entitiesByName[name]
+    end
+
+    # Creates a CDQ scope, but also defines a method on the class that returns the 
+    # query directly.
+    #
+    def scope(name, query = nil, &block)
+      cdq.scope(name, query, &block)
+      if query
+        self.class.send(:define_method, name) do 
+          query
+        end
+      else
+        self.class.send(:define_method, name) do |*args|
+          block.call(*args)
+        end
+      end
+    end
+
+    def new(*args)
+      cdq.new(*args)
+    end
+
+    # Pass any unknown methods on to cdq. 
+    #
+    def method_missing(name, *args, &block)
+      cdq.send(name, *args, &block)
+    end
+
+    def responds_to?(name)
+      super || cdq.respond_to?(name)
+    end
+
+  end
+
+  # Register this object for destruction with the current context.  Will not
+  # actually be removed until the context is saved.
+  #
+  def destroy
+    managedObjectContext.deleteObject(self)
+  end
+
+  def inspect
+    description
+  end
+
+  protected
+
+  # Called from method that's dynamically added from
+  # +[CoreDataManagedObjectBase defineRelationshipMethod:]
+  def relationshipByName(name)
+    willAccessValueForKey(name)
+    set = CDQRelationshipQuery.extend_set(primitiveValueForKey(name), self, name)
+    didAccessValueForKey(name)
+    set
+  end
+end

data/resources/CDQ.xcdatamodeld/.xccurrentversion

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>_XCCurrentVersionName</key>
+	<string>0.0.1.xcdatamodel</string>
+</dict>
+</plist>