bubble-wrap 0.3.1 → 0.4.0

data/lib_spec/bubble-wrap/requirement_spec.rb

@@ -0,0 +1,72 @@
+require File.expand_path('../../motion_stub', __FILE__)
+require 'bubble-wrap'
+
+describe BubbleWrap::Requirement do
+
+  subject{ BubbleWrap::Requirement }
+
+  describe '.scan' do
+    before do
+      subject.paths = {}
+    end
+
+    let(:root_path) { File.expand_path('../../../', __FILE__) }
+
+    it 'asking for a not-yet-found file raises an exception' do
+      proc do 
+        subject.find('foo')
+      end.should raise_error
+    end
+
+    it 'finds the specified file' do
+      subject.scan(root_path, 'motion/core.rb')
+      subject.paths.keys.first.should == 'motion/core.rb'
+    end
+
+    it 'finds multiple files according to spec' do
+      subject.scan(root_path, 'motion/**/*.rb')
+      subject.files.size.should > 1
+    end
+
+    it 'never depends on itself' do
+      subject.scan(root_path, 'motion/core.rb') do
+        file('motion/core.rb').depends_on 'motion/core.rb'
+      end
+      subject.file('motion/core.rb').file_dependencies.should == []
+    end
+
+    it 'can depend on another file' do
+      subject.scan(root_path, 'motion/*.rb') do
+        file('motion/http.rb').depends_on('motion/core.rb')
+      end
+      subject.file('motion/http.rb').file_dependencies.should be_one
+    end
+
+    it 'can use a framework' do
+      subject.scan(root_path, 'motion/core.rb') do
+        file('motion/core.rb').uses_framework('FakeFramework')
+      end
+      subject.file('motion/core.rb').frameworks.should include('FakeFramework')
+    end
+
+    it "figures out the root of the project" do
+      subject.scan(File.join(root_path, 'lib/bubble-wrap.rb'), 'motion/core.rb')
+      subject.paths.values.first.root.should == root_path
+    end
+
+    describe '.frameworks' do
+      it 'includes UIKit by default' do
+        subject.frameworks.should include('UIKit')
+      end
+
+      it 'includes Foundation by default' do
+        subject.frameworks.should include('Foundation')
+      end
+
+      it 'includes CoreGraphics by default' do
+        subject.frameworks.should include('CoreGraphics')
+      end
+    end
+  end
+
+end

data/lib_spec/bubble-wrap_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path('../motion_stub.rb', __FILE__)
+require 'bubble-wrap'
+
+describe BubbleWrap do
+  describe '.root' do
+    it 'returns an absolute path' do
+      BubbleWrap.root[0].should == '/'
+    end
+  end
+
+  describe '.require' do
+    it 'delegates to Requirement.scan' do
+      BW::Requirement.should_receive(:scan)
+      BW.require('foo')
+    end
+  end
+end

data/lib_spec/motion_stub.rb

@@ -0,0 +1,12 @@
+# Create a fake Motion class hierarchy for testing.
+module Motion
+  module Project
+    class App
+      def self.setup
+      end
+    end
+    
+    class Config
+    end
+  end
+end

data/{lib/bubble-wrap → motion/core}/device.rb

@@ -30,22 +30,6 @@ module BubbleWrap
       @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

data/{lib → motion/core}/pollute.rb

@@ -2,5 +2,5 @@
   [NSIndexPath, NSIndexPathWrap],
   [UIControl, UIControlWrap]
 ].each do |base, wrapper|
-  base.send(:include, wrapper)
+    base.send(:include, wrapper)
 end

data/motion/core/string.rb

@@ -0,0 +1,38 @@
+module BubbleWrap
+  # This module contains simplified version of the `camelize` and 
+  # `underscore` methods from ActiveSupport, since these are such 
+  # common operations when dealing with the Cocoa API.
+  module String
+
+    # Convert 'snake_case' into 'CamelCase'
+    def camelize(uppercase_first_letter = true)
+      string = self.dup
+      string.gsub!(/(?:_|(\/))([a-z\d]*)/i) do
+        new_word = $2.downcase
+        new_word[0] = new_word[0].upcase
+        new_word = "/#{new_word}" if $1 == '/'
+        new_word
+      end
+      if uppercase_first_letter
+        string[0] = string[0].upcase
+      else
+        string[0] = string[0].downcase
+      end
+      string.gsub!('/', '::')
+      string
+    end
+
+    # Convert 'CamelCase' into 'snake_case'
+    def underscore
+      word = self.dup
+      word.gsub!(/::/, '/')
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+  end
+end
+
+String.send(:include, BubbleWrap::String)

data/motion/http.rb

@@ -0,0 +1,249 @@
+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.to_s =~ /20\d/ ? true : false
+      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
+        @cachePolicy = options.delete(:cache_policy) || NSURLRequestUseProtocolCachePolicy
+        @options = options
+        @response = HTTP::Response.new
+        initiate_request(url)
+        connection.start
+        UIApplication.sharedApplication.networkActivityIndicatorVisible = true
+        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 "BubbleWrap::HTTP building a NSRequest for #{url_string}" if SETTINGS[:debug]
+        @url = NSURL.URLWithString(url_string.stringByAddingPercentEscapesUsingEncoding NSUTF8StringEncoding)
+        @request = NSMutableURLRequest.requestWithURL(@url,
+                                                      cachePolicy:@cachePolicy,
+                                                      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 = 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
+      end
+
+      def connection(connection, didReceiveResponse:response)
+        @status_code = response.statusCode
+        @response_headers = response.allHeaderFields
+        @response_size = response.expectedContentLength.to_f
+      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)
+        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 = 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}" if SETTINGS[:debug]
+        @response.error_message = error.localizedDescription
+        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)
+
+        call_delegator_with_response
+      end
+
+      def connection(connection, didReceiveAuthenticationChallenge:challenge)
+
+        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}" if SETTINGS[:debug]
+          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
+
+      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