motion-prime 0.1.0 → 0.1.1

data/motion-prime/models/bag.rb

@@ -0,0 +1,129 @@
+module MotionPrime
+  module BagInstanceMethods
+    def self.included(base)
+      base.class_eval do
+        alias_method :saved, :savedObjects
+        alias_method :unsaved, :unsavedObjects
+        alias_method :removed, :removedObjects
+        alias_method :size, :count
+        alias_method :inflate, :inflateBag
+        alias_method :deflate, :deflateBag
+      end
+    end
+
+    def originalClassString
+      'NSFNanoBag'
+    end
+
+    def changed?
+      self.hasUnsavedChanges
+    end
+
+    # Return all objects in bag
+    #
+    # @return Array
+    def to_a
+      self.savedObjects.values + self.unsavedObjects.values
+    end
+
+    # Add an object to bag
+    #
+    # @return self
+    def <<(object)
+      error_ptr = Pointer.new(:id)
+      self.addObject(object, error:error_ptr)
+      raise StoreError, error_ptr[0].description if error_ptr[0]
+      self
+    end
+
+    # Add an object or array of objects to bag
+    #
+    # @return self
+    def add(object_or_array)
+      error_ptr = Pointer.new(:id)
+      if object_or_array.is_a?(Array)
+        self.addObjectsFromArray(object_or_array, error:error_ptr)
+      else
+        self.addObject(object_or_array, error:error_ptr)
+      end
+      raise StoreError, error_ptr[0].description if error_ptr[0]
+      self
+    end
+    alias_method :+, :add
+
+    # Remove object from bag with key
+    #
+    # @param [String] key - a key or array of keys
+    # @return self
+    def delete_key(key)
+      if key.is_a?(Array)
+        self.removeObjectsWithKeysInArray(key)
+      else
+        self.removeObjectWithKey(key)
+      end
+      self
+    end
+
+    # Remove an object or array of objects from bag
+    #
+    # @param [String] object_or_array
+    # @return self
+    def delete(object_or_array)
+      error_ptr = Pointer.new(:id)
+      if object_or_array.is_a?(Array)
+        self.removeObjectsInArray(object_or_array, error: error_ptr)
+      else
+        self.removeObject(object_or_array, error_ptr)
+      end
+      raise StoreError, error_ptr[0].description if error_ptr[0]
+      self
+    end
+    alias_method :-, :delete
+
+    # Clear content of the bag
+    #
+    # @return self
+    def delete_all
+      bag_copy = to_a.clone
+      # this removes childrens from model
+      delete(self.to_a)
+      # this removes collection from db
+      bag_copy.each(&:delete)
+      self
+    end
+    alias_method :clear, :delete_all
+
+
+    def store=(store)
+      store.addObject(self, error:nil)
+    end
+
+    def save
+      self.store ||= MotionPrime::Store.shared_store
+      error_ptr = Pointer.new(:id)
+      result = self.saveAndReturnError(error_ptr)
+      raise StoreError, error_ptr[0].description if error_ptr[0]
+      result
+    end
+
+    def reload
+      error_ptr = Pointer.new(:id)
+      result = self.reloadBagWithError(error_ptr)
+      raise StoreError, error_ptr[0].description if error_ptr[0]
+      result
+    end
+
+    def undo
+      error_ptr = Pointer.new(:id)
+      result = self.undoChangesWithError(error_ptr)
+      raise StoreError, error_ptr[0].description if error_ptr[0]
+      result
+    end
+  end
+
+  Bag = ::NSFNanoBag
+end
+
+class NSFNanoBag
+  include MotionPrime::BagInstanceMethods
+end

data/motion-prime/models/base.rb

@@ -1,12 +1,25 @@
 motion_require '../helpers/has_authorization'
+motion_require './bag.rb'
+motion_require './finder.rb'
+motion_require './model.rb'
+motion_require './store.rb'
+motion_require './store_extension.rb'
 module MotionPrime
-  class BaseModel < NanoStore::Model
+  class BaseModel < NSFNanoObject
     class_attribute :sync_url
     class_attribute :sync_attributes
     class_attribute :_associations
     alias_method :attributes, :info
     include MotionPrime::HasAuthorization
 
+    include MotionPrime::ModelMethods
+    extend MotionPrime::ModelClassMethods
+
+    extend MotionPrime::ModelFinderMethods
+    include MotionPrime::ModelAssociationMethods
+
+    extend MotionPrime::ModelAssociationClassMethods
+
     def sync_url
       self.class.sync_url.to_s.gsub(':id', id.to_s)
     end
@@ -134,15 +147,7 @@ module MotionPrime
     end
 
     def inspect
-      "#<#{self.class}:0x#{self.object_id.to_s(16)}> " + BW::JSON.generate(attributes)
-    end
-
-    # NOTE: .clear method doesn't work, using removeArray hack for now
-    def _clear_bag(bag_name)
-      bag = self.send(bag_name.to_sym)
-      bag_copy = bag.to_a.clone
-      bag - bag.to_a # this removes association from model
-      bag_copy.each(&:delete) # this removes collection from db
+      "#<#{self.class}:0x#{self.object_id.to_s(16)}> " + MotionPrime::JSON.generate(attributes)
     end
 
     def filtered_sync_attributes
@@ -160,61 +165,6 @@ module MotionPrime
       def sync_attributes(*attrs)
         attrs ? self.sync_attributes = attrs : super
       end
-
-      def has_one(association_name, options = {})
-        bag_name = "#{association_name.pluralize}_bag"
-        self.bag bag_name.to_sym
-
-        self._associations ||= {}
-        self._associations[association_name] = options.merge(type: :one)
-
-        define_method("#{association_name}=") do |value|
-          self._clear_bag(bag_name)
-
-          self.send(:"#{bag_name}") << value
-          value
-        end
-        define_method("#{association_name}_attributes=") do |value|
-          self._clear_bag(bag_name)
-
-          association = association_name.classify.constantize.new
-          association.sync_with_attributes(value)
-          association.save
-          self.send(:"#{bag_name}") << association
-          association
-        end
-        define_method("#{association_name}") do
-          self.send(:"#{bag_name}").to_a.first
-        end
-      end
-
-      def has_many(association_name, options = {})
-        bag_name = "#{association_name}_bag"
-        self.bag bag_name.to_sym
-
-        self._associations ||= {}
-        self._associations[association_name] = options.merge(type: :many)
-
-        define_method("#{association_name}_attributes=") do |value|
-          self._clear_bag(bag_name)
-
-          association = []
-          value.each do |attrs|
-            model = association_name.classify.constantize.new
-            model.sync_with_attributes(attrs)
-            association << model
-          end
-          self.send(:"#{bag_name}=", association)
-          association
-        end
-        define_method("#{association_name}=") do |value|
-          self._clear_bag(bag_name)
-          self.send(:"#{bag_name}=", value)
-        end
-        define_method("#{association_name}") do
-          self.send(:"#{bag_name}").to_a
-        end
-      end
     end
   end
 end

data/motion-prime/models/errors.rb

@@ -0,0 +1,3 @@
+module MotionPrime
+  class StoreError < StandardError; end
+end

data/motion-prime/models/finder.rb

@@ -0,0 +1,189 @@
+module MotionPrime
+  module ModelFinderMethods
+    # Find all models
+    #
+    # @return [Array] array of models
+    def all(*args)
+      if args[0].is_a?(Hash)
+        sort_options = args[0][:sort] || {}
+      else
+        sort_options = {}
+      end
+
+      if sort_options.empty?
+        self.store.objectsOfClassNamed(self.bare_class_name)
+      else
+        sort_descriptors = sort_descriptor_with_options(sort_options)
+        self.store.objectsOfClassNamed(self.bare_class_name, usingSortDescriptors:sort_descriptors)
+      end
+    end
+
+    # Find model by criteria
+    #
+    # Examples:
+    #   User.find(:name, NSFEqualTo, "Bob") # => [<User#1>]
+    #   User.find(:name => "Bob") # => [<User#1>]
+    #   User.find(:name => {NSFEqualTo => "Bob"}) # => [<User#1>]
+    #
+    # @return [Array] array of models
+    def find(*arg)
+      if arg[0].is_a?(Hash)
+        # hash style
+        options = arg[0]
+        if arg[1] && arg[1].is_a?(Hash)
+          sort_options = arg[1][:sort] || {}
+        else
+          sort_options = {}
+        end
+      elsif arg[0] && arg[1] && arg[2]
+        # standard way to find
+        options = {arg[0] => {arg[1] => arg[2]}}
+        if arg[4] && arg[4].is_a?(Hash)
+          sort_options = arg[4][:sort] || {}
+        else
+          sort_options = {}
+        end
+      elsif arg.empty?
+        options = {}
+        sort_options = {}
+      else
+        raise "unexpected parameters #{arg}"
+      end
+      search = NSFNanoSearch.searchWithStore(self.store)
+
+      expressions = expressions_with_options(options)
+      search.expressions = expressions
+
+      sort_descriptors = sort_descriptor_with_options(sort_options)
+      search.sort = sort_descriptors
+      search.filterClass = self.bare_class_name
+
+      error_ptr = Pointer.new(:id)
+      searchResults = search.searchObjectsWithReturnType(NSFReturnObjects, error:error_ptr)
+      raise StoreError, error_ptr[0].description if error_ptr[0]
+
+      if searchResults.is_a?(NSDictionary)
+        searchResults.values
+      else
+        searchResults
+      end
+    end
+
+    # Find model keys by criteria
+    #
+    # Examples:
+    #   User.find_keys(:name, NSFEqualTo, "Bob") # => ["1"]
+    #   User.find_keys(:name => "Bob") # => ["1"]
+    #   User.find_keys(:name => {NSFEqualTo => "Bob"}) # => ["1"]
+    #
+    # @return [Array] array of models
+    def find_keys(*arg)
+      if arg[0].is_a?(Hash)
+        # hash style
+        options = arg[0]
+        if arg[1] && arg[1].is_a?(Hash)
+          sort_options = arg[1][:sort] || {}
+        else
+          sort_options = {}
+        end
+      elsif arg[0] && arg[1] && arg[2]
+        # standard way to find
+        options = {arg[0] => {arg[1] => arg[2]}}
+        if arg[4] && arg[4].is_a?(Hash)
+          sort_options = arg[4][:sort] || {}
+        else
+          sort_options = {}
+        end
+      elsif arg.empty?
+        options = {}
+        sort_options = {}
+      else
+        raise "unexpected parameters #{arg}"
+      end
+
+      search = NSFNanoSearch.searchWithStore(self.store)
+
+      expressions = expressions_with_options(options)
+      search.expressions = expressions
+
+      sort_descriptors = sort_descriptor_with_options(sort_options)
+      search.sort = sort_descriptors
+      search.filterClass = self.bare_class_name
+
+      error_ptr = Pointer.new(:id)
+      searchResults = search.searchObjectsWithReturnType(NSFReturnKeys, error:error_ptr)
+      raise StoreError, error_ptr[0].description if error_ptr[0]
+
+      if searchResults.is_a?(NSDictionary)
+        searchResults.values
+      else
+        searchResults
+      end
+    end
+
+    # Find a model by key
+    #
+    # Examples:
+    #   User.find_by_key(my_key)
+    #
+    # @return [Object, Nil] an object or nil (if not found)
+    def find_by_key(key)
+      search = NSFNanoSearch.searchWithStore(self.store)
+      search.key = key
+
+      error_ptr = Pointer.new(:id)
+      searchResult = search.searchObjectsWithReturnType(NSFReturnObjects, error:error_ptr).first
+      raise StoreError, error_ptr[0].description if error_ptr[0]
+
+      searchResult.last if searchResult
+    end
+
+    def bare_class_name
+      self.to_s.split("::").last
+    end
+
+    private
+    def expressions_with_options(options)
+      expressions = []
+
+      options.each do |key, val|
+        attribute = NSFNanoPredicate.predicateWithColumn(NSFAttributeColumn, matching:NSFEqualTo, value:key.to_s)
+        expression = NSFNanoExpression.expressionWithPredicate(attribute)
+        if val.is_a?(Hash)
+          val.each do |operator, sub_val|
+            value = NSFNanoPredicate.predicateWithColumn(NSFValueColumn, matching:operator, value:sub_val.to_s)
+            expression.addPredicate(value, withOperator:NSFAnd)
+          end
+        elsif val.is_a?(Array)
+          value = NSFNanoPredicate.predicateWithColumn(NSFValueColumn, matching:NSFEqualTo, value:val.pop)
+          expression.addPredicate(value, withOperator:NSFAnd)
+
+          val.each do |sub_val|
+            value = NSFNanoPredicate.predicateWithColumn(NSFValueColumn, matching:NSFEqualTo, value:sub_val.to_s)
+            expression.addPredicate(value, withOperator:NSFOr)
+          end
+        else
+          value = NSFNanoPredicate.predicateWithColumn(NSFValueColumn, matching:NSFEqualTo, value:val.to_s)
+          expression.addPredicate(value, withOperator:NSFAnd)
+        end
+        expressions << expression
+      end
+      return expressions
+    end
+
+    SORT_MAPPING = {
+      'asc' => true,
+      'desc' => false,
+    }
+
+    def sort_descriptor_with_options(options)
+      sorter = options.collect do |opt_key, opt_val|
+        if SORT_MAPPING.keys.include?(opt_val.to_s.downcase)
+          NSFNanoSortDescriptor.alloc.initWithAttribute(opt_key.to_s, ascending:SORT_MAPPING[opt_val.to_s.downcase])
+        else
+          raise "unsupported sort parameters: #{opt_val}"
+        end
+      end
+    end
+  end
+end

data/motion-prime/models/json.rb

@@ -0,0 +1,45 @@
+module MotionPrime
+  module JSON
+    PARAMETRIZE_CLASSES = [Time, Date]
+    class ParserError < StandardError; end
+
+    # Parses a string or data object and converts it in data structure.
+    #
+    # @param [String, NSData] str_data the string or data to convert.
+    # @raise [ParserError] If the parsing of the passed string/data isn't valid.
+    # @return [Hash, Array, NilClass] the converted data structure, nil if the incoming string isn't valid.
+    def self.parse(str_data, &block)
+      return nil unless str_data
+      data = str_data.respond_to?(:to_data) ? str_data.to_data : str_data
+      opts = NSJSONReadingMutableContainers | NSJSONReadingMutableLeaves | NSJSONReadingAllowFragments
+      error = Pointer.new(:id)
+      obj = NSJSONSerialization.JSONObjectWithData(data, options: opts, error: error)
+      raise ParserError, error[0].description if error[0]
+      if block_given?
+        yield obj
+      else
+        obj
+      end
+    end
+
+    # Generates a string from data structure.
+    #
+    # @param [String, Fixnum, Array, Hash, Nil] obj the object to serialize.
+    # @param [Boolean] parametrize option to parametrize data before serialization.
+    # @return [String] the serialized data json.
+    def self.generate(obj, parametrize = true)
+      if parametrize && obj.is_a?(Hash)
+        obj.each do |key, value|
+          obj[key] = value.to_s if PARAMETRIZE_CLASSES.include?(value.class)
+        end
+      end
+      if parametrize && obj.is_a?(Array)
+        obj.map! do |value|
+          PARAMETRIZE_CLASSES.include?(value.class) ? value.to_s : value
+        end
+      end
+      data = NSJSONSerialization.dataWithJSONObject(obj, options: 0, error: nil)
+      data.to_str
+    end
+  end
+end