bubble-wrap 1.0.0 → 1.1.0

data/Rakefile

@@ -4,12 +4,17 @@ require 'motion/project'
 Bundler.setup
 Bundler.require
 
+require 'bubble-wrap/all'
 require 'bubble-wrap/test'
 
 Motion::Project::App.setup do |app|
   app.name = 'testSuite'
   app.identifier = 'io.bubblewrap.testSuite'
-  app.specs_dir = './spec/motion'
+  app.specs_dir = './spec/motion/'
+  # Hold your breath, we're going API spelunking!
+  spec_files = app.spec_files + Dir.glob(File.join(app.specs_dir, '**/*.rb'))
+  spec_files.uniq!
+  app.instance_variable_set(:@spec_files, spec_files)
 end
 
 namespace :spec do
@@ -21,4 +26,3 @@ namespace :spec do
 
   task :all => [:lib, :motion]
 end
-

data/lib/bubble-wrap.rb

@@ -1,4 +1,3 @@
 require "bubble-wrap/version" unless defined?(BubbleWrap::VERSION)
-require File.expand_path('../bubble-wrap/loader', __FILE__)
 require File.expand_path('../bubble-wrap/core', __FILE__)
 require File.expand_path('../bubble-wrap/http', __FILE__)

data/lib/bubble-wrap/all.rb

@@ -0,0 +1,4 @@
+require File.expand_path('../loader', __FILE__)
+['core', 'http', 'reactor', 'rss_parser', 'ui', 'location'].each { |sub|
+	require File.expand_path("../#{sub}", __FILE__)
+}

data/lib/bubble-wrap/camera.rb

@@ -0,0 +1,7 @@
+require 'bubble-wrap/loader'
+BubbleWrap.require('motion/core/device.rb')
+BubbleWrap.require('motion/core/device/**/*.rb') do
+  file('motion/core/device/camera_wrapper.rb').depends_on 'motion/core/device/camera.rb'
+  file('motion/core/device/camera.rb').depends_on 'motion/core/device.rb'
+  file('motion/core/device/screen.rb').depends_on 'motion/core/device.rb'
+end

data/lib/bubble-wrap/core.rb

@@ -1,7 +1,8 @@
 require 'bubble-wrap/loader'
 BubbleWrap.require('motion/core.rb')
-BubbleWrap.require('motion/core/**/*.rb') do 
+BubbleWrap.require('motion/core/**/*.rb') do
+  file('motion/core/device/camera.rb').depends_on 'motion/core/device.rb'
   file('motion/core/device/screen.rb').depends_on 'motion/core/device.rb'
   file('motion/core/pollute.rb').depends_on 'motion/core/ns_index_path.rb'
-  file('motion/core/pollute.rb').depends_on 'motion/core/ui_control.rb'
 end
+require 'bubble-wrap/ui'

data/lib/bubble-wrap/ext/motion_project_app.rb

@@ -6,9 +6,9 @@ module BubbleWrap
         base.instance_eval do
           def setup_with_bubblewrap(&block)
             bw_config = proc do |app|
-              app.files = (::BubbleWrap::Requirement.files + (app.files||[])).uniq
+              app.files = ::BubbleWrap::Requirement.files(app.files)
               app.files_dependencies ::BubbleWrap::Requirement.files_dependencies
-              app.frameworks = (::BubbleWrap::Requirement.frameworks + (app.frameworks||[])).uniq
+              app.frameworks = ::BubbleWrap::Requirement.frameworks(app.frameworks)
               block.call(app) unless block.nil?
             end
             configs.each_value &bw_config

data/lib/bubble-wrap/http.rb

@@ -1,2 +1,3 @@
 require 'bubble-wrap/loader'
+BubbleWrap.require('motion/core/ns_url_request.rb')
 BubbleWrap.require('motion/http.rb')

data/lib/bubble-wrap/loader.rb

@@ -2,22 +2,29 @@ unless defined?(Motion::Project::Config)
   raise "This file must be required within a RubyMotion project Rakefile."
 end
 
-require 'bubble-wrap/version'
-require 'bubble-wrap/ext'
-require 'bubble-wrap/requirement'
+unless defined?(BubbleWrap::LOADER_PRESENT)
 
-module BubbleWrap
+  require 'bubble-wrap/version' unless defined?(VERSION)
+  require 'bubble-wrap/ext'
+  require 'bubble-wrap/requirement'
 
-  module_function
+  module BubbleWrap
 
-  def root
-    File.expand_path('../../../', __FILE__)
-  end
+    LOADER_PRESENT=true
+    module_function
+
+    def root
+      File.expand_path('../../../', __FILE__)
+    end
+
+    def require(file_spec, &block)
+      Requirement.scan(caller.first, file_spec, &block)
+    end
 
-  def require(file_spec, &block)
-    Requirement.scan(caller.first, file_spec, &block)
   end
 
-end
+  BW = BubbleWrap unless defined?(BW)
 
-BW = BubbleWrap
+  BW.require 'motion/shortcut.rb'
+  
+end

data/lib/bubble-wrap/location.rb

@@ -0,0 +1,6 @@
+require 'bubble-wrap/loader'
+BubbleWrap.require('motion/core/string.rb')
+BubbleWrap.require('motion/location/**/*.rb') do
+  file('motion/location/pollute.rb').depends_on 'motion/location/location.rb'
+  file('motion/location/location.rb').uses_framework('CoreLocation')
+end

data/lib/bubble-wrap/reactor.rb

@@ -0,0 +1,10 @@
+require 'bubble-wrap/loader'
+
+BW.require 'motion/reactor.rb'
+BW.require 'motion/reactor/**/*.rb' do
+  file('motion/reactor.rb').depends_on Dir.glob('motion/reactor/**/*.rb')
+  file('motion/reactor/timer.rb').depends_on 'motion/reactor/eventable.rb'
+  file('motion/reactor/periodic_timer.rb').depends_on 'motion/reactor/eventable.rb'
+  file('motion/reactor/deferrable.rb').depends_on ['motion/reactor/timer.rb', 'motion/reactor/future.rb']
+  file('motion/reactor/default_deferrable.rb').depends_on 'motion/reactor/deferrable.rb'
+end

data/lib/bubble-wrap/requirement.rb

@@ -57,6 +57,7 @@ module BubbleWrap
         Dir.glob(File.expand_path(file_spec, root)).each do |file|
           p = new(file,root)
           self.paths[p.relative] = p
+          p.depends_on('motion/shortcut.rb') unless p.relative == 'motion/shortcut.rb'
         end
         self.class_eval(&block) if block
       end
@@ -65,8 +66,14 @@ module BubbleWrap
         paths.fetch(relative)
       end
 
-      def files
-        paths.values.map(&:to_s)
+      def files(app_files=nil)
+        files = paths.values.map(&:to_s)
+        files += app_files if app_files
+        files.uniq
+      end
+
+      def clear!
+        paths.select! { |k,v| v.relative == 'motion/shortcut.rb' }
       end
 
       def files_dependencies
@@ -77,9 +84,10 @@ module BubbleWrap
         deps
       end
 
-      def frameworks
+      def frameworks(app_frameworks=nil)
         frameworks = ['UIKit', 'Foundation', 'CoreGraphics'] +
           paths.values.map(&:frameworks)
+        frameworks += app_frameworks if app_frameworks
         frameworks.flatten.compact.sort.uniq
       end
 

data/lib/bubble-wrap/rss_parser.rb

@@ -0,0 +1,2 @@
+require 'bubble-wrap/loader'
+BubbleWrap.require('motion/rss_parser.rb')

data/lib/bubble-wrap/ui.rb

@@ -0,0 +1,4 @@
+require 'bubble-wrap/loader'
+BubbleWrap.require('motion/ui/**/*.rb') do 
+  file('motion/ui/pollute.rb').depends_on 'motion/ui/ui_control.rb'
+end

data/lib/bubble-wrap/version.rb

@@ -1,3 +1,3 @@
 module BubbleWrap
-  VERSION = '1.0.0'
+  VERSION = '1.1.0' unless defined?(BubbleWrap::VERSION)
 end

data/motion/core.rb

@@ -11,7 +11,7 @@ module BubbleWrap
     UIColor.colorWithRed((r/255.0), green:(g/255.0), blue:(b/255.0), alpha:a)
   end
 
-  def NSLocalizedString(key, value)
+  def localized_string(key, value)
     NSBundle.mainBundle.localizedStringForKey(key, value:value, table:nil)
   end
 
@@ -20,5 +20,11 @@ module BubbleWrap
     NSLog arg.inspect
   end
 
+  def create_uuid
+    uuid = CFUUIDCreate(nil)
+    uuid_string = CFUUIDCreateString(nil, uuid)
+    CFRelease(uuid)
+    uuid_string
+  end
+  
 end
-BW = BubbleWrap

data/motion/core/app.rb

@@ -1,4 +1,4 @@
-# Provides a module to store global states 
+# Provides a module to store global states
 #
 module BubbleWrap
   module App
@@ -26,12 +26,30 @@ module BubbleWrap
       NSUserDefaults.standardUserDefaults
     end
 
-    def alert(msg,cancelButtonTitle='OK')
-      alert = UIAlertView.alloc.initWithTitle msg, 
-        message: nil,
-        delegate: nil, 
-        cancelButtonTitle: cancelButtonTitle,
+    # Displays a UIAlertView.
+    #
+    # title - The title as a String.
+    # args  - The title of the cancel button as a String, or a Hash of options.
+    #         (Default: { cancel_button_title: 'OK' })
+    #         cancel_button_title - The title of the cancel button as a String.
+    #         message             - The main message as a String.
+    # block - Yields the alert object if a block is given, and does so before the alert is shown.
+    def alert(title, *args, &block)
+      options = { cancel_button_title: 'OK' }
+      options.merge!(args.pop) if args.last.is_a?(Hash)
+
+      if args.size > 0 && args.first.is_a?(String)
+        options[:cancel_button_title] = args.shift
+      end
+
+      alert = UIAlertView.alloc.initWithTitle title,
+        message: options[:message],
+        delegate: nil,
+        cancelButtonTitle: options[:cancel_button_title],
         otherButtonTitles: nil
+
+      yield(alert) if block_given?
+
       alert.show
       alert
     end
@@ -47,6 +65,16 @@ module BubbleWrap
                                               repeats: false)
     end
 
+    # Opens an url (string or instance of `NSURL`)
+    # in the device's web browser.
+    # Usage Example:
+    #   App.open_url("http://matt.aimonetti.net")
+    def open_url(url)
+      unless url.is_a?(NSURL)
+        url = NSURL.URLWithString(url)
+      end
+      UIApplication.sharedApplication.openURL(url)
+    end
 
     @states = {}
 

data/motion/core/device.rb

@@ -14,15 +14,24 @@ module BubbleWrap
       idiom == UIUserInterfaceIdiomPad
     end
 
+    # Use this to make a DSL-style call for picking images
+    # @example Device.camera.front
+    # @return [Device::Camera::CameraWrapper]
+    def camera
+      BubbleWrap::Device::CameraWrapper
+    end
+
     # Verifies that the device running has a front facing camera.
     # @return [TrueClass, FalseClass] true will be returned if the device has a front facing camera, false otherwise.
-    def front_camera?(picker=UIImagePickerController)
+    def front_camera?
+      p "This method (front_camera?) is DEPRECATED. Transition to using Device.camera.front?"
       picker.isCameraDeviceAvailable(UIImagePickerControllerCameraDeviceFront)
     end
 
     # Verifies that the device running has a rear facing camera.
     # @return [TrueClass, FalseClass] true will be returned if the device has a rear facing camera, false otherwise.
     def rear_camera?(picker=UIImagePickerController)
+      p "This method (rear_camera?) is DEPRECATED. Transition to using Device.camera.rear?"
       picker.isCameraDeviceAvailable(UIImagePickerControllerCameraDeviceRear)
     end
 

data/motion/core/device/camera.rb

@@ -0,0 +1,219 @@
+# Provides a nice DSL for interacting with the standard
+# UIImagePickerController
+#
+module BubbleWrap
+  module Device
+    class Camera
+      module Error
+        SOURCE_TYPE_NOT_AVAILABLE=0
+        INVALID_MEDIA_TYPE=1
+        MEDIA_TYPE_NOT_AVAILABLE=2
+        INVALID_CAMERA_LOCATION=3
+        CANCELED=1000
+      end
+
+      MEDIA_TYPE_HASH = {movie: KUTTypeMovie, image: KUTTypeImage}
+
+      # The camera location; if :none, then we can't use source_type: :camera
+      # in #picture
+      # [:front, :rear, :none]
+      attr_accessor :location
+
+      def self.front
+        return nil if not UIImagePickerController.isCameraDeviceAvailable(UIImagePickerControllerCameraDeviceFront)
+        Camera.new(:front).retain
+      end
+
+      def self.rear
+        return nil if not UIImagePickerController.isCameraDeviceAvailable(UIImagePickerControllerCameraDeviceRear)
+        Camera.new(:rear).retain
+      end
+
+      # For uploading photos from the library.
+      def self.any
+        Camera.new.retain
+      end
+
+      def initialize(location = :none)
+        self.location = location
+      end
+
+      def location=(location)
+        if not [:front, :rear, :none].member? location
+          raise Error::INVALID_CAMERA_LOCATION, "#{location} is not a valid camera location"
+        end
+        @location = location
+      end
+
+      def flash?
+        return false if self.location == :none
+        UIImagePickerController.isFlashAvailableForCameraDevice(camera_device)
+      end
+
+      # @param [Hash] options to open the UIImagePickerController with 
+      # the form {
+      #   source_type: :photo_library, :camera, or :saved_photos_album; default :photo_library
+      #   media_types: [] containing :image and/or :movie; default [:image]
+      #   allows_editing: true/false; default false
+      #   animated: true/false; default true
+      # }
+      # 
+      # @param [UIViewController] view controller from which to present the image picker;
+      #   if nil, uses the keyWindow's rootViewController.
+      # 
+      # @block for callback. takes one argument.
+      #   - On error or cancelled, is called with a hash {error: BW::Camera::Error::<Type>}
+      #   - On success, is called with a hash with a possible set of keys
+      #   [:media_type, :original_image, :edited_image, :crop_rect, :media_url,
+      #    :reference_url, :media_metadata]
+      #
+      # Example
+      # BW::Camera.picture(source_type: :photo_library, media_types: [:image]) do |result|
+      #   image_view = UIImageView.alloc.initWithImage(result[:original_image])
+      # end
+      def picture(options = {}, presenting_controller = nil, &block)
+        @callback = block
+
+        @options = options
+        @options[:allows_editing] = false if not @options.has_key? :allows_editing
+        @options[:animated] = true if not @options.has_key? :animated
+        @options[:media_types] = [:image] if not @options.has_key? :media_types
+
+        # If we're using Camera.any, by default use photo library
+        if !@options.has_key?(:source_type) and self.location == :none
+          @options[:source_type] = :photo_library
+        # If we're using a real Camera, by default use the camera.
+        elsif !@options.has_key?(:source_type)
+          @options[:source_type] = :camera
+        end
+
+        source_type = const_int_get("UIImagePickerControllerSourceType", @options[:source_type])
+        if not Camera.source_type_available?(source_type)
+          error(Error::SOURCE_TYPE_NOT_AVAILABLE) and return
+        end
+
+        media_types = @options[:media_types].collect { |mt| symbol_to_media_type(mt) }
+        if media_types.member? nil
+          error(Error::INVALID_MEDIA_TYPE) and return
+        end
+
+        media_types.each { |media_type|
+          if not Camera.media_type_available?(media_type, for_source_type: source_type)
+            error(Error::MEDIA_TYPE_NOT_AVAILABLE) and return
+          end
+        }
+
+        self.picker.delegate = self
+        self.picker.sourceType = source_type
+        self.picker.mediaTypes = media_types
+        self.picker.allowsEditing = @options[:allows_editing]
+
+        if source_type == :camera && ![:front, :rear].member?(self.location)
+          raise Error::INVALID_CAMERA_LOCATION, "Can't use camera location #{self.location} with source type :camera"
+        end
+
+        if source_type == :camera
+          self.picker.cameraDevice = camera_device
+        end
+
+        presenting_controller ||= UIApplication.sharedApplication.keyWindow.rootViewController
+        presenting_controller.presentViewController(self.picker, animated:@options[:animated], completion: lambda {})
+      end
+
+      ##########
+      # UIImagePickerControllerDelegate Methods
+      def imagePickerControllerDidCancel(picker)
+        error(Error::CANCELED)
+        dismiss
+      end
+
+      # Takes the default didFinishPickingMediaWithInfo hash,
+      # transforms the keys to be nicer symbols of :this_form
+      # instead of UIImagePickerControllerThisForm, and then sends it
+      # to the callback
+      def imagePickerController(picker, didFinishPickingMediaWithInfo: info)
+        delete_keys = []
+        callback_info = {}
+
+        info.keys.each { |k|
+          nice_key = k.gsub("UIImagePickerController", "").underscore.to_sym
+          val = info[k]
+          callback_info[nice_key] = val
+          info.delete k
+        }
+
+        if media_type = callback_info[:media_type]
+          callback_info[:media_type] = media_type_to_symbol(media_type)
+        end
+
+        @callback.call(callback_info)
+        dismiss
+      end
+
+      ##########
+      # Short Helper Methods
+      def picker
+        @picker_klass ||= UIImagePickerController
+        @picker ||= @picker_klass.alloc.init
+      end
+
+      def dismiss
+        self.picker.dismissViewControllerAnimated(@options[:animated], completion: lambda {})
+      end
+
+      # @param [UIImagePickerControllerSourceType] source_type to check
+      def self.source_type_available?(source_type)
+        UIImagePickerController.isSourceTypeAvailable(source_type)
+      end
+
+      # @param [String] (either KUTTypeMovie or KUTTypeImage)
+      # @param [UIImagePickerControllerSourceType]
+      def self.media_type_available?(media_type, for_source_type: source_type)
+        UIImagePickerController.availableMediaTypesForSourceType(source_type).member? media_type
+      end
+
+      private
+      def camera_device
+        const_int_get("UIImagePickerControllerCameraDevice", self.location)
+      end
+
+      # ex media_type_to_symbol(KUTTypeMovie) => :movie
+      def media_type_to_symbol(media_type)
+        MEDIA_TYPE_HASH.invert[media_type]
+      end
+
+      # ex symbol_to_media_type(:movie) => :KUTTypeMovie
+      def symbol_to_media_type(symbol)
+        MEDIA_TYPE_HASH[symbol]
+      end
+
+      def error(type)
+        @callback.call({ error: type })
+      end
+
+      # @param [String] base of the constant 
+      # @param [Integer, String, Symbol] the 
+      # @return [Integer] the constant for this base
+      # Examples
+      # const_int_get("UIReturnKey", :done) => UIReturnKeyDone == 9
+      # const_int_get("UIReturnKey", "done") => UIReturnKeyDone == 9
+      # const_int_get("UIReturnKey", 9) => 9
+      def const_int_get(base, value)
+        return value if value.is_a? Numeric
+        value = value.to_s.camelize
+        Kernel.const_get("#{base}#{value}")
+      end
+
+      # Looks like RubyMotion adds UIKit constants
+      # at compile time. If you don't use these
+      # directly in your code, they don't get added
+      # to Kernel and const_int_get crashes.
+      def load_constants_hack
+        [UIImagePickerControllerSourceTypePhotoLibrary, UIImagePickerControllerSourceTypeCamera, 
+          UIImagePickerControllerSourceTypeSavedPhotosAlbum
+        ]
+      end
+    end
+  end
+end
+::Camera = BubbleWrap::Device::Camera