cdq 0.1.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MjBhMWJiZjc1MTc0OGQyMzM4NTEwN2ZkMGIyOWQ3MTJmODdiNWZhYg==
+  data.tar.gz: !binary |-
+    NmE3MTQ2MjIyMmYxYTJiYzg4OTJmMDYxMjk5ZjE4YWU2YjgzMzY1Nw==
+SHA512:
+  metadata.gz: !binary |-
+    YTBlZTY0NDE4NzIxMDY2ODcxMmUzNGMxM2M3OWFhYTExM2RjYjc1ZWI2NjRh
+    MTFiZjUyNzIwY2VlMDRmOTk3MTFmMGE2MTg0YTQ3YTljMTJlZGVkNWJkYjJm
+    NzZlZjYzYWRiODQ2OGVhNzNjNGUwOTliMDhkNzZiZDQ3YmU1YTE=
+  data.tar.gz: !binary |-
+    YmM1Njk2Nzg3ODBkODYxMjAxOWNlNmVkZWU3ZTg0YzNhMDBjOTQ5OTljNjcx
+    OWJiODM1MGYxOGNlODg1NGM4MzY3MzEzZjUyM2I5OTE5OGEwZGE0YmNlMjkx
+    NzkxNjlkNzIzYzQyZGYxODQxZmIyNjg2NGQwOTk1ZWJiODczYzI=

data/.gitignore

@@ -0,0 +1,11 @@
+.repl_history
+.*.sw?
+build
+vendor/cdq/ext/build-*
+vendor/cdq/ext/ext.bridgesupport
+resources/*.nib
+resources/*.momd
+resources/*.storyboardc
+examples/**/*.nib
+tags
+.rbenv-version

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem 'rake'
+gem 'motion-stump', :group => :spec
+gem 'cdq', :path => '.'

data/Gemfile.lock

@@ -0,0 +1,32 @@
+PATH
+  remote: .
+  specs:
+    cdq (0.1.1)
+      motion-yaml
+      ruby-xcdm (~> 0.0, >= 0.0.5)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (3.2.16)
+      i18n (~> 0.6, >= 0.6.4)
+      multi_json (~> 1.0)
+    builder (3.2.2)
+    i18n (0.6.9)
+    motion-stump (0.3.0)
+    motion-yaml (1.2)
+    multi_json (1.8.2)
+    plist (3.1.0)
+    rake (10.1.0)
+    ruby-xcdm (0.0.5)
+      activesupport (~> 3.2)
+      builder (~> 3.2)
+      plist (~> 3.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  cdq!
+  motion-stump
+  rake

data/README.md

@@ -0,0 +1,173 @@
+
+# Streamlined Core Data for RubyMotion
+
+Core Data Query (CDQ) is a library to help you manage your Core Data stack
+while using RubyMotion.  It uses a data model file, which you can generate in
+XCode, or you can use [ruby-xcdm](https://github.com/infinitered/ruby-xcdm).
+CDQ aims to streamline the process of getting you up and running Core Data, while
+avoiding too much abstraction or method pollution on top of the SDK.  
+
+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
+so much.
+
+### Why use a static Data Model?
+
+By using a real data model file that gets compiled and included in your bundle,
+you can take advantage of automatic migration, which simplifies managing your
+schema as it grows, if you can follow a few simple rules.  
+
+## Installing
+
+Using Bundler:
+
+```ruby
+gem 'cdq'
+```
+
+If you want to see bleeding-edge changes, point Bundler at the git repo:
+
+```ruby
+gem 'cdq', git: 'git://github.com/infinitered/cdq.git'
+```
+
+## Setting up your stack
+
+You will need a data model file.  If you've created one in XCode, move or copy
+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:
+
+```ruby
+class AppDelegate
+  include CDQ
+
+  def application(application, didFinishLaunchingWithOptions:launchOptions)
+    cdq.setup
+    true
+  end
+end
+
+class TopLevel
+  include CDQ
+end
+```
+
+That's it!  You can create specific implementation classes for your entities if
+you want, but it's not required.  You can start running queries on the console or
+in your code right away.  
+
+## Creating new objects
+
+CDQ maintains a stack of NSManagedObjectContexts for you, and any create
+operations will insert new, unsaved objects into the context currently on top
+of the stack.  `cdq.save` will save the whole stack, including correctly using
+private threads if appropriate.
+
+```ruby
+cdq('Author').create(name: "Le Guin", publish_count: 150, first_published: 1970)
+cdq('Author').create(name: "Shakespeare", publish_count: 400, first_published: 1550)
+cdq('Author').create(name: "Blake", publish_count: 100, first_published: 1778)
+cdq.save
+
+```
+
+## Queries
+
+A quick aside about queries in Core Data.  You should avoid them whenever
+possible in your production code.  Core Data is designed to work efficiently
+when you hang on to references to specific objects and use them as you would
+any in-memory object, letting Core Data handle your memory usage for you.  If
+you're coming from a server-side rails background, this can be pretty hard to
+get used to, but this is a very different environment.  So if you find yourself
+running queries that only return a single object, consider rearchitecting.
+That said, queries are sometimes the only solution, and it's very handy to be
+able to use them easily when debugging from the console, or in unit tests.
+
+With that out of the way, here are some samples:
+
+```ruby
+# Simple Queries
+cdq('Author').where(:name).eq('Shakespeare') 
+cdq('Author').where(:publish_count).gt(10)
+
+# sort, limit, and offset
+cdq('Author').sort_by(:created_at).limit(1).offset(10)
+
+# Compound queries
+cdq('Author').where(:name).eq('Blake').and(:first_published).le(Time.local(1700))
+
+# Multiple comparisons against the same attribute
+cdq('Author').where(:created_at).ge(yesterday).and.lt(today)
+```
+
+## Named Scopes
+
+You can save up partially-constructed queries for later use using named scopes, even
+combining them seamlessly with other queries or other named scopes:
+
+```ruby
+cdq('Author').scope :a_authors, cdq(:name).begins_with('A')
+cdq('Author').scope :prolific, cdq(:publish_count).gt(99)
+
+cdq('Author').prolific.a_authors.limit(5)
+```
+
+> NOTE: strings and symbols are NOT interchangeable. `cdq('Entity')` gives you a
+query generator for an entity, but `cdq(:attribute)` starts a predicate for an
+attribute.
+
+## Dedicated Models
+
+If you're using CDQ in a brand new project, you'll probably want to use
+dedicated model classes for your entities.  It will enable the usual
+class-level customization of your model objects, and also a somewhat more
+familiar-looking and natural syntax for queries and scopes:
+
+```ruby
+class Author < CDQManagedOjbect
+  scope :a_authors, cdq(:name).begins_with('A')
+  scope :prolific, cdq(:publish_count).gt(99)
+end
+```
+
+Now you can change the queries above to:
+
+```ruby
+Author.where(:name).eq('Shakespeare') 
+Author.where(:publish_count).gt(10)
+Author.where(:name).eq('Blake').and(:first_published).le(Time.local(1700))
+Author.where(:created_at).ge(yesterday).and.lt(today)
+Author.prolific.a_authors.limit(5)
+```
+
+Anything you can do with `cdq('Author')` you can now do with just `Author`.  If you have a
+pre-existing implementation class that you can't turn into a CDQManagedObject, you can also
+just wrap the class: `cdq(Author)`.  
+
+## Using CDQ with a pre-existing model
+
+If you have an existing app that already manages its own data model, you can
+use that, too, and override CDQ's stack at any layer:
+
+```ruby
+cdq.setup(context: App.delegate.mainContext) # don't set up model or store coordinator
+cdq.setup(store: App.delegate.persistentStoreCoordinator) # Don't set up model
+cdq.setup(model: App.delegate.managedObjectModel) # Don't load model
+```
+
+You cannot use CDQManagedObject as a base class when overriding this way,
+you'll need to use <tt>cdq('Entity')</tt>.  If you have an existing model and
+want to use it with CDQManagedObject without changing its name, You'll need to
+use a <tt>cdq.yml</tt> config file.  See [CDQConfig](motion/cdq/config.rb).
+
+## Things that are currently missing
+
+* There is no facility for custom migrations yet
+* There are no explicit validations (but you can define them on your data model)
+

data/Rakefile

@@ -0,0 +1,24 @@
+$:.unshift("/Library/RubyMotion/lib")
+require 'motion/project/template/ios'
+
+require 'bundler'
+require 'bundler/gem_tasks'
+
+Motion::Project::App.setup do |app|
+  # Use `rake config' to see complete project settings.
+  app.name = 'CDQ'
+  app.vendor_project('vendor/cdq/ext', :static)
+end
+
+if ARGV.join(' ') =~ /spec/
+  Bundler.require :default, :spec
+else
+  Bundler.require
+end
+
+require 'cdq'
+require 'motion-stump'
+require 'ruby-xcdm'
+require 'motion-yaml'
+
+task :"build:simulator" => :"schema:build"

data/app/app_delegate.rb

@@ -0,0 +1,13 @@
+class AppDelegate
+  include CDQ
+
+  def application(application, didFinishLaunchingWithOptions:launchOptions)
+    cdq.setup
+    true
+  end
+end
+
+class TopLevel
+  include CDQ
+end
+

data/app/test_models.rb

@@ -0,0 +1,15 @@
+class Author < CDQManagedObject
+end
+
+class Article < CDQManagedObject
+  scope :all_published, where(:published).eq(true)
+  scope :with_title, where(:title).ne(nil).sort_by(:title, :descending)
+  scope :published_since { |date| where(:publishedAt).ge(date) }
+end
+
+class Citation < CDQManagedObject
+end
+
+class Writer < CDQManagedObject
+end
+

data/cdq.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/cdq/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["infinitered", "kemiller"]
+  gem.email         = ["ken@infinitered.com"]
+  gem.description   = "Core Data Query for RubyMotion"
+  gem.summary       = "Core Data Query for RubyMotion"
+  gem.homepage      = "http://github.com/infinitered/cdq"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "cdq"
+  gem.require_paths = ["lib"]
+  gem.add_runtime_dependency 'ruby-xcdm', '~> 0.0', '>= 0.0.5'
+  gem.add_runtime_dependency 'motion-yaml'
+  gem.version       = CDQ::VERSION
+end

data/lib/cdq.rb

@@ -0,0 +1,12 @@
+
+unless defined?(Motion::Project::App)
+  raise "This must be required from within a RubyMotion Rakefile"
+end
+
+Motion::Project::App.setup do |app|
+  parent = File.join(File.dirname(__FILE__), '..')
+  app.files.unshift(Dir.glob(File.join(parent, "motion/cdq/**/*.rb")))
+  app.files.unshift(Dir.glob(File.join(parent, "motion/*.rb")))
+  app.frameworks += %w{ CoreData }
+  app.vendor_project(File.join(parent, 'vendor/cdq/ext'), :static)
+end

data/lib/cdq/version.rb

@@ -0,0 +1,4 @@
+
+module CDQ
+  VERSION = '0.1.1'
+end

data/motion/cdq.rb

@@ -0,0 +1,58 @@
+
+module CDQ
+
+  class CDQObject; end
+  class CDQQuery < CDQObject; end
+  class CDQPartialPredicate < CDQObject; end
+  class CDQTargetedQuery < CDQQuery; end
+
+  extend self
+
+  def cdq(obj = nil)
+    obj ||= self
+
+    @@base_object ||= CDQObject.new
+
+    case obj
+    when Class
+      if obj.isSubclassOfClass(NSManagedObject)
+        entity_description = @@base_object.models.current.entitiesByName[obj.name]
+        if entity_description.nil?
+          raise "Cannot find an entity named #{obj.name}"
+        end
+        CDQTargetedQuery.new(entity_description, obj)
+      else
+        @@base_object
+      end
+    when String
+      entity_description = @@base_object.models.current.entitiesByName[obj]
+      target_class = NSClassFromString(entity_description.managedObjectClassName)
+      if entity_description.nil?
+        raise "Cannot find an entity named #{obj}"
+      end
+      CDQTargetedQuery.new(entity_description, target_class)
+    when Symbol
+      CDQPartialPredicate.new(obj, CDQQuery.new)
+    when CDQObject
+      obj
+    when NSManagedObject
+      CDQObjectProxy.new(obj)
+    when Array
+      if obj.first.class.isSubclassOfClass(NSManagedObject)
+        CDQCollectionProxy.new(obj, obj.first.entity)
+      else
+        @@base_object
+      end
+    else
+      @@base_object
+    end
+  end
+
+  def self.pollute(klass)
+  end
+
+end
+
+class UIResponder
+  include CDQ
+end

data/motion/cdq/collection_proxy.rb

@@ -0,0 +1,29 @@
+
+module CDQ
+  class CDQCollectionProxy < CDQTargetedQuery
+
+    def initialize(objects, entity_description)
+      @objects = objects
+      super(entity_description, constantize(entity_description.managedObjectClassName))
+      @predicate = self.where("%@ CONTAINS SELF", @objects).predicate
+    end
+
+    def count
+      @objects.size
+    end
+
+    def get
+      @objects
+    end
+
+    def array
+      @objects
+    end
+    
+    def first
+      @objects.first
+    end
+
+  end
+end
+

data/motion/cdq/config.rb

@@ -0,0 +1,67 @@
+module CDQ
+
+
+  # = Configure the CDQ Stack
+  #
+  # This class wraps the YAML configuration file that will allow you to
+  # override the names used when setting up the database file and finding the
+  # model file.  This file is named <tt>cdq.yml</tt> and must be found at the
+  # root of your resources directory.  It supports the following top-level keys:
+  #
+  #   [name]          The root name for both database and model
+  #   [database_name] The root name for the database file (relative to the documents directory)
+  #   [model_name]    The root name for the model file (relative to the bundle directory)
+  #
+  # Using the config file is not necessary.  If you do not include it, the bundle display name
+  # will be used.  For most people with a new app, this is what you want to do, especially if
+  # you are using ruby-xcdm schemas.  The only case where using the config file is required
+  # is when you want to use CDQManagedObject-based models with a custom model or database, because
+  # class loading order of operations makes it impossible to configure from within your
+  # AppDelegate.
+  #
+  class CDQConfig
+
+    attr_reader :config_file, :database_name, :model_name, :name
+
+    def initialize(config_file)
+      case config_file
+      when String
+        @config_file = config_file
+        if File.file?(config_file)
+          h = File.open(config_file) { |f| YAML.load(f.read) }
+        else
+          h = {}
+        end
+      when Hash
+        h = config_file
+      else
+        h = {}
+      end
+
+      @name = h['name'] || h[:name] || NSBundle.mainBundle.objectForInfoDictionaryKey("CFBundleDisplayName")
+      @database_name = h['database_name'] || h[:database_name] || name
+      @model_name = h['model_name'] || h[:model_name] || name
+    end
+
+    def database_url
+      dir = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, true).last
+      path = File.join(dir, database_name + '.sqlite')
+      NSURL.fileURLWithPath(path)
+    end
+
+    def model_url
+      NSBundle.mainBundle.URLForResource(model_name, withExtension: "momd");
+    end
+
+    def self.default
+      @default ||=
+        begin
+          cf_file = NSBundle.mainBundle.pathForResource("cdq", ofType: "yml");
+          new(cf_file)
+        end
+    end
+  end
+
+end
+
+