teacup 0.0.1.pre → 0.3.1

data/app/controllers/first_controller.rb

@@ -0,0 +1,71 @@
+
+class FirstController < UIViewController
+
+  stylesheet :first
+
+  layout :root do
+    subview(CustomView, :background) do
+      @welcome = subview(UILabel, :welcome)
+      subview(UILabel, :footer)
+      @button = subview(UIButton.buttonWithType(UIButtonTypeRoundedRect), :next_message)
+    end
+
+    @button.addTarget(self, action: :next_message, forControlEvents:UIControlEventTouchUpInside)
+  end
+
+  # used in testing
+  def landscape_only
+    UIApplication.sharedApplication.windows[0].rootViewController = LandscapeOnlyController.alloc.init
+  end
+
+  def next_view
+    landscape_only
+  end
+
+  def next_message
+    msg = messages.shift
+    if msg
+      @welcome.text = msg
+    else
+      @welcome.text = 'Next example...'
+
+      @button.removeTarget(self, action: :next_view, forControlEvents:UIControlEventTouchUpInside)
+      @button.addTarget(self, action: :next_view, forControlEvents:UIControlEventTouchUpInside)
+    end
+  end
+
+  def messages
+    @messages ||= [
+      'This is teacup',
+      'Welcome',
+      'This is teacup',
+      'Welcome to teacup',
+      'You can do anything at teacup',
+      'Anything at all',
+      'The only limit is yourself ',
+      'Welcome to teacup',
+      'Welcome to teacup',
+      'This is teacup',
+      'Welcome to teacup',
+      'This is teacup, Welcome',
+      'Yes, this is teacup',
+      'This is teacup and welcome to you who have come to teacup',
+      'Anything is possible at teacup',
+      'You can to anything teacup',
+      'The infinite is possible at teacup',
+      'The unattainable is unknown at teacup',
+      'Welcome to teacup',
+      'This is teacup',
+      'Welcome to teacup',
+      'Welcome',
+      'This is teacup',
+      'Welcome to teacup',
+      'Welcome to teacup',
+    ]
+  end
+
+  def shouldAutorotateToInterfaceOrientation(orientation)
+    autorotateToOrientation(orientation)
+  end
+
+end

data/app/controllers/landscape_only_controller.rb

@@ -0,0 +1,16 @@
+
+class LandscapeOnlyController < UIViewController
+
+  def viewDidLoad
+    UIApplication.sharedApplication.windows[0].rootViewController = FirstController.alloc.init
+  end
+
+  def shouldAutorotateToInterfaceOrientation(orientation)
+    if orientation == UIDeviceOrientationLandscapeLeft or orientation == UIDeviceOrientationLandscapeRight
+      true
+    else
+      false
+    end
+  end
+
+end

data/app/styles/main_styles.rb

@@ -0,0 +1,111 @@
+
+Teacup::Stylesheet.new(:first) do
+
+  # enable orientations on the root view
+  style :root,
+    left: 0,
+    top: 0,
+    width: 320,
+    height: 480,
+    backgroundColor:  UIColor.yellowColor,
+    portrait:    true,
+    upside_down:  false,
+
+    layer: {
+      cornerRadius: 10.0,
+    },
+
+    landscape: {
+      backgroundColor: UIColor.redColor,
+    },
+
+    landscape_left: {
+      layer: {
+        transform: spin(identity, -pi / 2),
+      },
+    },
+
+    landscape_right: {
+      layer: {
+        transform: spin(identity, pi / 2),
+      },
+    }
+
+  style(UILabel, {
+    textColor:  UIColor.blueColor,
+  })
+
+  style CustomView,
+    # for testing how styles override (this gets overridden by any property in
+    # a style block, regardless of whether it is in an orientation style)
+    portrait: {
+      alpha: 0.75
+    },
+    landscape: {
+      alpha: 0.75
+    }
+
+  style(:background, {
+    alpha: 0.5,
+    left: 10,
+    top: 30,
+    backgroundColor:  UIColor.blackColor,
+
+    portrait: {
+      width:  300,
+      height: 440,
+      backgroundColor:  UIColor.darkGrayColor,
+    },
+
+    landscape: {
+      width:  460,
+      height: 280,
+      alpha: 0.8,
+      backgroundColor:  UIColor.lightGrayColor,
+    },
+  })
+
+  style(:welcome, {
+    left:   10,
+    top:    40,
+    width:  280,
+    height: 20,
+    text:   "Welcome to teacup",
+    landscape: {
+      left: 90,
+    },
+  })
+
+  style(:footer, {
+    left:   10,
+    top:    410,
+    width:  280,
+    height: 20,
+    text:   "This is a teacup example",
+    landscape: {
+      top:  250,
+      left: 90,
+    },
+  })
+
+
+  style :next_message,
+    width:   130,
+    height:  20,
+    portrait: nil,
+    title:   "Next Message..."
+
+  # deliberately declaring this twice for testing purposes
+  # (declaring twice extends it)
+  style :next_message,
+    portrait: {
+      left:   150,
+      top:    370,
+    },
+
+    landscape: {
+      left:   20,
+      top:    200,
+    }
+
+end

data/app/views/custom_view.rb

@@ -0,0 +1,4 @@
+
+class CustomView < UIView
+  # not very custom, is it!?
+end

data/lib/dummy.rb

@@ -0,0 +1,56 @@
+class DummyView < UIView
+private
+  def dummy
+    setFrame(nil)
+    setOpaque(nil)
+  end
+end
+
+class DummyScrollView < UIScrollView
+private
+  def dummy
+    setScrollEnabled(nil)
+    setShowsVerticalScrollIndicator(nil)
+  end
+end
+
+class DummyActivityIndicatorView < UIActivityIndicatorView
+private
+  def dummy
+    setHidesWhenStopped(nil)
+  end
+end
+
+class DummyLabel < UILabel
+private
+  def dummy
+    setAdjustsFontSizeToFitWidth(nil)
+  end
+end
+
+class DummyTextField < UITextField
+private
+  def dummy
+    setReturnKeyType(nil)
+    setAutocapitalizationType(nil)
+    setAutocorrectionType(nil)
+    setSpellCheckingType(nil)
+  end
+end
+
+class DummyLayer < CALayer
+private
+  def dummy
+    setCornerRadius(nil)
+    setTransform(nil)
+    setMasksToBounds(nil)
+    setShadowOffset(nil)
+    setShadowOpacity(nil)
+    setShadowRadius(nil)
+    setShadowOffset(nil)
+    setShadowColor(nil)
+    setShadowPath(nil)
+    setOpaque(nil)
+    setTranslucent(nil)
+  end
+end

data/lib/teacup/handler.rb

@@ -0,0 +1,99 @@
+# Teacup handlers can modify (or alias) styling methods.  For instance, the
+# UIButton class doesn't have a `title` attribute, but we all know that what we
+# *mean* when we say `title: "button title"` is `setTitle("button title",
+# forControlState:UIControlStateNormal)`. A UIButton handler accomplishes this
+# translation.
+#
+# You can write your own handlers!
+#
+#     Teacup.handler UIButton, :title do |view, value|
+#       view.setTitle(value, forControlState:UIControlStateNormal)
+#     end
+#
+# You can declare multiple names in the Teacup.handler method to create aliases
+# for your handler:
+#
+#    Teacup.handler UIButton, :returnKeyType, :returnkey { |view, keytype|
+#      view.setReturnKeyType(keytype)
+#    }
+#
+# Since teacup already supports translating a property like `returnKeyType` into
+# the setter `setReturnKeyType`, you could just use an alias here instead.
+# Assign a hash to `Teacup.alias`:
+#
+#     Teacup.alias UIButton, :returnkey => :returnKeyType
+module Teacup
+  module_function
+
+  # applies a Hash of styles, and converts the frame styles (origin, size, top,
+  # left, width, height) into one frame property.
+  def apply_hash(target, properties)
+    properties.each do |key, value|
+      Teacup.apply target, key, value
+    end
+  end
+
+  # Applies a single style to a target.  Delegates to a teacup handler if one is
+  # found.
+  def apply(target, key, value)
+    # note about `debug`: not all objects in this method are a UIView instance,
+    # so don't assume that the object *has* a debug method.
+
+    target.class.ancestors.each do |ancestor|
+      if Teacup.handlers[ancestor].has_key? key
+        NSLog "#{ancestor.name} is handling #{key} = #{value.inspect}" if target.respond_to? :debug and target.debug
+        Teacup.handlers[ancestor][key].call(target, value)
+        return
+      end
+    end
+
+    # you can send methods to subviews (e.g. UIButton#titleLabel) and CALayers
+    # (e.g. UIView#layer) by assigning a hash to a style name.
+    if Hash === value
+      return Teacup.apply_hash target.send(key), value
+    end
+
+    if key =~ /^set[A-Z]/
+      assign = nil
+      setter = key.to_s + ':'
+    else
+      assign = :"#{key}="
+      setter = 'set' + key.to_s.sub(/^./) {|c| c.capitalize} + ':'
+    end
+
+    if assign and target.respond_to?(assign)
+      NSLog "Setting #{key} = #{value.inspect}" if target.respond_to? :debug and target.debug
+      target.send(assign, value)
+    elsif target.respondsToSelector(setter)
+      NSLog "Calling target(#{key}, #{value.inspect})" if target.respond_to? :debug and target.debug
+      target.send(setter, value)
+    else
+      NSLog "Teacup WARN: Can't apply #{setter.inspect}#{assign and " or " + assign.inspect or ""} to #{target.inspect}"
+    end
+  end
+
+  def handlers
+    @teacup_handlers ||= Hash.new{ |hash,klass| hash[klass] = {} }
+  end
+
+  def handler klass, *stylenames, &block
+    if stylenames.length == 0
+      raise TypeError.new "No style names assigned in Teacup[#{klass.inspect}]##handler"
+    else
+      stylenames.each do |stylename|
+        Teacup.handlers[klass][stylename] = block
+      end
+    end
+    self
+  end
+
+  def alias klass, aliases
+    aliases.each do |style_alias, stylename|
+      Teacup.handlers[klass][style_alias] = proc { |view, value|
+        Teacup.apply view, style_name, value
+      }
+    end
+    self
+  end
+
+end

data/lib/teacup/layout.rb

@@ -1,25 +1,27 @@
+
 module Teacup
-  # Teacup::Layout defines a layout function that can be used to configure the
-  # layout of views in your application.
+  # Teacup::Layout defines a layout and subview function that can be used to
+  # declare and configure the layout of views and the view hierarchy in your
+  # application.
   #
-  # It is included into UIView and UIViewController directly so these functions
-  # should be available when you need them.
+  # This module is included into UIView and UIViewController directly so these
+  # functions are available in the places you need them.
   #
   # In order to use layout() in a UIViewController most effectively you will want
   # to define a stylesheet method that returns a stylesheet.
   #
   # @example
   #   class MyViewController < UIViewController
-  #     interface(:my_view) do
+  #     layout(:my_view) do
   #       layout UIImage, :logo
   #     end
-  #  
+  #
   #     def stylesheet
-  #       Teacup::Stylesheet::Logo
+  #       Teacup::Stylesheet[:logo]
   #     end
   #   end
-  #
   module Layout
+    attr_accessor :stylesheet
 
     # Alter the layout of a view
     #
@@ -58,30 +60,29 @@ module Teacup
     #     subview(UIImage, backgroundColor: UIColor.colorWithImagePattern(image)
     #   }
     #
-    def layout(instance, name_or_properties, properties_or_nil=nil, &block)
-      if properties_or_nil
-        name = name_or_properties.to_sym
-        properties = properties_or_nil
-      elsif Hash === name_or_properties
+    def layout(view, name_or_properties=nil, properties_or_nil=nil, &block)
+      name = nil
+      properties = properties_or_nil
+
+      if Hash === name_or_properties
         name = nil
         properties = name_or_properties
-      else
+      elsif name_or_properties
         name = name_or_properties.to_sym
-        properties = nil
       end
 
-      instance.stylesheet = stylesheet
-      instance.style(properties) if properties
-      instance.stylename = name if name
+      view.stylesheet = stylesheet
+      view.stylename = name
+      view.style(properties) if properties
 
       begin
-        superview_chain << instance
-        instance_exec(instance, &block) if block_given?
+        superview_chain << view
+        instance_exec(view, &block) if block_given?
       ensure
         superview_chain.pop
       end
 
-      instance
+      view
     end
 
     # Add a new subview to the view heirarchy.
@@ -123,8 +124,6 @@ module Teacup
     #   }
     #
     def subview(class_or_instance, *args, &block)
-      instance = Class === class_or_instance ? class_or_instance.new : class_or_instance
-
       if Class === class_or_instance
         unless class_or_instance <= UIView
           raise "Expected subclass of UIView, got: #{class_or_instance.inspect}"
@@ -143,59 +142,8 @@ module Teacup
       instance
     end
 
-    # Returns a stylesheet to use to style the contents of this controller's
-    # view.
-    #
-    # This method will be queried each time {restyle!} is called, and also
-    # implicitly # whenever Teacup needs to draw your layout (currently only at
-    # view load time).
-    #
-    # @return Teacup::Stylesheet
-    #
-    # @example
-    #
-    #  def stylesheet
-    #    if [UIDeviceOrientationLandscapeLeft,
-    #        UIDeviceOrientationLandscapeRight].include?(UIDevice.currentDevice.orientation)
-    #      Teacup::Stylesheet::IPad
-    #    else
-    #      Teacup::Stylesheet::IPadVertical
-    #    end
-    #  end
-    def stylesheet
-      nil
-    end
-
-    # Instruct teacup to reapply styles to your subviews
-    #
-    # You should call this whenever the return value of your stylesheet meethod
-    # would change,
-    #
-    # @example
-    #   def willRotateToInterfaceOrientation(io, duration: duration)
-    #     restyle!
-    #   end
-    def restyle!
-      top_level_view.stylesheet = stylesheet
-    end
-
     protected
 
-    # Get's the top-level UIView for this object.
-    #
-    # This can either be 'self' if the current object is in fact a UIView,
-    # or 'view' if it's a controller.
-    #
-    # @return UIView
-    def top_level_view
-      case self
-      when UIViewController
-        view
-      when UIView
-        self
-      end
-    end
-
     # Get's the current stack of views in nested calls to layout.
     #
     # The view at the end of the stack is the one into which subviews

data/lib/teacup/merge_defaults.rb

@@ -0,0 +1,45 @@
+module Teacup
+  module_function
+
+  # Merges two Hashes.  This is similar to `Hash#merge`, except the values will
+  # be merged recursively (aka deep merge) when both values for a key are
+  # Hashes, and values for the *left* argument are preferred over values on the
+  # right.
+  #
+  # If you pass in a third argument, it will be acted upon directly instead of
+  # creating a new Hash.  Usually used with `merge_defaults!`, which merges values
+  # from `right` into `left`.
+  def merge_defaults(left, right, target={})
+    if target != left
+      left.each do |key, value|
+        if target.has_key? key and value.is_a?(Hash) and target[key].is_a?(Hash)
+          target[key] = Teacup::merge_defaults(target[key], value)
+        else
+          if value.is_a?(Hash)
+            # make a copy of the Hash
+            value = Teacup::merge_defaults!({}, value)
+          end
+          target[key] = value
+        end
+      end
+    end
+
+    right.each do |key, value|
+      if not target.has_key? key
+        if value.is_a?(Hash)
+          # make a copy of the Hash
+          value = Teacup::merge_defaults!({}, value)
+        end
+        target[key] = value
+      elsif value.is_a?(Hash) and left[key].is_a?(Hash)
+        target[key] = Teacup::merge_defaults(left[key], value, (left==target ? left[key] : {}))
+      end
+    end
+    target
+  end
+
+  # modifies left by passing it in as the `target`.
+  def merge_defaults!(left, right)
+    Teacup::merge_defaults(left, right, left)
+  end
+end

data/lib/teacup/style.rb

@@ -0,0 +1,93 @@
+module Teacup
+  # The Style class is where the precedence rules are applied.  A Style can
+  # query the Stylesheet that created it to look up other styles (for
+  # `extends:`) and to import other Stylesheets.  If it is handed a target (e.g.
+  # a `UIView` instance) and orientation, it will merge those in appropriately
+  # as well.
+  class Style < Hash
+    attr_accessor :stylename
+    attr_accessor :stylesheet
+
+    Orientations = [:portrait, :upside_up, :upside_down, :landscape, :landscape_left, :landscape_right]
+    Overrides = {
+      0 => [:portrait, :upside_up],
+      UIInterfaceOrientationPortrait => [:portrait, :upside_up],
+      UIInterfaceOrientationPortraitUpsideDown => [:portrait, :upside_down],
+      UIInterfaceOrientationLandscapeLeft => [:landscape, :landscape_left],
+      UIInterfaceOrientationLandscapeRight => [:landscape, :landscape_right],
+    }
+
+    # A hash of orientation => true/false.  true means the orientation is
+    # supported.
+    def supports
+      @supports ||= {}
+    end
+
+    def supports? orientation_key
+      supports.has_key? orientation_key
+    end
+
+    def build(target=nil, orientation=nil, seen={})
+      properties = Style.new.update(self)
+      properties.stylename = self.stylename
+      properties.stylesheet = self.stylesheet
+
+      # at this point, we really DO need the orientation
+      orientation = UIDevice.currentDevice.orientation unless orientation
+
+      # first, move orientation settings into properties "base" level.
+      if orientation
+        Overrides[orientation].each do |orientation_key|
+          if override = properties.delete(orientation_key)
+            # override is first, so it takes precedence
+            if override.is_a? Hash
+              Teacup::merge_defaults override, properties, properties
+            elsif not properties.has_key? orientation_key
+              properties[orientation_key] = override
+            end
+            properties.supports[orientation_key] = properties[orientation_key] ? true : false
+          end
+        end
+      end
+
+      # delete all of them from `properties`
+      Orientations.each do |orientation_key|
+        if properties.delete(orientation_key)
+          properties.supports[orientation_key] = true
+        end
+      end
+
+      # now we can merge extends, and importing.  before merging, these will go
+      # through the same process that we just finished on the local style
+      if stylesheet
+        stylesheet.imported_stylesheets.reverse.each do |stylesheet|
+          imported_properties = stylesheet.query(self.stylename, target, orientation, seen)
+          Teacup::merge_defaults! properties, imported_properties
+        end
+
+        if also_includes = properties.delete(:extends)
+          also_includes = [also_includes] unless also_includes.is_a? Array
+
+          # turn style names into Hashes by querying them on the stylesheet
+          # (this does not pass `seen`, because this is a new query)
+          also_includes.each do |also_include|
+            extended_properties = stylesheet.query(also_include, target, orientation)
+            Teacup::merge_defaults! properties, extended_properties
+          end
+        end
+
+        # if we know the class of the target, we can apply styles via class
+        # inheritance.  We do not pass `target` in this case.
+        if target
+          target.class.ancestors.each do |ancestor|
+            extended_properties = stylesheet.query(ancestor, nil, orientation)
+            Teacup::merge_defaults!(properties, extended_properties)
+          end
+        end
+      end
+
+      properties
+    end
+
+  end
+end