ruby_motion_query 0.1.1

data/lib/ruby_motion_query.rb

@@ -0,0 +1,8 @@
+unless defined?(Motion::Project::App)
+  raise "This must be required from within a RubyMotion Rakefile"
+end
+
+Motion::Project::App.setup do |app|
+  parent = File.join(File.dirname(__FILE__), '..')
+  app.files.unshift(Dir.glob(File.join(parent, "motion/**/*.rb")))
+end

data/motion/ext.rb

@@ -0,0 +1,34 @@
+class UIView
+  def rmq_data
+    @_rmq_data ||= RubyMotionQuery::ViewData.new
+  end
+
+  protected
+
+  def rmq(*selectors)
+    RubyMotionQuery::RMQ.create_with_selectors(selectors, RubyMotionQuery::RMQ.controller_for_view(self))
+  end
+end
+
+class UIViewController
+  def rmq(*selectors)
+    if RubyMotionQuery::RMQ.cache_controller_rmqs && selectors.length == 0
+      rmq_data.rmq ||= RubyMotionQuery::RMQ.create_with_selectors(selectors, self)
+    else
+      RubyMotionQuery::RMQ.create_with_selectors(selectors, self)
+    end
+  end
+
+  def rmq_data
+    @_rmq_data ||= RubyMotionQuery::ControllerData.new
+  end
+end
+
+# Used in console, so that you can just call rmq with an view or controller as self
+class TopLevel
+  def rmq(*selectors)
+    if window = RubyMotionQuery::RMQ.app.window
+      RubyMotionQuery::RMQ.create_with_selectors(selectors, window.subviews.first)
+    end
+  end
+end

data/motion/ruby_motion_query/actions.rb

@@ -0,0 +1,44 @@
+module RubyMotionQuery
+  class RMQ
+    def attr(new_settings)
+      selected.each do |view|
+        new_settings.each do |k,v|
+          view.send "#{k}=", v
+        end
+      end
+      self
+    end
+
+    def send(method, args = nil)
+      selected.each do |view|
+        if args
+          view.__send__ method, args
+        else
+          view.__send__ method
+        end
+      end
+      self
+    end
+
+    def hide
+      selected.each { |view| view.hidden = true }
+      self
+    end
+
+    def show
+      selected.each { |view| view.hidden = false }
+      self
+    end
+
+    def toggle
+      selected.each { |view| view.hidden = !view.hidden? }
+      self
+    end
+
+    def toggle_enabled
+      selected.each { |view| view.enabled = !view.enabled? }
+      self
+    end
+
+  end
+end

data/motion/ruby_motion_query/animations.rb

@@ -0,0 +1,125 @@
+module RubyMotionQuery
+  class RMQ
+    def animate(opts = {})
+      working_selected = self.selected
+      @_rmq = self # @ for rm bug
+
+      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
+        end
+      else
+        nil
+      end
+
+      return self unless animations_lambda
+
+      after_lambda = if (after_callback = (opts.delete(:completion) || opts.delete(:after)))
+        -> (did_finish) {
+          after_callback.call(did_finish, @_rmq)
+        }
+      else
+        nil
+      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
+
+    def animations
+      @_animations ||= Animations.new(self)
+    end
+  end
+
+  class Animations
+    def initialize(rmq)
+      @rmq = rmq
+    end
+
+    def fade_in(opts = {})
+      @rmq.each do |view|
+        view.layer.opacity = 0.0
+        view.hidden = false
+      end
+
+      opts[:animations] = lambda do |rmq|
+        rmq.get.layer.opacity = 1.0
+      end
+
+      @rmq.animate(opts)
+    end
+
+    def fade_out(opts = {})
+      opts[:animations] = lambda do |rmq|
+        rmq.get.layer.opacity = 0.0
+      end
+
+      @completion_block = opts[:completion] || opts[:after]
+
+      opts[:completion] = lambda do |did_finish, rmq|
+        rmq.each do |view|
+          view.hidden = true
+          view.layer.opacity = 1.0
+        end
+
+        @completion_block.call(did_finish, rmq) if @completion_block
+      end
+
+      @rmq.animate(opts)
+    end
+
+    def throb
+      @rmq.animate(
+        duration: 0.1,
+        animations: -> (q) {
+          q.style {|st| st.scale = 1.1}
+        },
+        completion: -> (did_finish, q) {
+          q.animate( 
+            duration: 0.4,
+            animations: -> (cq) {
+              cq.style {|st| st.scale = 1.0}
+            }
+          )
+        }
+      )
+    end
+
+    def blink
+      self.fade_out(duration: 0.2, after: lambda {|did_finish, rmq| rmq.animations.fade_in(duration: 0.2)})
+    end
+
+    def start_spinner(style = UIActivityIndicatorViewStyleGray)
+      spinner = Animations.window_spinner(style)
+      spinner.startAnimating
+      @rmq.create_rmq_in_context(spinner)
+    end
+
+    def stop_spinner
+      spinner = Animations.window_spinner
+      spinner.stopAnimating
+      @rmq.create_rmq_in_context(spinner)
+    end
+
+    def self.window_spinner(style = UIActivityIndicatorViewStyleGray)
+      @_window_spinner ||= begin
+        window = RMQ.app.window
+        UIActivityIndicatorView.alloc.initWithActivityIndicatorStyle(style).tap do |o|
+          o.center = window.center
+          o.hidesWhenStopped = true
+          o.layer.zPosition = NSIntegerMax
+          window.addSubview(o)
+        end
+      end
+    end
+  end
+end

data/motion/ruby_motion_query/app.rb

@@ -0,0 +1,71 @@
+module RubyMotionQuery
+  class RMQ
+    def app
+      App
+    end
+
+    def self.app
+      App
+    end
+
+    # TODO This is a bit wierd and may not work, need to think on this
+    # It's also confusing use of rmq which assumes a controller and subviews
+    #def window_rmq
+      #RMQ.create_with_selectors([App.window], self.context)
+    #end
+
+    #def self.window_rmq
+      #RMQ.create_with_selectors([App.window], App.window)
+    #end
+  end
+
+  class App
+    class << self
+
+      def window
+        UIApplication.sharedApplication.keyWindow || UIApplication.sharedApplication.windows[0]
+      end
+
+      def delegate 
+        UIApplication.sharedApplication.delegate
+      end
+
+      def environment
+        RUBYMOTION_ENV.to_sym
+      end
+
+      def release?
+        environment == :release
+      end
+      alias :production? :release?
+
+      def test?
+        environment == :test
+      end
+
+      def development?
+        environment == :development
+      end
+
+      def version
+        NSBundle.mainBundle.infoDictionary['CFBundleVersion']
+      end
+
+      def name
+        NSBundle.mainBundle.objectForInfoDictionaryKey 'CFBundleDisplayName'
+      end
+
+      def identifier
+        NSBundle.mainBundle.bundleIdentifier
+      end
+
+      def resource_path
+        NSBundle.mainBundle.resourcePath
+      end
+
+      def document_path
+        NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, true)[0]
+      end
+    end
+  end
+end

data/motion/ruby_motion_query/base.rb

@@ -0,0 +1,161 @@
+module RubyMotionQuery
+  class RMQ
+    attr_accessor :context, :parent_rmq
+
+    def initialize
+      @selected_dirty = true
+    end
+
+    def selected=(value)
+      @_selected = value
+      @selected_dirty = false
+    end
+    def selected
+      if @selected_dirty
+        @_selected = []
+
+        if RMQ.is_blank?(self.selectors)
+          @_selected << context_or_context_view
+        else
+          working_selectors = self.selectors.dup
+          extract_views_from_selectors(@_selected, working_selectors)
+
+          unless RMQ.is_blank?(working_selectors)
+            subviews = all_subviews_for(root_view)
+            subviews.each do |subview|
+              @_selected  << subview if match(subview, working_selectors)
+            end
+          end
+
+          @_selected.uniq!
+        end
+
+        @selected_dirty = false
+      else
+        @_selected ||= []
+      end
+
+      @_selected
+    end
+
+    # The view(s) this rmq was derived from
+    def origin_views
+      if @parent_rmq
+        @parent_rmq.selected
+      else
+        [self.view_controller.view]
+      end
+    end
+
+    # Returns a view or array of views. 
+    # Normally used to get the only view in selected.
+    #
+    # @example
+    # rmq(foo).parent.get.some_method_on_parent
+    def get
+      sel = self.selected
+      if sel.length == 1
+        sel.first
+      else
+        sel
+      end
+    end
+
+    def root?
+      (selected.length == 1) && (selected.first == @context)
+    end
+
+    def context_or_context_view
+      if @context.is_a?(UIViewController)
+        @context.view
+      else
+        @context
+      end
+    end
+
+    def extract_views_from_selectors(view_container, working_selectors)
+      unless RMQ.is_blank?(working_selectors)
+        working_selectors.each do |selector|
+          if selector.is_a?(UIView)
+            view_container << working_selectors.delete(selector)
+          end
+        end
+      end
+      [view_container, working_selectors]
+    end
+
+    def all_subviews_for(view)
+      # TODO maybe cache this, and invalidate cache properly
+      out = []
+      if view.subviews
+        view.subviews.each do |subview|
+          out << subview
+          out << all_subviews_for(subview)
+        end
+        out.flatten!
+      end
+
+      out
+    end
+
+    def all_superviews_for(view, out = [])
+      if (nr = view.nextResponder) && nr.is_a?(UIView)
+        out << nr
+        all_superviews_for(nr, out)
+      end     
+      out
+    end
+
+    def inspect
+      out = "RMQ #{self.object_id}. #{self.count} selected. selectors: #{self.selectors.to_s}. .log for more info"
+      out << "\n[#{selected.first}]" if self.count == 1
+      out
+    end
+
+    def log(opt = nil)
+      wide = (opt == :wide)
+      out =  "\n object_id   | class                 | style_name              | frame                           |"
+      out << "\n" unless wide
+      out <<   " sv id       | superview             | subviews count          | tags                            |"
+      line =   " - - - - - - | - - - - - - - - - - - | - - - - - - - - - - - - | - - - - - - - - - - - - - - - - |\n"
+      out << "\n"
+      out << line.chop if wide
+      out << line
+
+      selected.each do |view| 
+        out << " #{view.object_id.to_s.ljust(12)}|"
+        out << " #{view.class.name[0..21].ljust(22)}|"
+        out << " #{(view.rmq_data.style_name || '')[0..23].ljust(24)}|"
+
+        s = ""
+        if view.origin
+          format = '#0.#'
+          s = " {l: #{RMQ.format.numeric(view.origin.x, format)}"
+          s << ", t: #{RMQ.format.numeric(view.origin.y, format)}"
+          s << ", w: #{RMQ.format.numeric(view.size.width, format)}"
+          s << ", h: #{RMQ.format.numeric(view.size.height, format)}}"
+        end
+        out << s.ljust(33)
+        out << '|'
+
+        out << "\n" unless wide
+        out << " #{view.superview.object_id.to_s.ljust(12)}|"
+        out << " #{(view.superview ? view.superview.class.name : '')[0..21].ljust(22)}|"
+        out << " #{view.subviews.length.to_s.ljust(23)} |"
+        #out << "  #{view.subviews.length.to_s.rjust(8)} #{view.superview.class.name.ljust(20)} #{view.superview.object_id.to_s.rjust(10)}"
+        out << " #{view.rmq_data.tag_names.join(',').ljust(32)}|"
+        out << "\n"
+        out << line unless wide
+      end
+
+      out << "RMQ #{self.object_id}. #{self.count} selected. selectors: #{self.selectors.to_s}"
+
+      puts out
+    end
+
+    class << self
+      attr_accessor :cache_controller_rmqs
+      @cache_controller_rmqs = true
+    end
+  end
+end

data/motion/ruby_motion_query/color.rb

@@ -0,0 +1,80 @@
+module RubyMotionQuery
+  class RMQ
+    def self.color
+      Color
+    end
+
+    def color 
+      Color
+    end
+  end
+
+  class Color < UIColor
+
+    class << self
+      alias :clear         :clearColor                           
+      alias :white         :whiteColor                           
+      alias :light_gray    :lightGrayColor                       
+      alias :gray          :grayColor                            
+      alias :dark_gray     :darkGrayColor                        
+      alias :black         :blackColor                           
+                                                                 
+      alias :red           :redColor                             
+      alias :green         :greenColor                           
+      alias :blue          :blueColor                            
+      alias :yellow        :yellowColor                          
+      alias :orange        :orangeColor                          
+      alias :purple        :purpleColor                          
+      alias :brown         :brownColor                           
+      alias :cyan          :cyanColor                            
+      alias :magenta       :magentaColor                         
+                                                                 
+      alias :table_view    :groupTableViewBackgroundColor        
+      alias :scroll_view   :scrollViewTexturedBackgroundColor    
+      alias :flipside      :viewFlipsideBackgroundColor          
+      alias :under_page    :underPageBackgroundColor             
+      alias :light_text    :lightTextColor                       
+      alias :dark_text     :darkTextColor                        
+
+      def add_named(key, hex_or_color)
+        color = if hex_or_color.is_a?(String)
+          Color.from_hex(hex_or_color)
+        else
+          hex_or_color
+        end
+
+        Color.define_singleton_method(key) do
+          color
+        end
+      end
+
+      # Thanks bubblewrap for this method
+      def from_hex(hex_color)
+        hex_color.gsub!("#", "")   
+        case hex_color.size 
+          when 3
+            colors = hex_color.scan(%r{[0-9A-Fa-f]}).map{ |el| (el * 2).to_i(16) }
+          when 6
+            colors = hex_color.scan(%r<[0-9A-Fa-f]{2}>).map{ |el| el.to_i(16) }        
+          else
+            raise ArgumentError
+        end 
+        if colors.size == 3
+          from_rgba(colors[0], colors[1], colors[2], 1.0)
+        else
+          raise ArgumentError
+        end 
+      end 
+
+      def from_rgba(r,g,b,a)
+        UIColor.colorWithRed((r/255.0), green: (g/255.0), blue: (b/255.0), alpha: a)
+      end
+
+      def from_hsva(h,s,v,a)
+        UIColor.alloc.initWithHue(h, saturation: s, brightness: v, alpha: a)
+      end
+    end
+
+  end
+
+end

data/motion/ruby_motion_query/data.rb

@@ -0,0 +1,32 @@
+module RubyMotionQuery
+  class ViewData
+    attr_accessor :events, :style_name
+
+    def tags
+      @_tags ||= {}
+    end
+
+    def tag_names
+      tags.keys
+    end
+
+    def tag(*tag_or_tags)
+      tag_or_tags.flatten!
+      tag_or_tags.each do |tag_name|
+        tags[tag_name] = 1
+      end
+    end
+
+    def has_tag?(tag_name = nil)
+      if tag_name
+        tags.include?(tag_name)
+      else
+        RMQ.is_blank?(@_tags)
+      end
+    end
+  end
+
+  class ControllerData
+    attr_accessor :stylesheet, :rmq
+  end
+end

data/motion/ruby_motion_query/device.rb

@@ -0,0 +1,73 @@
+module RubyMotionQuery
+  class RMQ
+    def device
+      Device
+    end
+    def self.device
+      Device
+    end
+  end
+
+  class Device
+    class << self
+      def screen
+        UIScreen.mainScreen
+      end
+
+      def width
+        @_width ||= Device.screen.bounds.size.width
+      end
+
+      def height
+        @_height ||= Device.screen.bounds.size.height
+      end
+
+      def ipad?
+        @_ipad = (UIDevice.currentDevice.userInterfaceIdiom == UIUserInterfaceIdiomPad) if @_ipad.nil?
+        @_ipad
+      end
+
+      def iphone?
+        @_iphone = (UIDevice.currentDevice.userInterfaceIdiom == UIUserInterfaceIdiomPhone) if @_iphone.nil?
+        @_iphone
+      end
+
+      def four_inch?
+        @_four_inch = (Device.height == 568.0) if @_four_inch.nil?
+        @_four_inch
+      end
+
+      def retina?()
+        if @_retina.nil?
+          main_screen = Device.screen
+          @_retina = !!(main_screen.respondsToSelector('displayLinkWithTarget:selector:') && main_screen.scale == 2.0)
+        end
+
+        @_retina
+      end
+
+      def orientation
+        ORIENTATIONS[UIDevice.currentDevice.orientation] || :unknown
+      end
+
+      def landscape?
+        Device.orientation == :landscape_Left || Device.orientation == :landscape_right
+      end
+
+      def portrait?
+        Device.orientation == :portrait || Device.orientation == :unknown
+      end
+
+      ORIENTATIONS = { 
+        UIDeviceOrientationUnknown => :unkown,
+        UIDeviceOrientationPortrait => :portrait,
+        UIDeviceOrientationPortraitUpsideDown => :portrait_upside_down,
+        UIDeviceOrientationLandscapeLeft => :landscape_Left,
+        UIDeviceOrientationLandscapeRight => :landscape_right,
+        UIDeviceOrientationFaceUp => :face_up, 
+        UIDeviceOrientationFaceDown => :face_down
+      }
+
+    end
+  end
+end

data/motion/ruby_motion_query/enumerablish.rb

@@ -0,0 +1,74 @@
+module RubyMotionQuery 
+  class RMQ
+    # I'm purposly not including Enumerable, 
+    # please use to_a if you want one
+
+    def <<(value)
+      selected << value if value.is_a?(UIView)
+      self
+    end
+
+    # @example
+    #   rmq(UILabel)[3]
+    #   or
+    #   rmq(UILabel)[1..5]
+    def [](i)
+      RMQ.create_with_array_and_selectors([selected[i]], @selectors, @context)
+    end
+    alias :eq :[]
+
+    def each(&block)
+      return self unless block
+      RMQ.create_with_array_and_selectors(selected.each(&block), @selectors, @context)
+    end
+
+    def map(&block)
+      return self unless block
+      RMQ.create_with_array_and_selectors(selected.map(&block), @selectors, @context)
+    end
+    alias :collect :map
+
+    def select(&block)
+      return self unless block
+      RMQ.create_with_array_and_selectors(selected.select(&block), @selectors, @context)
+    end
+
+    def detect(&block) # Unlike enumerable, detect and find are not the same. See find in transverse
+      return self unless block
+      RMQ.create_with_array_and_selectors(selected.select(&block), @selectors, @context)
+    end
+
+    def grep(&block)
+      return self unless block
+      RMQ.create_with_array_and_selectors(selected.grep(&block), @selectors, @context)
+    end
+
+    def reject(&block)
+      return self unless block
+      RMQ.create_with_array_and_selectors(selected.reject(&block), @selectors, @context)
+    end
+
+    def inject(o, &block)
+      return self unless block
+      RMQ.create_with_array_and_selectors(selected.inject(o, &block), @selectors, @context)
+    end
+    alias :reduce :inject
+
+    def first
+      RMQ.create_with_array_and_selectors([selected.first], @selectors, @context)
+    end
+    def last
+      RMQ.create_with_array_and_selectors([selected.last], @selectors, @context)
+    end
+
+    def to_a
+      selected
+    end
+
+    def length
+      selected.length
+    end
+    alias :size :length
+    alias :count :length
+  end
+end