sugarcube 0.12 → 0.13

data/README.md

@@ -416,6 +416,9 @@ image.rotate(:right)
 image.rotate(:flip)  # 180° - if you have a better name, let me know!
 image.rotate(45.degrees)
 
+image.scale_to(new_size)  # won't stretch
+image.in_rect(frame)  # stretches
+
 # default insets are UIEdgeInsetsZero
 image.tileable
 image.tileable(insets)
@@ -423,7 +426,7 @@ image.stretchable
 image.stretchable(insets)
 ```
 
- UIAlertView
+UIAlertView
 --------
 
 Accepts multiple buttons and success and cancel handlers.  In its simplest
@@ -447,6 +450,36 @@ UIAlertView.alert "I mean, is this cool?", buttons: %w[No! Sure! Hmmmm],
   success: proc { |pressed| self.proceed if pressed == "Sure!" }
 ```
 
+UIActionSheet
+--------
+
+This is very similar to `UIAlertView.alert`, but instead of `cancel` and
+`success` handlers, you can have `cancel, success, and destructive` handlers,
+and there is no `message` argument.
+
+If you use an array of buttons (which you probably *should*), the order of
+arguments is `[:cancel, :destructive, :others, ...]`.  If you *dont* want a
+cancel or destructive button, pass `nil` in place.
+
+```ruby
+# simple
+UIActionSheet.alert 'This is happening, OK?' { self.happened! }
+# a little more complex, with cancel and destructive buttons
+UIActionSheet.alert('This is happening, OK?', buttons: ['Sure!', 'OK']
+  ) {
+  self.happened!
+}
+
+UIActionSheet.alert('Should I?', buttons: [nil, nil, 'OK', 'Nevermind']) { |pressed|
+  self.do_it if pressed == 'OK'
+}
+
+UIActionSheet.alert 'I mean, is this cool?', buttons: ['Nah', 'With fire!', 'Sure', 'whatever'],
+  cancel: proc { self.cancel },
+  destructive: proc { self.kill_it_with_fire }
+  success: proc { |pressed| self.proceed if pressed == 'Sure' }
+```
+
  UIView
 --------
 
@@ -773,11 +806,12 @@ test[:my] = 'new'
 
 Instead, just use the coercion methods `Rect()`, `Size()` and `Point()`.  They
 will happily convert most sensible (and some non-sensible) arguments into a
-`CGRect/CGSize/CGPoint` struct.  For more CoreGraphics additions, you should use
-[geomotion][] by [Clay Allsopp][].  It adds methods to `CGRect`, `CGPoint`, and
-`CGSize` to make these structures more rubyesque (these methods used to be part
-of SugarCube, but were removed in an attempt to decrease the amount of
-duplicated code).
+`CGRect/CGSize/CGPoint` struct.
+
+For more CoreGraphics additions, you should use [geomotion][] by [Clay
+Allsopp][].  It adds methods to `CGRect`, `CGPoint`, and `CGSize` to make these
+structures more rubyesque (these methods used to be part of SugarCube, but were
+removed in an attempt to decrease the amount of duplicated code).
 
 [geomotion]: https://github.com/clayallsopp
 [Clay Allsopp]: https://github.com/clayallsopp/geomotion
@@ -1020,6 +1054,16 @@ You can analyze `UIViewController` hierarchies, too.  There's even a handy
 => #<MainScreenController:0xac23b80>
 ```
 
+##### Nothing is sacred
+
+The adjust and tree methods act on global objects.  Once either of these methods
+is used, you can access that global if you want:
+
+```ruby
+$sugarcube_view  # => the view (or any object) being 'adjusted' (accessible using `adjust` or `a`)
+$sugarcube_items  # => the list of views that was output using `tree`
+```
+
 
  Pointers
 ----------

data/lib/sugarcube/uiactionsheet.rb

@@ -1,6 +1,6 @@
 class UIActionSheet
 
-  # UIActionSheet.alert("message",
+  # UIActionSheet.alert("title",
   #   # The first button is considered the 'cancel' button, for the purposes of
   #   # whether the cancel or success handler gets called, the second button is
   #   # the 'destructive' button, and the rest are plain old buttons.
@@ -10,49 +10,78 @@ class UIActionSheet
   #   success: proc{ |pressed| puts "pressed: #{pressed}" },
   #   )
   def self.alert(title, options={}, &block)
-    if options.is_a? String
-      options = {message: options}
-    end
-
     # create the delegate
     delegate = SugarCube::ActionSheetDelegate.new
     delegate.on_success = options[:success] || block
-    delegate.on_destructive = options[:destructive] || block
+    delegate.on_destructive = options[:destructive]
     delegate.on_cancel = options[:cancel]
     delegate.send(:retain)
 
     args = [title]            # initWithTitle:
-    args << options[:message] # message:
     args << delegate          # delegate:
 
-    buttons = options[:buttons] || []
+    buttons = []
+    buttons.concat(options[:buttons]) if options[:buttons]
+
     if buttons.empty?
-      # cancelButtonTitle: is first, so check for cancel
-      buttons << "Cancel" if options[:cancel]
-      # destructiveButtonTitle: is first, so check for cancel
-      buttons << "Cancel" if options[:cancel]
-      # otherButtonTitles:
-      buttons << "OK" if options[:success] or buttons.empty?
-    elsif buttons.length == 1 and options[:cancel]
-      raise "If you only have one button, use a :success handler, not :cancel (and definitely not BOTH)"
-    end
+      # cancelButtonTitle: is first, so check for cancel handler
+      if options[:cancel]
+        buttons << 'Cancel'
+      else
+        buttons << nil
+      end
 
-    # the button titles.  These are passed to the success handler.
-    delegate.buttons = buttons
+      # destructiveButtonTitle, check for destructive handler
+      if options[:destructive]
+        buttons << 'Delete'
+      else
+        buttons << nil
+      end
+    elsif buttons.length == 1 and (options[:cancel] or options[:destructive])
+      raise 'If you only have one button, use a :success handler, not :cancel or :destructive'
+    end
 
     # uses localized buttons in the actual alert
-    args.concat(buttons.map{ |s| s.localized })
+    if buttons.length == 0
+      buttons = [nil, nil]
+    elsif buttons.length == 1
+      buttons << nil
+    end
+
+    last_index = buttons.length - 1
+    offset = 0
+
+    button_index_map = {}
+    if buttons[1]  # destructive
+      button_index_map[0] = buttons[1]
+      offset += 1
+    else
+      last_index -= 1
+    end
+
+    if buttons[0]  # cancel
+      button_index_map[last_index] = buttons[0]
+    end
+
+    buttons[2..-1].each_with_index { |button, index|
+      button_index_map[index + offset] = button
+    }
+    # the button titles, mapped to how UIActionSheet orders them.  These are passed to the success handler.
+    delegate.button_index_map = button_index_map
+
+    args.concat(buttons.map{ |s| s ? s.localized : nil })
     args << nil  # otherButtonTitles:..., nil
 
     alert = self.alloc
-    alert.send('initWithTitle:message:delegate:cancelButtonTitle:destructiveButtonTitle:otherButtonTitles:', *args)
-    alert.show
+    alert.send('initWithTitle:delegate:cancelButtonTitle:destructiveButtonTitle:otherButtonTitles:', *args)
+    window = UIApplication.sharedApplication.keyWindow || UIApplication.sharedApplication.windows[0]
+    alert.showInView(window)
     alert
   end
 
   private
   def dummy
-    self.initWithTitle(nil, message:nil, delegate:nil, cancelButtonTitle:nil, destructiveButtonTitle:nil, otherButtonTitles:nil)
+    self.initWithTitle(nil, delegate:nil, cancelButtonTitle:nil, destructiveButtonTitle:nil, otherButtonTitles:nil)
   end
 
 end
@@ -60,12 +89,12 @@ end
 
 module SugarCube
   class ActionSheetDelegate
-    attr_accessor :buttons
+    attr_accessor :button_index_map
     attr_accessor :on_cancel
     attr_accessor :on_destructive
     attr_accessor :on_success
 
-    def alertSheet(alert, didDismissWithButtonIndex:index)
+    def actionSheet(alert, didDismissWithButtonIndex:index)
       if index == alert.destructiveButtonIndex && on_destructive
         on_destructive.call
       elsif index == alert.cancelButtonIndex && on_cancel
@@ -74,7 +103,7 @@ module SugarCube
         if on_success.arity == 0
           on_success.call
         else
-          button = buttons[index]
+          button = button_index_map[index]
           on_success.call(button)
         end
       end

data/lib/sugarcube/uicolor.rb

@@ -6,6 +6,10 @@ class UIColor
     _sugarcube_colors[:red]
   end
 
+  def cgcolor
+    self.CGColor
+  end
+
   def green
     _sugarcube_colors[:green]
   end

data/lib/sugarcube/uiview.rb

@@ -35,8 +35,15 @@ class UIView
     end
   end
 
+  # superview << view
+  # => superview.addSubview(view)
   def <<(view)
-    self.addSubview view
+    self.addSubview(view)
+    return self
+  end
+
+  def unshift(view)
+    self.insertSubview(view, atIndex:0)
     return self
   end
 
@@ -139,6 +146,21 @@ class UIView
     fade(options, &after)
   end
 
+  # Changes the layer opacity to 0 and then removes the view from its superview
+  # @see #fade_out
+  def fade_out_and_remove(options={}, &after)
+    if options.is_a? Numeric
+      options = { duration: options }
+    end
+
+    after_remove = proc {
+      removeFromSuperview
+      after.call if after
+    }
+
+    fade_out(options, &after_remove)
+  end
+
   def move_to(position, options={}, &after)
     if options.is_a? Numeric
       options = { duration: options }

data/lib/sugarcube/version.rb

@@ -1,3 +1,3 @@
 module SugarCube
-  Version = '0.12'
+  Version = '0.13'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sugarcube
 version: !ruby/object:Gem::Version
-  version: '0.12'
+  version: '0.13'
   prerelease: 
 platform: ruby
 authors: