motion-kit 0.10.5 → 0.10.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b22aaa500be2edac6395ebf69d34966726906a6f
-  data.tar.gz: 73762f0b31935e2eafdf23eaf8ad397b262e31f9
+  metadata.gz: 20015e2ea39d1ee5ade966a4db342b0605fcfb6e
+  data.tar.gz: 74a853c1ddf2ecb4627d2ef159411f6b76c9c324
 SHA512:
-  metadata.gz: 1a96bd95971b62699b7f5650c89d91b16dcc61220ec741c31b1d8ea79b25809a3b02840113d2f3bf42366044180e7f4afda70668abbeb7696a738e0565c8c2f0
-  data.tar.gz: 16151eed8d35d0db5848665d561a6cba5d3f4d66d93eeb1aae1e3fa474c02c318e1970d7709b8d093a4dfffab60296ea77a4f033bbe737b04160ef7f2f989782
+  metadata.gz: a2c4fb5357b601dafe6455b4f0f344b90b9913a44a2a984085f139903f187992f3d4b855a26717b0f4fb4beaaee83474f636318ad48e4f060cfc2249cedd0094
+  data.tar.gz: 3e7e1c372e731a783919e6567ebce275b4c74e149a463dc78ec1175d7839076d0ccd9660384721ed9a0298a109568ff0470afbeb43925c0a08cbc9ce473c5c9a

data/README.md

@@ -504,11 +504,18 @@ You can pass symbols like `autoresizing_mask :flexible_width`, or use
 symbols that have more intuitive meaning than the usual
 `UIViewAutoresizingFlexible*` constants.  These work in iOS and OS X.
 
+All of the `:pin_to_` shorthands have a fixed size, whereas the `:fill_`
+shorthands have flexible size.
+
 ```ruby
+# the :fill shorthands will get you a ton of mileage
+autoresizing_mask :fill_top
+# but if you want the size to stay constant, use :pin_to
+autoresizing_mask :pin_to_bottom
+# or, a list of flexible sides
 autoresizing_mask :flexible_right, :flexible_bottom, :flexible_width
+# or, combine them in some crazy fancy way
 autoresizing_mask :pin_to_left, :rigid_top  # 'rigid' undoes a 'flexible' setting
-autoresizing_mask :pin_to_bottom, :flexible_width
-autoresizing_mask :fill_top
 
 flexible_left:       Sticks to the right side
 flexible_width:      Width varies with parent
@@ -701,6 +708,16 @@ simplifying the controller code (and usually making it more testable).  See the
 [motion-kit-events]: https://github.com/rubymotion/motion-kit-events
 
 
+### MotionKit::Templates
+
+    gem install motion-kit-templates
+
+Adds project templates, for use with `motion create`.
+
+    motion create foo --template=mk-ios
+    motion create foo --template=mk-osx
+
+
 ## Some handy tricks and Features
 
 ### Orientation specific styles

data/lib/motion-kit-cocoa/constraints/constraints_layout.rb

@@ -18,485 +18,184 @@ module MotionKit
     end
 
     def x(value=nil)
-      constraint = Constraint.new(target.view, :left, :equal)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:left, :equal, value)
     end
     alias left x
 
     def min_x(value=nil)
-      constraint = Constraint.new(target.view, :left, :gte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:left, :gte, value)
     end
     alias min_left min_x
 
     def max_x(value=nil)
-      constraint = Constraint.new(target.view, :left, :lte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:left, :lte, value)
     end
     alias max_left max_x
 
     def leading(value=nil)
-      constraint = Constraint.new(target.view, :leading, :equal)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:leading, :equal, value)
     end
 
     def min_leading(value=nil)
-      constraint = Constraint.new(target.view, :leading, :gte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:leading, :gte, value)
     end
 
     def max_leading(value=nil)
-      constraint = Constraint.new(target.view, :leading, :lte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:leading, :lte, value)
     end
 
     def center_x(value=nil)
-      constraint = Constraint.new(target.view, :center_x, :equal)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:center_x, :equal, value)
     end
 
     def min_center_x(value=nil)
-      constraint = Constraint.new(target.view, :center_x, :gte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:center_x, :gte, value)
     end
 
     def max_center_x(value=nil)
-      constraint = Constraint.new(target.view, :center_x, :lte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:center_x, :lte, value)
     end
 
     def right(value=nil)
-      constraint = Constraint.new(target.view, :right, :equal)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:right, :equal, value)
     end
 
     def min_right(value=nil)
-      constraint = Constraint.new(target.view, :right, :gte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:right, :gte, value)
     end
 
     def max_right(value=nil)
-      constraint = Constraint.new(target.view, :right, :lte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:right, :lte, value)
     end
 
     def trailing(value=nil)
-      constraint = Constraint.new(target.view, :trailing, :equal)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:trailing, :equal, value)
     end
 
     def min_trailing(value=nil)
-      constraint = Constraint.new(target.view, :trailing, :gte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:trailing, :gte, value)
     end
 
     def max_trailing(value=nil)
-      constraint = Constraint.new(target.view, :trailing, :lte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:trailing, :lte, value)
     end
 
     def y(value=nil)
-      constraint = Constraint.new(target.view, :top, :equal)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:top, :equal, value)
     end
     alias top y
 
     def min_y(value=nil)
-      constraint = Constraint.new(target.view, :top, :gte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:top, :gte, value)
     end
     alias min_top min_y
 
     def max_y(value=nil)
-      constraint = Constraint.new(target.view, :top, :lte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:top, :lte, value)
     end
     alias max_top max_y
 
     def center_y(value=nil)
-      constraint = Constraint.new(target.view, :center_y, :equal)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:center_y, :equal, value)
     end
 
     def min_center_y(value=nil)
-      constraint = Constraint.new(target.view, :center_y, :gte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:center_y, :gte, value)
     end
 
     def max_center_y(value=nil)
-      constraint = Constraint.new(target.view, :center_y, :lte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:center_y, :lte, value)
     end
 
     def bottom(value=nil)
-      constraint = Constraint.new(target.view, :bottom, :equal)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:bottom, :equal, value)
     end
 
     def min_bottom(value=nil)
-      constraint = Constraint.new(target.view, :bottom, :gte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:bottom, :gte, value)
     end
 
     def max_bottom(value=nil)
-      constraint = Constraint.new(target.view, :bottom, :lte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:bottom, :lte, value)
     end
 
     def baseline(value=nil)
-      constraint = Constraint.new(target.view, :baseline, :equal)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:baseline, :equal, value)
     end
 
     def min_baseline(value=nil)
-      constraint = Constraint.new(target.view, :baseline, :gte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:baseline, :gte, value)
     end
 
     def max_baseline(value=nil)
-      constraint = Constraint.new(target.view, :baseline, :lte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:baseline, :lte, value)
     end
 
     def width(value=nil)
-      constraint = Constraint.new(target.view, :width, :equal)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:width, :equal, value)
     end
     alias w width
 
     def min_width(value=nil)
-      constraint = Constraint.new(target.view, :width, :gte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:width, :gte, value)
     end
 
     def max_width(value=nil)
-      constraint = Constraint.new(target.view, :width, :lte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:width, :lte, value)
     end
 
     def height(value=nil)
-      constraint = Constraint.new(target.view, :height, :equal)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:height, :equal, value)
     end
     alias h height
 
     def min_height(value=nil)
-      constraint = Constraint.new(target.view, :height, :gte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:height, :gte, value)
     end
 
     def max_height(value=nil)
-      constraint = Constraint.new(target.view, :height, :lte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:height, :lte, value)
     end
 
     def size(value=nil)
-      constraint = SizeConstraint.new(target.view, :size, :equal)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:size, :equal, value, SizeConstraint)
     end
 
     def min_size(value=nil)
-      constraint = SizeConstraint.new(target.view, :size, :gte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:size, :gte, value, SizeConstraint)
     end
 
     def max_size(value=nil)
-      constraint = SizeConstraint.new(target.view, :size, :lte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint(:size, :lte, value, SizeConstraint)
     end
 
     def center(value=nil)
-      constraint = PointConstraint.new(target.view, [:center_x, :center_y], :equal)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint([:center_x, :center_y], :equal, value, PointConstraint)
     end
 
     def min_center(value=nil)
-      constraint = PointConstraint.new(target.view, [:center_x, :center_y], :gte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint([:center_x, :center_y], :gte, value, PointConstraint)
     end
 
     def max_center(value=nil)
-      constraint = PointConstraint.new(target.view, [:center_x, :center_y], :lte)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint([:center_x, :center_y], :lte, value, PointConstraint)
     end
 
     def top_left(value=nil)
-      constraint = PointConstraint.new(target.view, [:left, :top], :equal)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint([:left, :top], :equal, value, PointConstraint)
     end
     alias origin top_left
 
     def top_right(value=nil)
-      constraint = PointConstraint.new(target.view, [:right, :top], :equal)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint([:right, :top], :equal, value, PointConstraint)
     end
 
     def bottom_left(value=nil)
-      constraint = PointConstraint.new(target.view, [:left, :bottom], :equal)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint([:left, :bottom], :equal, value, PointConstraint)
     end
 
     def bottom_right(value=nil)
-      constraint = PointConstraint.new(target.view, [:right, :bottom], :equal)
-
-      if value
-        constraint.equals(value)
-      end
-
-      target.add_constraints([constraint])
-      return constraint
+      target_constraint([:right, :bottom], :equal, value, PointConstraint)
     end
 
     def above(view)
@@ -533,5 +232,15 @@ module MotionKit
     end
     alias right_of after
 
+  private
+
+    def target_constraint(attribute, relationship, value=nil, constraint_class=nil)
+      constraint_class ||= Constraint
+      constraint = constraint_class.new(target.view, attribute, relationship)
+      constraint.equals(value) if value
+      target.add_constraints([constraint])
+      constraint
+    end
+
   end
 end

data/lib/motion-kit-osx/layouts/nsmenu_extensions.rb

@@ -4,7 +4,9 @@ module MotionKit
 
     # useful when writing menus
     def app_name
-      NSBundle.mainBundle.infoDictionary['CFBundleName']
+      # this returns an ImmediateRef, whatever that is.  It needs to be
+      # converted to a String.
+      "#{NSBundle.mainBundle.infoDictionary['CFBundleName']}"
     end
 
     def _menu_title_and_options(title, options, default_title=nil, default_options={})

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

@@ -0,0 +1,9 @@
+# @requires MotionKit::ViewCalculator
+module MotionKit
+  module_function
+
+  def calculate(view, dimension, amount, full_view=nil)
+    ViewCalculator.new.calculate(view, dimension, amount, full_view)
+  end
+
+end

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

@@ -0,0 +1,28 @@
+# @provides MotionKit::Calculator
+module MotionKit
+  class Calculator
+    attr_accessor :factor, :constant
+
+    def self.memo
+      @memo ||= {}
+    end
+
+    def self.scan(amount)
+      amount = amount.gsub(' ', '')
+      Calculator.memo[amount] ||= Calculator.new(amount)
+    end
+
+    def initialize(amount)
+      location = amount.index '%'
+      if location
+        self.factor = amount.slice(0, location).to_f / 100.0
+        location += 1
+      else
+        self.factor = 0
+        location = 0
+      end
+      self.constant = amount.slice(location, amount.size).to_f
+    end
+
+  end
+end

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

@@ -0,0 +1,65 @@
+# @provides module:MotionKit::FrameCalculator
+module MotionKit
+
+  module FrameCalculator
+
+    def calculate_frame(view, amount, full_view)
+      if amount.is_a?(Symbol)
+        calculate_frame_from_symbol(view, amount, full_view)
+      elsif amount.is_a?(Array)
+        calculate_frame_from_array(view, amount, full_view)
+      elsif amount.is_a?(Hash)
+        calculate_frame_from_hash(view, amount, full_view)
+      else
+        return amount
+      end
+    end
+
+    def calculate_frame_from_symbol(view, amount, full_view)
+      case amount
+      when :full, :auto
+        size = calculate_size(view, amount, full_view)
+        origin = [0, 0]
+      when :center
+        size = view.frame.size
+        origin = calculate_origin(view, :center, ['50%', '50%'], size, full_view)
+        origin.x -= size.width / 2.0
+        origin.y -= size.height / 2.0
+      else
+        raise "Unrecognized amount symbol #{amount.inspect} in MotionKit#calculate_frame"
+      end
+
+      return CGRect.new(origin, size)
+    end
+
+    def calculate_frame_from_array(view, amount, full_view)
+      if amount.length == 2
+        size = calculate_size(view, amount[1], full_view)
+        origin = calculate_origin(view, :origin, amount[0], size, full_view)
+      elsif amount.length == 4
+        size = calculate_size(view, [amount[2], amount[3]], full_view)
+        origin = calculate_origin(view, :origin, [amount[0], amount[1]], size, full_view)
+      else
+        raise "Don't know what to do with frame value #{amount.inspect}"
+      end
+
+      return CGRect.new(origin, size)
+    end
+
+    def calculate_frame_from_hash(view, amount, full_view)
+      size = calculate_size(view, (amount[:size] || amount), full_view)
+
+      if amount.key?(:center)
+        origin = calculate_origin(view, :center, amount[:center], size, full_view)
+        origin.x -= size.width / 2
+        origin.y -= size.height / 2
+      else
+        origin = calculate_origin(view, :origin, (amount[:origin] || amount), size, full_view)
+      end
+
+      return CGRect.new(origin, size)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,90 @@
+# @provides module:MotionKit::OriginCalculator
+module MotionKit
+
+  module OriginCalculator
+
+    def calculate_origin(view, dimension, amount, my_size=nil, full_view)
+      my_size ||= view.frame.size
+      if amount == :center
+        calculate_from_center(view, dimension, amount, my_size, full_view)
+      elsif amount.is_a?(Array) || amount.is_a?(Hash)
+        calculate_from_hash_array(view, dimension, amount, my_size, full_view)
+      else
+        return amount
+      end
+    end
+
+    def calculate_from_center(view, dimension, amount, my_size, full_view)
+      x = calculate(view, :width, '50%', full_view) - my_size.width / 2.0
+      y = calculate(view, :height, '50%', full_view) - my_size.height / 2.0
+      return CGPoint.new(x, y)
+    end
+
+    def calculate_from_hash_array(view, dimension, amount, my_size, full_view)
+      x, y, x_offset, y_offset = calculate_from_hash(view, dimension, amount, my_size)
+      x = calculate(view, :width, x, full_view) + (x_offset || 0)
+      y = calculate(view, :height, y, full_view) + (y_offset || 0)
+      return CGPoint.new(x, y)
+    end
+
+    def calculate_from_hash(view, dimension, amount, my_size)
+      return amount[0], amount[1], nil, nil if amount.is_a?(Array)
+      if amount[:relative]
+        calculate_relative_from_hash(view, dimension, amount, my_size)
+      else
+        calculate_absolute_from_hash(view, dimension, amount, my_size)
+      end
+    end
+
+    def calculate_relative_from_hash(view, dimension, amount, my_size)
+      x = amount[:x] || begin
+        x = view.frame.origin.x
+        x += my_size.width / 2.0 if dimension == :center
+        x
+      end
+
+      y = amount[:y] || begin
+        y = view.frame.origin.y
+        y += my_size.height / 2.0 if dimension == :center
+        y
+      end
+
+      x_offset = amount[:right] if amount.key?(:right)
+      x_offset = -amount[:left] if amount.key?(:left)
+
+      y_offset = amount[:down] if amount.key?(:down)
+      y_offset = -amount[:up] if amount.key?(:up)
+      y_offset = -y_offset if amount[:flipped]
+
+      return x, y, x_offset, y_offset
+    end
+
+    def calculate_absolute_from_hash(view, dimension, amount, my_size)
+      if amount.key?(:right)
+        x_offset = -my_size.width
+        x = amount[:right]
+      elsif amount.key?(:x) || amount.key?(:left)
+        x = amount[:x] || amount[:left]
+      elsif dimension == :center
+        x = view.frame.origin.x + (my_size.width / 2)
+      else
+        x = view.frame.origin.x
+      end
+
+      if amount.key?(:bottom)
+        y_offset = -my_size.height
+        y = amount[:bottom]
+      elsif amount.key?(:y) || amount.key?(:top)
+        y = amount[:y] || amount[:top]
+      elsif dimension == :center
+        y = view.frame.origin.y + (my_size.height / 2)
+      else
+        y = view.frame.origin.y
+      end
+
+      return x, y, x_offset, y_offset
+    end
+
+  end
+
+end

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

@@ -0,0 +1,65 @@
+# @provides module:MotionKit::SizeCalculator
+module MotionKit
+
+  module SizeCalculator
+
+    def calculate_size(view, amount, full_view)
+      if amount.is_a?(Array) || amount.is_a?(Hash)
+        calculate_size_from_multiple(view, amount, full_view)
+      elsif amount == :full
+        w = calculate(view, :width, '100%', full_view)
+        h = calculate(view, :height, '100%', full_view)
+        return CGSize.new(w, h)
+      elsif amount == :auto
+        return intrinsic_size(view)
+      elsif amount.is_a?(Symbol)
+        raise "Unrecognized amount symbol #{amount.inspect} in MotionKit#calculate_size"
+      else
+        return amount
+      end
+    end
+
+    def calculate_size_from_multiple(view, amount, full_view)
+      w, h = resolve_width_and_height(view, amount)
+
+      if w == :scale || h == :scale
+        w, h = calculate_scaled_width_height(w, h, view, full_view)
+      else
+        w = calculate(view, :width, w, full_view)
+        h = calculate(view, :height, h, full_view)
+      end
+
+      return CGSize.new(w, h)
+    end
+
+    def calculate_scaled_width_height(w, h, view, full_view)
+      # scaling is handled a little differently, because it is dependent on
+      # the other amount and the intrinsic size.
+      if w == :scale && h == :scale
+        raise "Either width or height can be :scale, but not both"
+      elsif w == :scale
+        h = calculate(view, :height, h, full_view)
+        size = intrinsic_size(view)
+        w = h * size.width / size.height
+      elsif h == :scale
+        w = calculate(view, :width, w, full_view)
+        size = intrinsic_size(view)
+        h = w * size.height / size.width
+      end
+      return w, h
+    end
+
+    def resolve_width_and_height(view, amount)
+      if amount.is_a?(Hash)
+        w = amount[:w] || amount[:width]  || view.frame.size.width
+        h = amount[:h] || amount[:height] || view.frame.size.height
+      else
+        w = amount[0]
+        h = amount[1]
+      end
+      return w, h
+    end
+
+  end
+
+end

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

@@ -0,0 +1,51 @@
+# @requires MotionKit::Calculator
+# @requires module:MotionKit::OriginCalculator
+# @requires module:MotionKit::SizeCalculator
+# @requires module:MotionKit::FrameCalculator
+# @provides MotionKit::ViewCalculator
+module MotionKit
+  class ViewCalculator
+    include MotionKit::OriginCalculator
+    include MotionKit::SizeCalculator
+    include MotionKit::FrameCalculator
+
+    def calculate(view, dimension, amount, full_view=nil)
+      if amount.is_a? Proc
+        return view.instance_exec(&amount)
+      elsif dimension == :origin || dimension == :center
+        return calculate_origin(view, dimension, amount, nil, full_view)
+      elsif dimension == :size
+        return calculate_size(view, amount, full_view)
+      elsif dimension == :frame
+        return calculate_frame(view, amount, full_view)
+      elsif amount == :full
+        return calculate(view, dimension, '100%', full_view)
+      elsif amount == :auto
+        return intrinsic_size(view).send(dimension) # :left or :right
+      elsif amount.is_a?(String) && amount.include?('%')
+        full_view ||= view.superview || begin
+          raise NoSuperviewError.new("Cannot calculate #{amount}% of #{dimension.inspect} because view #{view} has no superview.")
+        end
+        calc = Calculator.scan(amount)
+
+        raise "Unknown dimension #{dimension}" unless [:width, :height].include?(dimension)
+        return (full_view.frame.size.send(dimension) * calc.factor + calc.constant).round
+      else
+        return amount
+      end
+    end
+
+    def intrinsic_size(view)
+      size_that_fits = view.intrinsicContentSize
+      if size_that_fits.width == MotionKit.no_intrinsic_metric
+        size_that_fits.width = 0
+      end
+      if size_that_fits.height == MotionKit.no_intrinsic_metric
+        size_that_fits.height = 0
+      end
+      return size_that_fits
+    end
+
+  end
+
+end

data/lib/motion-kit/version.rb

@@ -1,3 +1,3 @@
 module MotionKit
-  VERSION = '0.10.5'
+  VERSION = '0.10.6'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: motion-kit
 version: !ruby/object:Gem::Version
-  version: 0.10.5
+  version: 0.10.6
 platform: ruby
 authors:
 - Colin T.A. Gray
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-13 00:00:00.000000000 Z
+date: 2014-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dbt
@@ -34,7 +34,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/motion-kit/calculate.rb
+- lib/motion-kit/calculator/calculate.rb
+- lib/motion-kit/calculator/calculator.rb
+- lib/motion-kit/calculator/frame_calculator.rb
+- lib/motion-kit/calculator/origin_calculator.rb
+- lib/motion-kit/calculator/size_calculator.rb
+- lib/motion-kit/calculator/view_calculator.rb
 - lib/motion-kit/layouts/base_layout.rb
 - lib/motion-kit/layouts/base_layout_class_methods.rb
 - lib/motion-kit/layouts/parent.rb

data/lib/motion-kit/calculate.rb

@@ -1,263 +0,0 @@
-# @provides MotionKit::Calculator
-module MotionKit
-  module_function
-
-  def calculate(view, dimension, amount, full_view=nil)
-    if amount.is_a? Proc
-      return view.instance_exec(&amount)
-    elsif dimension == :origin || dimension == :center
-      return calculate_origin(view, dimension, amount, nil, full_view)
-    elsif dimension == :size
-      return calculate_size(view, amount, full_view)
-    elsif dimension == :frame
-      return calculate_frame(view, amount, full_view)
-    elsif amount == :full
-      return calculate(view, dimension, '100%', full_view)
-    elsif amount == :auto
-      size_that_fits = intrinsic_size(view)
-
-      return case dimension
-      when :width
-        return size_that_fits.width
-      when :height
-        return size_that_fits.height
-      end
-    elsif amount.is_a?(String) && amount.include?('%')
-      full_view ||= view.superview
-      unless full_view
-        raise NoSuperviewError.new("Cannot calculate #{amount}% of #{dimension.inspect} because view #{view} has no superview.")
-      end
-      calc = Calculator.scan(amount)
-
-      factor = calc.factor
-      constant = calc.constant
-
-      return case dimension
-      when :width
-        return (full_view.frame.size.width * factor + constant).round
-      when :height
-        return (full_view.frame.size.height * factor + constant).round
-      else
-        raise "Unknown dimension #{dimension}"
-      end
-    else
-      return amount
-    end
-  end
-
-  def calculate_origin(view, dimension, amount, my_size=nil, full_view)
-    my_size ||= view.frame.size
-
-    if amount == :center
-      x = calculate(view, :width, '50%', full_view) - my_size.width / 2.0
-      y = calculate(view, :height, '50%', full_view) - my_size.height / 2.0
-      return CGPoint.new(x, y)
-    elsif amount.is_a?(Array) || amount.is_a?(Hash)
-      x_offset = 0
-      y_offset = 0
-
-      if amount.is_a?(Hash)
-        if amount[:relative]
-          if amount.key?(:x)
-            x = amount[:x]
-          else
-            x = view.frame.origin.x
-            if dimension == :center
-              x += my_size.width / 2.0
-            end
-          end
-
-          if amount.key?(:y)
-            y = amount[:y]
-          else
-            y = view.frame.origin.y
-            if dimension == :center
-              y += my_size.height / 2.0
-            end
-          end
-
-          if amount.key?(:right)
-            x_offset = amount[:right]
-          elsif amount.key?(:left)
-            x_offset = -amount[:left]
-          end
-
-          if amount.key?(:down)
-            y_offset = amount[:down]
-          elsif amount.key?(:up)
-            y_offset = -amount[:up]
-          end
-          y_offset = -y_offset if amount[:flipped]
-        else
-          if amount.key?(:right)
-            x_offset = -my_size.width
-            x = amount[:right]
-          elsif amount.key?(:x) || amount.key?(:left)
-            x = amount[:x] || amount[:left]
-          elsif dimension == :center
-            x = view.frame.origin.x
-            x += my_size.width / 2
-          else
-            x = view.frame.origin.x
-          end
-
-          if amount.key?(:bottom)
-            y_offset = -my_size.height
-            y = amount[:bottom]
-          elsif amount.key?(:y) || amount.key?(:top)
-            y = amount[:y] || amount[:top]
-          elsif dimension == :center
-            y = view.frame.origin.y
-            y += my_size.height / 2
-          else
-            y = view.frame.origin.y
-          end
-        end
-      else
-        x = amount[0]
-        y = amount[1]
-      end
-
-      x = calculate(view, :width, x, full_view) + x_offset
-      y = calculate(view, :height, y, full_view) + y_offset
-      return CGPoint.new(x, y)
-    else
-      return amount
-    end
-  end
-
-  def calculate_size(view, amount, full_view)
-    if amount.is_a?(Array) || amount.is_a?(Hash)
-      if amount.is_a?(Hash)
-        w = amount.fetch(:w, amount.fetch(:width, view.frame.size.width))
-        h = amount.fetch(:h, amount.fetch(:height, view.frame.size.height))
-      else
-        w = amount[0]
-        h = amount[1]
-      end
-
-      # scaling is handled a little differently, because it is dependent on
-      # the other amount and the intrinsic size.
-      if w == :scale || h == :scale
-        if w == :scale && h == :scale
-          raise "Either width or height can be :scale, but not both"
-        elsif w == :scale
-          h = calculate(view, :height, h, full_view)
-          size = intrinsic_size(view)
-          w = h * size.width / size.height
-        elsif h == :scale
-          w = calculate(view, :width, w, full_view)
-          size = intrinsic_size(view)
-          h = w * size.height / size.width
-        end
-      else
-        w = calculate(view, :width, w, full_view)
-        h = calculate(view, :height, h, full_view)
-      end
-
-      return CGSize.new(w, h)
-    elsif amount == :full
-      w = calculate(view, :width, '100%', full_view)
-      h = calculate(view, :height, '100%', full_view)
-      return CGSize.new(w, h)
-    elsif amount == :auto
-      return intrinsic_size(view)
-    elsif amount.is_a?(Symbol)
-      raise "Unrecognized amount symbol #{amount.inspect} in MotionKit#calculate_size"
-    else
-      return amount
-    end
-  end
-
-  def calculate_frame(view, amount, full_view)
-    if amount.is_a?(Symbol)
-      case amount
-      when :full, :auto
-        size = calculate_size(view, amount, full_view)
-        origin = [0, 0]
-      when :center
-        size = view.frame.size
-        origin = calculate_origin(view, :center, ['50%', '50%'], size, full_view)
-        origin.x -= size.width / 2.0
-        origin.y -= size.height / 2.0
-      else
-        raise "Unrecognized amount symbol #{amount.inspect} in MotionKit#calculate_frame"
-      end
-
-      return CGRect.new(origin, size)
-    elsif amount.is_a?(Array)
-      if amount.length == 2
-        size = calculate_size(view, amount[1], full_view)
-        origin = calculate_origin(view, :origin, amount[0], size, full_view)
-      elsif amount.length == 4
-        size = calculate_size(view, [amount[2], amount[3]], full_view)
-        origin = calculate_origin(view, :origin, [amount[0], amount[1]], size, full_view)
-      else
-        raise "Don't know what to do with frame value #{amount.inspect}"
-      end
-
-      return CGRect.new(origin, size)
-    elsif amount.is_a?(Hash)
-      if amount.key?(:size)
-        size = calculate_size(view, amount[:size], full_view)
-      else
-        size = calculate_size(view, amount, full_view)
-      end
-
-      if amount.key?(:center)
-        origin = calculate_origin(view, :center, amount[:center], size, full_view)
-        origin.x -= size.width / 2
-        origin.y -= size.height / 2
-      elsif amount.key?(:origin)
-        origin = calculate_origin(view, :origin, amount[:origin], size, full_view)
-      else
-        origin = calculate_origin(view, :origin, amount, size, full_view)
-      end
-
-      return CGRect.new(origin, size)
-    else
-      return amount
-    end
-  end
-
-  def intrinsic_size(view)
-    size_that_fits = view.intrinsicContentSize
-    if size_that_fits.width == MotionKit.no_intrinsic_metric
-      size_that_fits.width = 0
-    end
-    if size_that_fits.height == MotionKit.no_intrinsic_metric
-      size_that_fits.height = 0
-    end
-    return size_that_fits
-  end
-
-  class Calculator
-    attr_accessor :factor, :constant
-
-    def self.memo
-      @memo ||= {}
-    end
-
-    def self.scan(amount)
-      amount = amount.gsub(' ', '')
-      return Calculator.memo[amount] if Calculator.memo[amount]
-
-      calc = Calculator.new
-
-      location = amount.index '%'
-      if location
-        calc.factor = amount.slice(0, location).to_f / 100.0
-        location += 1
-      else
-        calc.factor = 0
-        location = 0
-      end
-      calc.constant = amount.slice(location, amount.size).to_f
-
-      Calculator.memo[amount] = calc
-      return calc
-    end
-
-  end
-
-end