bubble-wrap 0.1.0

data/.gitignore

@@ -0,0 +1,3 @@
+.rake_tasks~
+build/
+.DS_Store

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in bubble-wrap.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,26 @@
+LICENCE
+
+MIT: http://mattaimonetti.mit-license.org
+
+------------------------------------------------
+
+The MIT License (MIT)
+Copyright © 2012 Matt Aimonetti <matt.aimonetti@gmail.com>
+
+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,147 @@
+# BubbleWrap for RubyMotion
+
+A collection of helpers and wrappers used to wrap CocoaTouch code and provide more Ruby like APIs.
+
+## Installation
+
+```ruby
+gem install bubble-wrap
+```
+
+### Setup
+
+1. Edit the Rakefile of your RubyMotion project and add the following require line.
+```ruby
+require 'bubble-wrap'
+```
+
+2. Now, you can use BubbleWrap extension in your app:
+````ruby
+class AppDelegate
+  def application(application, didFinishLaunchingWithOptions:launchOptions)
+    puts "#{App.name} (#{documents_path})"
+    true
+  end
+end
+````
+
+For a more complete list of helper/wrapper descriptions and more details, see the [wiki](https://github.com/mattetti/BubbleWrap/wiki).
+
+## HTTP
+
+`BubbleWrap::HTTP` wraps `NSURLRequest`, `NSURLConnection` and friends to provide Ruby developers with a more familiar and easier to use API.
+The API uses async calls and blocks to stay as simple as possible.
+
+Usage example:
+
+```ruby
+BubbleWrap::HTTP.get("https://api.github.com/users/mattetti") do |response|
+  p response.body.to_str
+end
+```
+
+```ruby
+BubbleWrap::HTTP.get("https://api.github.com/users/mattetti", {credentials: {username: 'matt', password: 'aimonetti'}}) do |response|
+  p response.body.to_str # prints the response's body
+end
+```
+
+```ruby
+data = {first_name: 'Matt', last_name: 'Aimonetti'}
+BubbleWrap::HTTP.post("http://foo.bar.com/", {payload: data}) do |response|
+  if response.ok?
+    json = BubbleWrap::JSON.parse(response.body.to_str)
+    p json['id']
+  elsif response.status_code.to_s =~ /40\d/
+    alert("Login failed") # helper provided by the kernel file in this repo.
+  else
+    alert(response.error_message)
+  end
+end
+```
+
+## JSON
+
+`BubbleWrap::JSON` wraps `NSJSONSerialization` available in iOS5 and offers the same API as Ruby's JSON std lib.
+
+## Kernel
+
+A collection of useful methods used often in my RubyMotion apps.
+
+Examples:
+```ruby
+> iphone?
+# true
+> ipad?
+# false
+> orientation
+# :portrait
+> 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.
+
+## NSUserDefaults
+
+Helper methods added to the class repsonsible for user preferences.
+
+## NSIndexPath
+
+Helper methods added to give `NSIndexPath` a bit more or a Ruby
+interface.
+
+## Gestures
+
+Extra methods on `UIView` for working with gesture recognizers. A gesture recognizer can be added using a normal Ruby block, like so:
+
+```ruby
+    view.whenTapped do
+      UIView.animateWithDuration(1,
+        animations:lambda {
+          # animate
+          # @view.transform = ...
+        })
+    end
+```
+
+There are similar methods for pinched, rotated, swiped, panned, and pressed (for long presses). All of the methods return the actual recognizer object, so it is possible to set the delegate if more fine-grained control is needed.
+
+## UIButton
+
+Helper methods to give `UIButton` a Ruby-like interface. Ex:
+
+```ruby
+button.when(UIControlEventTouchUpInside) do
+  self.view.backgroundColor = UIColor.redColor
+end
+```
+
+## NSNotificationCenter
+
+Helper methods to give NSNotificationCenter a Ruby-like interface:
+
+```ruby
+def viewWillAppear(animated)
+  notification_center.observe self, UIApplicationWillEnterForegroundNotification do
+    loadAndRefresh
+  end
+  
+  notification_center.observe self, ReloadNotification do
+    loadAndRefresh
+  end
+end
+
+def viewWillDisappear(animated)
+  notification_center.unobserve self
+end
+
+def reload
+  notification_center.post ReloadNotification
+end
+```

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bubble-wrap.gemspec

@@ -0,0 +1,16 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/bubble-wrap/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Matt Aimonetti", "Francis Chong"]
+  gem.email         = ["mattaimonetti@gmail.com", "francis@ignition.hk"]
+  gem.description   = "RubyMotion wrappers and helpers (Ruby for iOS) - Making Cocoa APIs more Ruby like, one API at a time. Fork away and send your pull request."
+  gem.summary       = "RubyMotion wrappers and helpers (Ruby for iOS) - Making Cocoa APIs more Ruby like, one API at a time. Fork away and send your pull request."
+  gem.homepage      = "https://github.com/mattetti/BubbleWrap"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "bubble-wrap"
+  gem.require_paths = ["lib"]
+  gem.version       = BubbleWrap::VERSION
+end

data/lib/bubble-wrap.rb

@@ -0,0 +1,7 @@
+require "bubble-wrap/version"
+
+Motion::Project::App.setup do |app|
+  Dir.glob(File.join(File.dirname(__FILE__), 'bubble-wrap/*.rb')).each do |file|
+    app.files.unshift(file)
+  end
+end

data/lib/bubble-wrap/app.rb

@@ -0,0 +1,50 @@
+# Provides a module to store global states and a persistence layer.
+#
+module App
+  module_function
+
+  @states = {}
+
+  def states
+    @states
+  end
+
+  def name
+    NSBundle.mainBundle.bundleIdentifier
+  end
+
+  # Return application frame
+  def frame
+    UIScreen.mainScreen.applicationFrame
+  end
+
+  # Application Delegate
+  def delegate
+    UIApplication.sharedApplication.delegate
+  end
+
+  # Persistence module built on top of NSUserDefaults
+  module Persistence
+    def self.app_key
+      @app_key ||= App.name
+    end
+
+    def self.[]=(key, value)
+      defaults = NSUserDefaults.standardUserDefaults
+      defaults.setObject(value, forKey: storage_key(key))
+      defaults.synchronize
+    end
+
+    def self.[](key)
+      defaults = NSUserDefaults.standardUserDefaults
+      defaults.objectForKey storage_key(key)
+    end
+
+    private
+
+    def self.storage_key(key)
+      app_key + '_' + key
+    end
+  end
+
+end

data/lib/bubble-wrap/gestures.rb

@@ -0,0 +1,39 @@
+# Opens UIView to add methods for working with gesture recognizers.
+
+class UIView
+
+  def whenTapped(&proc)
+    addGestureRecognizerHelper(proc, UITapGestureRecognizer.alloc.initWithTarget(proc, action:'call'))
+  end
+
+  def whenPinched(&proc)
+    addGestureRecognizerHelper(proc, UIPinchGestureRecognizer.alloc.initWithTarget(proc, action:'call'))
+  end
+
+  def whenRotated(&proc)
+    addGestureRecognizerHelper(proc, UIRotationGestureRecognizer.alloc.initWithTarget(proc, action:'call'))
+  end
+
+  def whenSwiped(&proc)
+    addGestureRecognizerHelper(proc, UISwipeGestureRecognizer.alloc.initWithTarget(proc, action:'call'))
+  end
+
+  def whenPanned(&proc)
+    addGestureRecognizerHelper(proc, UIPanGestureRecognizer.alloc.initWithTarget(proc, action:'call'))
+  end
+
+  def whenPressed(&proc)
+    addGestureRecognizerHelper(proc, UILongPressGestureRecognizer.alloc.initWithTarget(proc, action:'call'))
+  end
+
+private
+
+  # Adds the recognizer and keeps a strong reference to the Proc object.
+  def addGestureRecognizerHelper(proc, recognizer)
+    self.addGestureRecognizer(recognizer)
+    @recognizers = {} unless @recognizers
+    @recognizers["#{proc}"] = proc
+  end
+
+end
+

data/lib/bubble-wrap/http.rb

@@ -0,0 +1,240 @@
+module BubbleWrap
+
+  SETTINGS = {}
+
+  # The HTTP module provides a simple interface to make HTTP requests.
+  #
+  # TODO: preflight support, easier/better cookie support, better error handling
+  module HTTP
+
+    # Make a GET request and process the response asynchronously via a block.
+    #
+    # @examples
+    #  # Simple GET request printing the body
+    #   BubbleWrap::HTTP.get("https://api.github.com/users/mattetti") do |response|
+    #     p response.body.to_str
+    #   end
+    #
+    #  # GET request with basic auth credentials
+    #   BubbleWrap::HTTP.get("https://api.github.com/users/mattetti", {credentials: {username: 'matt', password: 'aimonetti'}}) do |response|
+    #     p response.body.to_str # prints the response's body
+    #   end
+    #
+    def self.get(url, options={}, &block)
+      delegator = block_given? ? block : options.delete(:action)
+      HTTP::Query.new( url, :get, options.merge({:action => delegator}) )
+    end
+    
+    # Make a POST request
+    def self.post(url, options={}, &block)
+      delegator = block_given? ? block : options.delete(:action)
+      HTTP::Query.new( url, :post, options.merge({:action => delegator}) )
+    end
+    
+    # Make a PUT request
+    def self.put(url, options={}, &block)
+      delegator = block_given? ? block : options.delete(:action)
+      HTTP::Query.new( url, :put, options.merge({:action => delegator}) )
+    end
+    
+    # Make a DELETE request
+    def self.delete(url, options={}, &block)
+      delegator = block_given? ? block : options.delete(:action)
+      HTTP::Query.new( url, :delete, options.merge({:action => delegator}) )
+    end
+
+    # Make a HEAD request
+    def self.head(url, options={}, &block)
+      delegator = block_given? ? block : options.delete(:action)
+      HTTP::Query.new( url, :head, options.merge({:action => delegator}) )
+    end
+
+    # Make a PATCH request
+    def self.patch(url, options={}, &block)
+      delegator = block_given? ? block : options.delete(:action)
+      HTTP::Query.new( url, :patch, options.merge({:action => delegator}) )
+    end
+
+    # Response class wrapping the results of a Query's response
+    class Response
+      attr_reader :body
+      attr_reader :headers
+      attr_accessor :status_code, :error_message
+      attr_reader :url
+
+      def initialize(values={})
+        self.update(values)
+      end
+
+      def update(values)
+        values.each do |k,v|
+          self.instance_variable_set("@#{k}", v)
+        end
+      end
+
+      def ok?
+        status_code == 200
+      end
+
+    end
+
+    # Class wrapping NSConnection and often used indirectly by the BubbleWrap::HTTP module methods.
+    class Query
+      attr_accessor :request
+      attr_accessor :connection
+      attr_accessor :credentials # username & password has a hash
+      attr_accessor :proxy_credential # credential supplied to proxy servers
+      attr_accessor :post_data
+      attr_reader   :method
+
+      attr_reader :response
+      attr_reader :status_code
+      attr_reader :response_headers
+      attr_reader :response_size
+      attr_reader :options
+
+      # ==== Parameters
+      # url<String>:: url of the resource to download
+      # http_method<Symbol>:: Value representing the HTTP method to use
+      # options<Hash>:: optional options used for the query
+      #
+      # ==== Options
+      # :payload<String>   - data to pass to a POST, PUT, DELETE query.
+      # :delegator         - Proc, class or object to call when the file is downloaded.
+      # a proc will receive a Response object while the passed object
+      # will receive the handle_query_response method
+      # :headers<Hash>     - headers send with the request
+      # Anything else will be available via the options attribute reader.
+      #
+      def initialize(url, http_method = :get, options={})
+        @method = http_method.upcase.to_s
+        @delegator = options.delete(:action) || self
+        @payload = options.delete(:payload)
+        @credentials = options.delete(:credentials) || {}
+        @credentials = {:username => '', :password => ''}.merge(@credentials)
+        @timeout = options.delete(:timeout) || 30.0
+        headers = options.delete(:headers)
+        if headers
+          @headers = {}
+          headers.each{|k,v| @headers[k] = v.gsub("\n", '\\n') } # escaping LFs
+        end
+        @options = options
+        @response = HTTP::Response.new
+        initiate_request(url)
+        connection.start
+        connection
+      end
+
+      def generate_get_params(payload, prefix=nil)
+        list = []
+        payload.each do |k,v|
+          if v.is_a?(Hash)
+            new_prefix = prefix ? "#{prefix}[#{k.to_s}]" : k.to_s
+            param = generate_get_params(v, new_prefix)
+          else
+            param = prefix ? "#{prefix}[#{k}]=#{v}" : "#{k}=#{v}"
+          end
+          list << param
+        end
+        return list.flatten
+      end
+
+      def initiate_request(url_string)
+        # http://developer.apple.com/documentation/Cocoa/Reference/Foundation/Classes/nsrunloop_Class/Reference/Reference.html#//apple_ref/doc/constant_group/Run_Loop_Modes
+        # NSConnectionReplyMode
+        
+        unless @payload.nil?
+          if @payload.is_a?(Hash)
+            params   = generate_get_params(@payload)
+            @payload = params.join("&")
+          end
+          url_string = "#{url_string}?#{@payload}" if @method == "GET"
+        end
+        
+        p "HTTP building a NSRequest for #{url_string}"# if SETTINGS[:debug]
+        @url = NSURL.URLWithString(url_string)
+        @request = NSMutableURLRequest.requestWithURL(@url,
+                                                      cachePolicy:NSURLRequestUseProtocolCachePolicy,
+                                                      timeoutInterval:@timeout)
+        @request.setHTTPMethod @method
+        @request.setAllHTTPHeaderFields(@headers) if @headers
+
+        # @payload needs to be converted to data
+        unless @method == "GET" || @payload.nil?
+          @payload = @payload.to_s.dataUsingEncoding(NSUTF8StringEncoding)
+          @request.setHTTPBody @payload
+        end
+
+        # NSHTTPCookieStorage.sharedHTTPCookieStorage
+
+        @connection = NSURLConnection.connectionWithRequest(request, delegate:self)
+        @request.instance_variable_set("@done_loading", false)
+        def @request.done_loading; @done_loading; end
+        def @request.done_loading!; @done_loading = true; end
+      end
+
+      def connection(connection, didReceiveResponse:response)
+        @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
+      def connection(connection, didReceiveData:received_data)
+        @received_data ||= NSMutableData.new
+        @received_data.appendData(received_data)
+      end
+
+      def connection(connection, willSendRequest:request, redirectResponse:redirect_response)
+        puts "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)
+        new_request
+      end
+
+      def connection(connection, didFailWithError: error)
+        @request.done_loading!
+        p "HTTP Connection failed #{error.localizedDescription}"
+        @response.error_message = error.localizedDescription
+        if @delegator.respond_to?(:call)
+          @delegator.call( @response, self )
+        end
+      end
+
+      # The transfer is done and everything went well
+      def connectionDidFinishLoading(connection)
+        @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
+      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}"
+          new_credential = NSURLCredential.credentialWithUser(credentials[:username], password:credentials[:password], persistence:NSURLCredentialPersistenceForSession)
+          challenge.sender.useCredential(new_credential, forAuthenticationChallenge:challenge)
+        else
+          challenge.sender.cancelAuthenticationChallenge(challenge)
+          p 'Auth Failed :('
+        end
+      end
+    end
+  end
+end

data/lib/bubble-wrap/json.rb

@@ -0,0 +1,36 @@
+module BubbleWrap
+
+  # Handles JSON encoding and decoding in a similar way Ruby 1.9 does.
+  module JSON
+
+    class ParserError < StandardError; end
+
+    # Parses a string or data object and converts it in data structure.
+    #
+    # @param [String, NSData] str_data the string or data to serialize.
+    # @raise [ParserError] If the parsing of the passed string/data isn't valid.
+    # @return [Hash, Array, NilClass] the converted data structure, nil if the incoming string isn't valid.
+    #
+    # TODO: support options like the C Ruby module does
+    def self.parse(str_data, &block)
+      data = str_data.respond_to?(:to_data) ? str_data.to_data : str_data
+      opts = NSJSONReadingMutableContainers & NSJSONReadingMutableLeaves & NSJSONReadingAllowFragments
+      error = Pointer.new(:id)
+      obj = NSJSONSerialization.JSONObjectWithData(data, options:opts, error:error)
+      raise ParserError, error[0].description if error[0]
+      if block_given?
+        yield obj
+      else 
+        obj
+      end
+      
+    end
+
+    def self.generate(obj)
+      # opts = NSJSONWritingPrettyPrinted
+      data = NSJSONSerialization.dataWithJSONObject(obj, options:0, error:nil)
+      data.to_str
+    end
+
+  end
+end

data/lib/bubble-wrap/kernel.rb

@@ -0,0 +1,95 @@
+module Kernel
+  
+  # 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?
+    UIDevice.currentDevice.userInterfaceIdiom == 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?
+    UIDevice.currentDevice.userInterfaceIdiom == 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?
+    UIImagePickerController.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?
+    UIImagePickerController.isCameraDeviceAvailable(UIImagePickerControllerCameraDeviceRear)
+  end
+
+  # 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
+  
+  # Returns the application resource path where resource located
+  # @return [String] the application main bundle resource path
+  def resources_path
+    NSBundle.mainBundle.resourcePath
+  end
+
+  # Returns the default notification center
+  # @return [NSNotificationCenter] the default notification center
+  def notification_center
+    NSNotificationCenter.defaultCenter
+  end
+
+  def orientation
+    case UIDevice.currentDevice.orientation
+    when UIDeviceOrientationUnknown then :unknown
+    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
+
+  # @return [UIcolor]
+  def rgb_color(r,g,b)
+    rgba_color(r,g,b,1)
+  end
+
+  # @return [UIcolor]
+  def rgba_color(r,g,b,a)
+    UIColor.colorWithRed((r/255.0), green:(g/255.0), blue:(b/255.0), alpha:a)
+  end
+
+  def NSLocalizedString(key, value)
+    NSBundle.mainBundle.localizedStringForKey(key, value:value, table:nil)
+  end
+
+  def user_cache
+    NSUserDefaults.standardUserDefaults
+  end
+
+  def alert(msg)
+    alert = UIAlertView.alloc.initWithTitle msg, 
+                                              message: nil,
+                                              delegate: nil, 
+                                              cancelButtonTitle: "OK", 
+                                              otherButtonTitles: nil
+    alert.show
+  end
+
+  def simulator?
+    @simulator_state ||= !(UIDevice.currentDevice.model =~ /simulator/i).nil?
+  end
+
+  # I had issues with #p on the device, this is a temporary workaround
+  def p(arg)
+    NSLog arg.inspect
+  end
+
+end

data/lib/bubble-wrap/ns_index_path.rb

@@ -0,0 +1,23 @@
+class NSIndexPath
+
+  # Gives access to an index at a given position.
+  # @param [Integer] position to use to fetch the index
+  # @return [Integer] the index for the given position
+  def [](position)
+    raise ArgumentError unless position.is_a?(Integer)
+    indexAtPosition(position)
+  end
+
+  # Provides an iterator taking a block following the common Ruby idiom.
+  # @param [Block]
+  # @return [NSIndexPath] the iterated object itself
+  def each
+    i = 0
+    until i == self.length
+      yield self.indexAtPosition(i)
+      i += 1
+    end
+    self
+  end
+
+end

data/lib/bubble-wrap/ns_notification_center.rb

@@ -0,0 +1,22 @@
+class NSNotificationCenter
+  attr_reader :observers
+
+  def observe(observer, name, object=nil, &proc)
+    @observers            ||= {}
+    @observers[observer]  ||= []
+    @observers[observer]  << proc
+    self.addObserver(proc, selector:'call', name:name, object:object)
+  end
+
+  def unobserve(observer)
+    return unless @observers[observer]
+    @observers[observer].each do |proc|
+      removeObserver(proc)
+    end
+    @observers.delete(observer)
+  end
+  
+  def post(name, object=nil, info=nil)
+    self.postNotificationName(name, object: object, userInfo:info)
+  end
+end

data/lib/bubble-wrap/ns_user_defaults.rb

@@ -0,0 +1,15 @@
+# Reopens the NSUserDefaults class to add Array like accessors
+# @see https://developer.apple.com/library/ios/#documentation/Cocoa/Reference/Foundation/Classes/nsuserdefaults_Class/Reference/Reference.html
+class NSUserDefaults
+
+  # Retrieves the object for the passed key
+  def [](key)
+    self.objectForKey(key)
+  end
+
+  # Sets the value for a given key and save it right away.
+  def []=(key, val)
+    self.setObject(val, forKey: key)
+    self.synchronize
+  end
+end

data/lib/bubble-wrap/ui_button.rb

@@ -0,0 +1,7 @@
+class UIButton
+  def when(events, &block)
+    @callback ||= {}
+    @callback[events] = block
+    addTarget(@callback[events], action:'call', forControlEvents: events)
+  end
+end

data/lib/bubble-wrap/ui_view_controller.rb

@@ -0,0 +1,11 @@
+class UIViewController
+  # Short hand to get the content frame
+  # 
+  # Return content frame: the application frame - navigation bar frame
+  def content_frame
+    app_frame = App.frame
+    navbar_height = self.navigationController.nil? ? 
+      0 : self.navigationController.navigationBar.frame.size.height
+    CGRectMake(0, 0, app_frame.size.width, app_frame.size.height - navbar_height)
+  end
+end

data/lib/bubble-wrap/version.rb

@@ -0,0 +1,3 @@
+module BubbleWrap
+  VERSION = '0.1.0'
+end

data/spec/json_spec.rb

@@ -0,0 +1,116 @@
+describe "JSON" do
+
+  before do
+    @json_string = <<-EOS
+    {
+  "public_gists": 248,
+  "type": "User",
+  "blog": "http://merbist.com",
+  "location": "San Diego, CA",
+  "followers": 303,
+  "company": "LivingSocial",
+  "html_url": "https://github.com/mattetti",
+  "created_at": "2008-01-31T22:56:31Z",
+  "email": "mattaimonetti@gmail.com",
+  "hireable": true,
+  "gravatar_id": "c69521d6e22fc0bbd69337ec8b1698df",
+  "bio": "",
+  "public_repos": 137,
+  "following": 6,
+  "name": "Matt Aimonetti",
+  "login": "mattetti",
+  "url": "https://api.github.com/users/mattetti",
+  "id": 113,
+  "avatar_url": "https://secure.gravatar.com/avatar/c69521d6e22fc0bbd69337ec8b1698df?d=https://a248.e.akamai.net/assets.github.com%2Fimages%2Fgravatars%2Fgravatar-140.png"
+}
+EOS
+  end
+
+  describe "parsing a basic JSON string without block" do
+    
+    before do
+      @parsed = BubbleWrap::JSON.parse(@json_string)
+    end
+
+    it "should convert a top object into a Ruby hash" do
+      obj = @parsed
+      obj.class.should == Hash
+      obj.keys.size.should == 19
+    end
+
+    it "should properly convert integers values" do
+      @parsed["id"].is_a?(Integer).should == true
+    end
+
+    it "should properly convert string values" do
+      @parsed["login"].is_a?(String).should == true
+    end
+
+    it "should convert an array into a Ruby array" do
+      p Bacon::Counter.inspect
+      obj = BubbleWrap::JSON.parse("[1,2,3]")
+      obj.class.should == Array
+      obj.size.should == 3
+    end
+
+  end
+
+    describe "parsing a basic JSON string with block" do
+    
+    before do
+      BubbleWrap::JSON.parse(@json_string) do |parsed|
+        @parsed = parsed
+      end
+    end
+
+    it "should convert a top object into a Ruby hash" do
+      obj = @parsed
+      obj.class.should == Hash
+      obj.keys.size.should == 19
+    end
+
+    it "should properly convert integers values" do
+      @parsed["id"].is_a?(Integer).should == true
+    end
+
+    it "should properly convert string values" do
+      @parsed["login"].is_a?(String).should == true
+    end
+
+    it "should convert an array into a Ruby array" do
+      p Bacon::Counter.inspect
+      obj = BubbleWrap::JSON.parse("[1,2,3]")
+      obj.class.should == Array
+      obj.size.should == 3
+    end
+
+  end
+
+  describe "generating a JSON string from an object" do
+
+    before do
+      @obj = { foo: 'bar', 
+               'bar' => 'baz', 
+               baz: 123, 
+               foobar: [1,2,3], 
+               foobaz: {a: 1, b: 2} 
+            }
+    end
+
+    it "should generate from a hash" do
+      json = BubbleWrap::JSON.generate(@obj)
+      json.class == String
+      json.should == "{\"foo\":\"bar\",\"bar\":\"baz\",\"baz\":123,\"foobar\":[1,2,3],\"foobaz\":{\"a\":1,\"b\":2}}"
+    end
+
+    it "should encode and decode and object losslessly" do
+      json = BubbleWrap::JSON.generate(@obj)
+      obj = BubbleWrap::JSON.parse(json)
+      obj.keys.sort.should == @obj.keys.sort
+      obj.values.sort.should == @obj.values.sort
+    end
+
+  end
+
+end
+

data/spec/ns_notification_center_spec.rb

@@ -0,0 +1,32 @@
+describe "NSNotificationCenter" do
+  SampleNotification = "SampleNotification"
+  after do
+    @observer = Object.new
+  end
+  
+  after do
+    notification_center.unobserve(@observer)
+  end
+
+  it "return notification center" do
+    notification_center.should.not.be.nil
+  end
+
+  it "add observer" do
+    notified = false
+    notification_center.observe(@observer, SampleNotification) do
+      notified = true
+    end
+
+    lambda { 
+      notification_center.post SampleNotification
+    }.should.change { notified }
+  end
+
+  it "remove observer" do
+    lambda { 
+      notification_center.observe(@observer, SampleNotification) {}
+      notification_center.unobserve(@observer)
+    }.should.not.change { notification_center.observers.keys.size }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+class TestSuiteDelegate
+  def application(application, didFinishLaunchingWithOptions:launchOptions)
+    @window = UIWindow.alloc.initWithFrame(UIScreen.mainScreen.bounds)
+    @window.rootViewController = UIViewController.alloc.init
+    true
+  end
+end

data/spec_helper_patch.diff

@@ -0,0 +1,31 @@
+diff --git a/lib/motion/project/builder.rb b/lib/motion/project/builder.rb
+index 39956a8..3e5a646 100644
+--- a/lib/motion/project/builder.rb
++++ b/lib/motion/project/builder.rb
+@@ -143,6 +143,7 @@ module Motion; module Project;
+       if config.spec_mode
+         # Build spec files too, but sequentially.
+         objs << build_file.call(File.expand_path(File.join(File.dirname(__FILE__), '../spec.rb')))
++        objs << build_file.call(config.spec_helper) if File.exist?(config.spec_helper)
+         spec_objs = config.spec_files.map { |path| build_file.call(path) }
+         objs += spec_objs
+       end
+diff --git a/lib/motion/project/config.rb b/lib/motion/project/config.rb
+index 8c7ba43..d43d9a3 100644
+--- a/lib/motion/project/config.rb
++++ b/lib/motion/project/config.rb
+@@ -253,7 +253,13 @@ module Motion; module Project
+     end
+ 
+     def spec_files
+-      Dir.glob(File.join(specs_dir, '**', '*.rb'))
++      files = Dir.glob(File.join(specs_dir, '**', '*.rb'))
++      files.delete(spec_helper)
++      files
++    end
++
++    def spec_helper
++      File.join(specs_dir, 'spec_helper.rb')
+     end
+ 
+     def motiondir

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: bubble-wrap
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Matt Aimonetti
+- Francis Chong
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-22 00:00:00.000000000 Z
+dependencies: []
+description: RubyMotion wrappers and helpers (Ruby for iOS) - Making Cocoa APIs more
+  Ruby like, one API at a time. Fork away and send your pull request.
+email:
+- mattaimonetti@gmail.com
+- francis@ignition.hk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bubble-wrap.gemspec
+- lib/bubble-wrap.rb
+- lib/bubble-wrap/app.rb
+- lib/bubble-wrap/gestures.rb
+- lib/bubble-wrap/http.rb
+- lib/bubble-wrap/json.rb
+- lib/bubble-wrap/kernel.rb
+- lib/bubble-wrap/ns_index_path.rb
+- lib/bubble-wrap/ns_notification_center.rb
+- lib/bubble-wrap/ns_user_defaults.rb
+- lib/bubble-wrap/ui_button.rb
+- lib/bubble-wrap/ui_view_controller.rb
+- lib/bubble-wrap/version.rb
+- spec/http_spec.rb
+- spec/json_spec.rb
+- spec/ns_notification_center_spec.rb
+- spec/spec_helper.rb
+- spec_helper_patch.diff
+homepage: https://github.com/mattetti/BubbleWrap
+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.15
+signing_key: 
+specification_version: 3
+summary: RubyMotion wrappers and helpers (Ruby for iOS) - Making Cocoa APIs more Ruby
+  like, one API at a time. Fork away and send your pull request.
+test_files:
+- spec/http_spec.rb
+- spec/json_spec.rb
+- spec/ns_notification_center_spec.rb
+- spec/spec_helper.rb