motion-wiretap 0.1.0

data/README.md

@@ -0,0 +1,16 @@
+MotionWiretap
+-------
+
+An iOS / OS X wrapper heavily inspired by ReactiveCocoa.
+
+gem coming soon, just need to write the gemspec
+
+run the OSX specs using `rake spec platform=osx`
+
+Showdown
+-------
+
+Open these side by side to see the comparison:
+
+[reactive.rb](https://gist.github.com/colinta/d0a273f8d858a8f61c73)
+[reactive.mm](https://gist.github.com/colinta/5cfa588fed7b929193ae)

data/lib/motion-wiretap/all/signal.rb

@@ -0,0 +1,22 @@
+module Wiretap
+
+  # a Wiretap::Signal is much like a Promise in functional programming.  A
+  # Signal is triggered with a new value, or it is completed, or canceled with
+  # an error event.
+  class Signal
+
+    def initialize
+    end
+
+    def next(value)
+    end
+
+    def complete
+    end
+
+    def error
+    end
+
+  end
+
+end

data/lib/motion-wiretap/all/wiretap.rb

@@ -0,0 +1,447 @@
+$motion_wiretaps = []
+
+module MotionWiretap
+
+  class Wiretap
+
+    def initialize(&block)
+      $motion_wiretaps << self  # signal will be removed when it is completed
+
+      @is_torn_down = false
+      @is_completed = false
+      @is_error = false
+      @queue = nil
+
+      @listener_handlers = []
+      @completion_handlers = []
+      @error_handlers = []
+
+      listen &block if block
+    end
+
+    def dealloc
+      teardown
+      super
+    end
+
+    def teardown
+      return if @is_torn_down
+
+      @is_torn_down = true
+      $motion_wiretaps.remove(self)
+    end
+
+    # specify the GCD queue that the listeners should be run on
+    def queue(queue)
+      @queue = queue
+      return self
+    end
+
+    # send a block to the GCD queue
+    def enqueue(&block)
+      if @queue
+        @queue.async(&block)
+      else
+        block.call
+      end
+    end
+
+    ##|
+    ##|  Wiretap events
+    ##|
+
+    # called when the value changes
+    def listen(wiretap=nil, &block)
+      raise "Block or Wiretap is expected in #{self.class.name}##{__method__}" unless block || wiretap
+      raise "Only Block *or* Wiretap is expected in #{self.class.name}##{__method__}" if block && wiretap
+      @listener_handlers << (block || wiretap)
+      self
+    end
+
+    def trigger_changed(*values)
+      return if @is_torn_down || @is_completed || @is_error
+
+      @listener_handlers.each do |block_or_wiretap|
+        trigger_changed_on(block_or_wiretap, values)
+      end
+
+      return self
+    end
+
+    def trigger_changed_on(block_or_wiretap, values)
+      if block_or_wiretap.is_a? Wiretap
+        block_or_wiretap.trigger_changed(*values)
+      else
+        enqueue do
+          block_or_wiretap.call(*values)
+        end
+      end
+    end
+
+    # called when no more values are expected
+    def and_then(wiretap=nil, &block)
+      raise "Block or Wiretap is expected in #{self.class.name}##{__method__}" unless block || wiretap
+      raise "Only Block *or* Wiretap is expected in #{self.class.name}##{__method__}" if block && wiretap
+      @completion_handlers << (block || wiretap)
+      if @is_completed
+        trigger_completed_on(block || wiretap)
+      end
+      self
+    end
+
+    def trigger_completed
+      return if @is_torn_down || @is_completed || @is_error
+      @is_completed = true
+
+      @completion_handlers.each do |block_or_wiretap|
+        trigger_completed_on(block_or_wiretap)
+      end
+
+      teardown
+      return self
+    end
+
+    def trigger_completed_on(block_or_wiretap)
+      if block_or_wiretap.is_a? Wiretap
+        block_or_wiretap.trigger_completed
+      else
+        enqueue do
+          block_or_wiretap.call
+        end
+      end
+    end
+
+    # called when an error occurs, and no more values are expected
+    def on_error(wiretap=nil, &block)
+      raise "Block or Wiretap is expected in #{self.class.name}##{__method__}" unless block || wiretap
+      raise "Only Block *or* Wiretap is expected in #{self.class.name}##{__method__}" if block && wiretap
+      @error_handlers << (block || wiretap)
+      if @is_error
+        trigger_error_on(block || wiretap, @is_error)
+      end
+      self
+    end
+
+    def trigger_error(error)
+      return if @is_torn_down || @is_completed || @is_error
+      error ||= true
+      @is_error = error
+
+      @error_handlers.each do |block_or_wiretap|
+        trigger_error_on(block_or_wiretap, error)
+      end
+
+      teardown
+      return self
+    end
+
+    def trigger_error_on(block_or_wiretap, error)
+      if block_or_wiretap.is_a? Wiretap
+        block_or_wiretap.trigger_error(error)
+      else
+        enqueue do
+          block_or_wiretap.call(error)
+        end
+      end
+    end
+
+    ##|
+    ##|  Wiretap Predicates
+    ##|
+
+    # Returns a Wiretap that will only be called if the &condition block returns
+    # true
+    def filter(&block)
+      return WiretapFilter.new(self, block)
+    end
+
+    # Returns a Wiretap that combines all the values into one value (the values
+    # are all passed in at the same time)
+    def combine(&block)
+      return WiretapCombiner.new(self, block)
+    end
+
+    # Returns a Wiretap that passes each value through the block, and also the
+    # previous return value (memo).
+    # @example
+    #     wiretap.reduce(0) do |memo, item|
+    #       memo + item.price
+    #     end
+    #     # returns the total of all the prices
+    def reduce(memo=nil, &block)
+      return WiretapReducer.new(self, memo, block)
+    end
+
+    # Returns a Wiretap that passes each value through the provided block
+    def map(&block)
+      return WiretapMapper.new(self, block)
+    end
+
+  end
+
+  class WiretapTarget < Wiretap
+    attr :target
+
+    def initialize(target, &block)
+      @target = target
+      super(&block)
+    end
+
+    def teardown
+      @target = nil
+      super
+    end
+
+  end
+
+  class WiretapKvo < WiretapTarget
+    attr :property
+    attr :value
+
+    def initialize(target, property, &block)
+      @property = property
+      @value = nil
+      @initial_is_set = false
+      super(target, &block)
+
+      @target.addObserver(self,
+        forKeyPath: property.to_s,
+        options: NSKeyValueObservingOptionNew | NSKeyValueObservingOptionInitial,
+        context: nil
+        )
+    end
+
+    def teardown
+      @target.removeObserver(self,
+        forKeyPath: @property.to_s
+        )
+      @property = nil
+      @value = nil
+      super
+    end
+
+    def trigger_changed(*values)
+      super(@value)
+    end
+
+    def bind_to(wiretap)
+      wiretap.listen do |value|
+        @target.send("#{@property}=", value)
+      end
+      wiretap.trigger_changed
+    end
+
+    def observeValueForKeyPath(path, ofObject: target, change: change, context: context)
+      @value = change[NSKeyValueChangeNewKey]
+      if @initial_is_set
+        trigger_changed(@value)
+      else
+        @initial_is_set = true
+      end
+    end
+
+  end
+
+  class WiretapArray < WiretapTarget
+    attr :targets
+
+    def initialize(targets, &block)
+      raise "Not only is listening to an empty array pointless, it will also cause errors" if targets.length == 0
+
+      # the complete trigger isn't called until all the wiretaps are complete
+      @uncompleted = targets.length
+
+      # targets can be an array of Wiretap objects (they will be monitored), or
+      # plain objects (they'll just be included in the sequence)
+      super(targets, &block)
+
+      # gets assigned to the wiretap value if it's a Wiretap, or the object
+      # itself if it is anything else.
+      @value = []
+      @initial_is_set = true
+      # maps the wiretap object (which is unique)
+      @wiretaps = {}
+
+      targets.each_with_index do |wiretap,index|
+        unless wiretap.is_a? Wiretap
+          @value << wiretap
+          # not a wiretap, so doesn't need to be "completed"
+          @uncompleted -= 1
+        else
+          raise "You cannot store a Wiretap twice in the same sequence (for now - do you really need this?)" if @wiretaps.key?(wiretap)
+          @wiretaps[wiretap] = index
+
+          @value << wiretap.value
+
+          wiretap.listen do |value|
+            indx = @wiretaps[wiretap]
+            @value[index] = wiretap.value
+            trigger_changed(*@value)
+          end
+
+          wiretap.on_error do |error|
+            trigger_error(error)
+          end
+
+          wiretap.and_then do |error|
+            @uncompleted -= 1
+            if @uncompleted == 0
+              trigger_completed
+            end
+          end
+        end
+      end
+    end
+
+    def teardown
+      super
+      @wiretaps = nil
+    end
+
+    def trigger_changed(*values)
+      values = @value if values.length == 0
+      super(*values)
+    end
+
+  end
+
+  class WiretapFilter < Wiretap
+
+    def initialize(parent, filter)
+      @parent = parent
+      @filter = filter
+
+      @parent.listen(self)
+
+      super()
+    end
+
+    # passes the values through the filter before passing up to the parent
+    # implementation
+    def trigger_changed(*values)
+      if ( @filter.call(*values) )
+        super(*values)
+      end
+    end
+
+    def teardown
+      super
+      @parent = nil
+    end
+
+  end
+
+  class WiretapCombiner < Wiretap
+
+    def initialize(parent, combiner)
+      @parent = parent
+      @combiner = combiner
+
+      @parent.listen(self)
+
+      super()
+    end
+
+    # passes the values through the combiner before passing up to the parent
+    # implementation
+    def trigger_changed(*values)
+      super(@combiner.call(*values))
+    end
+
+    def teardown
+      super
+      @parent = nil
+    end
+
+  end
+
+  class WiretapReducer < Wiretap
+
+    def initialize(parent, memo, reducer)
+      @parent = parent
+      @reducer = reducer
+      @memo = memo
+
+      @parent.listen(self)
+
+      super()
+    end
+
+    # passes each value through the @reducer, passing in the return value of the
+    # previous call (starting with @memo)
+    def trigger_changed(*values)
+      super(values.inject(@memo, &@reducer))
+    end
+
+    def teardown
+      super
+      @parent = nil
+    end
+
+  end
+
+  class WiretapMapper < Wiretap
+
+    def initialize(parent, mapper)
+      @parent = parent
+      @mapper = mapper
+
+      @parent.listen(self)
+
+      super()
+    end
+
+    # passes the values through the mapper before passing up to the parent
+    # implementation
+    def trigger_changed(*values)
+      super(*values.map { |value| @mapper.call(value) })
+    end
+
+    def teardown
+      super
+      @parent = nil
+    end
+
+  end
+
+  class WiretapProc < WiretapTarget
+
+    def initialize(target, queue=nil, &block)
+      @started = false
+      super(target, &block)
+      queue(queue) if queue
+    end
+
+    def queue(queue)
+      super
+      start
+    end
+
+    def start
+      unless @started
+        @started = true
+        enqueue do
+          begin
+            trigger_changed(@target.call)
+          rescue Exception => error
+            trigger_error(error)
+          else
+            trigger_completed
+          end
+        end
+      end
+    end
+
+
+    def listen(wiretap=nil, &block)
+      raise "WiretapProc does not support listeners (only the `completed` event is triggered)"
+    end
+
+    def and_then(wiretap=nil, &block)
+      super
+      start
+    end
+
+  end
+
+end

data/lib/motion-wiretap/all/wiretap_exts.rb

@@ -0,0 +1,30 @@
+class NSObject
+  attr_accessor :motion_wiretap_observers
+
+  def wiretap(property, &block)
+    MotionWiretap::WiretapKvo.new(self, property, &block)
+  end
+
+end
+
+
+class NSArray
+
+  def wiretap(property=nil, &block)
+    raise "`wiretap` is not supported on Arrays (arrays are not observable).  You probably meant to use `wiretaps`."
+  end
+
+  def wiretaps(&block)
+    MotionWiretap::WiretapArray.new(self, &block)
+  end
+
+end
+
+
+class Proc
+
+  def wiretap(queue=nil, &block)
+    MotionWiretap::WiretapProc(queue, &block)
+  end
+
+end

data/lib/motion-wiretap/ios/wiretap_control_events.rb

@@ -0,0 +1,84 @@
+module MotionWiretap
+  class ControlEventNotFound < Exception
+  end
+
+  # Some UIControlEvent translators.  Based on SugarCube's uicontroleevent
+  # constants.
+  module ControlEvents
+    module_function
+
+    def convert(control_events)
+      return control_events if control_events.is_a? Fixnum
+
+      case control_events
+      when NSArray
+        retval = 0
+        control_events.each do |event|
+          begin
+            retval |= ControlEvents.convert(event)
+          rescue ControlEventNotFound
+            raise "Could not merge control event #{event.inspect}"
+          end
+        end
+        return retval
+      when :touch
+        return UIControlEventTouchUpInside
+      when :touch_up
+        return UIControlEventTouchUpInside
+      when :touch_down
+        return UIControlEventTouchDown
+      when :touch_start
+        return UIControlEventTouchDown | UIControlEventTouchDragEnter
+      when :touch_stop
+        return UIControlEventTouchUpInside | UIControlEventTouchCancel | UIControlEventTouchDragExit
+      when :change
+        return UIControlEventValueChanged | UIControlEventEditingChanged
+      when :begin
+        return UIControlEventEditingDidBegin
+      when :end
+        return UIControlEventEditingDidEnd
+      when :touch_down_repeat
+        return UIControlEventTouchDownRepeat
+      when :touch_drag_inside
+        return UIControlEventTouchDragInside
+      when :touch_drag_outside
+        return UIControlEventTouchDragOutside
+      when :touch_drag_enter
+        return UIControlEventTouchDragEnter
+      when :touch_drag_exit
+        return UIControlEventTouchDragExit
+      when :touch_up_inside
+        return UIControlEventTouchUpInside
+      when :touch_up_outside
+        return UIControlEventTouchUpOutside
+      when :touch_cancel
+        return UIControlEventTouchCancel
+      when :value_changed
+        return UIControlEventValueChanged
+      when :editing_did_begin
+        return UIControlEventEditingDidBegin
+      when :editing_changed
+        return UIControlEventEditingChanged
+      when :editing_did_change
+        return UIControlEventEditingChanged
+      when :editing_did_end
+        return UIControlEventEditingDidEnd
+      when :editing_did_end_on_exit
+        return UIControlEventEditingDidEndOnExit
+      when :all_touch
+        return UIControlEventAllTouchEvents
+      when :all_editing
+        return UIControlEventAllEditingEvents
+      when :application
+        return UIControlEventApplicationReserved
+      when :system
+        return UIControlEventSystemReserved
+      when :all
+        return UIControlEventAllEvents
+      else
+        raise ControlEventNotFound.new
+      end
+    end
+
+  end
+end

data/lib/motion-wiretap/ios/wiretap_exts_ios.rb

@@ -0,0 +1,24 @@
+class UIView
+
+  def wiretap(property=nil, &block)
+    if property.nil?
+      MotionWiretap::WiretapView.new(self, &block)
+    else
+      MotionWiretap::WiretapKvo.new(self, property, &block)
+    end
+  end
+
+end
+
+
+class UIControl
+
+  def wiretap(property=nil, &block)
+    if property.nil?
+      MotionWiretap::WiretapControl.new(self, &block)
+    else
+      MotionWiretap::WiretapKvo.new(self, property, &block)
+    end
+  end
+
+end

data/lib/motion-wiretap/ios/wiretap_gestures.rb

@@ -0,0 +1,143 @@
+module MotionWiretap
+  # Some gesture recognizer translators.  Based on SugarCube's gesture recognizer
+  # methods.
+  module Gestures
+    module_function
+
+    # @yield [recognizer] Handles the gesture event, and passes the recognizer instance to the block.
+    # @overload tap(taps)
+    #   @param taps [Fixnum] Number of taps
+    # @overload tap(options)
+    #   @option options [Fixnum] :taps Number of taps before gesture is recognized
+    #   @option options [Fixnum] :fingers Number of fingers before gesture is recognized
+    def tap(target, taps_or_options=nil)
+      taps = nil
+      fingers = nil
+
+      if taps_or_options
+        if taps_or_options.is_a? Hash
+          taps = taps_or_options[:taps] || taps
+          fingers = taps_or_options[:fingers] || fingers
+        else
+          taps = taps_or_options
+        end
+      end
+
+      recognizer = UITapGestureRecognizer.alloc.initWithTarget(target, action:'handle_gesture:')
+      recognizer.numberOfTapsRequired = taps if taps
+      recognizer.numberOfTouchesRequired = fingers if fingers
+      return recognizer
+    end
+
+    # @yield [recognizer] Handles the gesture event, and passes the recognizer instance to the block.
+    def pinch(target)
+      recognizer = UIPinchGestureRecognizer.alloc.initWithTarget(target, action:'handle_gesture:')
+      return recognizer
+    end
+
+    # @yield [recognizer] Handles the gesture event, and passes the recognizer instance to the block.
+    def rotate(target)
+      recognizer = UIRotationGestureRecognizer.alloc.initWithTarget(target, action:'handle_gesture:')
+      return recognizer
+    end
+
+    # @yield [recognizer] Handles the gesture event, and passes the recognizer instance to the block.
+    # @overload swipe(taps)
+    #   @param direction [Fixnum] Direction of swipe
+    # @overload swipe(options)
+    #   @option options [Fixnum] :fingers Number of fingers before gesture is recognized
+    #   @option options [Fixnum, Symbol] :direction Direction of swipe, as a UISwipeGestureRecognizerDirection constant or a symbol (`:left, :right, :up, :down`)
+    def swipe(target, direction_or_options)
+      direction = nil
+      fingers = nil
+
+      if direction_or_options
+        if direction_or_options.is_a? Hash
+          direction = direction_or_options[:direction] || direction
+          fingers = direction_or_options[:fingers] || fingers
+        else
+          direction = direction_or_options
+        end
+      end
+
+      case direction
+      when :left
+        direction = UISwipeGestureRecognizerDirectionLeft
+      when :right
+        direction = UISwipeGestureRecognizerDirectionRight
+      when :up
+        direction = UISwipeGestureRecognizerDirectionUp
+      when :down
+        direction = UISwipeGestureRecognizerDirectionDown
+      end
+
+      recognizer = UISwipeGestureRecognizer.alloc.initWithTarget(target, action:'handle_gesture:')
+      recognizer.direction = direction if direction
+      recognizer.numberOfTouchesRequired = fingers if fingers
+      return recognizer
+    end
+
+    # @yield [recognizer] Handles the gesture event, and passes the recognizer instance to the block.
+    # @overload tap(taps)
+    #   @param taps [Fixnum] Number of taps
+    # @overload tap(options)
+    #   @option options [Fixnum] :min_fingers Minimum umber of fingers for gesture to be recognized
+    #   @option options [Fixnum] :max_fingers Maximum number of fingers for gesture to be recognized
+    #   @option options [Fixnum] :fingers If min_fingers or max_fingers is not assigned, this will be the default.
+    def pan(target, fingers_or_options=nil)
+      fingers = nil
+      min_fingers = nil
+      max_fingers = nil
+
+      if fingers_or_options
+        if fingers_or_options.is_a? Hash
+          fingers = fingers_or_options[:fingers] || fingers
+          min_fingers = fingers_or_options[:min_fingers] || min_fingers
+          max_fingers = fingers_or_options[:max_fingers] || max_fingers
+        else
+          fingers = fingers_or_options
+        end
+      end
+
+      # if fingers is assigned, but not min/max, assign it as a default
+      min_fingers ||= fingers
+      max_fingers ||= fingers
+
+      recognizer = UIPanGestureRecognizer.alloc.initWithTarget(target, action:'handle_gesture:')
+      recognizer.maximumNumberOfTouches = min_fingers if min_fingers
+      recognizer.minimumNumberOfTouches = max_fingers if max_fingers
+      return recognizer
+    end
+
+    # @yield [recognizer] Handles the gesture event, and passes the recognizer instance to the block.
+    # @overload press(duration)
+    #   @param duration [Fixnum] How long in seconds before gesture is recognized
+    # @overload press(options)
+    #   @option options [Fixnum] :duration How long in seconds before gesture is recognized
+    #   @option options [Fixnum] :taps Number of taps before gesture is recognized
+    #   @option options [Fixnum] :fingers Number of fingers before gesture is recognized
+    def press(target, duration_or_options=nil)
+      duration = nil
+      taps = nil
+      fingers = nil
+
+      if duration_or_options
+        if duration_or_options.is_a? Hash
+          duration = duration_or_options[:duration] || duration
+          taps = duration_or_options[:taps] || taps
+          fingers = duration_or_options[:fingers] || fingers
+        else
+          duration = duration_or_options
+        end
+      end
+
+      recognizer = UILongPressGestureRecognizer.alloc.initWithTarget(target, action:'handle_gesture:')
+      recognizer.minimumPressDuration = duration if duration
+      recognizer.numberOfTapsRequired = taps if taps
+      recognizer.numberOfTouchesRequired = fingers if fingers
+      return recognizer
+    end
+
+  end
+
+end

data/lib/motion-wiretap/ios/wiretap_ios.rb

@@ -0,0 +1,55 @@
+module MotionWiretap
+
+  class WiretapView < WiretapTarget
+
+    def on(recognizer, options=nil, &block)
+      case recognizer
+      when :tap
+        recognizer = MotionWiretap::Gestures.tap(self, options)
+      when :pinch
+        recognizer = MotionWiretap::Gestures.pinch(self, options)
+      when :rotate
+        recognizer = MotionWiretap::Gestures.rotate(self, options)
+      when :swipe
+        recognizer = MotionWiretap::Gestures.swipe(self, options)
+      when :pan
+        recognizer = MotionWiretap::Gestures.pan(self, options)
+      when :press
+        recognizer = MotionWiretap::Gestures.press(self, options)
+      end
+
+      self.target.addGestureRecognizer(recognizer)
+      listen(&block) if block
+      return self
+    end
+
+    def handle_gesture(recognizer)
+      trigger_changed
+    end
+
+  end
+
+  class WiretapControl < WiretapView
+
+    # control_event can be any UIControlEventconstant, or any symbol found in
+    # wiretap_control_events.rb, or an array of UIControlEvent constants or
+    # symbols.
+    def on(control_event, options={}, &block)
+      begin
+        control_event = ControlEvents.convert(control_event)
+        self.target.addTarget(self, action:'handle_event:', forControlEvents:control_event)
+        listen(&block) if block
+      rescue ControlEventNotFound
+        super(control_event, options, &block)
+      end
+
+      return self
+    end
+
+    def handle_event(event)
+      trigger_changed
+    end
+
+  end
+
+end

data/lib/motion-wiretap/osx/wiretap_exts_osx.rb

@@ -0,0 +1,7 @@
+class NSView
+
+  def wiretap(property, &block)
+    MotionWiretap::WiretapView.new(self, property, &block)
+  end
+
+end

data/lib/motion-wiretap/osx/wiretap_osx.rb

@@ -0,0 +1,6 @@
+module MotionWiretap
+
+  class WiretapView < WiretapKvo
+  end
+
+end

data/lib/motion-wiretap/version.rb

@@ -0,0 +1,3 @@
+module MotionWiretap
+  Version = '0.1.0'
+end

data/motion-wiretap.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/motion-wiretap/version.rb', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = 'motion-wiretap'
+  gem.version       = MotionWiretap::Version
+
+  gem.authors = ['Colin T.A. Gray']
+  gem.email   = ['colinta@gmail.com']
+  gem.summary     = %{It's like ReactiveCocoa, but in RubyMotion}
+  gem.description = <<-DESC
+ReactiveCocoa is an amazing system, and RubyMotion could benefit from the
+lessons learned there!
+
+Motion-Wiretap is, essentially, a wrapper for Key-Value coding and observation.
+It exposes a +Wiretap+ class that you can use as a signal, or add listeners to
+it.
+
+Extensions are provided to listen to an +Array+ of +Wiretap+ objects, and the
+`UIKit`/`AppKit` classes are augmented to provide actions as events (gestures,
+mouse events, value changes).
+DESC
+
+  gem.homepage    = 'https://github.com/colinta/motion-wiretap'
+
+  gem.files        = Dir.glob('lib/motion-wiretap/**/*.rb') + ['README.md', 'motion-wiretap.gemspec']
+  gem.test_files   = gem.files.grep(%r{^spec/})
+
+  gem.require_paths = ['lib']
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: motion-wiretap
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Colin T.A. Gray
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-16 00:00:00.000000000 Z
+dependencies: []
+description: ! 'ReactiveCocoa is an amazing system, and RubyMotion could benefit from
+  the
+
+  lessons learned there!
+
+
+  Motion-Wiretap is, essentially, a wrapper for Key-Value coding and observation.
+
+  It exposes a +Wiretap+ class that you can use as a signal, or add listeners to
+
+  it.
+
+
+  Extensions are provided to listen to an +Array+ of +Wiretap+ objects, and the
+
+  `UIKit`/`AppKit` classes are augmented to provide actions as events (gestures,
+
+  mouse events, value changes).
+
+'
+email:
+- colinta@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/motion-wiretap/all/signal.rb
+- lib/motion-wiretap/all/wiretap.rb
+- lib/motion-wiretap/all/wiretap_exts.rb
+- lib/motion-wiretap/ios/wiretap_control_events.rb
+- lib/motion-wiretap/ios/wiretap_exts_ios.rb
+- lib/motion-wiretap/ios/wiretap_gestures.rb
+- lib/motion-wiretap/ios/wiretap_ios.rb
+- lib/motion-wiretap/osx/wiretap_exts_osx.rb
+- lib/motion-wiretap/osx/wiretap_osx.rb
+- lib/motion-wiretap/version.rb
+- README.md
+- motion-wiretap.gemspec
+homepage: https://github.com/colinta/motion-wiretap
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: It's like ReactiveCocoa, but in RubyMotion
+test_files: []