motion-prime 0.4.5 → 0.5.0

data/motion-prime/models/_association_mixin.rb

@@ -0,0 +1,139 @@
+module MotionPrime
+  module ModelAssociationMixin
+    extend ::MotionSupport::Concern
+
+    def _bags
+      @_bags ||= {}
+    end
+
+    def save
+      _bags.values.each do |bag|
+        bag.store = self.store
+        bag.save
+      end
+      super
+    end
+
+    module ClassMethods
+      # Defines bag associated with model, creates accessor for bag
+      #
+      # @param [String] name - the name of bag
+      # @return [Nil]
+      def bag(name)
+        define_method(name) do |*args, &block|
+          return _bags[name] if _bags[name]
+          bag_key = self.info[name]
+          if bag_key.present?
+            bag = self.class.store.bagsWithKeysInArray([bag_key]).first
+          end
+          unless bag
+            bag = Bag.bag
+            self.info[name] = bag.key
+          end
+
+          _bags[name] = bag
+        end
+
+        define_method((name + "=").to_sym) do |*args, &block|
+          bag = self.send(name)
+          case args[0]
+          when Bag
+            bag.clear
+            bag += args[0].saved.values
+          when Array
+            bag.clear
+            bag += args[0]
+          else
+            raise StoreError, "Unexpected type assigned to bags, must be an Array or MotionPrime::Bag, now: #{args[0].class}"
+          end
+          bag
+        end
+      end
+
+      # Defines has one association for model, creates accessor for association
+      #
+      # @param [String] name - the name of association
+      # @return [Nil]
+      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.send(bag_name).clear
+          self.send(:"#{bag_name}") << value
+          value
+        end
+        define_method("#{association_name}_attributes=") do |value|
+          self.send(bag_name).clear
+
+          association = association_name.classify.constantize.new
+          association.fetch_with_attributes(value)
+          association.save
+          self.send(:"#{bag_name}") << association
+          self.send(:"#{bag_name}").save
+          association
+        end
+        define_method("#{association_name}") do
+          self.send(:"#{bag_name}").to_a.first
+        end
+      end
+
+      # Defines has many association for model, creates accessor for association
+      #
+      # @param [String] name - the name of association
+      # @return [Nil]
+      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.send(bag_name).clear
+
+          pending_save_counter = 0
+          collection = value.inject({}) do |result, attrs|
+            model = association_name.classify.constantize.new
+            model.fetch_with_attributes(attrs)
+            unique_key = model.id || "pending_#{pending_save_counter+=1}"
+            result.merge(unique_key => model)
+          end
+          association_data = collection.values
+          self.send(:"#{bag_name}=", association_data)
+          self.send(:"#{bag_name}").save
+          association_data
+        end
+        define_method("#{association_name}=") do |value|
+          self.send(bag_name).clear
+          self.send(:"#{bag_name}=", value)
+        end
+        define_method("#{association_name}") do |*args|
+          bag = self.send(:"#{bag_name}")
+          collection_options = {
+            association_name: association_name,
+            inverse_relation: {
+              type: :has_one,
+              name: self.class_name_without_kvo.demodulize.underscore,
+              instance: self
+            }
+          }
+          AssociationCollection.new(bag, collection_options, *args)
+        end
+      end
+
+      def belongs_to(association_name, options = {})
+        self._associations ||= {}
+        self._associations[association_name] = {
+          type: :belongs_to_one,
+          class_name: association_name.classify
+        }.merge(options)
+
+        self.send(:attr_accessor, association_name)
+      end
+    end
+  end
+end

data/motion-prime/models/_base_mixin.rb

@@ -0,0 +1,184 @@
+module MotionPrime
+  module ModelBaseMixin
+    extend ::MotionSupport::Concern
+
+    def self.included(base)
+      base.class_attribute :default_sort_options
+    end
+
+    def save
+      raise StoreError, 'No store provided' unless self.store
+      error_ptr = Pointer.new(:id)
+      self.store.addObject(self, error: error_ptr)
+      raise StoreError, error_ptr[0].description if error_ptr[0]
+      self
+    end
+
+    def delete
+      raise StoreError, 'No store provided' unless self.store
+
+      error_ptr = Pointer.new(:id)
+      self.store.removeObject(self, error: error_ptr)
+      raise StoreError, error_ptr[0].description if error_ptr[0]
+      self
+    end
+
+    def store
+      super || self.class.store
+    end
+
+    def assign_attributes(new_attributes, options = {})
+      attributes = new_attributes.symbolize_keys
+      attributes.each do |k, v|
+        if has_attribute?(k)
+          assign_attribute(k, v) unless options[:skip_nil_values] && v.nil?
+        elsif options[:validate_attribute_presence]
+          raise(StoreError, "unknown attribute: '#{k}'")
+        else
+          NSLog("unknown attribute: #{k}")
+        end
+      end
+    end
+
+    def assign_attribute(name, value)
+      self.send("#{name}=", value) if has_attribute?(name)
+    end
+
+    def has_attribute?(name)
+      respond_to?("#{name}=")
+    end
+
+    def attributes_hash
+      self.info.to_hash.symbolize_keys
+    end
+
+    def new_record?
+      id.blank?
+    end
+
+    def persisted?
+      !new_record?
+    end
+
+    def model_name
+      self.class_name_without_kvo.underscore
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{self.object_id.to_s(16)}> " + MotionPrime::JSON.generate(info)
+    end
+
+    module ClassMethods
+      # Initialize a new object
+      #
+      # Examples:
+      #   User.new(name: "Bob", age: 10)
+      #
+      # @return MotionPrime::Model unsaved model
+      def new(data = {}, options = {})
+        data.keys.each do |key|
+          unless self.attributes.member? key.to_sym
+            if options[:validate_attribute_presence]
+              raise StoreError, "unknown attribute: '#{key}'"
+            else
+              data.delete(key)
+            end
+          end
+        end
+
+        object = self.nanoObjectWithDictionary(data)
+        object
+      end
+
+      # Initialize a new object and save it
+      #
+      # Examples:
+      #   User.create(name: "Bob", age: 10)
+      #
+      # @return MotionPrime::Model saved model
+      def create(data = {})
+        object = self.new(data)
+        object.save
+      end
+
+      # Define model attribute
+      #
+      # Examples:
+      #   class User < MotionPrime::Model
+      #     attribute :name
+      #     attribute :age
+      #   end
+      #
+      # @return Nil
+      def attribute(name, options = {})
+        attributes << name
+
+        define_method(name) do |*args, &block|
+          self.info[name]
+        end
+
+        define_method((name + "=").to_sym) do |*args, &block|
+          value = args[0]
+          case options[:type].to_s
+          when 'integer' then value = value.to_i
+          when 'float' then value = value.to_f
+          end unless value.nil?
+
+          self.info[name] = value
+        end
+
+        if options[:type].to_s == 'boolean'
+          define_method("#{name}?") do
+            !!self.info[name]
+          end
+        end
+      end
+
+      # Set or return all model attribute names
+      #
+      # @return Array array of attribute names
+      def attributes(*attrs)
+        if attrs.size > 0
+          attrs.each{|attr| attribute attr}
+        else
+          @attributes ||= []
+        end
+      end
+
+      # Return store associated with model class, or shared store by default
+      #
+      # @return MotionPrime::Store store
+      def store
+        @store ||= MotionPrime::Store.shared_store
+      end
+
+      # Define store associated with model class
+      #
+      # @param MotionPrime::Store store
+      # @return MotionPrime::Store store
+      def store=(store)
+        @store = store
+      end
+
+      # Count of models
+      #
+      # @return Fixnum count
+      def count
+        self.store.count(self)
+      end
+
+      # Delete objects from store
+      #
+      # @param [Array, MotionPrime::Model] objects to delete
+      # @return [Array] result
+      def delete(*args)
+        keys = find_keys(*args)
+        self.store.delete_keys(keys)
+      end
+
+      def default_sort(sort_options)
+        self.default_sort_options = sort_options
+      end
+    end
+  end
+end

data/motion-prime/models/_dirty_mixin.rb

@@ -0,0 +1,31 @@
+module MotionPrime
+  module ModelDirtyMixin
+    extend ::MotionSupport::Concern
+
+    def self.included(base)
+      base.class_attribute :_changed_attributes
+    end
+
+    def track_changed_attributes(&block)
+      @_changed_attributes ||= {}
+      old_attrs = self.info.clone
+      result = block.call
+      new_attrs = self.info.clone
+      new_attrs.each do |key, value|
+        if value != old_attrs[key] && ! @_changed_attributes.has_key?(key.to_s)
+          @_changed_attributes[key.to_s] = old_attrs[key]
+        end
+      end
+      result
+    end
+
+    def has_changed?(key = nil)
+      @_changed_attributes ||= {}
+      if key
+        @_changed_attributes.has_key?(key.to_s)
+      else
+        @_changed_attributes.present?
+      end
+    end
+  end
+end

data/motion-prime/models/_finder_mixin.rb

@@ -0,0 +1,208 @@
+module MotionPrime
+  module ModelFinderMixin
+    extend ::MotionSupport::Concern
+    
+    module ClassMethods      
+      attr_accessor :bare_class
+      
+      # Find all models
+      #
+      # @return [Array] array of models
+      def all(*args)
+        return [] unless self.store
+
+        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 last model model by default order
+      def last
+        all.last
+      end
+
+      # Find first model model by default order
+      def first
+        all.first
+      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
+        subject = @bare_class || self
+        subject.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
+end

data/motion-prime/models/{bag.rb → _nano_bag_mixin.rb}

@@ -1,6 +1,6 @@
-motion_require './finder.rb'
+motion_require './_finder_mixin.rb'
 module MotionPrime
-  module BagInstanceMethods
+  module NanoBagMixin
     def self.included(base)
       base.class_eval do
         alias_method :saved, :savedObjects
@@ -131,6 +131,6 @@ module MotionPrime
 end
 
 class NSFNanoBag
-  include MotionPrime::ModelFinderMethods
-  include MotionPrime::BagInstanceMethods
+  include MotionPrime::ModelFinderMixin::ClassMethods
+  include MotionPrime::NanoBagMixin
 end