rmx 0.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9cd874bc129e8aef4429698b30fe2bc429c419f0
+  data.tar.gz: dcc6f40d497510993ea5a28c7b6dee46868552e9
+SHA512:
+  metadata.gz: c900776ee05bcd66a894871dec855c5589493b28effd6e6b227386587402fabd355d194f19cf99fcc1bf140d9225ae22104705f6ffda2a445686f9754e73566f
+  data.tar.gz: e97f08b80bb2568f896af0717cb07124dca1bdd615bdb4590751ef278397a612adc47fa80c5eee2c336704843176b79cf224d60dcf569a251ba38b3601a287df

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+build
+build*
+*.bridgesupport

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+group :test, :development do
+  gem 'rake'
+end
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Joe Noon
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,40 @@
+RMX
+-----------------
+
+#### Extensions and helpers for dealing with various areas of rubymotion and iOS.
+
+#### [Documentation](https://github.com/joenoon/rmx/wiki/RMX-Documentation)
+
+#### [CHANGELOG](https://github.com/joenoon/rmx/wiki/CHANGELOG)
+
+Installation
+-----------------
+
+Add this line to your application's Gemfile:
+
+    gem 'rmx'
+
+And then execute:
+
+    $ bundle
+
+Contributing
+-----------------
+
+If you have a better way to accomplish anything this library is doing, please share!
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+License
+-----------------
+
+Please see [LICENSE](https://github.com/joenoon/rmx/blob/master/LICENSE.txt) for licensing details.
+
+Author
+-----------------
+
+[Joe Noon](https://github.com/joenoon)

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/gem_tasks"
+if ENV['rubymotion']
+  $:.unshift('/Library/RubyMotion/lib')
+  if ENV.fetch('platform', 'ios') == 'ios'
+    require 'motion/project/template/ios'
+  elsif ENV['platform'] == 'osx'
+    require 'motion/project/template/osx'
+  else
+    raise "Unsupported platform #{ENV['platform']}"
+  end
+  require 'bundler'
+  Bundler.require
+
+  Motion::Project::App.setup do |app|
+    # Use `rake config' to see complete project settings.
+    app.name = 'rmx'
+  end
+end

data/app/app_delegate.rb

@@ -0,0 +1,5 @@
+class AppDelegate
+  def application(application, didFinishLaunchingWithOptions:launchOptions)
+    true
+  end
+end

data/lib/motion/RMXActionSheet.rb

@@ -0,0 +1,14 @@
+class RMXActionSheet < UIActionSheet
+
+  def init
+    s = super
+    self.delegate = self
+    s
+  end
+
+  def actionSheet(actionSheet, clickedButtonAtIndex:buttonIndex)
+    title = actionSheet.buttonTitleAtIndex(buttonIndex)
+    RMX.new(self).trigger(:clickedButton, { :index => buttonIndex, :title => title })
+  end
+
+end

data/lib/motion/RMXAutoLayoutLabel.rb

@@ -0,0 +1,19 @@
+class RMXAutoLayoutLabel < UILabel
+  def layoutSubviews
+    super
+    if numberOfLines == 0
+      if preferredMaxLayoutWidth != frame.size.width
+        self.preferredMaxLayoutWidth = frame.size.width
+        setNeedsUpdateConstraints
+      end
+    end
+  end
+  def intrinsicContentSize
+    s = super
+    if numberOfLines == 0
+      # found out that sometimes intrinsicContentSize is 1pt too short!
+      s.height += 1
+    end
+    s
+  end
+end

data/lib/motion/RMXAutoLayoutScrollView.rb

@@ -0,0 +1,53 @@
+class RMXAutoLayoutScrollView < UIScrollView
+  class FollowView < UIView
+    RMX.new(self).weak_attr_accessor :fittedView
+    def layoutSubviews
+      s = super
+      fittedView.invalidateIntrinsicContentSize
+      fittedView.setNeedsUpdateConstraints
+      fittedView.layoutIfNeeded
+      s
+    end
+  end
+  class FittedView < UIView
+    RMX.new(self).weak_attr_accessor :followView
+    def intrinsicContentSize
+      followView.frame.size
+    end
+  end
+  attr_accessor :contentView
+  def self.fitted_to(parent)
+    followView = FollowView.new
+    followView.userInteractionEnabled = false
+    followView.hidden = true
+    fittedView = FittedView.new
+    fittedView.backgroundColor = UIColor.clearColor
+    fittedView.followView = followView
+    followView.fittedView = fittedView
+    # add a subview to parent called followView
+    RMX::Layout.new do |layout|
+      layout.view parent
+      layout.subviews "x" => followView
+      layout.eqs %Q{
+        x.top == 0
+        x.right == 0
+        x.bottom == 0
+        x.left == 0
+      }
+    end
+    x = new
+    x.contentView = fittedView
+    # add a subview to scrollView called contentView
+    RMX::Layout.new do |layout|
+      layout.view x
+      layout.subviews "x" => fittedView
+      layout.eqs %Q{
+        x.top == 0
+        x.right == 0
+        x.bottom == 0
+        x.left == 0
+      }
+    end
+    x
+  end
+end

data/lib/motion/RMXCommonMethods.rb

@@ -0,0 +1,27 @@
+module RMXCommonMethods
+
+  def rmx_dealloc
+  end
+
+  if RMX::DEBUG_DEALLOC
+    def dealloc
+      p " - dealloc! (queue: #{Dispatch::Queue.current.description})"
+      rmx_dealloc
+      super
+    end
+  else
+    def dealloc
+      rmx_dealloc
+      super
+    end
+  end
+
+  def description
+    rmx_object_desc
+  end
+
+  def inspect
+    rmx_object_desc
+  end
+
+end

data/lib/motion/RMXEventsFromProxy.rb

@@ -0,0 +1,103 @@
+# Proxy class used to hold the actual handlers and contexts of handlers.
+# When the real class deallocates, all handlers are removed.
+class RMXEventsFromProxy
+
+  QUEUE = Dispatch::Queue.new("RMXEventsFromProxy")
+
+  def initialize
+    @events = {}
+  end
+
+  # def rmx_dealloc
+  #   off
+  #   super
+  # end
+
+  def on(event, opts={}, &block)
+    block ||= proc {}
+    event = event.to_s
+    execution_block = RMXExecutionBlock.new
+    execution_block.strong = opts.delete(:strong)
+    execution_block.limit = opts.delete(:limit)
+    execution_block.queue = opts.delete(:queue)
+    execution_block.meta = opts
+    execution_block.block = block
+    off_block = RMXExecutionBlock.new
+    off_block.block = proc do
+      off(event, execution_block)
+    end
+    QUEUE.sync do
+      @events[event] ||= []
+      @events[event] << execution_block
+    end
+    off_block
+  end
+
+  def now_and_on(event, opts={}, &block)
+    RMX.block_on_main_q(block)
+    on(event, opts, &block)
+  end
+
+  def off(event=nil, execution_block=nil)
+    QUEUE.sync do
+      if event.is_a?(String) || event.is_a?(Symbol)
+        event = event.to_s
+        if execution_block
+          if events = @events[event]
+            deleted = events.delete(execution_block)
+            if RMX::DEBUG_EVENTS
+              p "remove the one block for the event", "EVENT:", event, "deleted:", deleted
+            end
+          end
+        else
+          deleted = @events.delete(event)
+          if RMX::DEBUG_EVENTS
+            p "remove all blocks for the event", "EVENT:", event, "deleted:", deleted
+          end
+        end
+      else
+        @events.clear
+        if RMX::DEBUG_EVENTS
+          p "remove all blocks for all events"
+        end
+      end
+    end
+    nil
+  end
+
+  def trigger(event, *values)
+    QUEUE.async do
+      # if RMX::DEBUG_EVENTS
+      #   p "TRIGGER:", event, values, "@events", @events
+      # end
+      event = event.to_s
+      _execution_blocks = @events[event]
+      next unless _execution_blocks
+      execution_blocks = _execution_blocks.dup
+      while execution_blocks.size > 0
+        execution_block = execution_blocks.shift
+        exclusive = execution_block.meta[:exclusive]
+        if exclusive
+          _exclusive = exclusive.dup
+          while _exclusive.size > 0
+            exclude = _exclusive.shift.to_s
+            deleted = @events.delete(exclude)
+            if RMX::DEBUG_EVENTS
+              p "REMOVING DUE TO EXCLUSIVE:", exclude, "FOR EVENT:", event, "deleted:", deleted
+            end
+          end
+        end
+        execution_block.call(*values)
+        if execution_block.dead
+          deleted = _execution_blocks.delete(execution_block)
+          if RMX::DEBUG_EVENTS
+            p "REMOVING DUE TO DEAD:", "FOR EVENT:", event, "deleted:", deleted
+          end
+        end
+      end
+    end
+    nil
+  end
+
+end
+

data/lib/motion/RMXExecutionBlock.rb

@@ -0,0 +1,51 @@
+class RMXExecutionBlock
+  attr_accessor :queue, :the_block, :dead, :desc, :strong, :meta, :limit
+  RMX.new(self).weak_attr_accessor :block_owner
+
+  def block=(_block)
+    self.block_owner = _block.owner
+    self.the_block = RMX.safe_block(_block)
+  end
+
+  def actual_queue
+    q = queue
+    if q == :async
+      q = RMXEventsFromProxy::QUEUE
+    elsif q == :main
+      q = Dispatch::Queue.main
+    end
+    q ||= Dispatch::Queue.main
+    q
+  end
+
+  def call(*args)
+    should_cleanup = false
+    if !dead && (blk = the_block) && (o = block_owner) && (q = actual_queue)
+      q.async do
+        blk.call(*args)
+        blk
+        o
+      end
+    else
+      should_cleanup = true
+    end
+    if limit
+      if limit > 0
+        self.limit -= 1
+      end
+      if limit == 0
+        should_cleanup = true
+      end
+    end
+    if should_cleanup
+      self.dead = true
+      self.strong = nil
+      self.meta = nil
+      self.limit = nil
+      self.the_block = nil
+      self.block_owner = nil
+    end
+  end
+
+end
+

data/lib/motion/RMXKeyboardHelpers.rb

@@ -0,0 +1,54 @@
+module RMXKeyboardHelpers
+
+  def keyboard_proxy
+    keyboard_proxy_constraints unless @keyboard_proxy_constraints
+    @keyboard_proxy
+  end
+
+  def keyboard_proxy_constraints
+    @keyboard_proxy ||= UIView.new
+    @keyboard_proxy_constraints ||= begin
+      x = {}
+      RMX::Layout.new do |layout|
+        layout.view = view
+        layout.subviews = {
+          "keyboard_proxy" => @keyboard_proxy
+        }
+        x[:bottom] = layout.eq "keyboard_proxy.bottom == #{-RMX.currentKeyboardHeight}"
+        x[:height] = layout.eq "keyboard_proxy.height == 0"
+      end
+      x
+    end
+  end
+
+  def listenForKeyboardChanged
+    NSNotificationCenter.defaultCenter.addObserver(self, selector:'keyboardChangedInternal:', name:"rmxKeyboardChanged", object:nil)
+  end
+
+  # listens for the rmxKeyboardChanged notification and extracts the userInfo to call a friendlier method
+  def keyboardChangedInternal(notification)
+    if isViewLoaded
+      info = notification.userInfo
+      keyboardChanged(info)
+    end
+  end
+
+  # by default, looks to see if the controller is using the @keyboard_proxy_constraint convention.
+  # if so, sets the constraint's constant and refreshes the layout in the same animationDuration
+  # as the keyboard's animation.
+  #
+  # if you want to do more/other stuff on keyboardChanged, you can override this, call super, or
+  # do everything on your own.
+  def keyboardChanged(info)
+    if constraint = @keyboard_proxy_constraints && @keyboard_proxy_constraints[:height]
+      Dispatch::Queue.main.async do
+        UIView.animateWithDuration(info[:animationDuration], animations: lambda do
+          keyboard_proxy_constraints[:bottom].constant = -RMX.currentKeyboardHeight
+          view.setNeedsUpdateConstraints
+          view.layoutIfNeeded
+        end)
+      end
+    end
+  end
+
+end

data/lib/motion/RMXLongTask.rb

@@ -0,0 +1,133 @@
+# RMXLongTask encapsulates beginBackgroundTaskWithExpirationHandler/endBackgroundTask:
+#
+# RMXLongTask.new("my long task") do |task|
+#   do_something_long
+#   task.end!
+# end
+#
+# RMXLongTask.new("my long task") do |task|
+#   do_something_long_async do
+#     # later this long task finishes...
+#     task.end!
+#   end
+# end
+#
+class RMXLongTask
+  attr_accessor :bgTask, :desc
+
+  include RMXCommonMethods
+
+  def self.time_remaining
+    UIApplication.sharedApplication.backgroundTimeRemaining
+  end
+
+  def self.when_all_complete(&block)
+    Dispatch::Queue.main.async do
+      if RMXLongTask.outstanding_tasks.size.zero?
+        RMX.block_on_main_q(block)
+      else
+        RMX.new(RMXLongTask).once(:all_complete) do
+          block.call
+        end
+      end
+    end
+  end
+
+  def self.outstanding_queue
+    Dispatch.once do
+      @outstanding_queue = Dispatch::Queue.new("#{NSBundle.mainBundle.bundleIdentifier}.outstanding.LongTask")
+    end
+    @outstanding_queue
+  end
+
+  def self.outstanding_tasks
+    Dispatch.once do
+      @outstanding_tasks = []
+    end
+    @outstanding_tasks
+  end
+
+  # RMXLongTask.verbose("my long task") { |task| task.end! }
+  def self.verbose(desc=nil, &block)
+    _creator(desc, true, true, &block)
+  end
+
+  # RMXLongTask.create("my long task") { |task| task.end! }
+  def self.create(desc=nil, &block)
+    _creator(desc, false, true, &block)
+  end
+
+  def self.internal(desc=nil, &block)
+    _creator(desc, false, false, &block)
+  end
+
+  def self._creator(desc=nil, verbose=false, tracking=true, &block)
+    x = new(desc, verbose, tracking)
+    block.weak!.call(x)
+    x
+  end
+
+  def self.reset_outstanding_tasks!
+    RMXLongTask.outstanding_queue.sync do
+      size = RMXLongTask.outstanding_tasks.size
+      if size > 0
+        p "WARNING: reset_outstanding_tasks! (was: #{size})"
+        RMXLongTask.outstanding_tasks.removeAllObjects
+      end
+    end
+  end
+
+  def initialize(desc=nil, verbose=false, tracking=true)
+    @verbose = verbose
+    @tracking = tracking
+    @desc = "#{rmx_object_desc} #{desc}"
+    @bgTask = UIApplication.sharedApplication.beginBackgroundTaskWithExpirationHandler(lambda do
+      p "ERROR: #{@desc} didn't call #end! in time!"
+      __end!
+    end)
+    if DEBUG_LONGTASK || @verbose
+      p "CREATED: #{@desc}"
+    end
+    if @tracking
+      RMXLongTask.outstanding_queue.sync do
+        RMXLongTask.outstanding_tasks << self
+      end
+    end
+    self
+  end
+
+  def end!
+    if DEBUG_LONGTASK || @verbose
+      p "SUCCESS: #{@desc} ended successfully."
+    end
+    __end!
+  end
+
+  def __end!
+    if @tracking
+      RMXLongTask.outstanding_queue.sync do
+        RMXLongTask.outstanding_tasks.delete(self)
+        RMXLongTask.internal("check for all complete") do |internal_task|
+          Dispatch::Queue.main.async do
+            if RMXLongTask.outstanding_tasks.size.zero?
+              RMX.new(RMXLongTask).trigger(:all_complete)
+            end
+            internal_task.end!
+          end
+        end
+      end
+    end
+    if @bgTask && @bgTask != UIBackgroundTaskInvalid
+      UIApplication.sharedApplication.endBackgroundTask(@bgTask)
+      @bgTask = UIBackgroundTaskInvalid
+    end
+  end
+
+  def rmx_dealloc
+    if DEBUG_DEALLOC
+      p "DEALLOC: #{@desc}"
+    end
+    super
+  end
+
+end