motion-prime 0.4.5 → 0.5.0

data/motion-prime/models/association.rb

@@ -1,134 +0,0 @@
-module MotionPrime
-  module ModelAssociationMethods
-    def _bags
-      @_bags ||= {}
-    end
-
-    def save
-      _bags.values.each do |bag|
-        bag.store = self.store
-        bag.save
-      end
-      super
-    end
-  end
-  module ModelAssociationClassMethods
-    # 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
-        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)
-        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

data/motion-prime/models/base.rb

@@ -1,27 +0,0 @@
-motion_require '../helpers/has_authorization'
-motion_require './bag.rb'
-motion_require './finder.rb'
-motion_require './model.rb'
-motion_require './store.rb'
-motion_require './sync.rb'
-motion_require './association.rb'
-motion_require './store_extension.rb'
-module MotionPrime
-  class BaseModel < NSFNanoObject
-    include MotionPrime::HasAuthorization
-    include MotionPrime::ModelMethods
-    include MotionPrime::ModelAssociationMethods
-    include MotionPrime::ModelSyncMethods
-
-    extend MotionPrime::ModelClassMethods
-    extend MotionPrime::ModelFinderMethods
-    extend MotionPrime::ModelAssociationClassMethods
-    extend MotionPrime::ModelSyncClassMethods
-
-    attribute :bag_key # need this as we use shared store; each nested resource must belong to parent bag
-
-    def errors
-      @errors ||= Errors.new(self)
-    end
-  end
-end

data/motion-prime/models/finder.rb

@@ -1,202 +0,0 @@
-module MotionPrime
-  module ModelFinderMethods
-    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
-
-    def last
-      all.last
-    end
-
-    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

data/motion-prime/screens/sidebar_container_screen.rb

@@ -1,80 +0,0 @@
-module MotionPrime
-  class SidebarContainerScreen < RESideMenu
-    include ::MotionPrime::ScreenBaseMixin
-
-    def self.new(menu, content, options={})
-      screen = self.alloc.initWithContentViewController(nil, menuViewController: nil)
-      screen.backgroundImage = Prime::Config.sidebar.background_image
-      screen.parallaxEnabled = false
-
-      full_width = UIScreen.mainScreen.bounds.size.width
-
-      if scale = options[:content_scale_value]
-        screen.contentViewScaleValue = scale
-      end
-      x_offset = options[:x_offset] || 45
-      screen.contentViewInPortraitOffsetCenterX = full_width*(1 + screen.contentViewScaleValue/2) - x_offset
-
-      if y_offset = options[:y_offset]
-        screen.contentViewInPortraitOffsetCenterY = UIScreen.mainScreen.bounds.size.height/2 + y_offset
-      end
-
-      screen.on_create(options) if screen.respond_to?(:on_create)
-      screen.menu_controller = menu unless menu.nil?
-      screen.content_controller = content unless content.nil?
-
-      screen
-    end
-
-    def show_sidebar
-      self.presentMenuViewController
-    end
-
-    def hide_sidebar
-      self.hideMenuViewController
-    end
-
-    def menu_controller=(c)
-      self.setMenuViewController prepare_controller(c)
-    end
-
-    def content_controller=(c)
-      controller = prepare_controller(c)
-      if should_reinit_content?(controller)
-        self.setContentViewController controller
-      else
-        content_controller.viewControllers = [controller]
-      end
-      hide_sidebar
-    end
-
-    def menu_controller
-      self.menuViewController
-    end
-
-    def content_controller
-      self.contentViewController
-    end
-
-    private
-
-      def should_reinit_content?(new_controller)
-        content_controller.nil? ||
-        content_controller.is_a?(TabBarController) ||
-        new_controller.is_a?(TabBarController)
-      end
-
-      def prepare_controller(controller)
-        controller = setup_screen_for_open(controller, {})
-        if should_reinit_content?(controller)
-          controller.wrap_in_navigation if controller.respond_to?(:wrap_in_navigation)
-          controller.send(:on_screen_load) if controller.respond_to?(:on_screen_load)
-          controller = controller.main_controller if controller.respond_to?(:main_controller)
-        else
-          controller.navigation_controller = content_controller if controller.respond_to?(:navigation_controller)
-          controller.send(:on_screen_load) if controller.respond_to?(:on_screen_load)
-        end
-        controller
-      end
-  end
-end