rmx 0.6.0

data/lib/motion/layout.rb

@@ -0,0 +1,357 @@
+class RMX
+  class Layout
+
+    ATTRIBUTE_LOOKUP = {
+      "left" => NSLayoutAttributeLeft,
+      "right" => NSLayoutAttributeRight,
+      "top" => NSLayoutAttributeTop,
+      "bottom" => NSLayoutAttributeBottom,
+      "leading" => NSLayoutAttributeLeading,
+      "trailing" => NSLayoutAttributeTrailing,
+      "width" => NSLayoutAttributeWidth,
+      "height" => NSLayoutAttributeHeight,
+      "centerX" => NSLayoutAttributeCenterX,
+      "centerY" => NSLayoutAttributeCenterY,
+      "baseline" => NSLayoutAttributeBaseline,
+      nil => NSLayoutAttributeNotAnAttribute
+    }
+
+    ATTRIBUTE_LOOKUP_INVERSE = ATTRIBUTE_LOOKUP.invert
+
+    RELATED_BY_LOOKUP = {
+      "<=" => NSLayoutRelationLessThanOrEqual,
+      "==" => NSLayoutRelationEqual,
+      ">=" => NSLayoutRelationGreaterThanOrEqual
+    }
+
+    RELATED_BY_LOOKUP_INVERSE = RELATED_BY_LOOKUP.invert
+
+    PRIORITY_LOOKUP = {
+      "max" => UILayoutPriorityRequired, # = 1000
+      "required" => UILayoutPriorityRequired, # = 1000
+      "high" => UILayoutPriorityDefaultHigh, # = 750
+      "med" => 500,
+      "low" => UILayoutPriorityDefaultLow, # = 250
+      "fit" => UILayoutPriorityFittingSizeLevel # = 50
+    }
+
+    PRIORITY_LOOKUP_INVERSE = PRIORITY_LOOKUP.invert
+
+    AXIS_LOOKUP = {
+      "h" => UILayoutConstraintAxisHorizontal,
+      "v" => UILayoutConstraintAxisVertical
+    }
+
+    # keeps track of views that are not #hidden? as constraints are built, so the
+    # special `last_visible` view name can be used in equations.
+    # exposed for advanced layout needs.
+    attr_accessor :visible_items
+
+    # Example:
+    # RMX::Layout.new do |layout|
+    #   ...
+    # end
+    def initialize(&block)
+      @block_owner = block.owner if block
+      @visible_items = []
+      @constraints = {}
+      unless block.nil?
+        block.call(self)
+        block = nil
+      end
+    end
+
+    # reopens the RMX::Layout instance for additional processing, ex:
+    #   @layout.reopen do |layout|
+    #     ...
+    #   end
+    # note: you would need to store your instance somewhere on creation to be able to reopen it later, ex:
+    #   @layout = RMX::Layout.new do |layout|
+    #     ...
+    #   end
+    def reopen
+      if block_given?
+        yield self
+      end
+      self
+    end
+
+    def clear!
+      @view.removeConstraints(@view.constraints)
+    end
+
+    def remove(constraint)
+      constraints = [ constraint ].flatten.compact
+      @view.removeConstraints(constraints)
+      @constraints.keys.each do |key|
+        @constraints.delete(key) if constraints.include?(@constraints.fetch(key))
+      end
+      true
+    end
+
+    def view(view)
+      @view = view
+    end
+
+    def view=(v)
+      view(v)
+    end
+
+    def subviews(subviews)
+      @subviews = subviews
+      @subviews.values.each do |subview|
+        subview.translatesAutoresizingMaskIntoConstraints = false
+        @view.addSubview(subview)
+      end
+      @subviews
+    end
+
+    def subviews=(views)
+      subviews(views)
+    end
+
+    # takes a string one or more equations separated by newlines and
+    # processes each.  returns an array of constraints
+    def eqs(str)
+      str.split("\n").map(&:strip).select { |x| !x.empty? }.map do |line|
+        eq(line)
+      end.compact
+    end
+
+    # Constraints are of the form "view1.attr1 <relation> view2.attr2 * multiplier + constant @ priority"
+    # processes one equation string
+    def eq(str, remove=false)
+      parts = str.split("#", 2).first.split(" ").select { |x| !x.empty? }
+      return if parts.empty?
+
+      item = nil
+      item_attribute = nil
+      related_by = nil
+      to_item = nil
+      to_item_attribute = nil
+      multiplier = 1.0
+      constant = 0.0
+      
+      debug = parts.delete("?")
+
+      # first part should always be view1.attr1
+      part = parts.shift
+      item, item_attribute = part.split(".", 2)
+
+      # second part should always be relation
+      related_by = parts.shift
+
+      # now things get more complicated
+
+      # look for priority
+      if idx = parts.index("@")
+        priority = parts[idx + 1]
+        parts.delete_at(idx)
+        parts.delete_at(idx)
+      end
+
+      # look for negative or positive constant
+      if idx = parts.index("-")
+        constant = "-#{parts[idx + 1]}"
+        parts.delete_at(idx)
+        parts.delete_at(idx)
+      elsif idx = parts.index("+")
+        constant = parts[idx + 1]
+        parts.delete_at(idx)
+        parts.delete_at(idx)
+      end
+
+      # look for multiplier
+      if idx = parts.index("*")
+        multiplier = parts[idx + 1]
+        parts.delete_at(idx)
+        parts.delete_at(idx)
+      end
+
+      # now we need to_item, to_item_attribute
+
+      if part = parts.shift
+        # if part includes a . it could be either view2.attr2 or a float like 10.5
+        l, r = part.split(".", 2)
+        if !r || (r && r =~ /\d/)
+          # assume a solo constant was on the right side
+          constant = part
+        else
+          # assume view2.attr2
+          to_item, to_item_attribute = l, r
+        end
+      end
+
+      # if we dont have to_item and the item_attribute is something that requires a to_item, then
+      # assume superview
+      if !to_item
+        unless item_attribute == "height" || item_attribute == "width"
+          to_item = "view"
+          to_item_attribute = item_attribute
+        end
+      end
+
+      # normalize
+
+      if item == "last_visible"
+        item = @visible_items.first || "view"
+      end
+
+      res_item = view_for_item(item)
+      res_constant = Float(PRIORITY_LOOKUP[constant] || constant)
+
+      if res_item
+        case item_attribute
+        when "resistH"
+          return res_item.setContentCompressionResistancePriority(res_constant, forAxis:UILayoutConstraintAxisHorizontal)
+        when "resistV"
+          return res_item.setContentCompressionResistancePriority(res_constant, forAxis:UILayoutConstraintAxisVertical)
+        when "hugH"
+          return res_item.setContentHuggingPriority(res_constant, forAxis:UILayoutConstraintAxisHorizontal)
+        when "hugV"
+          return res_item.setContentHuggingPriority(res_constant, forAxis:UILayoutConstraintAxisVertical)
+        end
+      end
+
+      if to_item == "last_visible"
+        to_item = @visible_items.detect { |x| x != item } || "view"
+      end
+
+      res_item_attribute = ATTRIBUTE_LOOKUP[item_attribute]
+      res_related_by = RELATED_BY_LOOKUP[related_by]
+      res_to_item = to_item ? view_for_item(to_item) : nil
+      res_to_item_attribute = ATTRIBUTE_LOOKUP[to_item_attribute]
+      res_multiplier = Float(multiplier)
+      res_priority = priority ? Integer(PRIORITY_LOOKUP[priority] || priority) : nil
+
+      errors = []
+      errors.push("Invalid view1: #{item}") unless res_item
+      errors.push("Invalid attr1: #{item_attribute}") unless res_item_attribute
+      errors.push("Invalid relatedBy: #{related_by}") unless res_related_by
+      errors.push("Invalid view2: #{to_item}") if to_item && !res_to_item
+      errors.push("Invalid attr2: #{to_item_attribute}") unless res_to_item_attribute
+
+      internal_ident = "#{item}.#{item_attribute} #{related_by} #{to_item}.#{to_item_attribute} * #{multiplier} @ #{priority}"
+
+      if errors.size > 0 || debug
+        p "======================== constraint debug ========================"
+        p "given:"
+        p "  #{str}"
+        p "interpreted:"
+        p "  item:                #{item}"
+        p "  item_attribute:      #{item_attribute}"
+        p "  related_by:          #{related_by}"
+        p "  to_item:             #{to_item}"
+        p "  to_item_attribute:   #{to_item_attribute}"
+        p "  multiplier:          #{multiplier}"
+        p "  constant:            #{constant}"
+        p "  priority:            #{priority || "required"}"
+        p "  internal_ident:      #{internal_ident}"
+      end
+
+      if errors.size > 0
+        raise(errors.join(", "))
+      end
+
+      unless res_item.hidden?
+        @visible_items.unshift(item)
+      end
+
+      if remove
+        if constraint = @constraints[internal_ident]
+          if debug
+            p "status:"
+            p "  existing (for removal)"
+          end
+          @view.removeConstraint(constraint)
+        else
+          raise "RMX::Layout could not find constraint to remove for internal_ident: `#{internal_ident}` (note: this is an internal representation of the constraint, not the exact string given).  Make sure the constraint was created first."
+        end
+      elsif constraint = @constraints[internal_ident]
+        if debug
+          p "status:"
+          p "  existing (for modification)"
+        end
+        constraint.constant = res_constant
+      else
+        constraint = NSLayoutConstraint.constraintWithItem(res_item,
+           attribute:res_item_attribute,
+           relatedBy:res_related_by,
+              toItem:res_to_item,
+           attribute:res_to_item_attribute,
+          multiplier:res_multiplier,
+            constant:res_constant)
+        if debug
+          p "status:"
+          p "  created"
+        end
+        @constraints[internal_ident] = constraint
+        if res_priority
+          constraint.priority = res_priority
+        end
+        @view.addConstraint(constraint)
+      end
+
+      if debug
+        p "implemented:"
+        p "  #{constraint.description}"
+      end
+
+      constraint
+    end
+
+    # removes the constraint matching equation string.  constant is not considered.
+    # if no matching constraint is found, it will raise an exception.
+    def xeq(str)
+      eq(str, true)
+    end
+
+    def describe_constraint(constraint)
+      self.class.describe_constraint(@subviews, constraint)
+    end
+
+    def describe_view
+      self.class.describe_view(@subviews, @view)
+    end
+
+    # transforms an NSLayoutConstraint into a string.  this string is for debugging and produces
+    # a verbose translation.  its not meant to be copied directly as an equation.
+    # pass the subviews hash just as you would to Layout#subviews=, followed by the NSLayoutConstraint
+    def self.describe_constraint(subviews, constraint)
+      subviews_inverse = subviews.invert
+      item = subviews_inverse[constraint.firstItem] || "view"
+      item_attribute = ATTRIBUTE_LOOKUP_INVERSE[constraint.firstAttribute]
+      related_by = RELATED_BY_LOOKUP_INVERSE[constraint.relation]
+      to_item = subviews_inverse[constraint.secondItem] || "view"
+      to_item_attribute = ATTRIBUTE_LOOKUP_INVERSE[constraint.secondAttribute]
+      multiplier = constraint.multiplier
+      constant = constraint.constant
+      priority = PRIORITY_LOOKUP_INVERSE[constraint.priority] || constraint.priority
+      "#{constraint.description}\n#{item}.#{item_attribute} #{related_by} #{to_item}.#{to_item_attribute} * #{multiplier} + #{constant} @ #{priority}"
+    end
+
+    # transforms a view's NSLayoutConstraints into strings.
+    # pass the subviews hash just as you would to Layout#subviews=, followed by the view to
+    # describe
+    def self.describe_view(subviews, view)
+      view.constraints.map do |constraint|
+        describe_constraint(subviews, constraint)
+      end.join("\n")
+    end
+
+    private
+
+    def view_for_item(item)
+      if item == "view"
+        @view
+      elsif item == "topLayoutGuide"
+        @block_owner && @block_owner.topLayoutGuide
+      elsif item == "bottomLayoutGuide"
+        @block_owner && @block_owner.bottomLayoutGuide
+      elsif v = (@subviews && @subviews[item])
+        v
+      end
+    end
+
+  end
+end

data/lib/motion/ui.rb

@@ -0,0 +1,55 @@
+class RMX
+
+  def self.app
+    UIApplication.sharedApplication
+  end
+
+  def self.ios_version
+    @ios_version ||= UIDevice.currentDevice.systemVersion.split(".").take(2).join(".").to_f    
+  end
+
+  def self.screen_pixel
+    1.0 / UIScreen.mainScreen.scale
+  end
+
+  def self.keyboardWillChangeFrame(notification)
+    @keyboardWillChangeFrameNotification = notification
+    processKeyboardWillChange
+  end
+
+  def self.processKeyboardWillChange
+    return unless notification = @keyboardWillChangeFrameNotification
+    info = notification.userInfo
+    keyboardFrame = info.objectForKey(UIKeyboardFrameEndUserInfoKey).CGRectValue
+    bounds = UIScreen.mainScreen.bounds
+    animationDuration = info.objectForKey(UIKeyboardAnimationDurationUserInfoKey).doubleValue
+    #  below the screen                              # above the screen                                                       # left of the screen                                                    # right of the screen
+    currentKeyboardHeight = if keyboardFrame.origin.y >= bounds.size.height || keyboardFrame.origin.y <= bounds.origin.y - keyboardFrame.size.height || keyboardFrame.origin.x <= bounds.origin.x - keyboardFrame.size.width || keyboardFrame.origin.x >= bounds.size.width
+      0
+    else
+      keyboardFrame.size.height
+    end
+    # p "================>"
+    if currentKeyboardHeight != @currentKeyboardHeight
+      @currentKeyboardHeight = currentKeyboardHeight
+      # p "currentKeyboardHeight", currentKeyboardHeight
+      # p "keyboardFrame", keyboardFrame
+      # p "UIScreen.mainScreen.bounds", UIScreen.mainScreen.bounds
+      NSNotificationCenter.defaultCenter.postNotificationName("rmxKeyboardChanged", object:nil, userInfo:{
+        :height => currentKeyboardHeight,
+        :animationDuration => animationDuration
+      })
+    end
+    @keyboardWillChangeFrameNotification = nil
+  end
+
+  def self.currentKeyboardHeight
+    @currentKeyboardHeight || 0
+  end
+  NSNotificationCenter.defaultCenter.addObserver(self, selector:'keyboardWillChangeFrame:', name:UIKeyboardWillChangeFrameNotification, object:nil)
+
+end
+
+def RMX(_object)
+  RMX.new(_object)
+end

data/lib/motion/util.rb

@@ -0,0 +1,155 @@
+class RMX
+
+  def self.safe_block(block)
+    weak_block_owner_holder = RMXWeakHolder.new(block.owner)
+    block.weak!
+    proc do |*args|
+      if wbo = weak_block_owner_holder.value
+        block.call(*args)
+      end
+    end
+  end
+
+  # Raises an exception when called from a thread other than the main thread.
+  # Good for development and experimenting.
+  def self.assert_main_thread!
+    raise "Expected main thread. #{Dispatch::Queue.current.description}" unless NSThread.currentThread.isMainThread
+  end
+
+  # call the block immediately if called on the main thread,
+  # otherwise call it async on the main queue
+  def self.inline_or_on_main_q(&block)
+    if NSThread.currentThread.isMainThread
+      block.call
+    else
+      Dispatch::Queue.main do
+        block.call
+      end
+    end
+  end
+
+  # call the block immediately if called on the main thread with the given args,
+  # otherwise call it async on the main queue.
+  # silently ignores nil blocks to avoid if !block.nil? checks, useful for async callbacks
+  # that optionally take a callback
+  def self.block_on_main_q(block, *args)
+    unless block.nil?
+      inline_or_on_main_q do
+        block.call(*args)
+      end
+    end
+  end
+
+  def require_queue!(queue, file, line)
+    unless Dispatch::Queue.current.description == queue.description
+      raise "WRONG QUEUE: was: #{Dispatch::Queue.current.description}, expected: #{queue.description}. #{@object.value.inspect} #{file}:#{line}, #{caller.inspect}"
+    end
+  end
+
+  def own_methods
+    if object = unsafe_unretained_object
+      (object.methods - (object.superclass.methods)).sort
+    end
+  end
+
+  # Shortcut to instance_variable_get and instance_variable_get:
+  # 1 arg for instance_variable_get
+  # 1 arg and block for instance_variable_get || instance_variable_set
+  # 2 args for instance_variable_set
+  def ivar(*args, &block)
+    if object = unsafe_unretained_object
+      key = args[0]
+      val = nil
+      if args.size == 1
+        if block
+          val = object.instance_variable_get("@#{key}")
+          if val.nil?
+            val = block.call
+            object.instance_variable_set("@#{key}", val)
+            val
+          end
+        else
+          val = object.instance_variable_get("@#{key}")
+        end
+      elsif args.size == 2
+        val = args[1]
+        object.instance_variable_set("@#{key}", val)
+      else
+        raise "RMX#ivar called with invalid arguments: #{args.inspect}"
+      end
+      val
+    end
+  end
+
+  def nil_instance_variables!
+    if object = unsafe_unretained_object
+      ivars = [] + object.instance_variables
+      while ivar = ivars.pop
+        object.instance_variable_set(ivar, nil)
+      end
+      true
+    end
+  end
+
+  def debounce(unique_id, opts={}, &block)
+    if (seconds = opts[:seconds]) && seconds > 0
+      debounce_seconds(seconds, unique_id, opts[:now], &block)
+    else
+      debounce_runloop(unique_id, opts[:now], &block)
+    end
+  end
+
+  def debounce_runloop(unique_id, run_immediately=false, &block)
+    if object = unsafe_unretained_object
+      lookup = Thread.current["rmx_debounce_runloop"] ||= {}
+      key = [ object, unique_id ]
+      lookup[key] ||= begin
+        block.call if run_immediately
+        CFRunLoopPerformBlock(
+          CFRunLoopGetCurrent(),
+          KCFRunLoopDefaultMode,
+          lambda do
+            lookup.delete(key)
+            block.call
+          end
+        )
+        true
+      end
+      nil
+    end
+  end
+
+  def debounce_seconds(seconds, unique_id, run_immediately=false, &block)
+    if object = unsafe_unretained_object
+      lookup = Thread.current["rmx_debounce_seconds"] ||= {}
+      key = [ object, unique_id ]
+      lookup[key] ||= begin
+        block.call if run_immediately
+        units = CFGregorianUnits.new
+        units.seconds = seconds
+        CFRunLoopAddTimer(
+          CFRunLoopGetCurrent(),
+          CFRunLoopTimerCreateWithHandler(
+            KCFAllocatorDefault,
+            CFAbsoluteTimeAddGregorianUnits(
+              CFAbsoluteTimeGetCurrent(),
+              nil,
+              units
+            ),
+            0,
+            0,
+            0,
+            lambda do |timer|
+              lookup.delete(key)
+              block.call
+            end
+          ),
+          KCFRunLoopDefaultMode
+        )
+        true
+      end
+      nil
+    end
+  end
+
+end

data/lib/rmx/version.rb

@@ -0,0 +1,3 @@
+class RMX
+  VERSION = "0.6.0"
+end

data/lib/rmx.rb

@@ -0,0 +1,50 @@
+require "rmx/version"
+
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+Motion::Project::App.setup do |app|
+  %w(
+    RMXObjectExtensions
+    base
+    env
+    layout
+    util
+    accessors
+    events
+    ui
+    RMXCommonMethods
+    RMXWeakHolder
+    RMXUnsafeUnretainedHolder
+    RMXWeakToStrongHash
+    RMXStrongToWeakHash
+    RMXSynchronizedStrongToWeakHash
+    RMXEventsFromProxy
+    RMXExecutionBlock
+    RMXSetAttributes
+    RMXViewControllerPresentation
+    RMXKeyboardHelpers
+    RMXNavigationController
+    RMXTableViewController
+    RMXViewController
+    RMXSegmentedController
+    RMXView
+    RMXActionSheet
+    RMXAutoLayoutLabel
+    RMXAutoLayoutScrollView
+    RMXTableHandler
+    RMXTableViewCell
+    RMXTableViewCellInnerContentView
+  ).reverse.each do |x|
+    app.files.unshift(File.join(File.dirname(__FILE__), "motion/#{x}.rb"))
+  end
+  FileUtils.mkdir_p(File.expand_path("../build", File.dirname(__FILE__)))
+  env_filename = File.expand_path("../build/env.rb", File.dirname(__FILE__))
+  rmx_env = ENV['rmx_env'] == '1' ? ENV.to_hash : {}
+  File.open(env_filename, "w") do |f|
+    f.puts %Q{class RMX\n  Env = #{rmx_env.inspect}\nend\n}
+  end
+  App.log "RMX::Env", rmx_env.inspect
+  app.files.unshift(env_filename)
+end

data/rmx.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rmx/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "rmx"
+  gem.version       = RMX::VERSION
+  gem.authors       = ["Joe Noon"]
+  gem.email         = ["joenoon@gmail.com"]
+  gem.description   = %q{Extensions and helpers for dealing with various areas of rubymotion}
+  gem.summary       = %q{Extensions and helpers for dealing with various areas of rubymotion}
+  gem.homepage      = "https://github.com/joenoon/rmx"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end