rm-extensions 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cbf506f0e146d719368d97d86a04b4fede0df97b
-  data.tar.gz: 6d8b171e1add24ee6c63d27ee4057c6051f944a4
+  metadata.gz: dddb35f12d5cf8cc9de4cb3b39df6644497bf550
+  data.tar.gz: 93e202d15df61498e5432194d8e2466d37ece16d
 SHA512:
-  metadata.gz: 3204fde1f0f0e9c903aa2fdda8a638f4c91544e2a81b404b728eb9bd100200ce8c81fa5d69cc6d2a57002a1182d968d331b8164e629fa30227b6f426e2ccdb18
-  data.tar.gz: 8fc6a988442c02b7ba501b7c360a1825d20ed40899b6707d3d4b179cb8e51c865f2552ab59357ea0a64368341a3345be2918aabdb7dc0f9f618c6ca11fcb825c
+  metadata.gz: c8494d5c4ee43c3bca403556e063b66cefc671f7b6cb56a2e5b70332a3332007f285377ae3d6beafb348d031623af22eaeda30ef38bc5955d8de0517ef3245a4
+  data.tar.gz: ddbc5a99d7939b0c9c2ffca586d852fb783f2216a388d638dfe20c4ea1aa656cf75dfb07ed6dba3b1fa3e33eea7b88ed1b3f128fb97f3e3b75139baa8904dabc

data/README.md

@@ -3,285 +3,9 @@ RMExtensions
 
 #### Extensions and helpers for dealing with various areas of rubymotion and iOS.
 
-## Equation-style AutoLayout Constraints 
+#### [Documentation](https://github.com/joenoon/rm-extensions/wiki/RMExtensions-Documentation)
 
-AutoLayout is a great way to lay out views, but writing constraints manually is
-confusing and verbose.
-
-Using Apple's "Visual Format Language" ASCII-inspired
-strings can improve things, but it has drawbacks:  **1)** It returns an array
-of constraints.  This means if you plan on altering one of them later, or removing
-one in particular, you would have to loop through all of the constraints, testing
-each one to see if its the one you want.  **2)** The `options` argument adds additional
-constraints.  For example, if you specify NSLayoutAttributeCenterY to a horizontal string,
-an additional constraint will be added for each view to set their centerY's equal to each
-other.  This compounds problem #1.  The chances you will get an error that the layout system
-cannot satisfy your constraints is probably because of these "extra" constraints. **3)**
-It can't handle complex constraints, so you end up needing to supplement it with
-verbose low-level constraint creation anyway.
-
-Apple makes note of how constraints can be thought of like a linear equation:
-
-http://developer.apple.com/library/ios/documentation/AppKit/Reference/NSLayoutConstraint_Class/NSLayoutConstraint/NSLayoutConstraint.html
-
-**Remember the formula:**
-
-```ruby
-view1.attr1 == view2.attr2 * multiplier + constant @ priority
-```
-
-**We can actually use this super-simple formula to write ALL of our constraints, simple OR complex!**
-
-Once you get the hang of the formula and visualization of how the geometry works, it becomes easy to create complex layouts with little
-effort.  And, in my opinion, its only slightly more verbose than the visual format language, but much clearer, and you only end up
-with the exact constraints you want.
-
-Available values for `attr1` and `attr2` are:
-
-- left
-- right
-- top
-- bottom
-- leading
-- trailing
-- width
-- height
-- centerX
-- centerY
-- baseline
-
-Available `relation` values are:
-
-- ==
-- <=
-- >=
-
-Available `priority` values are:
-
-- required (1000 is the default)
-- high (750)
-- low (250)
-- fit (50)
-- or, you can use your own value between 1-1000
-
-
-### Examples
-
-Here is a real example.  The Layout instance is created just like the motion-layout gem.  `layout.view` sets the view
-that will act as the 'superview' to the views set in `layout.subviews`.  Thats where the similarities end with
-motion-layout.  With RMExtensions::Layout, there are two methods: `eq` and `eqs`, short for equation and equations.
-
-- `layout.eq` takes one string, and returns *one constraint*
-- `layout.eqs` takes one string, assumes multiple constraints are separated by newlines, and returns an *array of constraints*
-
-```ruby
-RMExtensions::Layout.new do |layout|
-  layout.view view
-  layout.subviews({
-    "calendar" => calendarView,
-    "table" => tableView,
-    "shadow" => line
-  })
-
-  layout.eqs %Q{
-    calendar.left == 0
-    calendar.right == 0
-    table.left == 7
-    table.right == -7
-    shadow.left == 0
-    shadow.right == 0
-
-    calendar.top == 0
-    table.top == calendar.bottom
-    table.bottom == 0
-    shadow.top == table.top
-  }
-
-  @calendar_height_constraint = layout.eq "calendar.height == 0"
-end
-```
-
-Above, **calendar.left == 0** is short for **calendar.left == view.left * 1.0 + 0 @ 1000**.  If no view2 is given, the superview ('view') is assumed.
-If no multiplier is given, 1.0 is assumed.  If no constant is given, 0 is assumed.  If no priority is given, "required" (1000) is assumed.
-The last constraint is created separately and stored in @calendar_height_constraint, because I want to be able to change the calendar's height
-any time I want.
-
-Here is another example:
-
-```ruby
-RMExtensions::Layout.new do |layout|
-  layout.view self
-  layout.subviews({
-    "timeLabel" => @timeLabel,
-    "titleLabel" => @titleLabel,
-    "trackingImage" => @trackingImage,
-    "inOutStatusInImage" => @inOutStatusInImage,
-    "inOutStatusOutImage" => @inOutStatusOutImage,
-    "plannerImage" => @plannerImage,
-    "shareButton" => @shareButton,
-    "cancelledLabel" => @cancelledLabel,
-    "unreadImage" => @unreadImage
-  })
-  
-  layout.eqs %Q{
-    unreadImage.left == 6
-    unreadImage.top == 6
-    plannerImage.left == 14
-    plannerImage.centerY == 0
-    plannerImage.width == 30
-    plannerImage.height == 30
-    trackingImage.left == timeLabel.right + 5
-    inOutStatusOutImage.left == trackingImage.right + 5
-    inOutStatusInImage.left == inOutStatusOutImage.right + 5
-    timeLabel.left == plannerImage.right + 5
-    timeLabel.baseline == plannerImage.bottom + 1
-    trackingImage.centerY == timeLabel.centerY
-    inOutStatusOutImage.centerY == timeLabel.centerY
-    inOutStatusInImage.centerY == timeLabel.centerY
-    titleLabel.left == cancelledLabel.right
-    cancelledLabel.left == plannerImage.right + 5
-    titleLabel.top == plannerImage.top - 4
-    cancelledLabel.centerY == titleLabel.centerY
-    shareButton.right == -10
-    shareButton.centerY == 0
-    titleLabel.resistH == low
-    shareButton.left >= titleLabel.right + 5
-    timeLabel.resistH == low
-    shareButton.left >= inOutStatusInImage.right + 5
-  }
-
-end
-```
-
-Keep in mind none of these lines are using the multiplier, and thats OK.  I've only needed it on one constraint in my entire app so far,
-so don't think its odd if you can't find a use for it.
-
-There are two special cases at the moment.  **titleLabel.resistH == low** is not a "real" constraint.  Its a shortcut to
-`setContentCompressionResistancePriority`, and since its common when dealing with autolayout, its nice to include it
-in our layout code.  The same is done for `setContentHuggingPriority`.  The full list of "special cases" at the moment:
-
-- view1.resistH == priority
-- view1.resistV == priority
-- view1.hugH == priority
-- view1.hugV == priority
-
-"priority" can be one of the values listed earlier, or your own number between 1-1000.
-
-### Debugging constraints
-
-- You can include a **?** on any line, and debug output will be printed when that constraint is built:
-
-```ruby
-layout.eqs %Q{
-  label.left == photo.right + 5 ?
-}
-```
-
-- Since layout.eqs allows you to write many constraints in one string, and sometimes its nice to
-keep comments next to constraints, **comments are allowed**:
-
-```ruby
-layout.eqs %Q{
-  commentsCount.width == likesCount.width @ low # the widths of the labels prefer to be the same
-}
-```
-
-### Things to remember
-
-- Remember you usually want negative constants for right and bottom.  For example: label.right == -10 means "label's right should be 10 away from the right side of the superview".  But if you accidentally said label.right == 10, you would have created "label's right should be 10 PAST the right side of the superview".  It may require you to adjust your thinking.
-
-- The formula is just shorthand for `constraintWithItem:attribute:relatedBy:toItem:attribute:multiplier:constant:`.  You should **really** read up on constraints and
-understand this method, to fully understand the power and simplicity the shorthand formula gives you.
-
-
-
-
-
-
-
-
-## Observation/KVO, Events
-
-#### Make observations without needing to clean up/unobserve
-
-Call from anywhere on anything:
-
-```ruby
-class MyViewController < UIViewController
-  def viewDidLoad
-    super.tap do
-      rmext_observe(@model, "name") do |val|
-        p "name is #{val}"
-      end
-      foo.rmext_on(:some_event) do |val|
-        p "some_event called with #{val.inspect}"
-      end
-    end
-  end
-  def test_trigger
-    foo.rmext_trigger(:some_event, "hello!")
-  end
-end
-```
-
-Differences from BW::KVO and BW::Reactor::Eventable:
-
-- No need to include a module in the class you wish to use it on
-- the observation happens on a proxy object
-- KVO: The default is to observe and immediately fire the supplied callback
-- KVO: The callback only takes one argument, the new value
-- KVO: the object observing is not retained, and when it is deallocated, the observation
-  will be removed automatically for you. there is typically no need to clean up manually
-
-
-## Accessors
-
-#### weak attr_accessors:
-
-```ruby
-
-class MyView < UIView
-  rmext_weak_attr_accessor :delegate
-end
-
-class MyViewController < UIViewController
-  def viewDidLoad
-    super.tap do
-      v = MyView.alloc.initWithFrame(CGRectZero)
-      view.addSubview(v)
-      v.delegate = self
-    end
-  end
-end
-
-```
-
-## Queues
-
-#### Wraps GCD:
-
-```ruby
-# note +i+ will appear in order, and the thread will never change (main)
-100.times do |i|
-  rmext_on_main_q do
-    p "i: #{i} thread: #{NSThread.currentThread}"
-  end
-end
-
-# note +i+ will appear in order, and the thread will change
-100.times do |i|
-  rmext_on_serial_q("testing") do
-    p "i: #{i} thread: #{NSThread.currentThread}"
-  end
-end
-
-# note +i+ will sometimes appear out of order, and the thread will change
-100.times do |i|
-  rmext_on_concurrent_q("testing") do
-    p "i: #{i} thread: #{NSThread.currentThread}"
-  end
-end
-```
+#### [CHANGELOG](https://github.com/joenoon/rm-extensions/wiki/CHANGELOG)
 
 Installation
 -----------------
@@ -294,8 +18,6 @@ And then execute:
 
     $ bundle
 
-* Currently depends on bubblewrap (for BW::KVO).
-
 Contributing
 -----------------
 
@@ -312,8 +34,7 @@ License
 
 Please see [LICENSE](https://github.com/joenoon/rm-extensions/blob/master/LICENSE.txt) for licensing details.
 
-
 Author
 -----------------
 
-Joe Noon, [joenoon](https://github.com/joenoon)
+[Joe Noon](https://github.com/joenoon)

data/lib/motion/observation.rb

@@ -8,26 +8,22 @@ module RMExtensions
         @rmext_observation_proxy ||= ObservationProxy.new(self)
       end
 
-      # observe an object.key. takes a block that will be called with the
-      # new value upon change.
-      #
-      # rmext_observe_passive(@model, "name") do |val|
-      #   p "name is #{val}"
-      # end
-      def rmext_observe_passive(object, key, &block)
-        rmext_observation_proxy.observe(object, key, &block)
+      def rmext_observe_passive(object, keyPath:key, withBlock:block)
+        rmext_observe(object, keyPath:key, options:(NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld), withBlock:block)
       end
 
-      # like +rmext_observe_passive+ but additionally fires the callback immediately.
-      def rmext_observe(object, key, &block)
-        rmext_observe_passive(object, key, &block)
-        block.call(object.send(key)) unless block.nil?
+      def rmext_observe(object, keyPath:key, withBlock:block)
+        rmext_observe(object, keyPath:key, options:(NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld | NSKeyValueObservingOptionInitial), withBlock:block)
+      end
+
+      def rmext_observe(object, keyPath:key, options:options, withBlock:block)
+        rmext_observation_proxy.observe(object, keyPath:key, options:options, withBlock:block)
       end
 
       # unobserve an existing observation
-      def rmext_unobserve(object, key)
+      def rmext_unobserve(object, keyPath:key)
         if @rmext_observation_proxy
-          @rmext_observation_proxy.unobserve(object, key)
+          @rmext_observation_proxy.unobserve(object, keyPath:key)
         end
       end
 
@@ -39,14 +35,14 @@ module RMExtensions
       end
 
       # register a callback when an event is trigger on this object
-      def rmext_on(event, &block)
-        rmext_observation_proxy.on(event, &block)
+      def rmext_on(event, inContext:context, withBlock:block)
+        rmext_observation_proxy.on(event, inContext:context, withBlock:block)
       end
 
       # remove a specific callback for an event on this object
-      def rmext_off(event, &block)
+      def rmext_off(event, inContext:context, withBlock:block)
         if @rmext_observation_proxy
-          @rmext_observation_proxy.off(event, &block)
+          @rmext_observation_proxy.off(event, inContext:context, withBlock:block)
         end
       end
 
@@ -57,10 +53,10 @@ module RMExtensions
         end
       end
 
-      # trigger an event with args on this object
-      def rmext_trigger(event, *args)
+      # trigger an event with value on this object
+      def rmext_trigger(event, value=nil)
         if @rmext_observation_proxy
-          @rmext_observation_proxy.trigger(event, *args)
+          @rmext_observation_proxy.trigger(event, value)
         end
       end
 
@@ -75,19 +71,26 @@ module RMExtensions
 
   end
 
+  class ObservationResponse
+    attr_accessor :context, :value, :old_value, :target, :key, :indexes, :kind
+  end
+
+  class EventResponse
+    attr_accessor :context, :value, :target, :event
+  end
+
   # # Proxy class used to hold the actual observation and watches for the real
   # # class intended to hold the observation to be deallocated, so the
   # # observation can be cleaned up.
   class ObservationProxy
-    COLLECTION_OPERATIONS = [ NSKeyValueChangeInsertion, NSKeyValueChangeRemoval, NSKeyValueChangeReplacement ]
-    DEFAULT_OPTIONS = NSKeyValueObservingOptionNew
 
     def initialize(obj)
+      @weak_object = WeakRef.new(obj)
       @desc = obj.inspect
-      @events = {}
+      @events = NSMapTable.weakToStrongObjectsMapTable
       @targets = {}
       if ::RMExtensions.debug?
-        p "created ObservationProxy for #{@desc}"
+        p "created ObservationProxy(#{@desc})"
       end
     end
 
@@ -95,26 +98,27 @@ module RMExtensions
       @did_dealloc = true
       cleanup
       if ::RMExtensions.debug?
-        p "dealloc ObservationProxy for #{@desc}"
+        p "dealloc ObservationProxy(#{@desc})"
       end
       super
     end
 
     def cleanup
       if ::RMExtensions.debug?
-        p "cleanup #{@desc}"
+        p "cleanup ObservationProxy(#{@desc})"
       end
       unobserve_all
       off_all
       true
     end
 
-    def observe(target, key_path, &block)
-      target.addObserver(self, forKeyPath:key_path, options:DEFAULT_OPTIONS, context:nil) unless registered?(target, key_path)
-      add_observer_block(target, key_path, &block)
+    def observe(target, keyPath:key_path, options:options, withBlock:block)
+      already_registered = registered?(target, key_path)
+      add_observer_block(target, key_path, block)
+      target.addObserver(self, forKeyPath:key_path, options:options, context:nil) unless already_registered
     end
 
-    def unobserve(target, key_path)
+    def unobserve(target, keyPath:key_path)
       return unless registered?(target, key_path)
       target.removeObserver(self, forKeyPath:key_path)
       remove_observer_block(target, key_path)
@@ -122,22 +126,20 @@ module RMExtensions
 
     def remove_observer_block(target, key_path)
       return if target.nil? || key_path.nil?
-
-      key_paths = @targets[target]
-      if !key_paths.nil? && key_paths.has_key?(key_path.to_s)
-        key_paths.removeObject(key_path.to_s)
+      key_path = key_path.to_s
+      target_hash = @targets[target]
+      if !target_hash.nil? && target_hash.has_key?(key_path)
+        target_hash.delete(key_path)
       end
     end
 
     def unobserve_all
-      keys = @targets.keys.clone
-      while keys.size > 0
-        target = keys.pop
+      keys = [] + @targets.keys
+      while target = keys.pop
         target_hash = @targets[target]
-        paths = target_hash.keys.clone
-        while paths.size > 0
-          key_path = paths.pop
-          target.removeObserver(self, forKeyPath:key_path)
+        paths = [] + target_hash.keys
+        while key_path = paths.pop
+          unobserve(target, keyPath:key_path)
         end
       end
       @targets.removeAllObjects
@@ -147,42 +149,80 @@ module RMExtensions
       !target.nil? && !@targets[target].nil? && @targets[target].has_key?(key_path.to_s)
     end
 
-    def add_observer_block(target, key_path, &block)
+    def add_observer_block(target, key_path, block)
       return if target.nil? || key_path.nil? || block.nil?
+      key_path = key_path.to_s
       @targets[target] ||= {}
-      @targets[target][key_path.to_s] ||= NSHashTable.weakObjectsHashTable
-      @targets[target][key_path.to_s].addObject block
+      @targets[target][key_path] ||= []
+      @targets[target][key_path].addObject block
     end
 
     # NSKeyValueObserving Protocol
 
     def observeValueForKeyPath(key_path, ofObject:target, change:change, context:context)
-      rmext_on_main_q do
+      m_desc = nil
+      if ::RMExtensions.debug?
+        m_desc = "~~> ObservationProxy(#{@desc})#observeValueForKeyPath(#{key_path}, ofObject:#{target.inspect.split(" ").first}>, ...)"
+        p "called", m_desc
+      end
+      action = proc do
         next if @did_dealloc
         next if target.nil?
-        key_paths = @targets[target] || {}
-        blocks = key_paths[key_path] || []
-        blocks.each do |block|
-          args = [ change[NSKeyValueChangeNewKey] ]
-          args << change[NSKeyValueChangeIndexesKey] if collection?(change)
-          block.call(*args)
+        key_paths = @targets[target]
+        next if key_paths.nil?
+        blocks = key_paths[key_path]
+        next if blocks.nil?
+        blocks = [] + blocks # get a new array that can be popped
+        if ::RMExtensions.debug?
+          p "blocks.size", blocks.size, m_desc
+        end
+        while blk = blocks.pop
+          res = ObservationResponse.new
+          res.context = @weak_object
+          res.value = change[NSKeyValueChangeNewKey]
+          res.old_value = change[NSKeyValueChangeOldKey]
+          res.target = target
+          res.key = key_path
+          res.indexes = change[NSKeyValueChangeIndexesKey]
+          res.kind = change[NSKeyValueChangeKindKey]
+          blk.call(res)
         end
       end
+      if NSThread.currentThread.isMainThread
+        if ::RMExtensions.debug?
+          p "inline execution", m_desc
+        end
+        action.call
+      else
+        if ::RMExtensions.debug?
+          p "dispatch execution", m_desc
+        end
+        rmext_on_main_q(&action)
+      end
     end
 
-    def collection?(change)
-      COLLECTION_OPERATIONS.include?(change[NSKeyValueChangeKindKey])
-    end
-
-    def on(event, &block)
+    def on(event, inContext:context, withBlock:block)
       return if event.nil? || block.nil?
-      @events[event.to_s] ||= []
-      @events[event.to_s].addObject block
+      event = event.to_s
+      context ||= self.class
+      unless context_events = @events.objectForKey(context)
+        context_events = {}
+        @events.setObject(context_events, forKey:context)
+      end
+      unless context_event_blocks = context_events.objectForKey(event)
+        context_event_blocks = []
+        context_events.setObject(context_event_blocks, forKey:event)
+      end
+      context_event_blocks.addObject block
     end
 
-    def off(event, &block)
-      return if event.nil? || block.nil? || !@events.key?(event.to_s)
-      @events[event.to_s].removeObject block
+    def off(event, inContext:context, withBlock:block)
+      return if event.nil? || block.nil?
+      event = event.to_s
+      context ||= self.class
+      return unless context_events = @events.objectForKey(context)
+      return unless context_event_blocks = context_events.objectForKey(event)
+      context_event_blocks.removeObject block
       nil
     end
 
@@ -190,10 +230,39 @@ module RMExtensions
       @events.removeAllObjects
     end
 
-    def trigger(event, *args)
-      return if event.nil? || !@events.key?(event.to_s)
-      @events[event.to_s].each do |block|
-        block.call(*args)
+    def trigger(event, value)
+      m_desc = nil
+      if ::RMExtensions.debug?
+        m_desc = "~~> ObservationProxy(#{@desc})#trigger(#{event}, #{value.inspect.split(" ").first }>)"
+        p "called", m_desc
+      end
+      rmext_on_main_q do
+        next if @did_dealloc
+        next if event.nil?
+        event = event.to_s
+        keyEnumerator = @events.keyEnumerator
+        contexts = []
+        while context = keyEnumerator.nextObject
+          contexts.push context
+        end
+        while context = contexts.pop
+          if context_events = @events.objectForKey(context)
+            if event_blocks = context_events[event]
+              blocks = [] + event_blocks
+              if ::RMExtensions.debug?
+                p "blocks.size", blocks.size, m_desc
+              end
+              while blk = blocks.pop
+                res = EventResponse.new
+                res.context = context
+                res.value = value
+                res.target = @weak_object
+                res.event = event
+                blk.call(res)
+              end
+            end
+          end
+        end
       end
       nil
     end

data/lib/rm-extensions/version.rb

@@ -1,3 +1,3 @@
 module RMExtensions
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rm-extensions
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Joe Noon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-26 00:00:00.000000000 Z
+date: 2013-12-02 00:00:00.000000000 Z
 dependencies: []
 description: Extensions and helpers for dealing with various areas of rubymotion
 email:
@@ -18,7 +18,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
-- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md

data/CHANGELOG.md

@@ -1,49 +0,0 @@
-## 0.2.0
-
-[Commit history](https://github.com/joenoon/rm-extensions/compare/v0.1.10...v0.2.0)
-
-* Experimental changes.  Changelog to move to wiki soon.
-
-## 0.1.10
-
-[Commit history](https://github.com/joenoon/rm-extensions/compare/v0.1.9...v0.1.10)
-
-* Layout: compact constraint(s) passed to #remove so a nil can be passed to reduce code
-* Layout: adjust how to describe existing constraints
-
-## 0.1.9
-
-[Commit history](https://github.com/joenoon/rm-extensions/compare/v0.1.8...v0.1.9)
-
-* Util: Added #rmext_ivar, which is a shortcut to instance_variable_get/instance_variable_set
-* Layout: Added #reopen to yield the instance to a block for further processing
-* Layout: Added an internal "constraint table" to keep track of normalized equations and
-  NSLayoutConstraint objects.  equations can now be modified simply by re-applying the same
-  equation with a different constant.
-* Layout: Added #xeq to remove a constraint by equation
-* Layout: Added #remove(constraint(s)) to remove NSLayoutConstraint obects from the view
-  and also from the internal constraint table.
-
-## 0.1.8
-
-[Commit history](https://github.com/joenoon/rm-extensions/compare/v0.1.7...v0.1.8)
-
-* Added RMExtensions::Layout#clear! which is a shortcut to view.removeConstraints(view.constraints).
-  It must be called after the `view` is set.
-* Added 'max' as a valid priority shortcut, since it reads better than 'required' in many cases.
-* Comments are now allowed on a line by themselves inside a `eqs` string, to make for easier commenting,
-  or to easily comment out an equation.
-* Added a special `last_visible` view identifier which can be used instead of an actual view name
-  inside an equation.  It will refer to the last view a constraint was applied to that was not hidden.
-  This can be used to more easily lay out constraints when some views should not be anchored against.
-  For example, you have 3 labels, A, B, and C, that you want stacked vertically:
-    A.top == 0
-    B.top == A.bottom + 5
-    C.top == B.bottom + 5
-  If B is hidden, there would be 10px in between A and C.  Instead, you can let RMExtensions::Layout handle
-  this for you:
-    A.top == 0                        # last_visible is set to A
-    B.top == last_visible.bottom + 5  # B is hidden, so last_visible remains A
-    C.top == last_visible.bottom + 5  # C now aligns to the bottom of A
-  It is usually easier and cleaner to build all possible views and mark some hidden than it is to have
-  many if/else view creation and constraint construction specific to what should be displayed.