sugarcube 1.5.8 → 1.5.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b8dbbc1d4e5f7c49ce2780738d89a4ba64350ac2
-  data.tar.gz: 0afa5689aad18f713f60ad58ac6148950d56c5bf
+  metadata.gz: 095bfec455df3479380c6c660fc39317b97129a8
+  data.tar.gz: 14ec967daf20d6b0ea2090abd8098cab5c8c67d7
 SHA512:
-  metadata.gz: d04fcfd788daaafb0684826016f0112933b94d94d2d234961c4c0a0673b5594dc87a5e4474ac3219b615e7f896372dced9f029db11948585d54e5162a6875a68
-  data.tar.gz: 857c8b05d77e56b62faf0ea07212e8fbf9e836249f425f1dbff80a7d433b47467f9a63f381d7d93afd9f2ff5cdd4a4dd3a858b9619db8df12a1eca93cc65be61
+  metadata.gz: 718f2a93953af262d767e716c69ac2f824a639c9a5835590666b023082573fb0a4df6a2f02cbfe30055db44f573b7af79734fae1b6ef5ac8b7e37d14e799cc96
+  data.tar.gz: 65c9bab6c3b42c9de6c2ec3b977a5a685b7787080591e2883b1d754278bd228654ca73c8056d5f51c252eab2eaafda99e56c0667ed19b9586af6b9ab2d3e2f09

data/.travis.yml

@@ -1,4 +1,7 @@
 language: objective-c
 before_install:
-    - (ruby --version)
+    - brew update
+    - brew upgrade xctool
     - sudo motion update
+    - sudo chown -R travis ~/Library/RubyMotion
+    - mkdir -p ~/Library/RubyMotion/build

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    sugarcube (1.5.8)
+    sugarcube (1.5.9)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -607,28 +607,62 @@ Factories
 ###### UIAlertView
 
 Accepts multiple buttons and handlers.  In its simplest form, you can pass just
-a title and block.
+a title and block.  An optional `:message` can either be passed in as an option,
+or as the 2nd positional arg.
+
+Options:
+
+    UIAlertView.alert(options)
+    UIAlertView.alert(title, options)
+    UIAlertView.alert(title, message, options)
+    0 => title => String - title of the alert.  optional positional arg.
+    1 => message => String - message of the alert.  optional positional arg.
+    :title => String - title of the alert.
+    :message => String - message of the alert.
+    :success => Proc - the success handler
+    :cancel => Proc - the cancel handler
+    :buttons => [] - List of buttons ([cancel, others...])
+    :buttons => {} - Hash of buttons ({cancel:, others: ...}) in any order of course
+    :style => Symbol | Fixnum - A symbol (uialertstyle) or constant (UIAlertViewStyle*)
+    :show => Boolean - Whether to show the action sheet (default: true)
 
 ```ruby
-# simple
-UIAlertView.alert "This is happening, OK?" { self.happened! }
+# simple title/message alert
+UIAlertView.alert('This is happening, OK?', 'An optional message') do
+  self.it_happened!
+end
 
 # a little more complex - the cancel button should be first, and the block will
-# receive a string, not an index
-UIAlertView.alert("This is happening, OK?", buttons: ["Nevermind", "OK"],
-  message: "Don't worry, it'll be fine.") { |button|
-  if button == "OK"
+# receive a string and an index
+UIAlertView.alert('This is happening, OK?',
+  message: 'Don't worry, it'll be fine.',
+  buttons: ['Nevermind', 'OK'],
+  ) do |button, button_index|
+  if button == 'OK'  # or: button_index == 1
     self.happened!
   end
-}
+end
 
 # Full on whiz-bangery.  The cancel button should be the first entry in
 # `buttons:`.  When you specify the success and cancel button handlers this way,
 # you need not assign both.
-UIAlertView.alert "I mean, is this cool?", buttons: %w[No! Sure! Hmmmm],
-  message: "No going back now",
+UIAlertView.alert('I mean, is this cool?',
+  buttons: ['No!', 'Sure!', 'Hmmmm'],
+  message: 'No going back now',
   cancel: proc { self.cancel },
-  success: proc { |pressed| self.proceed if pressed == "Sure!" }
+  success: proc { |pressed| self.proceed if pressed == 'Sure!' }
+  )
+
+# To keep up with BubbleWrap's awesome BW::ActionSheet and BW::AlertView
+# helpers, SugarCube provides a similar interface.
+UIAlertView.alert('Confirm action!', 'Are you sure you want to do this?',
+  buttons: {
+    cancel: 'No!',
+    success: 'Sure!',
+    unsure: 'Hmmm',
+  }) do |button|
+  # button will be :cancel, :success or :unsure
+end
 ```
 
 ###### UIActionSheet
@@ -641,23 +675,54 @@ 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.
 
+Options:
+
+    UIActionSheet.alert(options)
+    UIActionSheet.alert(title, options)
+    0 => title => String - title of the action sheet
+    :title => Proc - title of the action sheet
+    :success => Proc - the success handler
+    :cancel => Proc - the cancel handler
+    :destructive => Proc - the destructive handler
+    :buttons => [] - List of buttons ([cancel, destructive, others...])
+    :buttons => {} - Hash of buttons ({cancel:, destructive:, others: ...}) in any order of course
+    :style => Symbol | Fixnum - A symbol (uiactionstyle) or constant (UIActionSheetStyle*)
+    :show => Boolean - Whether to show the action sheet (default: true)
+    :from => CGRect | UIBarButtonItem | UIToolbar | UITabBar | UIView (default: first window)
+             Where to display the alert.  Mostly relevant on iPad.
+
 ```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']
-  ) {
+UIActionSheet.alert 'This is happening, OK?' do
   self.happened!
-}
+end
+
+# a little more complex, with cancel and destructive buttons
+UIActionSheet.alert('This is happening, OK?', buttons: ['Cancel', 'Kill it!', 'Uh, what?']
+  ) do |button|
+  # button is 'Cancel', 'Kill it!' or 'Uh, what?'
+end
 
-UIActionSheet.alert('Should I?', buttons: [nil, nil, 'OK', 'Nevermind']) { |pressed|
+# skip cancel and destructive buttons:
+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' }
+
+# By passing a Hash to buttons you can get this improved interface, similar to
+# BubbleWrap's awesome interface.
+UIActionSheet.alert('Well, how bout it?',
+  buttons: {
+    cancel: 'Cancel',
+    destructive: 'Kill it with fire!',
+    help: 'Tell me more'
+  }) do |button|
+  # button is :cancel, :destructive or :help
+end
 ```
 
 ###### UIButton

data/lib/sugarcube/version.rb

@@ -1,3 +1,3 @@
 module SugarCube
-  Version = '1.5.8'
+  Version = '1.5.9'
 end

data/lib/sugarcube-color/symbol.rb

@@ -35,21 +35,21 @@ class Symbol
   }
 
   @uicolors = {
-    black:     :blackColor,
-    blue:      :blueColor,
-    brown:     :brownColor,
-    cyan:      :cyanColor,
+    black:      :blackColor,
+    blue:       :blueColor,
+    brown:      :brownColor,
+    cyan:       :cyanColor,
     dark_gray:  :darkGrayColor,
-    gray:      :grayColor,
-    green:     :greenColor,
+    gray:       :grayColor,
+    green:      :greenColor,
     light_gray: :lightGrayColor,
-    magenta:   :magentaColor,
-    orange:    :orangeColor,
-    purple:    :purpleColor,
-    red:       :redColor,
-    yellow:    :yellowColor,
-    white:     :whiteColor,
-    clear:     :clearColor,
+    magenta:    :magentaColor,
+    orange:     :orangeColor,
+    purple:     :purpleColor,
+    red:        :redColor,
+    yellow:     :yellowColor,
+    white:      :whiteColor,
+    clear:      :clearColor,
 
     light_text: :lightTextColor,
     dark_text:  :darkTextColor,

data/lib/sugarcube-factories/uiactionsheet.rb

@@ -17,6 +17,11 @@ class UIActionSheet
   #     # use one handler for all buttons
   #     UIActionSheet.alert("title", buttons: [...]) { |button| }
   def self.alert(title, options={}, &block)
+    if title.is_a?(Hash)
+      options = title
+      title = options[:title]
+    end
+
     # create the delegate
     delegate = SugarCube::ActionSheetDelegate.new
     delegate.on_default = block
@@ -28,10 +33,10 @@ class UIActionSheet
     args = [title]            # initWithTitle:
     args << delegate          # delegate:
 
-    buttons = []
-    buttons.concat(options[:buttons]) if options[:buttons]
-
+    buttons = (options[:buttons] || []).freeze
     if buttons.empty?
+      buttons = []  # an empty Hash becomes an Array
+
       # cancelButtonTitle:
       buttons << nil
 
@@ -45,32 +50,53 @@ class UIActionSheet
     end
 
     # cancelButtonTitle:destructiveButtonTitle:otherButtonTitles:
-    args.concat(buttons.map{ |s| s ? s.localized : nil })
+    # uses localized buttons in the actual alert
+    if buttons.is_a?(Hash)
+      if buttons.key?(:cancel)
+        args << (buttons[:cancel] && buttons[:cancel].localized)
+      else
+        args << nil
+      end
+      if buttons.key?(:destructive)
+        args << (buttons[:destructive] && buttons[:destructive].localized)
+      else
+        args << nil
+      end
+      args.concat(buttons.select { |k, m| k != :cancel && k != :destructive }.map { |k, m| m && m.localized })
+    else
+      args.concat(buttons.map { |m| m && m.localized })
+    end
     args << nil  # otherButtonTitles:..., nil
 
     # the button titles, mapped to how UIActionSheet orders them.  These are
     # passed to the success handler.
     buttons_mapped = {}
+    if buttons.is_a?(Hash)
+      button_titles = buttons.keys
+    else
+      button_titles = buttons
+    end
+
     if args[2] && args[3]  # cancel && destructive buttons
-      buttons_mapped[0] = buttons[1]                   # destructiveIndex == 0, button == 1
-      buttons_mapped[buttons.length - 1] = buttons[0]  # cancelIndex == last, button == 0
+      buttons_mapped[0] = button_titles[1]                   # destructiveIndex == 0, button == 1
+      buttons_mapped[button_titles.length - 1] = button_titles[0]  # cancelIndex == last, button == 0
       # from first+1 to last-1
-      buttons[2..-1].each_with_index do |button,index|
+      button_titles[2..-1].each_with_index do |button,index|
         buttons_mapped[index + 1] = button
       end
     elsif args[3]  # destructive button
-      buttons_mapped[0] = buttons[1]                   # destructiveIndex == 0, button == 1
+      buttons_mapped[0] = button_titles[1]                   # destructiveIndex == 0, button == 1
       # from first+1 to last-1
       buttons[2..-1].each_with_index do |button,index|
         buttons_mapped[index + 1] = button
       end
     elsif args[2]  # cancel button
-      buttons_mapped[buttons.length - 2] = buttons[0]  # cancelIndex == last, button == 0
-      buttons[2..-1].each_with_index do |button,index|
+      buttons_mapped[buttons.length - 2] = button_titles[0]  # cancelIndex == last, button == 0
+      button_titles[2..-1].each_with_index do |button,index|
         buttons_mapped[index] = button
       end
     else
-      buttons[2..-1].each_with_index do |button,index|
+      button_titles[2..-1].each_with_index do |button,index|
         buttons_mapped[index] = button
       end
     end
@@ -134,7 +160,7 @@ module SugarCube
     attr_accessor :on_destructive
     attr_accessor :on_success
 
-    def actionSheet(alert, didDismissWithButtonIndex:index)
+    def actionSheet(alert, didDismissWithButtonIndex: index)
       handler = nil
       if index == alert.destructiveButtonIndex && on_destructive
         handler = on_destructive
@@ -148,12 +174,14 @@ module SugarCube
       if handler
         if handler.arity == 0
           handler.call
-        elsif handler.arity == 1
-          button = buttons[index]
-          handler.call(button)
         else
           button = buttons[index]
-          handler.call(button, index)
+
+          if handler.arity == 1
+            handler.call(button)
+          else
+            handler.call(button, index)
+          end
         end
       end
 

data/lib/sugarcube-factories/uialertview.rb

@@ -1,22 +1,38 @@
 class UIAlertView
 
-  # UIAlertView.alert("title",
-  #   message: "help!",
-  #   # The first button is considered the 'cancel' button, for the purposes of
-  #   # whether the cancel or success handler gets called
-  #   buttons: %w"Cancel OK No-way",
-  #   cancel: proc{ puts "nevermind" },
-  #   success: proc{ |pressed| puts "pressed: #{pressed}" },
-  #   )
-  #
-  # If you choose
+  # @example
+  #     UIAlertView.alert("title",
+  #       message: "help!",
+  #       # The first button is considered the 'cancel' button, for the purposes of
+  #       # whether the cancel or success handler gets called
+  #       buttons: %w"Cancel OK No-way",
+  #       cancel: proc{ puts "nevermind" },
+  #       success: proc{ |pressed| puts "pressed: #{pressed}" },
+  #       )
+  #     # you can explicitly set the cancel button by using a Hash for the :buttons option
+  #     UIAlertView.alert("title",
+  #       message: "help!",
+  #       # The first button is considered the 'cancel' button, for the purposes of
+  #       # whether the cancel or success handler gets called
+  #       buttons: { cancel: 'Cancel', ok: 'OK', no_way: 'No-way' },
+  #       cancel: proc{ puts "nevermind" },
+  #       success: proc{ |pressed| puts "pressed: #{pressed.inspect}" },
+  #       )  # pressed will be :ok or :no_way
   def self.alert(title, options={}, more_options={}, &block)
-    if options.is_a? String
-      more_options[:message] = options
+    if title.is_a?(Hash)
+      options = title
+      title = options[:title]
+      message = options[:message]
+    elsif options.is_a? String
+      message = options
       options = more_options
+    else
+      message = options[:message]
     end
 
-    # create the delegate
+    # The delegate gets retained here because UIAlertView#delegate is a weak
+    # reference.  It's released in the delegate method
+    # `#didDismissWithButtonIndex(index)`
     delegate = SugarCube::AlertViewDelegate.new
     delegate.on_success = options[:success]
     delegate.on_cancel = options[:cancel]
@@ -24,11 +40,13 @@ class UIAlertView
     delegate.send(:retain)
 
     args = [title]            # initWithTitle:
-    args << options[:message] # message:
+    args << message           # message:
     args << delegate          # delegate:
 
-    buttons = options[:buttons] || []
+    buttons = (options[:buttons] || []).freeze
     if buttons.empty?
+      buttons = []  # an empty Hash becomes an Array
+
       # cancelButtonTitle: is first, so check for cancel
       if options[:cancel]
         buttons << "Cancel"
@@ -41,19 +59,35 @@ class UIAlertView
       elsif options[:success]
         buttons << "OK"
       end
+    elsif buttons.is_a?(Hash)
+
     elsif buttons.length == 1 && options[:cancel]
       raise "If you only have one button, use a :success handler, not :cancel (and definitely not BOTH)"
     end
 
     # the button titles.  These are passed to the success handler.
-    delegate.buttons = buttons
+    if buttons.is_a?(Hash)
+      button_titles = buttons.keys
+    else
+      button_titles = buttons
+    end
+    delegate.buttons = button_titles
 
     # uses localized buttons in the actual alert
-    args.concat(buttons.map { |m| m && m.localized })
+    if buttons.is_a?(Hash)
+      if buttons.key?(:cancel)
+        args << (buttons[:cancel] && buttons[:cancel].localized)
+      else
+        args << nil
+      end
+      args.concat(buttons.select { |k, m| k != :cancel }.map { |k, m| m && m.localized })
+    else
+      args.concat(buttons.map { |m| m && m.localized })
+    end
     args << nil  # otherButtonTitles:..., nil
 
     alert = self.alloc
-    alert.send(:"initWithTitle:message:delegate:cancelButtonTitle:otherButtonTitles:", *args)
+    alert.send("initWithTitle:message:delegate:cancelButtonTitle:otherButtonTitles:", *args)
     if options.key?(:style)
       style = options[:style]
       style = style.uialertstyle if style.respond_to?(:uialertstyle)
@@ -115,6 +149,7 @@ module SugarCube
           # but only send the ones they asked for
           args = args[0...handler.arity]
         end
+
         handler.call(*args)
       end
 

data/runtests

@@ -1 +1,3 @@
-rake spec && rake spec retina=3.5 output=tap && rake spec retina=4 output=tap
+rake spec output=tap && \
+rake spec retina=3.5 output=tap && \
+rake spec retina=4 output=tap