teacup 0.3.12 → 1.0.0

data/.gitignore

@@ -1,4 +1,5 @@
 .repl_history
+*.bridgesupport
 build
 resources/*.nib
 resources/*.momd

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    teacup (0.3.12)
+    teacup (0.3.13)
       rake
 
 GEM

data/README.md

@@ -162,6 +162,46 @@ Any method that accepts a single value can be assigned here.  Please don't abuse
 this by hiding application logic in your stylesheets - these are meant for
 *design*, not behavior.  That said, if you're coding by yourself - go for it! ;)
 
+Stylesheets
+===========
+
+The `Teacup::Stylesheet` class has methods that create a micro-DSL in the
+context of a `style` declaration.  You can view the source (most of them are
+very short methods) in `lib/teacup/stylesheet_extensions/*.rb`.
+
+```ruby
+# autoresizingMask
+style :spinner,
+  center: [320, 460],
+  autoresizingMask: flexible_left|flexible_right|flexible_top|flexible_bottom
+
+
+# device-specific geometries - app_size, screen_size, and device/device? methods
+style :root,
+  origin: [0, 0],
+  size: app_size  # doesn't include the status bar - screen_size does
+
+if device? iPhone
+  style :image, image: UIImage.imageNamed "my iphone image"
+elsif device? iPad
+  style :image, image: UIImage.imageNamed "my ipad image"
+end
+
+# the device method can be OR'd with the devices.  The return value is always a
+# number, so make sure to compare to 0
+if device|iPhone > 0
+  # ...
+end
+# so yeah, you might as well use `device? iPhone`, in my opinion.
+
+
+# rotations - use the identity and pi methods
+style :button,
+  layer: {
+    transform: spin identity, 2*pi
+  }
+```
+
 Orientations
 ============
 

data/Rakefile

@@ -8,4 +8,5 @@ Motion::Project::App.setup do |app|
   # Use `rake config' to see complete project settings.
   app.name = 'teacup'
   app.identifier = 'com.rubymotion.teacup'
+  app.vendor_project 'vendor/TeacupDummy', :static
 end

data/app/app_delegate.rb

@@ -1,7 +1,9 @@
 class AppDelegate
 
   def application(application, didFinishLaunchingWithOptions:launchOptions)
-    application.setStatusBarStyle(UIStatusBarStyleBlackTranslucent)
+    return true if RUBYMOTION_ENV == 'test'
+
+    application.setStatusBarHidden(true, withAnimation:UIStatusBarAnimationSlide)
 
     @window = UIWindow.alloc.initWithFrame(UIScreen.mainScreen.bounds)
     @window.rootViewController = FirstController.new

data/app/controllers/first_controller.rb

@@ -13,13 +13,7 @@ class FirstController < UIViewController
     @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

data/lib/dummy.rb

@@ -1,3 +1,9 @@
+class TeacupDummy
+  def anyMethodName
+    @anyobject.type = nil
+  end
+end
+
 class DummyView < UIView
 private
   def dummy
@@ -46,6 +52,13 @@ private
   end
 end
 
+class DummyPickerView < UIPickerView
+private
+  def dummy
+    setShowsSelectionIndicator(nil)
+  end
+end
+
 class DummyLayer < CALayer
 private
   def dummy

data/lib/teacup/constraint.rb

@@ -0,0 +1,258 @@
+module Teacup
+  class Constraint
+    attr_accessor :target
+    attr_accessor :attribute
+    attr_accessor :relationship
+    attr_accessor :relative_to
+    attr_accessor :attribute2
+    attr_accessor :multiplier
+    attr_accessor :constant
+    attr_accessor :priority
+
+    if defined? NSLayoutRelationEqual
+      Priorities = {
+        required: 1000,  # NSLayoutPriorityRequired
+        high: 750,  # NSLayoutPriorityDefaultHigh
+        low: 250,  # NSLayoutPriorityDefaultLow
+      }
+      Relationships = {
+        equal: NSLayoutRelationEqual,
+        lte: NSLayoutRelationLessThanOrEqual,
+        gte: NSLayoutRelationGreaterThanOrEqual,
+      }
+      Attributes = {
+        none: NSLayoutAttributeNotAnAttribute,
+        left: NSLayoutAttributeLeft,
+        right: NSLayoutAttributeRight,
+        top: NSLayoutAttributeTop,
+        bottom: NSLayoutAttributeBottom,
+        leading: NSLayoutAttributeLeading,
+        trailing: NSLayoutAttributeTrailing,
+        width: NSLayoutAttributeWidth,
+        height: NSLayoutAttributeHeight,
+        center_x: NSLayoutAttributeCenterX,
+        center_y: NSLayoutAttributeCenterY,
+        baseline: NSLayoutAttributeBaseline,
+      }
+    else
+      Relationships = {}
+      Attributes = {}
+    end
+
+    def self.from_sym(sym, relative_to=:superview)
+      case sym
+      when :full
+        [
+          Teacup::Constraint.new(:self, :left).equals(relative_to, :left),
+          Teacup::Constraint.new(:self, :top).equals(relative_to, :top),
+          Teacup::Constraint.new(:self, :width).equals(relative_to, :width),
+          Teacup::Constraint.new(:self, :height).equals(relative_to, :height),
+        ]
+      when :full_width
+        [
+          Teacup::Constraint.new(:self, :left).equals(relative_to, :left),
+          Teacup::Constraint.new(:self, :width).equals(relative_to, :width),
+        ]
+      when :full_height
+        [
+          Teacup::Constraint.new(:self, :top).equals(relative_to, :top),
+          Teacup::Constraint.new(:self, :height).equals(relative_to, :height),
+        ]
+      when :center_x
+        [
+          Teacup::Constraint.new(:self, :center_x).equals(:superview, :center_x),
+        ]
+      when :center_y
+        [
+          Teacup::Constraint.new(:self, :center_y).equals(:superview, :center_y),
+        ]
+      when :centered
+        [
+          Teacup::Constraint.new(:self, :center_x).equals(:superview, :center_x),
+          Teacup::Constraint.new(:self, :center_y).equals(:superview, :center_y),
+        ]
+      when :top
+        [
+          Teacup::Constraint.new(:self, :top).equals(relative_to, :top),
+        ]
+      when :right
+        [
+          Teacup::Constraint.new(:self, :right).equals(relative_to, :right),
+        ]
+      when :bottom
+        [
+          Teacup::Constraint.new(:self, :bottom).equals(relative_to, :bottom),
+        ]
+      when :left
+        [
+          Teacup::Constraint.new(:self, :left).equals(relative_to, :left),
+        ]
+      when :top_left
+        [
+          Teacup::Constraint.new(:self, :left).equals(relative_to, :left),
+          Teacup::Constraint.new(:self, :top).equals(relative_to, :top),
+        ]
+      when :top_right
+        [
+          Teacup::Constraint.new(:self, :right).equals(relative_to, :right),
+          Teacup::Constraint.new(:self, :top).equals(relative_to, :top),
+        ]
+      when :bottom_right
+        [
+          Teacup::Constraint.new(:self, :right).equals(relative_to, :right),
+          Teacup::Constraint.new(:self, :bottom).equals(relative_to, :bottom),
+        ]
+      when :bottom_left
+        [
+          Teacup::Constraint.new(:self, :left).equals(relative_to, :left),
+          Teacup::Constraint.new(:self, :bottom).equals(relative_to, :bottom),
+        ]
+      else
+        raise "Unknown symbol #{sym.inspect}"
+      end
+    end
+
+    def initialize(target=nil, attribute=nil)
+      self.target = target
+      self.attribute = attribute
+      self.constant = 0
+      self.multiplier = 1
+      self.priority = :high
+    end
+
+    def equals(relative_to, attribute2=nil)
+      self.set_relationship(NSLayoutRelationEqual, relative_to, attribute2)
+    end
+
+    def lte(relative_to, attribute2=nil)
+      self.set_relationship(NSLayoutRelationLessThanOrEqual, relative_to, attribute2)
+    end
+    alias at_most lte
+    alias is_at_most lte
+
+    def gte(relative_to, attribute2=nil)
+      self.set_relationship(NSLayoutRelationGreaterThanOrEqual, relative_to, attribute2)
+    end
+    alias at_least gte
+    alias is_at_least gte
+
+    def set_relationship(relation, relative_to, attribute2)
+      if attribute2.nil?
+        self.constant = relative_to
+        self.relative_to = nil
+        self.attribute2 = :none
+      else
+        self.relative_to = relative_to
+        self.attribute2 = attribute2
+      end
+      self.relationship = relation
+
+      self
+    end
+
+    def attribute=(attribute)
+      @attribute = attribute_lookup attribute
+    end
+
+    def attribute2=(attribute)
+      @attribute2 = attribute_lookup attribute
+    end
+
+    def times(multiplier)
+      self.multiplier *= multiplier
+      self
+    end
+
+    def divided_by(multiplier)
+      times 1.0/multiplier
+    end
+
+    def plus(constant)
+      self.constant += constant
+      self
+    end
+
+    def minus(constant)
+      plus -constant
+    end
+
+    def priority(priority=nil)
+      return @priority if priority.nil?
+
+      self.priority = priority
+      self
+    end
+
+    def copy
+      copy = Teacup::Constraint.new(self.target, self.attribute)
+      copy.relationship = self.relationship
+      copy.relative_to = self.relative_to
+      copy.attribute2 = self.attribute2
+      copy.multiplier = self.multiplier
+      copy.constant = self.constant
+      copy.priority = self.priority
+      copy
+    end
+
+    def inspect
+      "#<#{self.class.name} ##{object_id.to_s(16)}" +
+      " target=#{target.inspect}" +
+      " attribute=#{attribute_reverse(attribute).inspect}" +
+      " relationship=#{relationship_reverse(relationship).inspect}" +
+      " relative_to=#{relative_to.inspect}" +
+      " attribute2=#{attribute_reverse(attribute2).inspect}" +
+      " multiplier=#{multiplier.inspect}" +
+      " constant=#{constant.inspect}" +
+      ">"
+    end
+
+    def nslayoutconstraint
+      NSLayoutConstraint.constraintWithItem( self.target,
+                                  attribute: self.attribute,
+                                  relatedBy: self.relationship,
+                                     toItem: self.relative_to,
+                                  attribute: self.attribute2,
+                                 multiplier: self.multiplier,
+                                   constant: self.constant
+                                           ) .tap do |nsconstraint|
+        nsconstraint.priority = priority_lookup self.priority
+      end
+    end
+
+private
+    def attribute_lookup(attribute)
+      return attribute if attribute.is_a? Fixnum
+      raise "Unsupported attribute #{attribute.inspect}" unless Attributes.key? attribute
+      Attributes[attribute]
+    end
+
+    def priority_lookup(priority)
+      return priority if priority.is_a? Fixnum
+      raise "Unsupported priority #{priority.inspect}" unless Priorities.key? priority
+      Priorities[priority]
+    end
+
+    def relationship_lookup(relationship)
+      return relationship if relationship.is_a? Fixnum
+      raise "Unsupported relationship #{relationship.inspect}" unless Relationships.key? relationship
+      Relationships[relationship]
+    end
+
+    def attribute_reverse(attribute)
+      Attributes.key(attribute) || :none
+    end
+
+    def relationship_reverse(relationship)
+      Relationships.key(relationship)
+    end
+  end
+end
+
+# constraintWithItem: target
+#          attribute: attribute
+#          relatedBy: relationship
+#             toItem: relative_to
+#          attribute: attribute2
+#         multiplier: multiplier
+#           constant: constant
+

data/lib/teacup/handler.rb

@@ -38,6 +38,9 @@ module Teacup
   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.
+    if value.is_a? Proc
+      value = target.instance_exec(&value)
+    end
 
     handled = false
     target.class.ancestors.each do |ancestor|
@@ -56,7 +59,7 @@ module Teacup
 
     # 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
+    if value.is_a? Hash
       return Teacup.apply_hash target.send(key), value
     end
 
@@ -64,7 +67,7 @@ module Teacup
       assign = nil
       setter = key.to_s + ':'
     else
-      assign = :"#{key}="
+      assign = key.to_s + '='
       setter = 'set' + key.to_s.sub(/^./) {|c| c.capitalize} + ':'
     end
 
@@ -75,7 +78,7 @@ module Teacup
       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}"
+      NSLog "TEACUP WARNING: Can't apply #{setter.inspect}#{assign and " or " + assign.inspect or ""} to #{target.inspect}"
     end
   end
 

data/lib/teacup/layout.rb

@@ -11,16 +11,57 @@ module Teacup
   #
   # @example
   #   class MyViewController < UIViewController
+  #     stylesheet :logo
+  #
   #     layout(:my_view) do
   #       layout UIImage, :logo
   #     end
-  #
-  #     def stylesheet
-  #       Teacup::Stylesheet[:logo]
-  #     end
   #   end
   module Layout
-    attr_accessor :stylesheet
+    # Assign a Stylesheet or Stylesheet name (Symbol)
+    #
+    # @return val
+    #
+    # @example
+    #
+    #   stylesheet = Stylesheet.new do
+    #                  style :root, backgroundColor: UIColor.blueColor
+    #                end
+    #   controller.stylesheet = stylesheet
+    #   # or use a stylename
+    #   view.stylesheet = :stylesheet_name
+    #
+    def stylesheet= val
+      @stylesheet = val
+    end
+
+    # Returns a stylesheet to use to style the contents of this controller's
+    # view.  You can also assign a stylesheet to {stylesheet=}, which will in
+    # turn call {restyle!}.
+    #
+    # 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 [UIInterfaceOrientationLandscapeLeft,
+    #        UIInterfaceOrientationLandscapeRight].include?(UIInterface.currentDevice.orientation)
+    #      Teacup::Stylesheet[:ipad]
+    #    else
+    #      Teacup::Stylesheet[:ipadvertical]
+    #    end
+    #  end
+    def stylesheet
+      if @stylesheet.is_a? Symbol
+        @stylesheet = Teacup::Stylesheet[@stylesheet]
+      end
+
+      @stylesheet
+    end
 
     # Alter the layout of a view
     #
@@ -65,7 +106,7 @@ module Teacup
       name = nil
       properties = properties_or_nil
 
-      if Hash === name_or_properties
+      if name_or_properties.is_a? Hash
         name = nil
         properties = name_or_properties
       elsif name_or_properties
@@ -75,7 +116,9 @@ module Teacup
       # prevents the calling of restyle! until we return to this method
       should_restyle = Teacup.should_restyle_and_block
 
-      view.stylesheet = stylesheet
+      unless view.stylesheet
+        view.stylesheet = stylesheet
+      end
       view.stylename = name
       if properties
         view.style(properties) if properties
@@ -88,9 +131,8 @@ module Teacup
       end
 
       if should_restyle
-        view.restyle!
-        # restore to whatever it was, either nil or true
         Teacup.should_restyle!
+        view.restyle!
       end
       view
     end
@@ -165,5 +207,6 @@ module Teacup
     def superview_chain
       @superview_chain ||= []
     end
+
   end
 end

data/lib/teacup/restyle.rb

@@ -1,22 +1,29 @@
 module Teacup
   module_function
 
-  def dont_restyle
+  def dont_restyle?
     @dont_restyle ||= nil
   end
 
   def should_restyle?
-    return ! self.dont_restyle
+    return ! self.dont_restyle?
   end
 
   def should_restyle_and_block
     should_restyle = self.should_restyle?
-    @dont_style = true
+    @dont_restyle = true
     return should_restyle
   end
 
-  def should_restyle!
-    @dont_style = nil
+  def should_restyle! &block
+    if block
+      _dont_restyle = dont_restyle?
+      @dont_restyle = nil
+      yield
+      @dont_restyle = _dont_restyle
+    else
+      @dont_restyle = nil
+    end
   end
 
 end

data/lib/teacup/style.rb

@@ -60,7 +60,7 @@ module Teacup
 
       # 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
+      if stylesheet && stylesheet.is_a?(Teacup::Stylesheet)
         stylesheet.imported_stylesheets.reverse.each do |stylesheet|
           imported_properties = stylesheet.query(self.stylename, target, orientation, seen)
           Teacup::merge_defaults! properties, imported_properties

data/lib/teacup/stylesheet.rb

@@ -102,7 +102,7 @@ module Teacup
       if name
         @name = name.to_sym
         if Teacup::Stylesheet[@name]
-          NSLog("WARNING: A stylesheet with the name #{@name.inspect} has already been created.")
+          NSLog("TEACUP WARNING: A stylesheet with the name #{@name.inspect} has already been created.")
         end
         Teacup::Stylesheet[@name] = self
       end
@@ -114,6 +114,30 @@ module Teacup
       @block = block
     end
 
+    # The stylesheet_cache stores "compiled" styles.  It is reset whenever the
+    # stylesheet imports a new Stylesheet, and when a style entry is added or
+    # changed (then only that entry is removed)
+    #
+    # This method builds the gnarly hash that stores this stuff - the get/set
+    # methods use this method to ensure the object exists, in other places the
+    # @stylesheet_cache object is manipulated directly (to invalidate entries,
+    # or the entire cache)
+    def stylesheet_cache
+      @stylesheet_cache ||= Hash.new { |cache,_stylename|
+        cache[_stylename] = Hash.new { |_target,_orientation|
+          _target[_orientation] = {}
+        }
+      }
+    end
+
+    def get_stylesheet_cache(stylename, target, orientation)
+      stylesheet_cache[stylename][target][orientation]
+    end
+
+    def set_stylesheet_cache(stylename, target, orientation, value)
+      self.stylesheet_cache[stylename][target][orientation] = value
+    end
+
     # Include another Stylesheet into this one, the rules defined
     # within it will have lower precedence than those defined here
     # in the case that they share the same keys.
@@ -138,6 +162,7 @@ module Teacup
     #   @stylesheet.import(base_stylesheet)
     #
     def import(name_or_stylesheet)
+      @stylesheet_cache = nil
       imported << name_or_stylesheet
     end
 
@@ -155,19 +180,25 @@ module Teacup
     #   # => {backgroundImage: UIImage.imageNamed("big_red_shiny_button"), title: "Continue!", top: 50}
     def query(stylename, target=nil, orientation=nil, seen={})
       return {} if seen[self]
+      return {} unless stylename
 
-      # the block handed to Stylesheet#new is not run immediately - it is run
-      # the first time the stylesheet is queried.  This fixes bugs related to
-      # some resources (fonts) not available when the application is first
-      # started.  The downside is that @instance variables and variables that
-      # should be closed over are not.
-      if @block
-        instance_eval &@block
-        @block = nil
+      unless get_stylesheet_cache(stylename, target, orientation)
+        # the block handed to Stylesheet#new is not run immediately - it is run
+        # the first time the stylesheet is queried.  This fixes bugs related to
+        # some resources (fonts) not available when the application is first
+        # started.  The downside is that @instance variables and variables that
+        # should be closed over are not.
+        if @block
+          instance_eval &@block
+          @block = nil
+        end
+        seen[self] = true
+
+        set_stylesheet_cache(stylename, target, orientation, styles[stylename].build(target, orientation, seen))
       end
-      seen[self] = true
 
-      styles[stylename].build(target, orientation, seen)
+      # mutable hashes could mess with our cache, so return a duplicate
+      get_stylesheet_cache(stylename, target, orientation).dup
     end
 
     # Add a set of properties for a given stylename or multiple stylenames.
@@ -193,6 +224,9 @@ module Teacup
       end
 
       queries.each do |stylename|
+        # reset the stylesheet_cache for this stylename
+        @stylesheet_cache.delete(stylename) if @stylesheet_cache
+
         # merge into styles[stylename], new properties "win"
         Teacup::merge_defaults(properties, styles[stylename], styles[stylename])
       end

data/lib/teacup/stylesheet_extensions/autoresize.rb

@@ -0,0 +1,39 @@
+# Example:
+#     Teacup::Stylesheet.new :main do
+#       style :root,
+#         # stays centered and grows in height
+#         autoresizingMask: left|right|height
+#     end
+module Teacup
+  class Stylesheet
+
+    def none
+      UIViewAutoresizingNone
+    end
+
+    def flexible_left
+      UIViewAutoresizingFlexibleLeftMargin
+    end
+
+    def flexible_width
+      UIViewAutoresizingFlexibleWidth
+    end
+
+    def flexible_right
+      UIViewAutoresizingFlexibleRightMargin
+    end
+
+    def flexible_top
+      UIViewAutoresizingFlexibleTopMargin
+    end
+
+    def flexible_height
+      UIViewAutoresizingFlexibleHeight
+    end
+
+    def flexible_bottom
+      UIViewAutoresizingFlexibleBottomMargin
+    end
+
+  end
+end