teacup 2.3.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cfe17cc290b5832599be8594c185cf67699aa667
-  data.tar.gz: 6a6c4ac9230c4d1292b5b81feb344035de230a13
+  metadata.gz: 4821b6532d8a60017501696bb0ba85647b46974b
+  data.tar.gz: 00a8be407b48a624e3e07c735122871029228bc4
 SHA512:
-  metadata.gz: 689b8e6bcbe6a90f24684fb78258fe3b30f605c6f41eb8e1cbee7614033e1348a4be371d716c8a1d99fa6357e9e97c705444f2ad07bb928fce16adeca6f25001
-  data.tar.gz: 9ebc65ac66f076e60a2816780ce425078da8b331f60bcb415e2ccd774fdf76c40a1c8c5b13e933664b0a9f79e91db5faac6c8c8b4a431c0e4cc87b20a3fc2110
+  metadata.gz: 4ed282b7d63702e9ffc0c72a2a5ea436ca989f41111d1c5e13172376da27160216c43806884f7fe0dd49e62fa6ca528c4a1cf12431c06817da41fed2458cbb4b
+  data.tar.gz: 7f61cfc625f369c9e53802b9aa28e3a1f016f888fc9936505942c4b093febcf02a9ea2edb120d5ec9daf92121d52c54a400326ebaead379ade403bd82b1ee125

data/README.md

@@ -63,7 +63,7 @@ require 'teacup'
     class MyController < UIViewController
       stylesheet :main_screen
 
-      layout do
+      def teacup_layout
         subview(UIButton, :hi_button)
       end
     end
@@ -103,7 +103,7 @@ other GUI system ever*. :-|
     class MyController < TeacupWindowController
       stylesheet :main_window
 
-      layout do
+      def teacup_layout
         subview(NSButton, :hi_button)
       end
     end
@@ -139,6 +139,36 @@ Teacup supports [Pixate][] and [NUI][], too, so you can use those systems for
 styling and Teacup to manage your view hierarchy and apply auto-layout
 constraints.  Teacup can also integrate with the [motion-layout][] gem!
 
+### Changes in 3.0
+
+There is one significant change in version 3.0.  In every version of Teacup
+prior (from 0.2.0 to 2.3.0) the controller layout was usually created by calling
+a class method called `layout`.  It was discovered, embarrassingly late, that
+this system is causing memory leaks.  To fix it we had to remove this feature
+altogether.  So if you are looking at old Teacup examples, you will see this
+block syntax that is no longer offered.  It is easy to update to 3.0, though:
+
+```ruby
+# <= 2.3.0
+class MyController < UIViewController
+  layout(:root_stylename) do  # <= this block is what caused the memory leak!
+    # teacup code goes here
+  end
+end
+
+# 3.0
+class MyController < UIViewController
+  def teacup_layout  # in 3.0 we just changed it to be a method
+    # introduced in 3.0, this is how you assign a stylename to the root view
+    root(:root_stylename, { background: UIColor.blueColor })
+    # teacup code goes here - no other code changes necessary
+  end
+  # actually, this method still works as long as you don't pass a block.  It's
+  # the same as calling `root(stylename, {})`
+  layout(:root_stylename, {})
+end
+```
+
 ### Table of Contents
 
 * [Layouts](#layouts) — define your views
@@ -178,17 +208,18 @@ iOS, and `NSWindowController`, `NSViewController`, and `NSView` on OS X. These
 classes can take advantage of the view-hierarchy DSL.
 
 You saw an example in the primer, using the
-`UIViewController`/`NSWindowController` class method `layout`.  This is a helper
-function that stores the layout code.  A more direct example might look like
-this:
+`UIViewController`/`NSWindowController` class method `layout` and the
+`teacup_layout` method.  You could just as easily use Teacup's DSL to create
+your views from a `loadView` method, for instance you might want to use a
+custom view subclass as your root view.  An example might look like this:
 
 ```ruby
 # controller example
 class MyController < UIViewController
 
-  def viewDidLoad
-    # we will modify the controller's `view`, assigning it the stylename `:root`
-    layout(self.view, :root) do
+  def loadView
+    # we will create the controller's view, assigning it the stylename :root
+    self.view = layout(FancyView, :root) do
       # these subviews will be added to `self.view`
       subview(UIToolbar, :toolbar)
       subview(UIButton, :hi_button)
@@ -243,9 +274,11 @@ The reason it is so easy to define view hierarchies in Teacup is because the
 ```ruby
 subview(UIView, :container) do  # create a UIView instance and give it the stylename :container
   subview(UIView, :inputs) do  # create another container
+    # these views will be added to the :inputs view
     @email_input = subview(UITextField, :email_input)
     @password_input = subview(UITextField, :password_input)
   end
+  # this view will be added to :container
   subview(UIButton.buttonWithType(UIButtonTypeRoundedRect), :submit_button)
 end
 ```
@@ -255,7 +288,7 @@ to add your *own view helpers*!  I refer to this as a "partials" system, but
 really it's just Ruby code (and isn't that the best system?).
 
 ```ruby
-# the methods you add here will be available in UIView/NSview,
+# the methods you add here will be available in UIView/NSView,
 # UIViewController/NSViewController/NSWindowController, and any of your own
 # classes that `include Teacup::Layout`
 module Teacup::Layout
@@ -297,7 +330,7 @@ end
 ```ruby
 class MyController < UIViewController
 
-  layout do
+  def teacup_layout
     @button1 = button()
     @button2 = button(:blue_button)
     @button3 = button_with_icon(UIImage.imageNamed('email_icon'), 'Email')
@@ -306,31 +339,14 @@ class MyController < UIViewController
 end
 ```
 
-The `Controller##layout` method that has been used so far is going to be
-the first or second thing you add to a controller when you are building an app
-with Teacup.  It's method signature is
-
-```ruby
-# defined in teacup/teacup_controller.rb as Teacup::Controller module
-UIViewController.layout(stylename=nil, styles={}, &block)
-NSViewController.layout(stylename=nil, styles={}, &block)
-NSWindowController.layout(stylename=nil, styles={}, &block)
-```
-
-* `stylename` is the stylename you want applied to your controller's `self.view`
-  object.
-* `styles` are *rarely* applied here, but one common use case is when you assign
-  a custom view in `loadView`, and you want to apply settings to it.  I find it
-  cleaner to move this code into the body of the `layout` block, though.
-* `&block` is the most important - it is the layout code that will be called
-  during `viewDidLoad`.
+The `Controller#teacup_layout` method is going to be the first or second thing
+you add to a controller when you are building an app with Teacup.  Inside you
+will add subviews using `subview` *or* you can create a view using the `layout`
+method (`subview` delegates most of its work to `layout`)
 
 After the views have been added and styles have been applied Teacup calls the
 `layoutDidLoad` method.  If you need to perform some additional initialization
-on your views, you should do it in this method.  If you use the `layout` block
-the styles have not yet been applied.  Frames will not be set, text and titles
-will be empty, and images will not have images.  This all happens at the *end*
-of the `layout` block.
+on your views, you can do it in this method.
 
 Stylesheets
 -----------
@@ -418,7 +434,7 @@ class MainController < UIViewController
 
   stylesheet :main  # <= assigns the stylesheet named :main to this controller
 
-  layout do
+  def teacup_layout
     subview(UILabel, :h1)  # <= :h1 is the stylename
   end
 
@@ -442,7 +458,7 @@ We can tackle this a couple ways.  You can apply "last-minute" styles in the
 `layout` and `subview` methods:
 
 ```ruby
-layout do
+def teacup_layout
   subview(UILabel, :h1,
     # the `subview` and `layout` methods can apply styles
     text: "Omg, it's full of stars"
@@ -473,7 +489,7 @@ not all our labels say "OMG", but we want to use our font from the `:h1` style.
 We can tell the `:main_header` style that it `extends` the `:h1` style:
 
 ```ruby
-layout do
+def teacup_layout
   subview(UILabel, :main_header)
 end
 
@@ -936,7 +952,7 @@ springs and struts.  And honestly, I recommend you try using the
 
 But at the end of the day, once you really understand the auto-layout system
 that Apple released in iOS 6, you can build your UIs to be responsive to
-different devices, orientations, and sizes. UIs built with auto-layout do not
+different devices, orientations, and sizes. UIs built with auto-layout not
 usually need to adjust anything during a rotation.  The constraints take *care*
 of it all.  It's impressive.
 
@@ -1007,7 +1023,7 @@ Teacup stylenames assigned to your views will be used in the dictionary that the
 ASCII-based system relies on.
 
 ```ruby
-layout do
+def teacup_layout
   subview(UIView, :view_a)
   subview(UIView, :view_b)
   subview(UIView, :view_c)
@@ -1214,7 +1230,8 @@ class SomeController < UIViewController
 
   stylesheet :some_view
 
-  layout :root do
+  def teacup_layout
+    root(:root)
     subview(UITextField, :field)
     @search = subview(UITextField, :search)
   end
@@ -1298,7 +1315,7 @@ okay, because we have a chance to add these styles in the `subview` and `layout`
 methods.
 
 ```ruby
-layout do
+def teacup_layout
   subview(UITableView, delegate: self)
 end
 ```
@@ -1309,7 +1326,7 @@ stylesheet is not necessarily applied immediately, these styles could be
 overwritten before they take effect.
 
 ```ruby
-layout do
+def teacup_layout
   table_view = subview(UITableView, :tableview, delegate: self,
     font: UIFont.boldSystemFontOfSize(10)  # the stylesheet could override this during rotation
     )
@@ -1328,7 +1345,7 @@ More examples!
 ```ruby
 class MyController < UIViewController
   stylesheet :my_sheet
-  layout do
+  def teacup_layout
     subview(UILabel, :label, text: 'overrides')
   end
 end
@@ -1387,7 +1404,7 @@ appear on many screens in an app.  You should not shy away from adding teacup's
 
 If you are using your controller as your table view dataSource, the `subview`
 and `layout` methods continue to work as you expect them to.  This is for the
-case when you are using a helper class.
+case when you are using a helper class as the dataSource and/or delegate.
 
 ```ruby
 class TableHelper

data/lib/teacup-ios/style.rb

@@ -96,7 +96,11 @@ module Teacup
         # if we know the class of the target, we can apply styles via class
         # inheritance.
         if target_class
-          target_class.class.ancestors.each do |ancestor|
+          unless target_class.is_a?(Class)
+            target_class = target_class.class
+          end
+
+          target_class.ancestors.each do |ancestor|
             extended_properties = stylesheet.query(ancestor, nil, rotation_orientation)
             Teacup::merge_defaults!(properties, extended_properties)
           end

data/lib/teacup-osx/style.rb

@@ -10,7 +10,7 @@ module Teacup
     # orientation is completely ignored on OS X, but the Teacup code was written
     # to support them, and it was easier to ignore the orientation system than
     # refactor it out of the shared code base.
-    def build(target=nil, rotation_orientation=nil, seen={})
+    def build(target_class=nil, rotation_orientation=nil, seen={})
       properties = Style.new
       properties.stylename = self.stylename
       properties.stylesheet = self.stylesheet
@@ -24,7 +24,7 @@ module Teacup
       # local style
       if stylesheet && stylesheet.is_a?(Teacup::Stylesheet)
         stylesheet.imported_stylesheets.reverse.each do |stylesheet|
-          imported_properties = stylesheet.query(self.stylename, target, rotation_orientation, seen)
+          imported_properties = stylesheet.query(self.stylename, target_class, rotation_orientation, seen)
           delete_keys.each do |key|
             imported_properties.delete(key)
           end
@@ -37,7 +37,7 @@ module Teacup
           # 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, rotation_orientation)
+            extended_properties = stylesheet.query(also_include, target_class, rotation_orientation)
             delete_keys.each do |key|
               extended_properties.delete(key)
             end
@@ -46,10 +46,14 @@ module Teacup
         end
         properties.delete(:extends)
 
-        # 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|
+        # if we know the class of the target_class, we can apply styles via class
+        # inheritance.  We do not pass `target_class` in this case.
+        if target_class
+          unless target_class.is_a?(Class)
+            target_class = target_class.class
+          end
+
+          target_class.ancestors.each do |ancestor|
             extended_properties = stylesheet.query(ancestor, nil, rotation_orientation)
             Teacup::merge_defaults!(properties, extended_properties)
           end

data/lib/teacup/layout.rb

@@ -158,7 +158,7 @@ module Teacup
         begin
           # yield will not work if this is defined in the context of the
           # UIViewController `layout` class method.
-          instance_exec(view, &block)
+          yield view
         rescue NoMethodError => e
           NSLog("Exception executing layout(#{view.inspect}) in #{self.inspect} (stylesheet=#{stylesheet})")
           raise e

data/lib/teacup/stylesheet.rb

@@ -127,12 +127,15 @@ module Teacup
     # @stylesheet_cache object is manipulated directly (to invalidate entries,
     # or the entire cache)
     def stylesheet_cache
-      @stylesheet_cache ||= Hash.new do |by_stylename,_stylename|
-        by_stylename[_stylename] = Hash.new do |by_target_class,_target_class|
-          by_orientation = {}
-          by_target_class[_target_class] = by_orientation
-        end
-      end
+      @stylesheet_cache ||= Hash.new(&lambda do |by_stylename,_stylename|
+        by_stylename[_stylename] = Hash.new(&lambda do |by_target_class,_target_class|
+          if _target_class && ! _target_class.is_a?(Class)
+            _target_class = _target_class.class
+          end
+
+          by_target_class[_target_class] = {}
+        end.weak!)
+      end.weak!)
     end
 
     def get_stylesheet_cache(stylename, target_class, orientation)

data/lib/teacup/teacup_controller.rb

@@ -27,7 +27,8 @@ module Teacup
     #
     # @example
     #   class MyViewController < UIViewController
-    #     layout :my_view do
+    #     def teacup_layout
+    #       root :my_view
     #       subview UILabel, title: "Test"
     #       subview UITextField, {
     #         frame: [[200, 200], [100, 100]]
@@ -39,8 +40,25 @@ module Teacup
     #     end
     #   end
     #
-    def layout(stylename=nil, properties={}, &block)
-      @layout_definition = [stylename, properties, block]
+    def layout(stylename=nil, properties={})
+      if block_given?
+        msg = <<-MSG
+Time to update your syntax!
+
+It was discovered that passing a block to the Controller##layout was causing
+irreparable memory leaks.  The only recourse is to use a new syntax and remove
+the old functionality.
+
+If you need to assign a stylename to the root view, you can still do this using
+`layout :stylename`, but you cannot pass a block to this class method any
+longer.
+
+Instead, define a method called `teacup_layout` and create your views there.  No
+other changes are required.
+MSG
+        raise msg
+      end
+      @layout_definition = [stylename, properties]
     end
 
   end
@@ -61,8 +79,8 @@ module Teacup
     #
     # @example
     #
-    #   stylesheet = Teacup::Stylesheet[:ipadhorizontal]
-    #   stylesheet = :ipadhorizontal
+    #   stylesheet = Teacup::Stylesheet[:main]
+    #   stylesheet = :main
     def stylesheet=(new_stylesheet)
       super
       if self.viewLoaded?
@@ -70,6 +88,19 @@ module Teacup
       end
     end
 
+    def root(stylename=nil, properties={})
+      if stylename.is_a?(NSDictionary)
+        properties = stylename
+        stylename = nil
+      end
+
+      if stylename || properties
+        layout(top_level_view, stylename, properties)
+      else
+        top_level_view
+      end
+    end
+
     # Instantiate the layout from the class, and then call layoutDidLoad.
     #
     # If you want to use Teacup in your controller, please hook into layoutDidLoad,
@@ -97,8 +128,12 @@ module Teacup
       end
 
       if layout_definition
-        stylename, properties, block = layout_definition
-        layout(top_level_view, stylename, properties, &block)
+        stylename, properties = layout_definition
+        layout(top_level_view, stylename, properties)
+      end
+
+      if respond_to?(:teacup_layout)
+        teacup_layout
       end
 
       layoutDidLoad

data/lib/teacup/version.rb

@@ -1,5 +1,5 @@
 module Teacup
 
-  VERSION = '2.3.0'
+  VERSION = '3.0.0'
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: teacup
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 3.0.0
 platform: ruby
 authors:
 - the rubymotion community
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-05 00:00:00.000000000 Z
+date: 2014-07-22 00:00:00.000000000 Z
 dependencies: []
 description: |
   Teacup is a community-driven DSL for RubyMotion.  It has CSS-like styling, and
@@ -67,6 +67,7 @@ files:
 - spec/ios/gradient_spec.rb
 - spec/ios/layout_module_spec.rb
 - spec/ios/layout_spec.rb
+- spec/ios/limelight_spec.rb
 - spec/ios/main_spec.rb
 - spec/ios/memory_leak_spec.rb
 - spec/ios/motion_layout_spec.rb
@@ -79,7 +80,6 @@ files:
 - spec/ios/ui_view_getters_spec.rb
 - spec/ios/uiswitch_spec.rb
 - spec/ios/view_spec.rb
-- spec/limelight_spec.rb
 homepage: https://github.com/rubymotion/teacup
 licenses:
 - BSD
@@ -114,6 +114,7 @@ test_files:
 - spec/ios/gradient_spec.rb
 - spec/ios/layout_module_spec.rb
 - spec/ios/layout_spec.rb
+- spec/ios/limelight_spec.rb
 - spec/ios/main_spec.rb
 - spec/ios/memory_leak_spec.rb
 - spec/ios/motion_layout_spec.rb
@@ -126,4 +127,3 @@ test_files:
 - spec/ios/ui_view_getters_spec.rb
 - spec/ios/uiswitch_spec.rb
 - spec/ios/view_spec.rb
-- spec/limelight_spec.rb