bubble-wrap 0.4.0 → 1.0.0.pre

data/lib_spec/bubble-wrap/requirement/path_manipulation_spec.rb

@@ -1,50 +1,49 @@
 require File.expand_path('../../../../lib/bubble-wrap/requirement/path_manipulation', __FILE__)
 
 describe BubbleWrap::Requirement::PathManipulation do
-
-  subject do
-    o = Object.new
-    o.extend BubbleWrap::Requirement::PathManipulation
-    o
+  
+  before do
+    @subject = Object.new
+    @subject.extend BubbleWrap::Requirement::PathManipulation
   end
 
   describe '#convert_caller_to_path' do
     it 'strips off from the second-to-last colon' do
-      subject.convert_caller_to_path("/fake/:path:91:in `fake_method'").
+      @subject.convert_caller_to_path("/fake/:path:91:in `fake_method'").
         should == '/fake/:path'
     end
 
     it 'leaves plain old paths unmolested' do
-      subject.convert_caller_to_path("/fake/path").
+      @subject.convert_caller_to_path("/fake/path").
         should == '/fake/path'
     end
   end
 
   describe '#convert_to_absolute_path' do
     it 'converts relative paths to absolute paths' do
-      subject.convert_to_absolute_path('foo')[0].should == '/'
+      @subject.convert_to_absolute_path('foo')[0].should == '/'
     end
 
     it "doesn't modify absolute paths" do
-      subject.convert_to_absolute_path('/foo').should == '/foo'
+      @subject.convert_to_absolute_path('/foo').should == '/foo'
     end
   end
 
   describe '#strip_up_to_last_lib' do
     it 'strips off from the last lib' do
-      subject.strip_up_to_last_lib('/fake/lib/dir/lib/foo').
+      @subject.strip_up_to_last_lib('/fake/lib/dir/lib/foo').
         should == '/fake/lib/dir'
     end
 
     it "doesn't modify the path otherwise" do
-      subject.strip_up_to_last_lib('/fake/path').
+      @subject.strip_up_to_last_lib('/fake/path').
         should == '/fake/path'
     end
   end
 
   describe "#convert_to_relative" do
     it 'strips off the root portion' do
-      subject.convert_to_relative('/foo/bar/baz', '/foo').
+      @subject.convert_to_relative('/foo/bar/baz', '/foo').
         should == 'bar/baz'
     end
   end

data/lib_spec/bubble-wrap/requirement_spec.rb

@@ -3,68 +3,69 @@ require 'bubble-wrap'
 
 describe BubbleWrap::Requirement do
 
-  subject{ BubbleWrap::Requirement }
+  before do
+    @subject = BubbleWrap::Requirement
+  end
 
   describe '.scan' do
     before do
-      subject.paths = {}
+      @subject.paths = {}
+      @root_path = File.expand_path('../../../', __FILE__) 
     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
+      should.raise(Exception) do 
+        @subject.find('foo')
+      end
     end
 
     it 'finds the specified file' do
-      subject.scan(root_path, 'motion/core.rb')
-      subject.paths.keys.first.should == 'motion/core.rb'
+      @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
+      @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
+      @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 == []
+      @subject.file('motion/core.rb').file_dependencies.should == []
     end
 
     it 'can depend on another file' do
-      subject.scan(root_path, 'motion/*.rb') 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
+      @subject.file('motion/http.rb').file_dependencies.size.should == 1
     end
 
     it 'can use a framework' do
-      subject.scan(root_path, 'motion/core.rb') 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')
+      @subject.file('motion/core.rb').frameworks.member?('FakeFramework').should == true
     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
+      @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')
+        @subject.frameworks.member?('UIKit').should == true
       end
 
       it 'includes Foundation by default' do
-        subject.frameworks.should include('Foundation')
+        @subject.frameworks.member?('Foundation').should == true
       end
 
       it 'includes CoreGraphics by default' do
-        subject.frameworks.should include('CoreGraphics')
+        @subject.frameworks.member?('CoreGraphics').should == true
       end
     end
   end

data/lib_spec/bubble-wrap_spec.rb

@@ -1,3 +1,4 @@
+require 'mocha-on-bacon'
 require File.expand_path('../motion_stub.rb', __FILE__)
 require 'bubble-wrap'
 
@@ -10,7 +11,7 @@ describe BubbleWrap do
 
   describe '.require' do
     it 'delegates to Requirement.scan' do
-      BW::Requirement.should_receive(:scan)
+      BW::Requirement.expects(:scan)
       BW.require('foo')
     end
   end

data/motion/core/app.rb

@@ -67,6 +67,11 @@ module BubbleWrap
       UIScreen.mainScreen.applicationFrame
     end
 
+    # Main Screen bounds. Useful when starting the app
+    def bounds
+      UIScreen.mainScreen.bounds
+    end
+
     # Application Delegate
     def delegate
       UIApplication.sharedApplication.delegate

data/motion/core/device/screen.rb

@@ -52,7 +52,7 @@ module BubbleWrap
       # The same as `.width` and `.height` but
       # compensating for screen rotation (which
       # can do your head in).
-      def widthForOrientation(o=orientation)
+      def width_for_orientation(o=orientation)
         return height if (o == :landscape_left) || (o == :landscape_right) 
         width
       end
@@ -60,7 +60,7 @@ module BubbleWrap
       # The same as `.width` and `.height` but
       # compensating for screen rotation (which
       # can do your head in).
-      def heightForOrientation(o=orientation)
+      def height_for_orientation(o=orientation)
         return width if (o == :landscape_left) || (o == :landscape_right) 
         height
       end

data/motion/core/kvo.rb

@@ -0,0 +1,91 @@
+# Usage example:
+#
+# class ExampleViewController < UIViewController
+#     include BW::KVO
+#
+#     def viewDidLoad
+#         @label = create_ui_label()
+#
+#         observe(@label, "text") do |old_value, new_value|
+#             puts "Changed #{old_value} to #{new_value}"
+#         end
+#     end
+#
+# end
+#
+# @see https://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/KeyValueObserving/KeyValueObserving.html#//apple_ref/doc/uid/10000177i
+module BubbleWrap
+  module KVO
+    COLLECTION_OPERATIONS = [ NSKeyValueChangeInsertion, NSKeyValueChangeRemoval, NSKeyValueChangeReplacement ]
+    DEFAULT_OPTIONS = NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld
+
+    def observe(target, key_path, &block)
+      target.addObserver(self, forKeyPath:key_path, options:DEFAULT_OPTIONS, context:nil) unless registered?(target, key_path)
+      add_observer_block(target, key_path, &block)
+    end
+
+    def unobserve(target, key_path)
+      return unless registered?(target, key_path)
+
+      target.removeObserver(self, forKeyPath:key_path)
+      remove_observer_block(target, key_path)
+    end
+
+    def unobserve_all
+      return if @targets.nil?
+
+      @targets.each do |target, key_paths|
+        key_paths.each_key do |key_path|
+          target.removeObserver(self, forKeyPath:key_path)
+        end  
+      end
+      remove_all_observer_blocks
+    end
+
+    # Observer blocks
+
+    private
+    def registered?(target, key_path)
+      !@targets.nil? && !@targets[target].nil? && @targets[target].has_key?(key_path)
+    end
+
+    def add_observer_block(target, key_path, &block)
+      return if target.nil? || key_path.nil? || block.nil?
+
+      @targets ||= {}
+      @targets[target] ||= {}
+      @targets[target][key_path] ||= []
+      @targets[target][key_path] << block
+    end
+
+    def remove_observer_block(target, key_path)
+      return if @targets.nil? || target.nil? || key_path.nil?
+
+      key_paths = @targets[target]
+      if !key_paths.nil? && key_paths.has_key?(key_path)
+        key_paths.delete(key_path)
+      end
+    end
+
+    def remove_all_observer_blocks
+      @targets.clear unless @targets.nil?
+    end
+
+    # NSKeyValueObserving Protocol
+
+    def observeValueForKeyPath(key_path, ofObject:target, change:change, context:context)
+      key_paths = @targets[target] || {}
+        blocks = key_paths[key_path] || []
+        blocks.each do |block|
+          args = [ change[NSKeyValueChangeOldKey], change[NSKeyValueChangeNewKey] ]
+          args << change[NSKeyValueChangeIndexesKey] if collection?(change)
+          block.call(*args)
+        end
+      end
+
+      def collection?(change)
+        COLLECTION_OPERATIONS.include?(change[NSKeyValueChangeKindKey])
+      end
+
+  end
+end

data/motion/core/persistence.rb

@@ -8,14 +8,16 @@ module BubbleWrap
     end
 
     def []=(key, value)
-      defaults = NSUserDefaults.standardUserDefaults
-      defaults.setObject(value, forKey: storage_key(key.to_s))
-      defaults.synchronize
+      storage.setObject(value, forKey: storage_key(key.to_s))
+      storage.synchronize
     end
 
     def [](key)
-      defaults = NSUserDefaults.standardUserDefaults
-      defaults.objectForKey storage_key(key.to_s)
+      storage.objectForKey storage_key(key.to_s)
+    end
+
+    def storage
+      NSUserDefaults.standardUserDefaults
     end
 
     def storage_key(key)

data/motion/core/time.rb

@@ -1,8 +1,19 @@
 class Time
+  
   def self.iso8601(time)
-    formatter = NSDateFormatter.alloc.init
-    formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss'Z'"
-    formatter.timeZone   = NSTimeZone.timeZoneWithAbbreviation "UTC"
-    formatter.dateFromString time
+    cached_date_formatter("yyyy-MM-dd'T'HH:mm:ss'Z'").
+      dateFromString(time)
   end
+
+  private
+
+  def self.cached_date_formatter(dateFormat)
+    Thread.current[:date_formatters] ||= {}
+    Thread.current[:date_formatters][dateFormat] ||= 
+      NSDateFormatter.alloc.init.tap do |formatter|
+        formatter.dateFormat = dateFormat
+        formatter.timeZone   = NSTimeZone.timeZoneWithAbbreviation "UTC"
+      end
+  end
+
 end

data/motion/http.rb

@@ -21,38 +21,38 @@ module BubbleWrap
     #   end
     #
     def self.get(url, options={}, &block)
-      delegator = block_given? ? block : options.delete(:action)
-      HTTP::Query.new( url, :get, options.merge({:action => delegator}) )
+      create_query url, :get, options, block
     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}) )
+      create_query url, :post, options, block
     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}) )
+      create_query url, :put, options, block
     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}) )
+      create_query url, :delete, options, block
     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}) )
+      create_query url, :head, options, block
     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}) )
+      create_query url, :patch, options, block
+    end
+
+    private
+    def self.create_query(url, method, options, passed_block)
+      options[:action] = passed_block if passed_block
+      HTTP::Query.new( url, method, options )
     end
 
     # Response class wrapping the results of a Query's response
@@ -113,12 +113,8 @@ module BubbleWrap
         @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
+        @headers = escape_line_feeds(options.delete :headers)
+        @cache_policy = options.delete(:cache_policy) || NSURLRequestUseProtocolCachePolicy
         @options = options
         @response = HTTP::Response.new
         initiate_request(url)
@@ -127,16 +123,22 @@ module BubbleWrap
         connection
       end
 
-      def generate_get_params(payload, prefix=nil)
+      def generate_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)
+            param = generate_params(v, new_prefix)
+            list << param
+          elsif v.is_a?(Array)
+            v.each do |val|
+              param = prefix ? "#{prefix}[#{k}][]=#{val}" : "#{k}[]=#{val}"
+              list << param
+            end
           else
             param = prefix ? "#{prefix}[#{k}]=#{v}" : "#{k}=#{v}"
+            list << param
           end
-          list << param
         end
         return list.flatten
       end
@@ -147,16 +149,16 @@ module BubbleWrap
         
         unless @payload.nil?
           if @payload.is_a?(Hash)
-            params   = generate_get_params(@payload)
+            params   = generate_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]
+        #this method needs a refactor when the specs are done. (especially this utf8 escaping part)
+        log "BubbleWrap::HTTP building a NSRequest for #{url_string}"
         @url = NSURL.URLWithString(url_string.stringByAddingPercentEscapesUsingEncoding NSUTF8StringEncoding)
         @request = NSMutableURLRequest.requestWithURL(@url,
-                                                      cachePolicy:@cachePolicy,
+                                                      cachePolicy:@cache_policy,
                                                       timeoutInterval:@timeout)
         @request.setHTTPMethod @method
         @request.setAllHTTPHeaderFields(@headers) if @headers
@@ -168,11 +170,8 @@ module BubbleWrap
         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
+        patch_nsurl_request
       end
 
       def connection(connection, didReceiveResponse:response)
@@ -188,7 +187,7 @@ module BubbleWrap
       end
 
       def connection(connection, willSendRequest:request, redirectResponse:redirect_response)
-        p "HTTP redirected #{request.description}" if SETTINGS[:debug]
+        log "HTTP redirected #{request.description}"
         new_request = request.mutableCopy
         # new_request.setValue(@credentials.inspect, forHTTPHeaderField:'Authorization') # disabled while we figure this one out
         new_request.setAllHTTPHeaderFields(@headers) if @headers
@@ -200,7 +199,7 @@ module BubbleWrap
       def connection(connection, didFailWithError: error)
         UIApplication.sharedApplication.networkActivityIndicatorVisible = false
         @request.done_loading!
-        NSLog"HTTP Connection failed #{error.localizedDescription}" if SETTINGS[:debug]
+        log "HTTP Connection failed #{error.localizedDescription}"
         @response.error_message = error.localizedDescription
         call_delegator_with_response
       end
@@ -225,15 +224,37 @@ module BubbleWrap
           # NSURLCredentialPersistenceNone,
           # NSURLCredentialPersistenceForSession,
           # NSURLCredentialPersistencePermanent
-          p "auth challenged, answered with credentials: #{credentials.inspect}" if SETTINGS[:debug]
+          log "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 :('
+          log 'Auth Failed :('
         end
       end
 
+
+      private
+
+      def log(message)
+        NSLog message if SETTINGS[:debug]
+      end
+
+      def escape_line_feeds(hash)
+        return nil if hash.nil?
+        escaped_hash = {}
+        
+        hash.each{|k,v| escaped_hash[k] = v.gsub("\n", '\\n') }
+        escaped_hash
+      end
+
+      def patch_nsurl_request
+        @request.instance_variable_set("@done_loading", false)
+        
+        def @request.done_loading; @done_loading; end
+        def @request.done_loading!; @done_loading = true; end
+      end
+
       def call_delegator_with_response
         if @delegator.respond_to?(:call)
           @delegator.call( @response, self )