bubble-wrap 0.2.1 → 0.3.0

data/.gitignore

@@ -3,3 +3,5 @@ pkg/*
 Gemfile.lock
 build/
 .DS_Store
+.repl_history
+0

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.3.0
+
+* Major refactoring preparing for 1.0: https://github.com/mattetti/BubbleWrap/compare/v0.2.1…v0.3.0
+
 ## 0.2.1
 
 * Minor fix in the way the dependencies are set (had to monkey patch

data/README.md

@@ -14,6 +14,8 @@ gem install bubble-wrap
 ```ruby
 require 'bubble-wrap'
 ```
+Note: **DON'T** use `app.files =` in your Rakefile to set up your files once you've required BubbleWrap.
+Make sure to append onto the array or use `+=`.
 
 2. Now, you can use BubbleWrap extension in your app:
 
@@ -65,28 +67,36 @@ end
 
 `BubbleWrap::JSON` wraps `NSJSONSerialization` available in iOS5 and offers the same API as Ruby's JSON std lib.
 
-## Kernel
+## Device
 
-A collection of useful methods used often in my RubyMotion apps.
+A collection of useful methods about the current device:
 
 Examples:
 ```ruby
-> iphone?
+> Device.iphone?
 # true
-> ipad?
+> Device.ipad?
 # false
-> orientation
+> Device.orientation
 # :portrait
-> simulator?
+> Device.simulator?
 # true
-> documents_path
-# "/Users/mattetti/Library/Application Support/iPhone Simulator/5.0/Applications/EEC6454E-1816-451E-BB9A-EE18222E1A8F/Documents"
 ```
 
 ## App
 
-A module allowing developers to store global states and also provides a
-persistence layer.
+A module with useful methods related to the running application
+
+```ruby
+> App.documents_path
+# "/Users/mattetti/Library/Application Support/iPhone Simulator/5.0/Applications/EEC6454E-1816-451E-BB9A-EE18222E1A8F/Documents"
+> App.resources_path
+# "/Users/mattetti/Library/Application Support/iPhone Simulator/5.0/Applications/EEC6454E-1816-451E-BB9A-EE18222E1A8F/testSuite_spec.app"
+> App.name
+# "testSuite"
+> App.identifier
+# "io.bubblewrap.testSuite"
+```
 
 ## NSUserDefaults
 
@@ -94,7 +104,7 @@ Helper methods added to the class repsonsible for user preferences.
 
 ## NSIndexPath
 
-Helper methods added to give `NSIndexPath` a bit more or a Ruby
+Helper methods added to give `NSIndexPath` a bit more of a Ruby
 interface.
 
 ## Gestures
@@ -129,20 +139,21 @@ Helper methods to give NSNotificationCenter a Ruby-like interface:
 
 ```ruby
 def viewWillAppear(animated)
-  notification_center.observe self, UIApplicationWillEnterForegroundNotification do
+  @foreground_observer = notification_center.observe UIApplicationWillEnterForegroundNotification do |notification|
     loadAndRefresh
   end
   
-  notification_center.observe self, ReloadNotification do
+  @reload_observer notification_center.observe ReloadNotification do |notification|
     loadAndRefresh
   end
 end
 
 def viewWillDisappear(animated)
-  notification_center.unobserve self
+  notification_center.unobserve @foreground_observer
+  notification_center.unobserve @reload_observer
 end
 
 def reload
   notification_center.post ReloadNotification
 end
-```
+```

data/Rakefile

@@ -3,14 +3,15 @@ $:.unshift("/Library/RubyMotion/lib")
 require 'motion/project'
 
 Motion::Project::App.setup do |app|
-  app.name = 'MotionLibTestSuite'
+  app.name = 'testSuite'
+  app.identifier = 'io.bubblewrap.testSuite'
   
   app.development do
     app.files << './lib/tests/test_suite_delegate.rb'
     app.delegate_class = 'TestSuiteDelegate'
   end
 
-  app.files += Dir.glob('./lib/bubble-wrap/**.rb')
+  app.files += Dir.glob('./lib/bubble-wrap/**/*.rb')
   wrapper_files = app.files.dup
   pollution_file = Dir.glob('./lib/pollute.rb')[0]
   app.files << pollution_file

data/lib/bubble-wrap.rb

@@ -29,11 +29,11 @@ end
 
 Motion::Project::App.setup do |app|
   wrapper_files = []
-  Dir.glob(File.join(File.dirname(__FILE__), 'bubble-wrap/*.rb')).each do |file|
+  Dir.glob(File.join(File.dirname(__FILE__), 'bubble-wrap/**/*.rb')).each do |file|
     app.files << file
     wrapper_files << file
   end
   pollution_file = File.expand_path(File.join(File.dirname(__FILE__), 'pollute.rb'))
-  app.files << pollution_file
+  app.files.unshift pollution_file
   app.files_dependencies pollution_file => wrapper_files
 end

data/lib/bubble-wrap/app.rb

@@ -1,50 +1,75 @@
-# Provides a module to store global states and a persistence layer.
+# Provides a module to store global states 
 #
-module App
-  module_function
+module BubbleWrap
+  module App
+    module_function
 
-  @states = {}
+    # Returns the application's document directory path where users might be able to upload content.
+    # @return [String] the path to the document directory
+    def documents_path
+      NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, true)[0]
+    end
 
-  def states
-    @states
-  end
+    # Returns the application resource path where resource located
+    # @return [String] the application main bundle resource path
+    def resources_path
+      NSBundle.mainBundle.resourcePath
+    end
 
-  def name
-    NSBundle.mainBundle.bundleIdentifier
-  end
+    # Returns the default notification center
+    # @return [NSNotificationCenter] the default notification center
+    def notification_center
+      NSNotificationCenter.defaultCenter
+    end
 
-  # Return application frame
-  def frame
-    UIScreen.mainScreen.applicationFrame
-  end
+    def user_cache
+      NSUserDefaults.standardUserDefaults
+    end
 
-  # Application Delegate
-  def delegate
-    UIApplication.sharedApplication.delegate
-  end
+    def alert(msg,cancelButtonTitle='OK')
+      alert = UIAlertView.alloc.initWithTitle msg, 
+        message: nil,
+        delegate: nil, 
+        cancelButtonTitle: cancelButtonTitle,
+        otherButtonTitles: nil
+      alert.show
+      alert
+    end
+
+    @states = {}
 
-  # Persistence module built on top of NSUserDefaults
-  module Persistence
-    def self.app_key
-      @app_key ||= App.name
+    def states
+      @states
     end
 
-    def self.[]=(key, value)
-      defaults = NSUserDefaults.standardUserDefaults
-      defaults.setObject(value, forKey: storage_key(key.to_s))
-      defaults.synchronize
+    def name
+      NSBundle.mainBundle.objectForInfoDictionaryKey 'CFBundleDisplayName'
     end
 
-    def self.[](key)
-      defaults = NSUserDefaults.standardUserDefaults
-      defaults.objectForKey storage_key(key.to_s)
+    def identifier
+      NSBundle.mainBundle.bundleIdentifier
     end
 
-    private
+    # Return application frame
+    def frame
+      UIScreen.mainScreen.applicationFrame
+    end
 
-    def self.storage_key(key)
-      app_key + '_' + key.to_s
+    # Application Delegate
+    def delegate
+      UIApplication.sharedApplication.delegate
     end
-  end
 
+    # @return [NSLocale] locale of user settings
+    def current_locale
+      languages = NSLocale.preferredLanguages
+      if languages.count > 0
+        return NSLocale.alloc.initWithLocaleIdentifier(languages.first)
+      else
+        return NSLocale.currentLocale
+      end
+    end
+
+  end
 end
+::App = BubbleWrap::App

data/lib/bubble-wrap/device.rb

@@ -0,0 +1,66 @@
+module BubbleWrap
+  module Device
+    module_function
+
+    # Verifies that the device running the app is an iPhone.
+    # @return [TrueClass, FalseClass] true will be returned if the device is an iPhone, false otherwise.
+    def iphone?(idiom=UIDevice.currentDevice.userInterfaceIdiom)
+      idiom == UIUserInterfaceIdiomPhone
+    end
+
+    # Verifies that the device running the app is an iPad.
+    # @return [TrueClass, FalseClass] true will be returned if the device is an iPad, false otherwise.
+    def ipad?(idiom=UIDevice.currentDevice.userInterfaceIdiom)
+      idiom == UIUserInterfaceIdiomPad
+    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)
+      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)
+      picker.isCameraDeviceAvailable(UIImagePickerControllerCameraDeviceRear)
+    end
+
+    def simulator?
+      @simulator_state ||= !(UIDevice.currentDevice.model =~ /simulator/i).nil?
+    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)
+      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)
+      picker.isCameraDeviceAvailable(UIImagePickerControllerCameraDeviceRear)
+    end
+
+    def simulator?
+      @simulator_state ||= !(UIDevice.currentDevice.model =~ /simulator/i).nil?
+    end
+
+    # Shameless shorthand for accessing BubbleWrap::Screen
+    def screen
+      BubbleWrap::Device::Screen
+    end
+
+    # Delegates to BubbleWrap::Screen.retina?
+    def retina?
+      screen.retina?
+    end
+
+    # Delegates to BubbleWrap::Screen.orientation
+    def orientation
+      screen.orientation
+    end
+
+  end
+end
+::Device = BubbleWrap::Device

data/lib/bubble-wrap/device/screen.rb

@@ -0,0 +1,69 @@
+module BubbleWrap
+  module Device
+    module Screen
+
+      module_function
+
+      # Certifies that the device running the app has a Retina display
+      # @return [TrueClass, FalseClass] true will be returned if the device has a Retina display, false otherwise.
+      def retina?(screen=UIScreen.mainScreen)
+        if screen.respondsToSelector('displayLinkWithTarget:selector:') && screen.scale == 2.0
+          true
+        else
+          false
+        end
+      end
+
+      # Figure out the current physical orientation of the device
+      # @return [:portrait, :portrait_upside_down, :landscape_left, :landscape_right, :face_up, :face_down, :unknown]
+      def orientation(device_orientation=UIDevice.currentDevice.orientation)
+        case device_orientation
+        when UIDeviceOrientationPortrait then :portrait
+        when UIDeviceOrientationPortraitUpsideDown then :portrait_upside_down
+        when UIDeviceOrientationLandscapeLeft then :landscape_left
+        when UIDeviceOrientationLandscapeRight then :landscape_right
+        when UIDeviceOrientationFaceUp then :face_up
+        when UIDeviceOrientationFaceDown then :face_down
+        else
+          :unknown
+        end
+      end
+
+      # The width of the device's screen.
+      # The real resolution is dependant on the scale
+      # factor (see `retina?`) but the coordinate system
+      # is in non-retina pixels. You can get pixel
+      # accuracy by using half-coordinates.
+      # This is a Float
+      def width
+        UIScreen.mainScreen.bounds.size.width
+      end
+
+      # The height of the device's screen.
+      # The real resolution is dependant on the scale
+      # factor (see `retina?`) but the coordinate system
+      # is in non-retina pixels. You can get pixel
+      # accuracy by using half-coordinates.
+      # This is a Float
+      def height
+        UIScreen.mainScreen.bounds.size.height
+      end
+
+      # The same as `.width` and `.height` but
+      # compensating for screen rotation (which
+      # can do your head in).
+      def widthForOrientation(o=orientation)
+        return height if (o == :landscape_left) || (o == :landscape_right) 
+        width
+      end
+
+      # The same as `.width` and `.height` but
+      # compensating for screen rotation (which
+      # can do your head in).
+      def heightForOrientation(o=orientation)
+        return width if (o == :landscape_left) || (o == :landscape_right) 
+        height
+      end
+    end
+  end
+end

data/lib/bubble-wrap/gestures.rb

@@ -2,34 +2,35 @@
 
 class UIView
 
-  def whenTapped(&proc)
-    addGestureRecognizerHelper(proc, UITapGestureRecognizer.alloc.initWithTarget(proc, action:'call'))
+  def whenTapped(enableInteraction=true, &proc)
+    addGestureRecognizerHelper(proc, enableInteraction, UITapGestureRecognizer.alloc.initWithTarget(proc, action:'call'))
   end
 
-  def whenPinched(&proc)
-    addGestureRecognizerHelper(proc, UIPinchGestureRecognizer.alloc.initWithTarget(proc, action:'call'))
+  def whenPinched(enableInteraction=true, &proc)
+    addGestureRecognizerHelper(proc, enableInteraction, UIPinchGestureRecognizer.alloc.initWithTarget(proc, action:'call'))
   end
 
-  def whenRotated(&proc)
-    addGestureRecognizerHelper(proc, UIRotationGestureRecognizer.alloc.initWithTarget(proc, action:'call'))
+  def whenRotated(enableInteraction=true, &proc)
+    addGestureRecognizerHelper(proc, enableInteraction, UIRotationGestureRecognizer.alloc.initWithTarget(proc, action:'call'))
   end
 
-  def whenSwiped(&proc)
-    addGestureRecognizerHelper(proc, UISwipeGestureRecognizer.alloc.initWithTarget(proc, action:'call'))
+  def whenSwiped(enableInteraction=true, &proc)
+    addGestureRecognizerHelper(proc, enableInteraction, UISwipeGestureRecognizer.alloc.initWithTarget(proc, action:'call'))
   end
 
-  def whenPanned(&proc)
-    addGestureRecognizerHelper(proc, UIPanGestureRecognizer.alloc.initWithTarget(proc, action:'call'))
+  def whenPanned(enableInteraction=true, &proc)
+    addGestureRecognizerHelper(proc, enableInteraction, UIPanGestureRecognizer.alloc.initWithTarget(proc, action:'call'))
   end
 
-  def whenPressed(&proc)
-    addGestureRecognizerHelper(proc, UILongPressGestureRecognizer.alloc.initWithTarget(proc, action:'call'))
+  def whenPressed(enableInteraction=true, &proc)
+    addGestureRecognizerHelper(proc, enableInteraction, UILongPressGestureRecognizer.alloc.initWithTarget(proc, action:'call'))
   end
 
-private
+  private
 
   # Adds the recognizer and keeps a strong reference to the Proc object.
-  def addGestureRecognizerHelper(proc, recognizer)
+  def addGestureRecognizerHelper(proc, enableInteraction, recognizer)
+    setUserInteractionEnabled true if enableInteraction && !isUserInteractionEnabled
     self.addGestureRecognizer(recognizer)
     @recognizers = {} unless @recognizers
     @recognizers["#{proc}"] = proc

data/lib/bubble-wrap/http.rb

@@ -118,6 +118,7 @@ module BubbleWrap
           @headers = {}
           headers.each{|k,v| @headers[k] = v.gsub("\n", '\\n') } # escaping LFs
         end
+        @cachePolicy = options.delete(:cache_policy) || NSURLRequestUseProtocolCachePolicy
         @options = options
         @response = HTTP::Response.new
         initiate_request(url)
@@ -152,10 +153,10 @@ module BubbleWrap
           url_string = "#{url_string}?#{@payload}" if @method == "GET"
         end
         
-        p "BubbleWrap::HTTP building a NSRequest for #{url_string}"# if SETTINGS[:debug]
-        @url = NSURL.URLWithString(url_string)
+        p "BubbleWrap::HTTP building a NSRequest for #{url_string}" if SETTINGS[:debug]
+        @url = NSURL.URLWithString(url_string.stringByAddingPercentEscapesUsingEncoding NSUTF8StringEncoding)
         @request = NSMutableURLRequest.requestWithURL(@url,
-                                                      cachePolicy:NSURLRequestUseProtocolCachePolicy,
+                                                      cachePolicy:@cachePolicy,
                                                       timeoutInterval:@timeout)
         @request.setHTTPMethod @method
         @request.setAllHTTPHeaderFields(@headers) if @headers
@@ -168,7 +169,7 @@ module BubbleWrap
 
         # NSHTTPCookieStorage.sharedHTTPCookieStorage
 
-        @connection = NSURLConnection.connectionWithRequest(request, delegate:self)
+        @connection = create_connection(request, self)
         @request.instance_variable_set("@done_loading", false)
         def @request.done_loading; @done_loading; end
         def @request.done_loading!; @done_loading = true; end
@@ -178,7 +179,6 @@ module BubbleWrap
         @status_code = response.statusCode
         @response_headers = response.allHeaderFields
         @response_size = response.expectedContentLength.to_f
-        # p "HTTP status code: #{@status_code}, content length: #{@response_size}, headers: #{@response_headers}" if SETTINGS[:debug]
       end
 
       # This delegate method get called every time a chunk of data is being received
@@ -188,49 +188,44 @@ module BubbleWrap
       end
 
       def connection(connection, willSendRequest:request, redirectResponse:redirect_response)
-        p "HTTP redirected #{request.description}" #if SETTINGS[:debug]
+        p "HTTP redirected #{request.description}" if SETTINGS[:debug]
         new_request = request.mutableCopy
         # new_request.setValue(@credentials.inspect, forHTTPHeaderField:'Authorization') # disabled while we figure this one out
         new_request.setAllHTTPHeaderFields(@headers) if @headers
         @connection.cancel
-        @connection = NSURLConnection.connectionWithRequest(new_request, delegate:self)
+        @connection = create_connection(new_request, self)
         new_request
       end
 
       def connection(connection, didFailWithError: error)
         UIApplication.sharedApplication.networkActivityIndicatorVisible = false
         @request.done_loading!
-        NSLog"HTTP Connection failed #{error.localizedDescription}"
+        NSLog"HTTP Connection failed #{error.localizedDescription}" if SETTINGS[:debug]
         @response.error_message = error.localizedDescription
-        if @delegator.respond_to?(:call)
-          @delegator.call( @response, self )
-        end
+        call_delegator_with_response
       end
 
+
       # The transfer is done and everything went well
       def connectionDidFinishLoading(connection)
         UIApplication.sharedApplication.networkActivityIndicatorVisible = false
         @request.done_loading!
-
         # copy the data in a local var that we will attach to the response object
         response_body = NSData.dataWithData(@received_data) if @received_data
         @response.update(status_code: status_code, body: response_body, headers: response_headers, url: @url)
-        # Don't reset the received data since this method can be called multiple times if the headers can report the wrong length.
-        # @received_data = nil
-        if @delegator.respond_to?(:call)
-          @delegator.call( @response, self )
-        end
+
+        call_delegator_with_response
       end
 
       def connection(connection, didReceiveAuthenticationChallenge:challenge)
-        # p "HTTP auth required" if SETTINGS[:debug]
+
         if (challenge.previousFailureCount == 0)
           # by default we are keeping the credential for the entire session
           # Eventually, it would be good to let the user pick one of the 3 possible credential persistence options:
           # NSURLCredentialPersistenceNone,
           # NSURLCredentialPersistenceForSession,
           # NSURLCredentialPersistencePermanent
-          p "auth challenged, answered with credentials: #{credentials.inspect}"
+          p "auth challenged, answered with credentials: #{credentials.inspect}" if SETTINGS[:debug]
           new_credential = NSURLCredential.credentialWithUser(credentials[:username], password:credentials[:password], persistence:NSURLCredentialPersistenceForSession)
           challenge.sender.useCredential(new_credential, forAuthenticationChallenge:challenge)
         else
@@ -238,6 +233,17 @@ module BubbleWrap
           p 'Auth Failed :('
         end
       end
+
+      def call_delegator_with_response
+        if @delegator.respond_to?(:call)
+          @delegator.call( @response, self )
+        end
+      end
+
+      # This is a temporary method used for mocking.
+      def create_connection(request, delegate)
+        NSURLConnection.connectionWithRequest(request, delegate:delegate)
+      end
     end
   end
 end