cha_work 0.1

data/lib/cha_work/sugar/time.rb

@@ -0,0 +1,81 @@
+class Numeric
+
+  def milliseconds
+    self / 1000.0
+  end
+  alias millisecond milliseconds
+  alias millisecs milliseconds
+  alias millisec milliseconds
+
+  def in_milliseconds
+    self * 1000
+  end
+
+  def seconds
+    self
+  end
+  alias second seconds
+  alias sec seconds
+  alias secs seconds
+
+  def in_seconds
+    self
+  end
+
+  def minutes
+    self * 60
+  end
+  alias minute minutes
+  alias min minutes
+  alias mins minutes
+
+  def in_minutes
+    self / 1.minute.to_f
+  end
+
+  def hours
+    self * 3600
+  end
+  alias hour hours
+
+  def in_hours
+    self / 1.hour.to_f
+  end
+
+  def days
+    self.hours * 24
+  end
+  alias day days
+
+  def in_days
+    self / 1.day.to_f
+  end
+
+  def weeks
+    self.days * 7
+  end
+  alias week weeks
+
+  def in_weeks
+    self / 1.week.to_f
+  end
+
+  def months
+    self.days * 30
+  end
+  alias month months
+
+  def in_months
+    self / 1.month.to_f
+  end
+
+  def years
+    self.days * 365
+  end
+  alias year years
+
+  def in_years
+    self / 1.year.to_f
+  end
+
+end

data/lib/cha_work/sugar/uiactionsheet.rb

@@ -0,0 +1,189 @@
+class UIActionSheet
+
+  # For the purposes of whether the cancel or success handler gets called, the
+  # first button is considered the 'cancel' button, the second button is the
+  # 'destructive' button, and the rest are plain old buttons.
+  #
+  # If you use just one block, it will be used for *all* of the buttons.
+  #
+  # @example
+  #     # use a different handler for each button type
+  #     UIActionSheet.alert("title",
+  #       buttons: %w"Cancel Delete No-way",
+  #       cancel: proc{ puts "nevermind" },
+  #       destructive: proc{ puts "OHHH YEAAH!" },
+  #       success: proc{ |pressed| puts "pressed: #{pressed}" },
+  #       )
+  #     # use one handler for all buttons
+  #     UIActionSheet.alert("title", buttons: [...]) { |button| }
+  def self.alert(title, options={}, &block)
+    if title.is_a?(NSDictionary)
+      options = title
+      title = options[:title]
+    end
+
+    # create the delegate
+    delegate = ChaWork::ActionSheetDelegate.new
+    delegate.on_default = block
+    delegate.on_success = options[:success]
+    delegate.on_destructive = options[:destructive]
+    delegate.on_cancel = options[:cancel]
+    delegate.send(:retain)
+
+    args = [title]            # initWithTitle:
+    args << delegate          # delegate:
+
+    buttons = (options[:buttons] || []).freeze
+    if buttons.empty?
+      buttons = []  # an empty Hash becomes an Array
+
+      # cancelButtonTitle:
+      buttons << nil
+
+      # destructiveButtonTitle
+      buttons << nil
+
+      # otherButtonTitles:
+      buttons << 'OK'
+    elsif buttons.length == 1 && (options[:cancel] || options[:destructive])
+      raise 'If you only have one button, use a :success handler, not :cancel or :destructive'
+    end
+
+    # the button titles, mapped to how UIActionSheet orders them.  These are
+    # passed to the success handler.
+    buttons_mapped = {}
+
+    # cancelButtonTitle:destructiveButtonTitle:otherButtonTitles:
+    # uses localized buttons in the actual alert
+    if buttons.is_a?(NSDictionary)
+      button_keys = buttons.keys
+      if buttons.key?(:cancel)
+        args << (buttons[:cancel] && NSBundle.mainBundle.localizedStringForKey(buttons[:cancel], value: nil, table: nil))
+      else
+        args << nil
+      end
+      if buttons.key?(:destructive)
+        args << (buttons[:destructive] && NSBundle.mainBundle.localizedStringForKey(buttons[:destructive], value: nil, table: nil))
+      else
+        args << nil
+      end
+      args.concat(buttons.select { |k, m| k != :cancel && k != :destructive }.map { |k, m| m && NSBundle.mainBundle.localizedStringForKey(m, value: nil, table: nil) })
+    else
+      button_keys = buttons
+      args.concat(buttons.map { |m| m && NSBundle.mainBundle.localizedStringForKey(m, value: nil, table: nil) })
+    end
+    args << nil  # otherButtonTitles:..., nil
+
+    if args[2] && args[3]  # cancel && destructive buttons
+      buttons_mapped[0] = button_keys[1]                   # destructiveIndex == 0, button == 1
+      buttons_mapped[button_keys.length - 1] = button_keys[0]  # cancelIndex == last, button == 0
+      # from first+1 to last-1
+      button_keys[2..-1].each_with_index do |button,index|
+        buttons_mapped[index + 1] = button
+      end
+    elsif args[3]  # destructive button
+      buttons_mapped[0] = button_keys[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] = button_keys[0]  # cancelIndex == last, button == 0
+      button_keys[2..-1].each_with_index do |button,index|
+        buttons_mapped[index] = button
+      end
+    else
+      button_keys[2..-1].each_with_index do |button,index|
+        buttons_mapped[index] = button
+      end
+    end
+    delegate.buttons = buttons_mapped
+
+    alert = self.alloc
+    alert.send('initWithTitle:delegate:cancelButtonTitle:destructiveButtonTitle:otherButtonTitles:', *args)
+
+    if options.key?(:style)
+      style = options[:style]
+      if style.respond_to?(:uiactionstyle)
+        style = style.uiactionstyle
+      end
+      alert.actionSheetStyle = style
+    end
+
+    if options.fetch(:show, true)
+      if options.key?(:from)
+        from = options[:from]
+      else
+        from = UIApplication.sharedApplication.windows[0]
+      end
+
+      case from
+      when CGRect
+        view = options.fetch(:view, UIApplication.sharedApplication.windows[0])
+        alert.showFromRect(from, inView: view, animated: true)
+      when UIBarButtonItem
+        alert.showFromBarButtonItem(from, animated: true)
+      when UIToolbar
+        alert.showFromToolbar(from)
+      when UITabBar
+        alert.showFromTabBar(from)
+      when UIView
+        alert.showInView(from)
+      else
+        raise "Unknown :from option #{from.inspect}"
+      end
+    end
+
+    alert
+  end
+
+  def <<(title)
+    addButtonWithTitle(title)
+  end
+
+  private
+  def dummy
+    self.initWithTitle(nil, delegate:nil, cancelButtonTitle:nil, destructiveButtonTitle:nil, otherButtonTitles:nil)
+  end
+
+end
+
+
+module ChaWork
+  class ActionSheetDelegate
+    attr_accessor :buttons
+    attr_accessor :on_default
+    attr_accessor :on_cancel
+    attr_accessor :on_destructive
+    attr_accessor :on_success
+
+    def actionSheet(alert, didDismissWithButtonIndex: index)
+      handler = nil
+      if index == alert.destructiveButtonIndex && on_destructive
+        handler = on_destructive
+      elsif index == alert.cancelButtonIndex && on_cancel
+        handler = on_cancel
+      elsif index != alert.destructiveButtonIndex && index != alert.cancelButtonIndex && on_success
+        handler = on_success
+      end
+      handler ||= on_default
+
+      if handler
+        if handler.arity == 0
+          handler.call
+        else
+          button = buttons[index]
+
+          if handler.arity == 1
+            handler.call(button)
+          else
+            handler.call(button, index)
+          end
+        end
+      end
+
+      self.send(:autorelease)
+    end
+
+  end
+end

data/lib/cha_work/sugar/uibutton.rb

@@ -0,0 +1,7 @@
+class UIButton
+
+	def title=(text)
+		self.setTitle(text, forState:UIControlStateNormal)
+		self
+	end
+end

data/lib/cha_work/sugar/uicontrol.rb

@@ -0,0 +1,99 @@
+# Additions to UIControl to support jQuery-style `on` and `off` methods.
+class UIControl
+
+  # Add event handlers to UIControls.  See symbol.rb for the uicontrolevent
+  # constant aliases.
+  #
+  # @example
+  #   button = UIButton.alloc.initWithFrame([0, 0, 10, 10])
+  #   button.on(:touch) { my_code }
+  #   button.on(:touch_up_outside, :touch_cancel) { my_code }
+  #   # up to two arguments can be passed in
+  #   button.on(:touch) { |sender,touch_event| my_code }
+  def on(*events, &block)
+    handler = ChaWork::UIControlCallbackHelper.new(block)
+
+    events.each do |event|
+      event = event.uicontrolevent if event.respond_to?(:uicontrolevent)
+
+      sugarcube_callbacks(event).push(handler)
+      self.addTarget(handler, action:'call:event:', forControlEvents:event)
+    end
+
+    self
+  end
+
+  # Removes all events that were bound with `on`.  See symbol.rb for the
+  # uicontrolevent constant aliases.
+  #
+  # @example
+  #   button.off(:touch)
+  #   button.off(:touch_up_outside, :touch_cancel)
+  #   button.off  # all events
+  def off(*events)
+    if events.length == 0
+      events = sugarcube_callbacks.keys
+    end
+
+    events.each do |event|
+      event = event.uicontrolevent if event.respond_to?(:uicontrolevent)
+
+      sugarcube_callbacks(event).each do |handler|
+        self.removeTarget(handler, action:'call:event:', forControlEvents:event)
+      end
+      sugarcube_callbacks.delete(event)
+    end
+
+    self
+  end
+
+  # Useful during testing, or to simulate a button press.
+  #
+  # @example
+  #   button.trigger(:touch)
+  #   button.trigger(:touch_drag_outside, :touch_drag_exits)
+  def trigger(*events)
+    event_mask = 0
+    events.each do |event|
+      event = event.uicontrolevent if event.respond_to?(:uicontrolevent)
+      event_mask |= event
+    end
+    sendActionsForControlEvents(event_mask)
+  end
+
+private
+  # event blocks need to be retained, and the addTarget method explicitly does
+  # *not* retain `target`.  This makes sure that callbacks are retained by
+  # pushing the block onto a stack.
+  def sugarcube_callbacks(event=nil)
+    @sugarcube_callbacks ||= {}
+    if event
+      @sugarcube_callbacks[event] ||= []
+      return @sugarcube_callbacks[event]
+    else
+      return @sugarcube_callbacks
+    end
+  end
+
+end
+
+
+module ChaWork
+  class UIControlCallbackHelper
+
+    def initialize(callback)
+      @callback = callback.respond_to?('weak!') ? callback.weak! : callback
+    end
+
+    def call(sender, event:event)
+      case @callback.arity
+      when 0
+        @callback.call
+      when 1
+        @callback.call(sender)
+      else
+        @callback.call(sender, event)
+      end
+    end
+  end
+end

data/lib/cha_work/sugar/uiimageview.rb

@@ -0,0 +1,4 @@
+class UIImageView
+
+
+end

data/lib/cha_work/sugar/uilabel.rb

@@ -0,0 +1,21 @@
+class UILabel
+
+	def on
+		self.becomeFirstResponder
+	end
+
+	def off
+		self.resignFirstResponder
+	end
+
+	def color(value)
+		self.textColor = value.class == UIColor ? value : value.uicolor
+		self
+	end
+
+	def size(value)
+		self.font = UIFont.systemFontOfSize(value)
+		self
+	end
+
+end

data/lib/cha_work/sugar/uitableview.rb

@@ -0,0 +1,13 @@
+class UITableView
+  class << self
+
+    def plain(frame=[[0, 0], [0, 0]])
+      UITableView.alloc.initWithFrame(frame, style: UITableViewStylePlain)
+    end
+
+    def grouped(frame=[[0, 0], [0, 0]])
+      UITableView.alloc.initWithFrame(frame, style: UITableViewStyleGrouped)
+    end
+
+  end
+end

data/lib/cha_work/sugar/uiview.rb

@@ -0,0 +1,306 @@
+class UIView
+
+  class << self
+
+    def attr_updates(*attrs)
+      attr_accessor(*attrs)
+      attrs.each do |attr|
+        define_method("#{attr}=") do |value|
+          if instance_variable_get("@#{attr}") != value
+            setNeedsDisplay
+          end
+          willChangeValueForKey(attr)
+          instance_variable_set("@#{attr}", value)
+          didChangeValueForKey(attr)
+        end
+      end
+    end
+
+  end
+
+  # superview << view
+  # => superview.addSubview(view)
+  def <<(view)
+    self.addSubview(view)
+    return self
+  end
+
+
+  def show
+    self.hidden = false
+    return self
+  end
+
+  def hide
+    self.hidden = true
+    return self
+  end
+  
+   # Easily take a snapshot of a `UIView`.
+   #
+   # Calling `uiimage` with no arguments will return the image based on the
+   # `bounds` of the image.  In the case of container views (notably
+   # `UIScrollView` and its children) this does not include the entire contents,
+   # which is something you probably want.
+   #
+   # If you pass a truthy value to this method, it will use the `contentSize` of
+   # the view instead of the `bounds`, and it will draw all the child views, not
+   # just those that are visible in the viewport.
+   #
+   # It is guaranteed that `true` and `:all` will always have this behavior.  In
+   # the future, if this argument becomes something that accepts multiple values,
+   # those two are sacred.
+  def uiimage(use_content_size=false)
+    if use_content_size
+      UIGraphicsBeginImageContextWithOptions(contentSize, false, 0.0)
+      context = UIGraphicsGetCurrentContext()
+      self.subviews.each do |subview|
+        CGContextSaveGState(context)
+        CGContextTranslateCTM(context, subview.frame.origin.x, subview.frame.origin.y)
+        subview.layer.renderInContext(context)
+        CGContextRestoreGState(context)
+      end
+      image = UIGraphicsGetImageFromCurrentImageContext()
+      UIGraphicsEndImageContext()
+    else
+      UIGraphicsBeginImageContextWithOptions(bounds.size, false, 0.0)
+      if self.respond_to?('drawViewHierarchyInRect:afterScreenUpdates:')
+        self.drawViewHierarchyInRect(self.bounds, afterScreenUpdates: true)
+      else
+        layer.renderInContext(UIGraphicsGetCurrentContext())
+      end
+      image = UIGraphicsGetImageFromCurrentImageContext()
+      UIGraphicsEndImageContext()
+    end
+    return image
+  end
+
+  # A generic gesture adder, but accepts a block like the other gesture methods
+  # @yield [recognizer] Handles the gesture event, and passes the recognizer instance to the block.
+  # @param options [Hash] method/value pairs to call on the gesture.
+  # @overload on_gesture(recognizer)
+  #   Adds the gesture to the view, and yields the block when the gesture is recognized
+  # @overload on_gesture(recognizer_class)
+  #   Instantiates a gesture and adds it to the view.
+  # @example Using a UIGestureRecognizer class
+  #   view.on_gesture(UISwipeGestureRecognizer, direction: UISwipeGestureRecognizerDirectionLeft) { puts "swiped left" }
+  # @example Using a UIGestureRecognizer instance
+  #   gesture = UISwipeGestureRecognizer
+  #   gesture.direction = UISwipeGestureRecognizerDirectionLeft
+  #   view.on_gesture(gesture) { puts "swiped left" }
+  def on_gesture(klass, options={}, &proc)
+    if klass.is_a? UIGestureRecognizer
+      recognizer = klass
+      recognizer.addTarget(self, action:'sugarcube_handle_gesture:')
+    else
+      recognizer = klass.alloc.initWithTarget(self, action:'sugarcube_handle_gesture:')
+    end
+
+    options.each do |method, value|
+      recognizer.send(method, value)
+    end
+    sugarcube_add_gesture(proc, recognizer)
+  end
+
+  def off_gestures
+    if @sugarcube_recognizers
+      @sugarcube_recognizers.each do |recognizer, proc|
+        self.removeGestureRecognizer(recognizer)
+      end
+      @sugarcube_recognizers = nil
+    end
+
+    self
+  end
+
+  # @yield [recognizer] Handles the gesture event, and passes the recognizer instance to the block.
+  # @overload on_tap(taps)
+  #   @param taps [Fixnum] Number of taps
+  # @overload on_tap(options)
+  #   @option options [Fixnum] :taps Number of taps before gesture is recognized
+  #   @option options [Fixnum] :fingers Number of fingers before gesture is recognized
+  def on_tap(taps_or_options=nil, &proc)
+    taps = nil
+    fingers = nil
+
+    if taps_or_options
+      if taps_or_options.is_a? Hash
+        taps = taps_or_options[:taps] || taps
+        fingers = taps_or_options[:fingers] || fingers
+      else
+        taps = taps_or_options
+      end
+    end
+
+    recognizer = UITapGestureRecognizer.alloc.initWithTarget(self, action:'sugarcube_handle_gesture:')
+    recognizer.numberOfTapsRequired = taps if taps
+    recognizer.numberOfTouchesRequired = fingers if fingers
+    sugarcube_add_gesture(proc, recognizer)
+  end
+
+  # @yield [recognizer] Handles the gesture event, and passes the recognizer instance to the block.
+  def on_pinch(&proc)
+    recognizer = UIPinchGestureRecognizer.alloc.initWithTarget(self, action:'sugarcube_handle_gesture:')
+    sugarcube_add_gesture(proc, recognizer)
+  end
+
+  # @yield [recognizer] Handles the gesture event, and passes the recognizer instance to the block.
+  def on_rotate(&proc)
+    recognizer = UIRotationGestureRecognizer.alloc.initWithTarget(self, action:'sugarcube_handle_gesture:')
+    sugarcube_add_gesture(proc, recognizer)
+  end
+
+  # @yield [recognizer] Handles the gesture event, and passes the recognizer instance to the block.
+  # @overload on_swipe(taps)
+  #   @param direction [Fixnum] Direction of swipe
+  # @overload on_swipe(options)
+  #   @option options [Fixnum] :fingers Number of fingers before gesture is recognized
+  #   @option options [Fixnum, Symbol] :direction Direction of swipe, as a UISwipeGestureRecognizerDirection constant or a symbol (`:left, :right, :up, :down`)
+  def on_swipe(direction_or_options=nil, &proc)
+    direction = nil
+    fingers = nil
+
+    if direction_or_options
+      if direction_or_options.is_a? Hash
+        direction = direction_or_options[:direction] || direction
+        fingers = direction_or_options[:fingers] || fingers
+      else
+        direction = direction_or_options
+      end
+    end
+
+    case direction
+    when :left
+      direction = UISwipeGestureRecognizerDirectionLeft
+    when :right
+      direction = UISwipeGestureRecognizerDirectionRight
+    when :up
+      direction = UISwipeGestureRecognizerDirectionUp
+    when :down
+      direction = UISwipeGestureRecognizerDirectionDown
+    end
+
+    recognizer = UISwipeGestureRecognizer.alloc.initWithTarget(self, action:'sugarcube_handle_gesture:')
+    recognizer.direction = direction if direction
+    recognizer.numberOfTouchesRequired = fingers if fingers
+    sugarcube_add_gesture(proc, recognizer)
+  end
+
+  # @yield [recognizer] Handles the gesture event, and passes the recognizer instance to the block.
+  # @overload on_tap(taps)
+  #   @param taps [Fixnum] Number of taps
+  # @overload on_tap(options)
+  #   @option options [Fixnum] :min_fingers Minimum number of fingers for gesture to be recognized
+  #   @option options [Fixnum] :max_fingers Maximum number of fingers for gesture to be recognized
+  #   @option options [Fixnum] :fingers If min_fingers or max_fingers is not assigned, this will be the default.
+  def on_pan(fingers_or_options=nil, &proc)
+    fingers = nil
+    min_fingers = nil
+    max_fingers = nil
+
+    if fingers_or_options
+      if fingers_or_options.is_a? Hash
+        fingers = fingers_or_options[:fingers] || fingers
+        min_fingers = fingers_or_options[:min_fingers] || min_fingers
+        max_fingers = fingers_or_options[:max_fingers] || max_fingers
+      else
+        fingers = fingers_or_options
+      end
+    end
+
+    # if fingers is assigned, but not min/max, assign it as a default
+    min_fingers ||= fingers
+    max_fingers ||= fingers
+
+    recognizer = UIPanGestureRecognizer.alloc.initWithTarget(self, action:'sugarcube_handle_gesture:')
+    recognizer.maximumNumberOfTouches = min_fingers if min_fingers
+    recognizer.minimumNumberOfTouches = max_fingers if max_fingers
+    sugarcube_add_gesture(proc, recognizer)
+  end
+
+  # @yield [recognizer] Handles the gesture event, and passes the recognizer instance to the block.
+  # @overload on_press(duration)
+  #   @param duration [Fixnum] How long in seconds before gesture is recognized
+  # @overload on_tap(options)
+  #   @option options [Fixnum] :duration How long in seconds before gesture is recognized
+  #   @option options [Fixnum] :taps Number of taps before gesture is recognized
+  #   @option options [Fixnum] :fingers Number of fingers before gesture is recognized
+  def on_press(duration_or_options=nil, &proc)
+    duration = nil
+    taps = nil
+    fingers = nil
+
+    if duration_or_options
+      if duration_or_options.is_a? Hash
+        duration = duration_or_options[:duration] || duration
+        taps = duration_or_options[:taps] || taps
+        fingers = duration_or_options[:fingers] || fingers
+      else
+        duration = duration_or_options
+      end
+    end
+
+    recognizer = UILongPressGestureRecognizer.alloc.initWithTarget(self, action:'sugarcube_handle_gesture:')
+    recognizer.minimumPressDuration = duration if duration
+    recognizer.numberOfTapsRequired = taps if taps
+    recognizer.numberOfTouchesRequired = fingers if fingers
+    sugarcube_add_gesture(proc, recognizer)
+  end
+
+  def on_press_begin(duration_or_options=nil, &proc)
+    duration = nil
+    taps = nil
+    fingers = nil
+
+    if duration_or_options
+      if duration_or_options.is_a? Hash
+        duration = duration_or_options[:duration] || duration
+        taps = duration_or_options[:taps] || taps
+        fingers = duration_or_options[:fingers] || fingers
+      else
+        duration = duration_or_options
+      end
+    end
+
+    recognizer = UILongPressGestureRecognizer.alloc.initWithTarget(self, action:'sugarcube_handle_gesture_long_press_on_begin:')
+    recognizer.minimumPressDuration = duration if duration
+    recognizer.numberOfTapsRequired = taps if taps
+    recognizer.numberOfTouchesRequired = fingers if fingers
+    sugarcube_add_gesture(proc, recognizer)
+  end
+
+
+private
+  def sugarcube_handle_gesture(recognizer)
+    handler = @sugarcube_recognizers[recognizer]
+    if handler.arity == 0
+      handler.call
+    else
+      handler.call(recognizer)
+    end
+  end
+  def sugarcube_handle_gesture_long_press_on_begin(recognizer)
+    if recognizer.state==UIGestureRecognizerStateBegan
+      handler = @sugarcube_recognizers[recognizer]
+      if handler.arity == 0
+        handler.call
+      else
+        handler.call(recognizer)
+      end
+    end
+  end
+
+  # Adds the recognizer and keeps a strong reference to the Proc object.
+  def sugarcube_add_gesture(proc, recognizer)
+    unless self.userInteractionEnabled?
+      puts("SugarCube: userInteractionEnabled is false on #{self.inspect}. Adding a gesture will have no effect.")
+    end
+    self.addGestureRecognizer(recognizer)
+
+    @sugarcube_recognizers = {} unless @sugarcube_recognizers
+    @sugarcube_recognizers[recognizer] = proc.respond_to?('weak!') ? proc.weak! : proc
+
+    recognizer
+  end
+
+end