motion-kit 0.10.11 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8a10411c98102a36da52805858f833ea4e6e3f04
-  data.tar.gz: 56f823f65361bd4141c5f9e7a9c4f5bc57511347
+  metadata.gz: e90a4e2a89071ea4a7c57be68a26bcef7b868a84
+  data.tar.gz: 4ac95d41d19e21264920f090de6a5516c226d331
 SHA512:
-  metadata.gz: 06e500e3f4a458becc6024937193bf36b4e99fce587138a9017f764cfa8340a562912a511265431b5f3970b018c569fc88abdc902a92e36935b6e832717213ce
-  data.tar.gz: 3952471f3d7b3ab7181a8a8373b5954fbd8f73f5475c3eb99d42fc87155a4105202d7b2b19af5da6fb83b12ec02f43d80596e7f59b3d133ea4b7bee56e788cb6
+  metadata.gz: 884f0edc12798df07d0f82b0396d6cbdb48f5eb4fa2da67c2554259403e7402c8de6f7076a26d473bd1f5de385b8216efd3bf944e838ec5573fe4a15ec131c5d
+  data.tar.gz: bec3426f2ffe80d9f47a7d6f0423816b3595a5474753893a00d6e9caf022b781347beb944a6fea3a690924f24911f18a243dd966404cd819a78de2e9fd07689a

data/README.md

@@ -20,7 +20,7 @@
 7. Styles and layouts are "just code" (not hash-based like in Teacup)
 8. Written by [the authors][authors] of [ProMotion][] and [Teacup][]
 
-[authors]: CONTRIBUTORS.md
+[authors]: CONTRIBUTORS.yaml
 [Colin]: https://github.com/colinta
 [Jamon]: https://github.com/jamonholmgren
 [ProMotion]: https://github.com/clearsightstudio/ProMotion
@@ -115,6 +115,8 @@ class SimpleLayout < MotionKit::Layout
   def button_style
     # this will call 'setTitle(forState:)' via a UIButton helper
     title 'Press it!'
+    size_to_fit
+
     # this shorthand is much better!  More about frame helpers below.
     center ['50%', '50% + 50']
   end
@@ -267,6 +269,32 @@ end
 ```
 
 
+### Using child-layouts
+
+If you have a very complicated layout that you want to break up into child
+layouts, that is supported as well:
+
+```ruby
+class ParentLayout < MK::Layout
+
+  def layout
+    add ChildLayout, :child_id
+  end
+
+end
+```
+
+The id is (as always) optional, but allows you to fetch the layout using
+`get(id)`.
+
+```ruby
+layout.get(:child_id)  # => ChildLayout
+```
+
+Calling `get(:child_id).view` will return the *view* associated with that
+layout.
+
+
 ### Setting a custom root view
 
 If you need to use a custom root view, you can use the `root` method from within
@@ -593,6 +621,8 @@ constraints do
   # setting the priority:
   (x.is >= 10).priority(:required)
   (x.is == 15).priority(:low)
+  # setting the identifier
+  x.equals(15).identifier('foo')
 end
 ```
 
@@ -601,12 +631,20 @@ the element-id as a placeholder for a view works especially well here.
 
 ```ruby
 constraints do
-  top_left.equals x: 5, y:5
+  top_left.equals x: 5, y: 5     # this sets the origin relative to the superview
+  top_left.equals(:superview).plus([5, 5])  # this will do the same thing!
+
   width.equals(:foo).minus(10)  # searches for a view named :foo
   height.equals(:foo).minus(10)
   # that's repetitive, so just set 'size'
   size.equals(:foo).minus(10)
   size.equals(:foo).minus([10, 15])  # 10pt thinner, 15pt shorter
+
+  # if you are using a view that has a sensible intrinsic size, like an image,
+  # you can use :scale to have the width or height adjusted according to the
+  # other size
+  width.equals(:superview)
+  height(:scale)  # scale the height according to the width
 end
 ```
 
@@ -700,6 +738,58 @@ class MainController < UIViewController
 end
 ```
 
+#### Animating and Changing constraints
+
+It might feel natural to treat constraints as "frame setters", but they are
+persistent objects that are attached to your views.  This means if you create
+new constraints, like during a screen rotation, your old constraints don't “go
+away”.  For example:
+
+```ruby
+def label_style
+  portrait do
+    left 10
+  end
+
+  landscape do
+    left 15  # adds *another* constraint on the left attribute - in addition to the `left 10` constraint!
+  end
+end
+```
+
+Instead, you should retain the constraint and make changes to it directly:
+
+```ruby
+  initial do
+    constraints do
+      @label_left_constraint = left 10
+    end
+  end
+
+  reapply do
+    portrait do
+      @label_left_constraint.equals 10
+    end
+
+    landscape do
+      @label_left_constraint.equals 15
+    end
+  end
+```
+
+If you want to animate a constraint change, you can use `layoutIfNeeded` from
+within a UIView animation block.  The sample app "Chatty" does this to move a
+text field when the keyboard is displayed.  `kbd_height` is the height of the
+keyboard.
+
+```ruby
+@container_bottom.minus kbd_height  # set @container_bottom.constant = 0 when the keyboard disappears
+
+UIView.animateWithDuration(duration, delay: 0, options: curve, animations: -> do
+  self.view.layoutIfNeeded  # applies the constraint change
+end, completion: nil)
+```
+
 ### MotionKit::Events
 
     gem install motion-kit-events

data/lib/motion-kit/calculator/calculate.rb

@@ -3,7 +3,7 @@ module MotionKit
   module_function
 
   def calculate(view, dimension, amount, full_view=nil)
-    ViewCalculator.new.calculate(view, dimension, amount, full_view)
+    ViewCalculator.calculate(view, dimension, amount, full_view)
   end
 
 end

data/lib/motion-kit/calculator/view_calculator.rb

@@ -5,11 +5,11 @@
 # @provides MotionKit::ViewCalculator
 module MotionKit
   class ViewCalculator
-    include MotionKit::OriginCalculator
-    include MotionKit::SizeCalculator
-    include MotionKit::FrameCalculator
+    extend MotionKit::OriginCalculator
+    extend MotionKit::SizeCalculator
+    extend MotionKit::FrameCalculator
 
-    def calculate(view, dimension, amount, full_view=nil)
+    def self.calculate(view, dimension, amount, full_view=nil)
       if amount.is_a? Proc
         return view.instance_exec(&amount)
       elsif dimension == :origin || dimension == :center
@@ -35,7 +35,7 @@ module MotionKit
       end
     end
 
-    def intrinsic_size(view)
+    def self.intrinsic_size(view)
       size_that_fits = view.intrinsicContentSize
       if size_that_fits.width == MotionKit.no_intrinsic_metric
         size_that_fits.width = 0

data/lib/motion-kit/layouts/base_layout.rb

@@ -30,7 +30,7 @@ module MotionKit
       @preset_root = args[:root]
     end
 
-    def set_layout(layout)
+    def set_parent_layout(layout)
       @layout = WeakRef.new(layout)
     end
 
@@ -88,14 +88,14 @@ module MotionKit
     #         corner_radius 5
     #       end
     #     end
-    def context(target, &block)
-      return target unless block
+    def context(new_target, &block)
+      return new_target unless block
       # this little line is incredibly important; the context is only set on
       # the top-level Layout object.
-      return parent_layout.context(target, &block) unless is_parent_layout?
+      return parent_layout.context(new_target, &block) unless is_parent_layout?
 
-      if target.is_a?(Symbol)
-        target = self.get(target)
+      if new_target.is_a?(Symbol)
+        new_target = self.get_view(new_target)
       end
 
       context_was, parent_was, delegate_was = @context, @parent, @layout_delegate
@@ -107,17 +107,20 @@ module MotionKit
         @should_run_deferred = false
       end
       @parent = MK::Parent.new(context_was)
-      @context = target
-      @context.motion_kit_meta[:delegate] ||= Layout.layout_for(parent_layout, @context.class)
+      @context = new_target
+      @context.motion_kit_meta[:delegate] ||= Layout.layout_for(@context.class)
       @layout_delegate = @context.motion_kit_meta[:delegate]
+      if @layout_delegate
+        @layout_delegate.set_parent_layout(parent_layout)
+      end
       yield
       @layout_delegate, @context, @parent = delegate_was, context_was, parent_was
       if @should_run_deferred
-        run_deferred(target)
+        run_deferred(new_target)
       end
       @should_run_deferred = prev_should_run
 
-      target
+      new_target
     end
 
     # Blocks passed to `deferred` are run at the end of a "session", usually
@@ -217,11 +220,14 @@ module MotionKit
       objc_method_name, objc_method_args = objc_version(method_name, args)
       ruby_method_name = ruby_version(method_name)
 
-      @layout_delegate ||= Layout.layout_for(parent_layout, target.class)
-      if objc_method_name && @layout_delegate.respond_to?(objc_method_name)
-        return @layout_delegate.send(objc_method_name, *objc_method_args, &block)
-      elsif @layout_delegate.respond_to?(ruby_method_name)
-        return @layout_delegate.send(ruby_method_name, *args, &block)
+      @layout_delegate ||= Layout.layout_for(target.class)
+      if @layout_delegate
+        @layout_delegate.set_parent_layout(parent_layout)
+        if objc_method_name && @layout_delegate.respond_to?(objc_method_name)
+          return @layout_delegate.send(objc_method_name, *objc_method_args, &block)
+        elsif @layout_delegate.respond_to?(ruby_method_name)
+          return @layout_delegate.send(ruby_method_name, *args, &block)
+        end
       end
 
       if block

data/lib/motion-kit/layouts/base_layout_class_methods.rb

@@ -22,9 +22,9 @@ module MotionKit
     end
 
     # Instantiates a new Layout instance using `layout` as the root-level layout
-    def layout_for(layout, klass)
+    def layout_for(klass)
       memoized_klass = memoize(klass)
-      memoized_klass.new_child(layout) if memoized_klass
+      memoized_klass && memoized_klass.new
     end
 
     # Cache registered classes
@@ -40,10 +40,5 @@ module MotionKit
       @memoize[klass]
     end
 
-    def new_child(layout=nil)
-      child = self.new
-      child.set_layout(layout)
-      child
-    end
   end
 end

data/lib/motion-kit/layouts/tree_layout.rb

@@ -28,26 +28,41 @@ module MotionKit
       #       end
       #
       #     end
-      def view(name)
-        ivar_name = "@#{name}"
-        define_method(name) do
-          unless instance_variable_get(ivar_name)
-            view = self.get(name)
-            unless view
-              build_view unless @view
-              view = instance_variable_get(ivar_name) || self.get(name)
+      #
+      # You can also set multiple views in a single line.
+      #
+      # @example
+      #     class MyLayout < MK::Layout
+      #       view :label, :login_button
+      #     end
+      def view(*names)
+        names.each do |name|
+          ivar_name = "@#{name}"
+          define_method(name) do
+            unless instance_variable_get(ivar_name)
+              view = self.get_view(name)
+              unless view
+                build_view unless @view
+                view = instance_variable_get(ivar_name) || self.get_view(name)
+              end
+              self.send("#{name}=", view)
+              return view
             end
-            self.send("#{name}=", view)
-            return view
+            return instance_variable_get(ivar_name)
           end
-          return instance_variable_get(ivar_name)
+          # KVO compliance
+          attr_writer name
         end
-        # KVO compliance
-        attr_writer name
       end
 
     end
 
+    def initialize(args={})
+      super
+      @child_layouts = []
+      @elements = {}
+    end
+
     # The main view.  This method builds the layout and returns the root view.
     def view
       unless is_parent_layout?
@@ -56,14 +71,6 @@ module MotionKit
       @view ||= build_view
     end
 
-    # For private use.  The "root" is context sensitive, whereas the "view" is
-    # constant.  In most cases they are the same object, but when you are
-    # building a hierarchy that is *outside* the view created from the "layout"
-    # method, the top-most view in that hierarchy will be "root".
-    def _root
-      @root || view
-    end
-
     # Builds the layout and then returns self for chaining.
     def build
       view
@@ -104,59 +111,44 @@ module MotionKit
         raise ContextConflictError.new("Already created the root view")
       end
 
-      @view = initialize_element(element)
+      @view = initialize_element(element, element_id)
+
       if block
         if @context
           raise ContextConflictError.new("Already in a context")
         end
-
-        context(@view) do
-          # We're just using the `create` method for its side effects: calling the
-          # style method and calling the block.
-          create(@view, element_id, &block)
-        end
-      elsif element_id
-        create(@view, element_id)
       end
 
+      style_and_context(@view, element_id, &block)
+
       return @view
     end
 
     # instantiates a view, possibly running a 'layout block' to add child views.
     def create(element, element_id=nil, &block)
-      element = initialize_element(element)
-
-      if element_id
-        # We set the optional id and call the '_style' method, if it's been
-        # defined.
-        element.motion_kit_id = element_id
-        self.call_style_method(element, element_id)
-      end
-
-      if block
-        context(element, &block)
-      end
+      element = initialize_element(element, element_id)
+      style_and_context(element, element_id, &block)
 
       element
     end
 
-    def call_style_method(element, element_id)
-      style_method = "#{element_id}_style"
-      if parent_layout.respond_to?(style_method)
-        parent_layout.context(element) do
-          parent_layout.send(style_method)
+    # Calls the style method of all objects in the view hierarchy that are
+    # part of this layout.  The views in a child layout are not styled, but
+    # those layouts will receive a `reapply!` message if no root is specified.
+    def reapply!
+      root ||= self.view
+      @layout_state = :reapply
+
+      @elements.each do |element_id, elements|
+        elements.each do |element|
+          style_and_context(element, element_id)
         end
       end
-      return element
-    end
 
-    # Calls the style method of all objects in the view hierarchy
-    def reapply!(root=nil)
-      root ||= self.view
-      @layout_state = :reapply
-      MotionKit.find_all_views(root) do |view|
-        call_style_method(view, view.motion_kit_id) if view.motion_kit_id
+      @child_layouts.each do |child_layout|
+        child_layout.reapply!
       end
+
       @layout_state = :initial
 
       return self
@@ -189,70 +181,93 @@ module MotionKit
       return self
     end
 
+    def name_element(element, element_id)
+      @elements[element_id] ||= []
+      @elements[element_id] << element
+    end
+
     # Instantiates a view via `create` and adds the view to the current target.
-    # If no view exists on the stack, a default root view can be created if that
-    # has been enabled.  The block is run in the context of the new view.
+    # If there is no context, a default root view can be created if that has
+    # been enabled (e.g. within the `layout` method).  The block is run in the
+    # context of the new view.
     def add(element, element_id=nil, &block)
       # make sure we have a target - raises NoContextError if none exists
       self.target
 
-      element = initialize_element(element)
       unless @context
         create_default_root_context
       end
-      self.apply(:add_child, element)
-      create(element, element_id)
 
-      if block
-        context(element, &block)
-      end
+      # We want to be sure that the element has a supeview or superlayer before
+      # the style method is called.
+      element = initialize_element(element, element_id)
+      self.apply(:add_child, element)
+      style_and_context(element, element_id, &block)
 
       element
     end
 
+    def child_layouts
+      @child_layouts
+    end
+
     # Retrieves a view by its element id.  This will return the *first* view
-    # with this element_id in the tree, where *first* means the view closest to
-    # the root view. Aliased to `first` to distinguish it from `last`.
+    # with this element_id in the tree, where *first* means the first object
+    # that was added with assigned that name.
     def get(element_id)
       unless is_parent_layout?
         return parent_layout.get(element_id)
       end
-      self.get(element_id, in: self._root)
+      @elements[element_id] && @elements[element_id].first
     end
     def first(element_id) ; get(element_id) ; end
 
-    # Same as `get`, but with the root view specified.
-    def get(element_id, in: root)
-      MotionKit.find_first_view(root) { |view| view.motion_kit_id == element_id }
+    # Just like `get`, but if `get` returns a Layout, this method returns the
+    # layout's view.
+    def get_view(element_id)
+      element = get(element_id)
+      if element.is_a?(Layout)
+        element = element.view
+      end
+      element
     end
-    def first(element_id, in: root) ; get(element_id, in: root) ; end
 
-    # Retrieves a view by its element id.  This will return the *last* view
-    # with this element_id, where last means the view deepest and furthest from
-    # the root view.
+    # Retrieves a view by its element id.  This will return the *last* view with
+    # this element_id in the tree, where *last* means the last object that was
+    # added with assigned that name.
     def last(element_id)
       unless is_parent_layout?
         return parent_layout.last(element_id)
       end
-      self.last(element_id, in: self._root)
+      @elements[element_id] && @elements[element_id].last
     end
 
-    # Same as `last`, but with the root view specified.
-    def last(element_id, in: root)
-      MotionKit.find_last_view(root) { |view| view.motion_kit_id == element_id }
+    # Just like `last`, but if `last` returns a Layout, this method returns the
+    # layout's view.
+    def last_view(element_id)
+      element = last(element_id)
+      if element.is_a?(Layout)
+        element = element.view
+      end
+      element
     end
 
-    # Returns all the elements with a given element_id in the view tree.
+    # Returns all the elements with a given element_id
     def all(element_id)
       unless is_parent_layout?
         return parent_layout.all(element_id)
       end
-      self.all(element_id, in: self._root)
+      @elements[element_id] || []
     end
 
-    # Same as `all`, but with the root view specified.
-    def all(element_id, in: root)
-      MotionKit.find_all_views(root) { |view| view.motion_kit_id == element_id }
+    # Just like `all`, but if `all` returns a Layout, this method returns the
+    # layout's view.
+    def all_views(element_id)
+      element = all(element_id)
+      if element.is_a?(Layout)
+        element = element.view
+      end
+      element
     end
 
     # Returns all the elements with a given element_id
@@ -260,9 +275,14 @@ module MotionKit
       self.all(element_id)[index]
     end
 
-    # Same as `nth`, but with the root view specified.
-    def nth(element_id, at: index, in: root)
-      self.all(element_id, in: root)[index]
+    # Just like `nth`, but if `nth` returns a Layout, this method returns the
+    # layout's view.
+    def nth_view(element_id, index)
+      element = nth(element_id)
+      if element.is_a?(Layout)
+        element = element.view
+      end
+      element
     end
 
     # Removes a view (or several with the same name) from the hierarchy
@@ -271,15 +291,11 @@ module MotionKit
       unless is_parent_layout?
         return parent_layout.remove(element_id)
       end
-      self.remove(element_id, from: self._root)
-    end
-
-    # Same as `remove`, but with the root view specified.
-    def remove(element_id, from: root)
-      context(root) do
-        all(element_id).each do |subview|
-          self.apply(:remove_child, subview)
+      context(self.view) do
+        all(element_id).each do |element|
+          self.apply(:remove_child, element)
         end
+        @elements[element_id] = nil
       end
     end
 
@@ -329,17 +345,6 @@ module MotionKit
       @view
     end
 
-    # This method needs to set the @root so that calls to `get(:id)` defer to
-    # the "current root", not the layout root view.
-    def run_deferred(top_level_context)
-      root_was = @root
-      @root = top_level_context
-      retval = super
-      @root = root_was
-
-      return retval
-    end
-
     def layout
     end
 
@@ -348,18 +353,48 @@ module MotionKit
     #
     # Accepts a view instance, a class (which is instantiated with 'new') or a
     # `ViewLayout`, which returns the root view.
-    def initialize_element(elem)
+    def initialize_element(elem, element_id)
       if elem.is_a?(Class) && elem < TreeLayout
-        elem = elem.new_child(parent_layout).view
+        layout = elem.new
+        elem = layout.view
       elsif elem.is_a?(Class)
         elem = elem.new
       elsif elem.is_a?(TreeLayout)
+        layout = elem
         elem = elem.view
       end
 
+      if layout
+        if element_id
+          name_element(layout, element_id)
+        end
+        @child_layouts << layout
+      elsif element_id
+        name_element(elem, element_id)
+      end
+
       return elem
     end
 
+    # Calls the `_style` method with the element as the context, and runs the
+    # optional block in that context.  This is usually done immediately after
+    # `initialize_element`, except in the case of `add`, which adds the item to
+    # the tree before styling it.
+    def style_and_context(element, element_id, &block)
+      style_method = "#{element_id}_style"
+      if parent_layout.respond_to?(style_method) || block_given?
+        parent_layout.context(element) do
+          if parent_layout.respond_to?(style_method)
+            parent_layout.send(style_method)
+          end
+
+          if block_given?
+            yield
+          end
+        end
+      end
+    end
+
   end
 
 end

data/lib/motion-kit/object.rb

@@ -1,13 +1,4 @@
 class Object
-  attr_accessor :motion_kit_meta
-
-  def motion_kit_id=(element_id)
-    motion_kit_meta[:id] = element_id
-  end
-
-  def motion_kit_id
-    motion_kit_meta[:id]
-  end
 
   def motion_kit_meta
     @motion_kit_meta ||= {}

data/lib/motion-kit/version.rb

@@ -1,3 +1,3 @@
 module MotionKit
-  VERSION = '0.10.11'
+  VERSION = '0.11.0'
 end