ruby_motion_query 0.4.1 → 0.5.0

data/motion/ruby_motion_query/actions.rb

@@ -61,5 +61,25 @@ module RubyMotionQuery
       self
     end
 
+    def enable
+      selected.each { |view| view.enabled = true }
+      self
+    end
+
+    def disable
+      selected.each { |view| view.enabled = false }
+      self
+    end
+
+    def enable_interaction
+      selected.each { |view| view.userInteractionEnabled = true }
+      self
+    end
+
+    def disable_interaction
+      selected.each { |view| view.userInteractionEnabled = false }
+      self
+    end
+
   end
 end

data/motion/ruby_motion_query/animations.rb

@@ -1,39 +1,42 @@
 module RubyMotionQuery
   class RMQ
 
+    # Animate
+    #
     # @return [RMQ]
     def animate(opts = {})
+      animations_callback = (opts[:animations] || opts[:changes])
+      after_callback = (opts[:completion] || opts[:after])
+      return self unless animations_callback
+
+
       working_selected = self.selected
-      @_rmq = self # @ for rm bug
+      self_rmq = self
 
-      animations_lambda = if (animations_callback = (opts.delete(:animations) || opts.delete(:changes)))
-        -> do
-          working_selected.each do |view|
-            animations_callback.call(@_rmq.create_rmq_in_context(view))
-          end
+      working_selected.each do |view|
+        view_rmq = self_rmq.wrap(view)
+
+        animations_lambda = -> do
+          animations_callback.call(view_rmq)
         end
-      else
-        nil
-      end
 
-      return self unless animations_lambda
+        after_lambda = if after_callback
+          ->(did_finish) {
+            after_callback.call(did_finish, view_rmq)
+          }
+        else
+          nil
+        end
 
-      after_lambda = if (after_callback = (opts.delete(:completion) || opts.delete(:after)))
-        -> (did_finish) {
-          after_callback.call(did_finish, @_rmq)
-        }
-      else
-        nil
+        UIView.animateWithDuration(
+          opts[:duration] || 0.3,
+          delay: opts[:delay] || 0,
+          options: opts[:options] || UIViewAnimationOptionCurveEaseInOut,
+          animations: animations_lambda,
+          completion: after_lambda
+        )
       end
 
-      UIView.animateWithDuration(
-        opts.delete(:duration) || 0.3,
-        delay: opts.delete(:delay) || 0,
-        options: (opts.delete(:options) || UIViewAnimationOptionCurveEaseInOut),
-        animations: animations_lambda,
-        completion: after_lambda
-      )
-
       self
     end
 
@@ -86,34 +89,38 @@ module RubyMotionQuery
     def throb(opts = {})
       opts.merge!({
         duration: 0.4,
-        animations: -> (cq) {
+        animations: ->(cq) {
           cq.style {|st| st.scale = 1.0}
         }
       })
 
-      @rmq.animate(
+      out = @rmq.animate(
         duration: 0.1,
-        animations: -> (q) {
+        animations: ->(q) {
           q.style {|st| st.scale = 1.1}
         },
-        completion: -> (did_finish, q) {
-          q.animate(opts)
+        completion: ->(did_finish, completion_rmq) {
+          if did_finish
+            completion_rmq.animate(opts)
+          end
         }
       )
+      out
     end
 
+    # @return [RMQ]
     def drop_and_spin(opts = {})
       remove_view = opts[:remove_view]
       opts.merge!({
         duration: 0.4 + (rand(8) / 10),
         options: UIViewAnimationOptionCurveEaseIn|UIViewAnimationOptionBeginFromCurrentState,
-        animations: -> (cq) {
+        animations: ->(cq) {
           cq.style do |st| 
             st.top = @rmq.device.height + st.height
             st.rotation = 180 + rand(50) 
           end
         },
-        completion: -> (did_finish, q) {
+        completion: ->(did_finish, q) {
           if did_finish
             q.style do |st| 
               st.rotation = 0

data/motion/ruby_motion_query/app.rb

@@ -26,7 +26,7 @@ module RubyMotionQuery
 
       # @return [Symbol] Environment the app is running it
       def environment
-        RUBYMOTION_ENV.to_sym
+        @_environment ||= RUBYMOTION_ENV.to_sym
       end
 
       # @return [Boolean] true if the app is running in the :release environment
@@ -69,6 +69,26 @@ module RubyMotionQuery
       def document_path
         NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, true)[0]
       end
+
+      # Returns the current view controller in the app. If the current controller is a tab or
+      # navigation controller, then it gets the current tab or topmost controller in the nav.
+      #
+      # This mostly works... mostly. As there really isn't a "current view_controller"
+      #
+      # @return [UIViewController]
+      def current_view_controller(root_view_controller = nil)
+        if root_view_controller || ((window = RMQ.app.window) && (root_view_controller = window.rootViewController))
+          case root_view_controller
+          when UINavigationController
+            root_view_controller.visibleViewController
+          when UITabBarController
+            current_view_controller(root_view_controller.selectedViewController)
+          else 
+            root_view_controller
+          end
+        end
+      end
+
     end
   end
 end

data/motion/ruby_motion_query/base.rb

@@ -16,12 +16,36 @@ module RubyMotionQuery
   #   controller that the view is currently in or to the current screen's
   #   controller
   class RMQ
-    attr_accessor :context
 
     def initialize
       @selected_dirty = true
     end
 
+    # This is mostly used internally
+    #
+    # If rmq was called in a view, context will be that view. If it was called
+    # in a UIViewController, it will be that controller. If it is called in another
+    # object, it will be current controller's rmq instance and thus context will be 
+    # that controller
+    def context=(value)
+      if value
+        if value.is_a?(UIViewController)
+          @context = RubyMotionQuery::RMQ.weak_ref(value)
+        elsif value.is_a?(UIView)
+          @context = value
+        #else
+          #debug.log_detailed('Invalid context', objects: {value: value})
+        end
+      else
+        @context = nil
+      end
+      @context
+    end
+
+    def context
+      @context
+    end
+
     # Do not use
     def selected=(value)
       @_selected = value
@@ -90,6 +114,7 @@ module RubyMotionQuery
       @_parent_rmq
     end
     def parent_rmq=(value)
+      #debug.assert(value.is_a?(RMQ) || value.nil?, 'Invalid parent_rmq', { value: value })
       @_parent_rmq = value
     end
 
@@ -100,7 +125,7 @@ module RubyMotionQuery
       if pq = self.parent_rmq
         pq.selected
       else
-        [self.view_controller.view]
+        [self.weak_view_controller.view]
       end
     end
 
@@ -284,19 +309,6 @@ module RubyMotionQuery
       out
     end
 
-    class << self
-      attr_accessor :cache_controller_rmqs
-      @cache_controller_rmqs = true
-
-      def debugging?
-        @debugging ||= ENV['rmq_debug'] == 'true'
-      end
-
-      def debugging=(flag)
-        @debugging = flag
-      end
-    end
-
     protected 
     def extract_views_from_selectors(view_container, working_selectors)
       unless RMQ.is_blank?(working_selectors)

data/motion/ruby_motion_query/data.rb

@@ -43,9 +43,19 @@ module RubyMotionQuery
         RMQ.is_blank?(@_tags)
       end
     end
+
+    def view_controller=(value)
+      #RubyMotionQuery::RMQ.debug.assert(value.is_a?(UIViewController), 'Invalid controller in ViewData', { controller: value })
+
+      @_view_controller = RubyMotionQuery::RMQ.weak_ref(value)
+    end
+
+    def view_controller
+      @_view_controller
+    end
   end
 
   class ControllerData
-    attr_accessor :stylesheet, :rmq
+    attr_accessor :stylesheet, :cached_rmq
   end
 end

data/motion/ruby_motion_query/debug.rb

@@ -0,0 +1,92 @@
+module RubyMotionQuery
+  class RMQ
+    def self.debug
+      Debug
+    end
+
+    def self.debugging?
+      @debugging ||= ENV['rmq_debug'] == 'true'
+    end
+
+    def self.debugging=(flag)
+      @debugging = flag
+    end
+
+    # @return [Debug]
+    def debug 
+      Debug
+    end
+  end
+
+  # Notes:
+  #
+  # rake debug=1 NSZombieEnabled=YES
+  #
+  # rake debug=1 NSZombieEnabled=YES MallocStackLogging=1
+  # /usr/bin/malloc_history 89032 0x9508da0
+  # /usr/bin/malloc_history 47706 0x937e5c0 | grep "rb_scope__.+?__"
+  class Debug
+    class << self
+      # Warning, this is very slow
+      def log_detailed(label, params = {})
+        return unless RMQ.app.development? || RMQ.app.test?
+
+        objects = params[:objects]
+        skip_first_caller = params[:skip_first_caller]
+
+        if block_given? && !objects
+          objects = yield
+        end
+
+        callers = caller
+        callers = callers.drop(1) if skip_first_caller
+
+        out = %(
+
+          ------------------------------------------------
+          Deep log - #{label}
+          At: #{Time.now.to_s}
+
+          Callers: 
+          #{callers.join("\n - ")}
+
+          Objects:
+          #{objects.map{|k, v| "#{k.to_s}: #{v.inspect}" }.join("\n\n")}
+          ------------------------------------------------
+
+        ).gsub(/^ +/, '')
+
+        NSLog out
+        label
+      end
+
+      # Warning, this is very slow to output log, checking truthy however is 
+      # basically as performant as an if statement
+      #
+      # @example
+      #
+      # # foo and bar are objects we want to inspect
+      # rmq.debug.assert(1==2, 'Bad stuff happened', {
+      #   foo: foo,
+      #   bar: bar
+      # })
+      def assert(truthy, label = nil, objects = nil)
+        if (RMQ.app.development? || RMQ.app.test?) && !truthy
+          label ||= 'Assert failed'
+          if block_given? && !objects
+            objects = yield
+          end
+          log_detailed label, objects: objects, skip_first_caller: true
+        end
+      end
+    end
+  end
+end
+
+
+#class UIViewController
+  #def dealloc
+    #puts "dealloc controller #{self.object_id}"
+    #super
+  #end
+#end

data/motion/ruby_motion_query/factory.rb

@@ -1,38 +1,49 @@
 module RubyMotionQuery
   class RMQ
-    # TODO question, should there be a rmq pool to reuse?
-
+    # This is used internally, to get a new rmq instance, just call "rmq" in your view or controller or
+    # just create a new one like so: RubyMotionQuery::RMQ.new
+    #
     # @return [RMQ]
     def create_blank_rmq
       RMQ.create_with_array_and_selectors([], self.selectors, @context)
     end
 
+    # This is used internally, to get a new rmq instance, just call "rmq" in your view or controller or
+    # just create a new one like so: RubyMotionQuery::RMQ.new
+    #
     # @return [RMQ]
-    def create_rmq_in_context(*selectors)
-      RMQ.create_with_selectors(selectors, @context)
+    def create_rmq_in_context(*working_selectors)
+      RMQ.create_with_selectors(working_selectors, @context)
     end
 
     class << self
 
+      # This is used internally, to get a new rmq instance, just call "rmq" in your view or controller or
+      # just create a new one like so: RubyMotionQuery::RMQ.new
+      #
       # @return [RMQ]
-      def create_with_selectors(selectors, context, parent_rmq = nil)
-        RMQ.new.tap do |o|
-          o.context = context
-          o.parent_rmq = parent_rmq
-          o.selectors = selectors
-        end
+      def create_with_selectors(working_selectors, current_context, working_parent_rmq = nil)
+        q = RMQ.new
+        q.context = current_context
+        q.parent_rmq = working_parent_rmq
+        q.selectors = working_selectors
+        q
       end
 
+      # This is used internally, to get a new rmq instance, just call "rmq" in your view or controller or
+      # just create a new one like so: RubyMotionQuery::RMQ.new
+      #
       # @return [RMQ]
-      def create_with_array_and_selectors(array, selectors, context, parent_rmq = nil) # TODO, convert to opts
-        RMQ.new.tap do |o|
-          o.context = context
-          o.selectors = selectors
-          o.parent_rmq = parent_rmq
-          o.selected = array # Must be last
-        end
+      def create_with_array_and_selectors(array, working_selectors, current_context, working_parent_rmq = nil) # TODO, convert to opts
+        q = RMQ.new
+        q.context = current_context
+        q.selectors = working_selectors
+        q.parent_rmq = working_parent_rmq
+        q.selected = array # Must be last
+        q
       end
 
     end
   end
+
 end

data/motion/ruby_motion_query/image.rb

@@ -65,12 +65,12 @@ module RubyMotionQuery
         scale = UIScreen.mainScreen.scale
         if use_content_size
           UIGraphicsBeginImageContextWithOptions(view.contentSize, false, scale)
-          context = UIGraphicsGetCurrentContext()
+          graphics_context = UIGraphicsGetCurrentContext()
           view.subviews.each do |subview|
-            CGContextSaveGState(context)
-            CGContextTranslateCTM(context, subview.frame.origin.x, subview.frame.origin.y)
-            subview.layer.renderInContext(context)
-            CGContextRestoreGState(context)
+            CGContextSaveGState(graphics_context)
+            CGContextTranslateCTM(graphics_context, subview.frame.origin.x, subview.frame.origin.y)
+            subview.layer.renderInContext(graphics_context)
+            CGContextRestoreGState(graphics_context)
           end
           image = UIGraphicsGetImageFromCurrentImageContext()
           UIGraphicsEndImageContext()