bubble-wrap 1.0.0 → 1.1.0

data/motion/location/location.rb

@@ -0,0 +1,152 @@
+# Provides a nice DSL for interacting with the standard
+# CLLocationManager
+#
+module BubbleWrap
+  module CLLocationWrap
+
+    def latitude
+      self.coordinate.latitude
+    end
+
+    def longitude
+      self.coordinate.longitude
+    end
+  end
+
+  module Location
+    module Error
+      DISABLED=0
+      PERMISSION_DENIED=1
+      NETWORK_FAILURE=2
+      LOCATION_UNKNOWN=3
+    end
+
+    module_function
+    # Start getting locations
+    # @param [Hash] options = {
+    #   significant: true/false; whether to listen for significant location changes or
+    #     all location changes (see Apple docs for info); default == false
+    #   distance_filter:  minimum change in distance to be updated about, in meters;
+    #     default == uses KCLDistanceFilterNone,
+    #   desired_accuracy: minimum accuracy for updates to arrive; 
+    #     any of :best_for_navigation, :best, :nearest_ten_meters,
+    #     :hundred_meters, :kilometer, or :three_kilometers; default == :best
+    #   purpose: string to display when the system asks user for location,
+    #   retries: if location cant be found. how many errors do we retry; default == 5
+    # }
+    # @block for callback. takes one argument, `result`.
+    #   - On error or cancelled, is called with a hash {error: BW::Location::Error::<Type>}
+    #   - On success, is called with a hash {to: #<CLLocation>, from: #<CLLocation>}
+    # 
+    # Example
+    # BW::Location.get(distance_filter: 10, desired_accuracy: :nearest_ten_meters) do |result|
+    #   result[:to].class == CLLocation
+    #   result[:from].class == CLLocation
+    #   p "Lat #{result[:to].latitude}, Long #{result[:to].longitude}"
+    # end
+    def get(options = {}, &block)
+      @callback = block
+      @options = options
+
+      @options[:significant] = false if @options[:significant].nil?
+      @options[:distance_filter] ||= KCLDistanceFilterNone
+      @options[:desired_accuracy] ||= KCLLocationAccuracyBest
+      @options[:retries] ||= 5
+      @retries = 0
+
+      if not enabled?
+        error(Error::DISABLED) and return
+      end
+
+      self.location_manager.distanceFilter = @options[:distance_filter]
+      self.location_manager.desiredAccuracy = const_int_get("KCLLocationAccuracy", @options[:desired_accuracy])
+      self.location_manager.purpose = @options[:purpose] if @options[:purpose]
+
+      if @options[:significant]
+        self.location_manager.startMonitoringSignificantLocationChanges
+      else
+        self.location_manager.startUpdatingLocation
+      end
+    end
+
+    def get_significant(options = {}, &block)
+      get(options.merge(significant: true), &block)
+    end
+
+    # Stop getting locations
+    def stop
+      if @options[:significant]
+        self.location_manager.stopMonitoringSignificantLocationChanges
+      else
+        self.location_manager.stopUpdatingLocation
+      end
+    end
+
+    def location_manager
+      @location_manager ||= CLLocationManager.alloc.init
+      @location_manager.delegate ||= self
+      @location_manager
+    end
+
+    # returns true/false whether services are enabled for the _device_
+    def enabled?
+      CLLocationManager.locationServicesEnabled
+    end
+
+    def error(type)
+      @callback && @callback.call({ error: type })
+      @callback = nil
+      self.location_manager.stopUpdatingLocation
+    end
+
+    ##########
+    # CLLocationManagerDelegate Methods
+    def locationManager(manager, didUpdateToLocation:newLocation, fromLocation:oldLocation)
+      @callback.call({to: newLocation, from: oldLocation})
+    end
+
+    def locationManager(manager, didFailWithError:error)
+      if error.domain == KCLErrorDomain
+        case error.code
+        when KCLErrorDenied
+          error(Error::PERMISSION_DENIED)
+        when KCLErrorLocationUnknown
+          # Docs specify that this is a temporary error,
+          # so we stop/start updating to try again.
+          @retries += 1
+          if @retries > @options[:retries]
+            error(Error::LOCATION_UNKNOWN)
+          else
+            self.locationManager.stopUpdatingLocation
+            self.locationManager.startUpdatingLocation
+          end
+        when KCLErrorNetwork
+          error(Error::NETWORK_FAILURE)
+        end
+      end
+    end
+
+    def locationManager(manager, didChangeAuthorizationStatus:status)
+      case status
+      when KCLAuthorizationStatusRestricted
+        error(Error::PERMISSION_DENIED)
+      when KCLAuthorizationStatusDenied
+        error(Error::PERMISSION_DENIED)
+      end
+    end
+
+    def const_int_get(base, value)
+      return value if value.is_a? Numeric
+      value = value.to_s.camelize
+      Kernel.const_get("#{base}#{value}")
+    end
+
+    def load_constants_hack
+      [KCLLocationAccuracyBestForNavigation, KCLLocationAccuracyBest,
+        KCLLocationAccuracyNearestTenMeters, KCLLocationAccuracyHundredMeters,
+        KCLLocationAccuracyKilometer, KCLLocationAccuracyThreeKilometers,
+      ]
+    end
+  end
+end
+::Location = BubbleWrap::Location

data/motion/location/pollute.rb

@@ -0,0 +1,5 @@
+[
+  [CLLocation, BubbleWrap::CLLocationWrap],
+].each do |base, wrapper|
+    base.send(:include, wrapper)
+end

data/motion/reactor.rb

@@ -0,0 +1,105 @@
+module BubbleWrap
+  module Reactor
+    module_function
+
+    # Always returns true - for compatibility with EM
+    def reactor_running?
+      true
+    end
+    alias reactor_thread? reactor_running?
+
+    # Call `callback` or the passed block in `interval` seconds.
+    # Returns a timer signature that can be passed into
+    # `cancel_timer`
+    def add_timer(interval, callback=nil, &blk)
+      @timers ||= {}
+      timer = Timer.new(interval,callback,&blk)
+      timer.on(:fired) do
+        @timers.delete(timer.object_id)
+      end
+      timer.on(:cancelled) do
+        @timers.delete(timer.object_id)
+      end
+      @timers[timer.object_id] = timer
+      timer.object_id
+    end
+
+    # Cancel a timer by passing in either a Timer object or
+    # a timer id (as returned by `add_timer` and
+    # `add_periodic_timer`).
+    def cancel_timer(timer)
+      return timer.cancel if timer.respond_to?(:cancel)
+      @timers ||= {}
+      return @timers[timer].cancel if @timers[timer]
+      false
+    end
+
+    # Call `callback` or the passed block every `interval` seconds.
+    # Returns a timer signature that can be passed into
+    # `cancel_timer`
+    def add_periodic_timer(interval, callback=nil, &blk)
+      @timers ||= {}
+      timer = PeriodicTimer.new(interval,callback,&blk)
+      timer.on(:cancelled) do
+        @timers.delete(timer)
+      end
+      @timers[timer.object_id] = timer
+      timer.object_id
+    end
+
+    # Defer is for integrating blocking operations into the reactor's control
+    # flow.
+    # Call defer with one or two blocks, the second block is optional.
+    #     operator = proc do
+    #       # perform a long running operation here
+    #       "result"
+    #     end
+    #     callback = proc do |result|
+    #       # do something with the result here, such as trigger a UI change
+    #     end
+    #     BubbleWrap::Reactor.defer(operation,callback)
+    # The action of `defer` is to take the block specified in the first
+    # parameter (the "operation") and schedule it for asynchronous execution
+    # on a GCD concurrency queue. When the operation completes the result (if any)
+    # is passed into the callback (if present).
+    def defer(op=nil,cb=nil,&blk) 
+      schedule do
+        result = (op||blk).call
+        schedule(result, &cb) if cb
+      end
+    end
+
+    # A version of `defer` which schedules both the operator
+    # and callback operations on the application's main thread.
+    def defer_on_main(op=nil,cb=nil,&blk) 
+      schedule_on_main do
+        result = (op||blk).call
+        schedule_on_main(result, &cb) if cb
+      end
+    end
+
+    # Schedule a block for execution on the reactor queue.
+    def schedule(*args, &blk)
+      @queue ||= ::Dispatch::Queue.concurrent("#{NSBundle.mainBundle.bundleIdentifier}.reactor")
+
+      cb = proc do
+        blk.call(*args)
+      end
+      @queue.async &cb
+      nil
+    end
+
+    # Schedule a block for execution on your application's main thread.
+    # This is useful as UI updates need to be executed from the main
+    # thread.
+    def schedule_on_main(*args, &blk)
+      cb = proc do
+        blk.call(*args)
+      end
+      ::Dispatch::Queue.main.async &cb
+    end
+    
+  end
+end
+
+::EM = ::BubbleWrap::Reactor # Yes I dare!

data/motion/reactor/default_deferrable.rb

@@ -0,0 +1,9 @@
+module BubbleWrap
+  module Reactor
+    # A basic class which includes Deferrable when all
+    # you need is a deferrable without any added behaviour.
+    class DefaultDeferrable
+      include ::BubbleWrap::Reactor::Deferrable
+    end
+  end
+end

data/motion/reactor/deferrable.rb

@@ -0,0 +1,126 @@
+module BubbleWrap
+  module Reactor
+    # Provides a mixin for deferrable jobs.
+    module Deferrable
+
+      # def self.included(base)
+      #   base.extend ::BubbleWrap::Reactor::Future
+      # end
+
+      # Specify a block to be executed if and when the Deferrable object 
+      # receives a status of :succeeded. See set_deferred_status for more 
+      # information.
+      # Calling this method on a Deferrable object whose status is not yet 
+      # known will cause the callback block to be stored on an internal 
+      # list. If you call this method on a Deferrable whose status is 
+      # :succeeded, the block will be executed immediately, receiving 
+      # the parameters given to the prior set_deferred_status call.
+      def callback(&blk)
+        return unless blk
+        @deferred_status ||= :unknown
+        if @deferred_status == :succeeded
+          blk.call(*@deferred_args)
+        elsif @deferred_status != :failed
+          @callbacks ||= []
+          @callbacks.unshift blk
+        end
+      end
+
+      # Cancels an outstanding timeout if any. Undoes the action of timeout.
+      def cancel_timeout
+        @deferred_timeout ||= nil
+        if @deferred_timeout
+          @deferred_timeout.cancel
+          @deferred_timeout = nil
+        end
+      end
+
+      # Specify a block to be executed if and when the Deferrable object 
+      # receives a status of :failed. See set_deferred_status for more 
+      # information.
+      def errback(&blk)
+        return unless blk
+        @deferred_status ||= :unknown
+        if @deferred_status == :failed
+          blk.call(*@deferred_args)
+        elsif @deferred_status != :succeeded
+          @errbacks ||= []
+          @errbacks.unshift blk 
+        end
+      end
+
+      # Sugar for set_deferred_status(:failed, …)
+      def fail(*args)
+        set_deferred_status :failed, *args
+      end
+      alias set_deferred_failure fail
+
+      # Sets the “disposition” (status) of the Deferrable object. See also 
+      # the large set of sugarings for this method. Note that if you call 
+      # this method without arguments, no arguments will be passed to the 
+      # callback/errback. If the user has coded these with arguments, 
+      # then the user code will throw an argument exception. Implementors 
+      # of deferrable classes must document the arguments they will supply 
+      # to user callbacks.
+      # OBSERVE SOMETHING VERY SPECIAL here: you may call this method even 
+      # on the INSIDE of a callback. This is very useful when a 
+      # previously-registered callback wants to change the parameters that 
+      # will be passed to subsequently-registered ones.
+      # You may give either :succeeded or :failed as the status argument.
+      # If you pass :succeeded, then all of the blocks passed to the object 
+      # using the callback method (if any) will be executed BEFORE the 
+      # set_deferred_status method returns. All of the blocks passed to the 
+      # object using errback will be discarded.
+      # If you pass :failed, then all of the blocks passed to the object 
+      # using the errback method (if any) will be executed BEFORE the 
+      # set_deferred_status method returns. All of the blocks passed to the 
+      # object using # callback will be discarded.
+      # If you pass any arguments to set_deferred_status in addition to the 
+      # status argument, they will be passed as arguments to any callbacks 
+      # or errbacks that are executed. It’s your responsibility to ensure 
+      # that the argument lists specified in your callbacks and errbacks match 
+      # the arguments given in calls to set_deferred_status, otherwise Ruby 
+      # will raise an ArgumentError.
+      def set_deferred_status(status, *args)
+        cancel_timeout
+        @errbacks ||= nil
+        @callbacks ||= nil
+        @deferred_status = status
+        @deferred_args = args
+        case @deferred_status
+        when :succeeded
+          if @callbacks
+            while cb = @callbacks.pop
+              cb.call(*@deferred_args)
+            end
+          end
+          @errbacks.clear if @errbacks
+        when :failed
+          if @errbacks
+            while eb = @errbacks.pop
+              eb.call(*@deferred_args)
+            end
+          end
+          @callbacks.clear if @callbacks
+        end
+      end
+
+      # Sugar for set_deferred_status(:succeeded, …)
+      def succeed(*args)
+        set_deferred_status :succeeded, *args
+      end
+      alias set_deferred_success succeed
+
+      # Setting a timeout on a Deferrable causes it to go into the failed 
+      # state after the Timeout expires (passing no arguments to the object’s 
+      # errbacks). Setting the status at any time prior to a call to the 
+      # expiration of the timeout will cause the timer to be cancelled.
+      def timeout(seconds)
+        cancel_timeout
+        me = self
+        @deferred_timeout = Timer.new(seconds) {me.fail}
+      end
+
+    end
+  end
+end

data/motion/reactor/eventable.rb

@@ -0,0 +1,24 @@
+module BubbleWrap
+  module Reactor
+    # A simple mixin that adds events to your object.
+    module Eventable
+
+      # When `event` is triggered the block will execute
+      # and be passed the arguments that are passed to
+      # `trigger`.
+      def on(event, &blk)
+        @events ||= Hash.new { |h,k| h[k] = [] }
+        @events[event].push blk
+      end
+
+      # Trigger an event
+      def trigger(event, *args)
+        @events ||= Hash.new { |h,k| h[k] = [] }
+        @events[event].map do |event|
+          event.call(*args)
+        end
+      end
+
+    end
+  end
+end

data/motion/reactor/future.rb

@@ -0,0 +1,22 @@
+module BubbleWrap
+  module Reactor
+    module Future
+
+      # A future is a sugaring of a typical deferrable usage.
+      def future arg, cb=nil, eb=nil, &blk
+        arg = arg.call if arg.respond_to?(:call)
+
+        if arg.respond_to?(:set_deferred_status)
+          if cb || eb
+            arg.callback(&cb) if cb
+            arg.errback(&eb) if eb
+          else
+            arg.callback(&blk) if blk
+          end
+        end
+
+        arg
+      end
+    end
+  end
+end