motion_data_wrapper 0.0.1

data/lib/motion_data_wrapper.rb

@@ -0,0 +1,18 @@
+require 'motion_data_wrapper/version'
+
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+Motion::Project::App.setup do |app|
+
+  # Load class definitions that require the following modules, these will get compiled after b/c we're using "unshift"
+  Dir[File.join(File.dirname(__FILE__), "motion_data_wrapper/*.rb")].each { |f| app.files.unshift(f) }
+  
+  # Load in the modules
+  %w(errors model relation).each do |mod|
+    Dir[File.join(File.dirname(__FILE__), "motion_data_wrapper/#{mod}/**/*.rb")].each { |f| app.files.unshift(f) }
+  end
+
+  app.frameworks << "CoreData" unless app.frameworks.include?("CoreData")
+end

data/lib/motion_data_wrapper/delegate.rb

@@ -0,0 +1,52 @@
+module MotionDataWrapper
+  module Delegate
+
+    def managedObjectContext
+      @managedObjectContext ||= begin
+        documentsDirectory = NSFileManager.defaultManager.URLsForDirectory(NSDocumentDirectory, inDomains:NSUserDomainMask).lastObject;
+        storeURL = documentsDirectory.URLByAppendingPathComponent("#{sqlite_store_name}.sqlite")
+
+        error_ptr = Pointer.new(:object)
+        unless persistentStoreCoordinator.addPersistentStoreWithType(NSSQLiteStoreType, configuration:nil, URL:storeURL, options:persistent_store_options, error:error_ptr)
+          raise "Can't add persistent SQLite store: #{error_ptr[0].description}"
+        end
+
+        context = NSManagedObjectContext.alloc.init
+        context.persistentStoreCoordinator = persistentStoreCoordinator
+
+        context
+      end
+    end
+
+    def managedObjectModel
+      @managedObjectModel ||= begin
+        model = NSManagedObjectModel.mergedModelFromBundles([NSBundle.mainBundle]).mutableCopy
+
+        model.entities.each do |entity|
+          begin
+            Kernel.const_get(entity.name)
+            entity.setManagedObjectClassName(entity.name)
+
+          rescue NameError
+            entity.setManagedObjectClassName("Model")
+          end
+        end
+
+        model
+      end
+    end
+
+    def persistentStoreCoordinator
+      @coordinator ||= NSPersistentStoreCoordinator.alloc.initWithManagedObjectModel(managedObjectModel)
+    end
+
+    def sqlite_store_name
+      NSBundle.mainBundle.infoDictionary.objectForKey("CFBundleName")
+    end
+
+    def persistent_store_options
+      nil
+    end
+
+  end
+end

data/lib/motion_data_wrapper/errors/record_invalid.rb

@@ -0,0 +1,11 @@
+module MotionDataWrapper
+  class RecordInvalid < StandardError
+  
+    def initialize(record)
+      @record = record
+      @errors = @record.errors
+      super(@errors.map { |k,v| "#{k} #{v}"}.join(', '))
+    end
+  
+  end
+end

data/lib/motion_data_wrapper/errors/record_not_found.rb

@@ -0,0 +1,11 @@
+module MotionDataWrapper
+  class RecordNotFound < StandardError
+  
+    def initialize(klass, id)
+      @klass = klass
+      @id = id
+      super("Could not find #{@klass.name} id: #{@id}")
+    end
+  
+  end
+end

data/lib/motion_data_wrapper/errors/record_not_saved.rb

@@ -0,0 +1,11 @@
+module MotionDataWrapper
+  class RecordNotSaved < StandardError
+  
+    def initialize(record)
+      @record = record
+      @errors = @record.errors
+      super(@errors.map { |k,v| "#{k} #{v}"}.join(', '))
+    end
+  
+  end
+end

data/lib/motion_data_wrapper/model.rb

@@ -0,0 +1,18 @@
+module MotionDataWrapper
+  class Model < NSManagedObject
+    include CoreData
+    include FinderMethods
+    include Persistence
+    include Validations
+
+    def inspect
+      properties = []
+      entity.properties.select { |p| p.is_a?(NSAttributeDescription) }.each do |property|
+        properties << "#{property.name}: #{valueForKey(property.name).inspect}"
+      end
+
+      "#<#{entity.name} #{properties.join(", ")}>"
+    end
+
+  end
+end

data/lib/motion_data_wrapper/model/core_data.rb

@@ -0,0 +1,19 @@
+module MotionDataWrapper
+  class Model < NSManagedObject
+    module CoreData
+  
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+  
+      module ClassMethods
+    
+        def entity_description
+          @_metadata ||= UIApplication.sharedApplication.delegate.managedObjectModel.entitiesByName[name]
+        end
+    
+      end
+  
+    end
+  end
+end

data/lib/motion_data_wrapper/model/finder_methods.rb

@@ -0,0 +1,107 @@
+module MotionDataWrapper
+  class Model < NSManagedObject
+    module FinderMethods
+    
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    
+      module ClassMethods
+      
+        def all
+          relation.to_a
+        end
+      
+        def count
+          relation.count
+        end
+        
+        def destroy_all
+          all.map &:destroy
+        end
+      
+        def except(query_part)
+          relation.except(query_part)
+        end
+      
+        def find(object_id)
+          raise MotionDataWrapper::RecordNotFound.new(self, object_id) unless entity = find_by_id(object_id)
+          entity
+        end
+      
+        def first
+          relation.first
+        end
+      
+        def first!
+          first or raise MotionDataWrapper::RecordNotFound
+        end
+
+        def last
+          relation.last
+        end
+
+        def last!
+          last or raise MotionDataWrapper::RecordNotFound
+        end
+      
+        def limit(l)
+          relation.limit(l)
+        end
+      
+        def method_missing(method, *args, &block)
+          if method.start_with?("find_by_")
+            attribute = method.gsub("find_by_", "")
+            relation.where("#{attribute} = ?", *args).first
+          elsif method.start_with?("find_all_by_")
+            attribute = method.gsub("find_all_by_", "")
+            relation.where("#{attribute} = ?", *args).to_a
+          else
+            super
+          end
+        end
+      
+        def offset(o)
+          relation.offset(o)
+        end
+
+        def order(*args)
+          relation.order(*args)
+        end
+      
+        def pluck(column)
+          relation.pluck(column)
+        end
+        
+        def reorder(*args)
+          relation.except(:order).order(*args)
+        end
+      
+        def respond_to?(method)
+          if method.start_with?("find_by_") || method.start_with?("find_all_by_")
+            true
+          else
+            super
+          end
+        end
+      
+        def uniq
+          relation.uniq
+        end
+
+        def where(*args)
+          relation.where(*args)
+        end
+      
+      private
+      
+        def relation
+          Relation.alloc.initWithClass(self)
+        end
+      
+      end 
+    
+    end
+    
+  end
+end

data/lib/motion_data_wrapper/model/persistence.rb

@@ -0,0 +1,85 @@
+module MotionDataWrapper
+  class Model < NSManagedObject
+    module Persistence
+    
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+ 
+      module ClassMethods
+      
+        def create(attributes={})
+          begin
+            model = create!(attributes)
+          rescue MotionDataWrapper::RecordNotSaved
+          end
+          model
+        end
+
+        def create!(attributes={})
+          model = new(attributes)
+          model.save!
+          model
+        end
+      
+        def new(attributes={})
+          alloc.initWithEntity(entity_description, insertIntoManagedObjectContext:nil).tap do |model|
+            model.instance_variable_set('@new_record', true)
+            attributes.each do |keyPath, value|
+              model.setValue(value, forKey:keyPath)
+            end
+          end
+        end
+      
+      end
+    
+      def destroy
+      
+        if context = managedObjectContext
+          context.deleteObject(self)
+          error = Pointer.new(:object)
+          context.save(error)
+        end
+      
+        @destroyed = true
+        freeze
+      end
+    
+      def destroyed?
+        @destroyed || false
+      end
+    
+      def new_record?
+        @new_record || false
+      end
+    
+      def persisted?
+        !(new_record? || destroyed?)
+      end
+    
+      def save
+        begin
+          save!
+        rescue MotionDataWrapper::RecordNotSaved
+          return false
+        end
+        true
+      end
+    
+      def save!        
+        unless context = managedObjectContext
+          context = UIApplication.sharedApplication.delegate.managedObjectContext
+          context.insertObject(self)
+        end
+
+        error = Pointer.new(:object)
+        unless context.save(error)
+          managedObjectContext.deleteObject(self)
+          raise MotionDataWrapper::RecordNotSaved, self and return false
+        end
+        true
+      end
+    
+    end
+  end
+end

data/lib/motion_data_wrapper/model/validations.rb

@@ -0,0 +1,65 @@
+module MotionDataWrapper
+  class Model < NSManagedObject
+    module Validations
+    
+      def valid?
+        error_ptr = Pointer.new(:object)
+        v = new_record? ? validateForInsert(error_ptr) : validateForUpdate(error_ptr)
+        yield(v, error_ptr[0]) if block_given?
+        v
+      end
+
+      def errors
+        errors = {}
+        valid? do |valid, error|
+          next if error.nil?
+          if error.code == NSValidationMultipleErrorsError
+            errs = error.userInfo[NSDetailedErrorsKey]
+            errs.each do |nserr|
+              property = nserr.userInfo['NSValidationErrorKey']
+              errors[property] = message_for_error_code(nserr.code, property)
+            end
+          else
+            property = error.userInfo['NSValidationErrorKey']
+            errors[property] = message_for_error_code(error.code, property)
+          end
+        end
+        errors
+      end
+    
+      private
+      def message_for_error_code(c, prop)
+        message = case c
+        when NSValidationMissingMandatoryPropertyError
+          "can't be blank"
+        when NSValidationNumberTooLargeError
+          "too large"
+        when NSValidationNumberTooSmallError
+          "too small"
+        when NSValidationDateTooLateError
+          "too late"
+        when NSValidationDateTooSoonError
+          "too soon"
+        when NSValidationInvalidDateError
+          "invalid date"
+        when NSValidationStringTooLongError
+          "too long"
+        when NSValidationStringTooShortError
+          "too short"
+        when NSValidationStringPatternMatchingError
+          "incorrect pattern"
+        when NSValidationRelationshipExceedsMaximumCountError
+          "too many"
+        when NSValidationRelationshipLacksMinimumCountError
+          "too few"
+        when NSValidationRelationshipDeniedDeleteError
+          "can't delete"
+        when NSManagedObjectValidationError
+          warnings = entity.propertiesByName[prop].validationWarnings rescue []
+          warnings.empty? ? "invalid" : warnings.join(', ')
+        end
+      end
+    
+    end
+  end
+end

data/lib/motion_data_wrapper/relation.rb

@@ -0,0 +1,12 @@
+module MotionDataWrapper
+  class Relation < NSFetchRequest
+    include CoreData
+    include FinderMethods
+
+    def initWithClass(klass)
+      self.entity = klass.entity_description if init
+      self
+    end
+
+  end
+end

data/lib/motion_data_wrapper/relation/core_data.rb

@@ -0,0 +1,21 @@
+module MotionDataWrapper
+  class Relation < NSFetchRequest
+    module CoreData
+    
+      def inspect
+         to_a
+       end
+    
+      def to_a
+        error_ptr = Pointer.new(:object)
+        context.executeFetchRequest(self, error:error_ptr)
+      end
+    
+    private
+    def context
+      UIApplication.sharedApplication.delegate.managedObjectContext
+    end
+    
+    end
+  end
+end

data/lib/motion_data_wrapper/relation/finder_methods.rb

@@ -0,0 +1,97 @@
+module MotionDataWrapper
+  class Relation < NSFetchRequest
+    module FinderMethods
+    
+      def all
+        to_a
+      end
+    
+      def count
+        return to_a.count if fetchOffset > 0
+        old_result_type = self.resultType
+        self.resultType = NSCountResultType
+        count = to_a[0]
+        self.resultType = old_result_type
+        return count
+      end
+      
+      def destroy_all
+        all.map &:destroy
+      end
+    
+      def except(query_part)
+        case query_part.to_sym
+         when :where
+           self.predicate = nil
+         when :order
+           self.sortDescriptors = nil
+         when :limit
+           self.fetchLimit = 0
+         else
+           raise ArgumentError, "unsupport query part '#{query_part}'"
+         end
+         self
+      end
+    
+      def first
+        self.fetchLimit = 1
+        to_a[0]
+      end
+
+      def last
+        self.fetchOffset = self.count - 1 unless self.count < 1
+        self.fetchLimit = 1
+        to_a[0]
+      end
+    
+      def limit(l)
+        l = l.to_i
+        raise ArgumentError, "limit '#{l}' cannot be less than zero. Use zero for no limit." if l < 0
+        self.fetchLimit = l
+        self
+      end
+    
+      def offset(o)
+        o = o.to_i
+        raise ArgumentError, "offset '#{o}' cannot be less than zero." if o < 0
+        self.fetchOffset = o
+        self
+      end
+          
+      def order(column, opts={})
+        descriptors = sortDescriptors.nil? ? [] : sortDescriptors.mutableCopy
+        descriptors << NSSortDescriptor.sortDescriptorWithKey(column.to_s, ascending:opts.fetch(:ascending, true))
+        self.sortDescriptors = descriptors
+        self
+      end
+    
+      def pluck(column)
+        self.resultType = NSDictionaryResultType
+
+         attribute_description = entity.attributesByName[column]
+         raise ArgumentError, "#{column} not a valid column name" if attribute_description.nil?
+
+         self.propertiesToFetch = [attribute_description]
+         to_a.collect { |r| r[column] }
+      end
+    
+      def uniq
+        self.returnsDistinctResults = true
+        self
+      end
+    
+      def where(format, *args)
+        new_predicate = NSPredicate.predicateWithFormat(format.gsub("?", "%@"), argumentArray:args)
+
+        if self.predicate
+          self.predicate = NSCompoundPredicate.andPredicateWithSubpredicates([predicate, new_predicate])
+        else
+          self.predicate = new_predicate
+        end
+
+        self
+      end
+    
+    end
+  end
+end

data/lib/motion_data_wrapper/version.rb

@@ -0,0 +1,3 @@
+module MotionDataWrapper
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: motion_data_wrapper
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Matt Brewer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-23 00:00:00.000000000 Z
+dependencies: []
+description: Forked from the mattgreen/nitron gem, this provides an intuitive way
+  to query and persist data in CoreData, while letting you use the powerful Xcode
+  data modeler and versioning tools for schema definitions.
+email:
+- matt.brewer@me.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/motion_data_wrapper.rb
+- lib/motion_data_wrapper/delegate.rb
+- lib/motion_data_wrapper/errors/record_invalid.rb
+- lib/motion_data_wrapper/errors/record_not_found.rb
+- lib/motion_data_wrapper/errors/record_not_saved.rb
+- lib/motion_data_wrapper/model.rb
+- lib/motion_data_wrapper/model/core_data.rb
+- lib/motion_data_wrapper/model/finder_methods.rb
+- lib/motion_data_wrapper/model/persistence.rb
+- lib/motion_data_wrapper/model/validations.rb
+- lib/motion_data_wrapper/relation.rb
+- lib/motion_data_wrapper/relation/core_data.rb
+- lib/motion_data_wrapper/relation/finder_methods.rb
+- lib/motion_data_wrapper/version.rb
+homepage: https://github.com/macfanatic/motion_data_wrapper
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Provides an easy ActiveRecord-like interface to CoreData
+test_files: []
+has_rdoc: