motion-ui-geometry 0.5.1

data/lib/motion-ui-geometry/float.rb

@@ -0,0 +1,42 @@
+class Float
+
+  EPSILON = 0.00001
+
+  def clamp(min, max)
+    max = 0 + max
+    min = 0 + min
+
+    min, max = max, min if min > max
+
+    if self > max
+      max
+    elsif self < min
+      min
+    else
+      self
+    end
+  end
+
+  def to_radians
+    self * Math::PI / 180.0
+  end
+  alias :to_rad :to_radians
+
+  def to_degrees
+    self * 180.0 / Math::PI
+  end
+  alias :to_deg :to_degrees
+
+  def roughly_equal?(other, epsilon = EPSILON)
+    (self - other).abs <= epsilon
+  end
+
+  def =~(other)
+    roughly_equal?(other)
+  end
+
+  def to_value
+    NSNumber.numberWithFloat self
+  end
+
+end

data/lib/motion-ui-geometry/nsdictionary.rb

@@ -0,0 +1,21 @@
+class NSDictionary
+
+  def to_point
+    point = Pointer.new CGPoint.type
+    CGPointMakeWithDictionaryRepresentation self, point
+    point[0]
+  end
+
+  def to_size
+    size = Pointer.new CGSize.type
+    CGSizeMakeWithDictionaryRepresentation self, size
+    size[0]
+  end
+
+  def to_rect
+    rect = Pointer.new CGRect.type
+    CGRectMakeWithDictionaryRepresentation self, rect
+    rect[0]
+  end
+
+end

data/lib/motion-ui-geometry/nsstring.rb

@@ -0,0 +1,17 @@
+class NSString
+  def to_point
+    CGPointFromString(self)
+  end
+
+  def to_size
+    CGSizeFromString(self)
+  end
+
+  def to_rect
+    CGRectFromString(self)
+  end
+
+  def to_transform
+    CGAffineTransformFromString(self)
+  end
+end

data/lib/motion-ui-geometry/spec_app_delegate.rb

@@ -0,0 +1,7 @@
+class SpecAppDelegate
+  def application(application, didFinishLaunchingWithOptions:launchOptions)
+    @window = UIWindow.alloc.initWithFrame(UIScreen.mainScreen.bounds)
+    @window.rootViewController = UIViewController.alloc.init
+    true
+  end
+end

data/lib/motion-ui-geometry/version.rb

@@ -0,0 +1,7 @@
+module Motion
+  module UI
+    module Geometry
+      VERSION = "0.5.1"
+    end
+  end
+end

data/motion-ui-geometry.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/motion-ui-geometry/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Sebastian Burkhart"]
+  gem.email         = ["sebastianburkhart@me.com"]
+  gem.description   = %q{Access CoreGraphics UI geometry the Ruby way.}
+  gem.summary       = %q{Contains Ruby-ish interfaces mixed into Float, CGPoint, CGRect, CGSize and CGPoint.}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "motion-ui-geometry"
+  gem.require_paths = ["lib"]
+  gem.version       = Motion::UI::Geometry::VERSION
+end

data/spec/cgaffinetransform_spec.rb

@@ -0,0 +1,272 @@
+describe CGAffineTransform do
+
+  before do
+    @t = CGAffineTransform.new 1, 2, 3, 4, 5, 6
+    @double_scale = CGAffineTransform.new 2, 0, 0, 2, 0, 0
+    @double_t = CGAffineTransform.new 2, 4, 6, 8, 10, 12
+  end
+
+
+  describe "#initialize(a, b, c, d, tx, ty)" do
+    it "initializes an affine transform" do
+      t = CGAffineTransform.new 1, 2, 3, 4, 5, 6
+      t.should.is_a(CGAffineTransform)
+      t.a.should  == 1
+      t.b.should  == 2
+      t.c.should  == 3
+      t.d.should  == 4
+      t.tx.should == 5
+      t.ty.should == 6
+    end
+  end
+
+
+  describe "Factory methods" do
+
+    describe ".identity" do
+      it "returns the identity transform" do
+        CGAffineTransform.identity.should == CGAffineTransformIdentity
+        CGAffineTransform.identity.should.is_a(CGAffineTransform)
+      end
+    end
+
+    describe ".rotation(angle_in_rad)" do
+      it "creates a rotation transform" do
+        t = CGAffineTransform.rotation(Math::PI)
+        t.should =~ CGAffineTransform.new(-1, 0, 0, -1, 0, 0)
+      end
+    end
+
+    describe ".scale(sx, sy)" do
+      it "creates a scale transform" do
+        t = CGAffineTransform.scale(2, 3)
+        t.should.is_a(CGAffineTransform)
+        t.should == CGAffineTransform.new(2, 0, 0, 3, 0, 0)
+      end
+
+      it "works with only one parameter" do
+        t = CGAffineTransform.scale(2)
+        t.should.is_a(CGAffineTransform)
+        t.should == CGAffineTransform.new(2, 0, 0, 2, 0, 0)
+      end
+    end
+
+    describe ".translation(tx, ty)" do
+      it "creates a translation transform" do
+        t = CGAffineTransform.translation(4, 5)
+        t.should.is_a(CGAffineTransform)
+        t.should == CGAffineTransform.new(1, 0, 0, 1, 4, 5)
+      end
+    end
+
+    describe ".skew(sx, sy)" do
+      it "creates a skew transform" do
+        skew = CGAffineTransform.skew(4, 5)
+        skew.should.is_a(CGAffineTransform)
+        skew.should == CGAffineTransformMake(1, 5, 4, 1, 0, 0)
+      end
+    end
+
+  end
+
+
+  describe "Comparison operators" do
+
+    describe "==" do
+      it "returns true when equal" do
+        CGAffineTransformIdentity.should == CGAffineTransformIdentity
+        CGAffineTransformIdentity.should == CGAffineTransform.new(1, 0, 0, 1, 0, 0)
+      end
+
+      it "returns false when not equal" do
+        CGAffineTransformIdentity.should != CGAffineTransform.new(1, 1, 1, 1, 1, 1)
+      end
+    end
+
+    describe "=~" do
+      before do
+        @t1 = CGAffineTransform.new  1, 1, 1, 1, 1, 1
+        @t2 = CGAffineTransform.new  0.999999, 0.999999, 0.999999, 0.999999, 0.999999, 0.999999
+        @t3 = CGAffineTransform.new  1.0000001, 1.0000001, 1.0000001, 1.0000001, 1.0000001, 1.0000001
+        @t4 = CGAffineTransform.new -1.0000001, 1.0000001, 1.0000001, 1.0000001, 1.0000001, 1.0000001
+      end
+
+      it "returns true if transforms are roughly equal" do
+        @t1.should =~ @t1
+        @t1.should =~ @t2
+        @t2.should =~ @t3
+      end
+
+      it "returns false if transforms are not roughly equal" do
+        @t1.should.not =~ @t4
+        @t2.should.not =~ @t4
+        @t3.should.not =~ @t4
+      end
+    end
+
+  end
+
+
+  describe "Applying transforms on other transforms" do
+
+    describe "#concat(other)" do
+      it "returns the result of applying the other transform on self" do
+        @t.concat(CGAffineTransformIdentity).should == @t
+        CGAffineTransformIdentity.concat(@t).should == @t
+        @t.concat(@double_scale).should == @double_t
+      end
+    end
+
+    describe "#apply_on(other)" do
+      it "behaves reverse to concat" do
+        CGAffineTransformIdentity.apply_on(@t).should == @t
+        @t.apply_on(CGAffineTransformIdentity).should == @t
+        @double_scale.apply_on(@t).should == @double_t
+      end
+    end
+
+    describe "via operators" do
+
+      describe "+" do
+        it "translates if given a CGSize" do
+          t = CGAffineTransformIdentity + CGSizeMake(2, 3)
+          t.should == CGAffineTransform.translation(2, 3)
+        end
+
+        it "translates if given a CGPoint" do
+          t = CGAffineTransformIdentity + CGPointMake(2, 3)
+          t.should == CGAffineTransform.translation(2, 3)
+        end
+
+        it "raises if given another type" do
+          lambda { CGAffineTransformIdentity + "abc" }.should.raise TypeError
+        end
+      end
+
+      describe "-" do
+        it "translates if given a CGSize" do
+          t = CGAffineTransformIdentity - CGSizeMake(2, 3)
+          t.should == CGAffineTransform.translation(-2, -3)
+        end
+
+        it "translates if given a CGPoint" do
+          t = CGAffineTransformIdentity - CGPointMake(2, 3)
+          t.should == CGAffineTransform.translation(-2, -3)
+        end
+      end
+
+      describe "unary -" do
+        it "inverts the transform" do
+          (-CGAffineTransform.identity).should == CGAffineTransform.identity
+          (-CGAffineTransform.scale(2, 4)).should == CGAffineTransform.scale(0.5, 0.25)
+          (-CGAffineTransform.rotation(20)).should =~ CGAffineTransform.rotation(-20)
+          (-CGAffineTransform.translation(2, 4)).should == CGAffineTransform.translation(-2, -4)
+        end
+      end
+
+      describe "*" do
+        it "behaves like #concat if given a transform" do
+          @t.concat(CGAffineTransformIdentity).should == @t
+          CGAffineTransformIdentity.concat(@t).should == @t
+          @t.concat(@double_scale).should == @double_t
+        end
+
+        it "scales the transform if given a Float" do
+          (CGAffineTransformIdentity * 23.0).should =~ CGAffineTransform.scale(23.0, 23.0)
+        end
+
+        it "scales the transform if given a Fixnum" do
+          (CGAffineTransformIdentity * 5).should =~ CGAffineTransform.scale(5.0, 5.0)
+        end
+
+        it "raises if given another type" do
+          lambda { CGAffineTransformIdentity * "abc" }.should.raise TypeError
+        end
+      end
+
+    end
+
+    describe "via shortcut methods" do
+
+      describe "#translate(tx, ty)" do
+        it "translates the transform by an offset of (tx, ty)" do
+          t = CGAffineTransform.identity.translate(4, 5)
+          t.should == CGAffineTransform.translation(4, 5)
+          t.should == CGAffineTransform.new(1, 0, 0, 1, 4, 5)
+        end
+      end
+
+      describe "#scale(sx, sy)" do
+        it "scales the transform by a factor of (sx, sy)" do
+          t = CGAffineTransform.identity.scale(23, 42)
+          t.should == CGAffineTransform.scale(23, 42)
+          t.should == CGAffineTransform.new(23, 0, 0, 42, 0, 0)
+        end
+
+        it "works with only one parameter" do
+          t = CGAffineTransform.identity
+          t.should.is_a(CGAffineTransform)
+          t.scale(2).should == CGAffineTransform.new(2, 0, 0, 2, 0, 0)
+        end
+      end
+
+      describe "#rotate(angle_in_rad)" do
+        it "rotates the transform by given angle" do
+          t = CGAffineTransform.identity.rotate(Math::PI)
+          t.should    == CGAffineTransform.rotation(Math::PI)
+          t.a.should  == -1
+          t.b.should  =~  0
+          t.c.should  =~  0
+          t.d.should  == -1
+          t.tx.should ==  0
+          t.ty.should ==  0
+        end
+      end
+
+      describe "#skew(sx, sy)" do
+        it "skew the transform by given offsets" do
+          t = CGAffineTransform.identity.skew(3, 4)
+          t.should == CGAffineTransform.skew(3, 4)
+          t.should == CGAffineTransform.new(1, 4, 3, 1, 0, 0)
+        end
+      end
+
+    end
+
+  end
+
+  describe "#invert" do
+    it "inverts the transform" do
+      i = CGAffineTransform.identity
+      i.invert.should == i
+      CGAffineTransform.scale(2, 4).invert.should == CGAffineTransform.scale(0.5, 0.25)
+      CGAffineTransform.rotation(10).invert.should == CGAffineTransform.rotation(-10)
+      CGAffineTransform.translation(2, 4).invert.should == CGAffineTransform.translation(-2, -4)
+    end
+  end
+
+  describe "#identity?" do
+    it "returns true for the identity transform" do
+      CGAffineTransform.identity.should.be.identity
+    end
+
+    it "returns false for other transforms" do
+      CGAffineTransform.translation(1, 2).should.not.be.identity
+    end
+  end
+
+  describe "#to_value" do
+    it "returns a NSValue containing the transform" do
+      t = CGAffineTransform.new 1, 2, 3, 4, 5, 6
+      t.to_value.CGAffineTransformValue.should == t
+    end
+  end
+
+  describe "#to_s" do
+    it "returns a NSString encoding" do
+      CGAffineTransform.new(1, 2, 3, 4, 5, 6).to_s.
+        should == "[1, 2, 3, 4, 5, 6]"
+    end
+  end
+
+end

data/spec/cgpoint_spec.rb

@@ -0,0 +1,210 @@
+describe "CGPoint" do
+
+  describe "== operator" do
+    it "returns true for the same point" do
+      CGPointMake(-12345, -12345).should == CGPointMake(-12345, -12345)
+      CGPointMake(1, 1).should == CGPointMake(1, 1)
+    end
+
+    it "returns false for other points" do
+      CGPointMake(1, 1).should != CGPointMake(0.999, 0.999)
+      CGPointMake(1, 1).should != CGPointZero
+    end
+  end
+
+  describe "=~ operator" do
+    it "should return true if the points are roughly equal" do
+      CGPointZero.should =~ CGPointZero
+      CGPointZero.should =~ CGPointMake( 0.00001,  0.00001)
+      CGPointZero.should =~ CGPointMake(-0.00001, -0.00001)
+    end
+
+    it "should return false if the points are not roughly equal" do
+      CGPointZero.should.not =~ CGPointMake(1, 1)
+    end
+
+    it "should return true if vectors are roughly equal" do
+      CGPointZero.should =~ CGSizeZero
+      CGPointZero.should =~ CGSizeMake( 0.00001,  0.00001)
+      CGPointZero.should =~ CGSizeMake(-0.00001, -0.00001)
+    end
+
+    it "should return false if vectors are not roughly equal" do
+      CGPointZero.should.not =~ CGSizeMake(1, 1)
+    end
+
+    it "should raise if given a wrong type" do
+      lambda { CGPointZero =~ "abc" }.should.raise(TypeError)
+    end
+  end
+
+  describe "unary -" do
+    it "returns the point with negative coordinates" do
+      (-CGPointMake(1, 1)).should == CGPointMake(-1, -1)
+      (-CGPointZero).should == CGPointZero
+    end
+  end
+
+  describe "- operator" do
+    it "returns the subtracted point vectors as point" do
+      (CGPointMake(1, 1) - CGPointMake(1, 1)).should == CGPointZero
+      (CGPointZero - CGPointMake(1, 1)).should == CGPointMake(-1, -1)
+    end
+
+    it "raises if not given a point" do
+      lambda { CGPointZero - "abc" }.should.raise(TypeError)
+    end
+  end
+
+  describe "+ operator" do
+    it "returns the added point vectors as point" do
+      (CGPointMake(1, 2) + CGPointMake(3, 4)).should == CGPointMake(4, 6)
+      (CGPointMake(-1, -2) + CGPointMake(1, 2)).should == CGPointZero
+    end
+
+    it "raises if not given a point" do
+      lambda { CGPointZero + "abc" }.should.raise(TypeError)
+    end
+  end
+
+  describe "* operator" do
+    it "scales the point if given a Float" do
+      (CGPointZero * 23.0).should == CGPointZero
+      (CGPointMake(1, 2) * 23.0).should == CGPointMake(23, 46)
+      (CGPointMake(1, 2) * -1.0).should == CGPointMake(-1, -2)
+    end
+
+    it "scales the point if given a Fixnum" do
+      (CGPointZero * 23).should == CGPointZero
+      (CGPointMake(1, 2) * 23).should == CGPointMake(23, 46)
+      (CGPointMake(1, 2) * -1).should == CGPointMake(-1, -2)
+    end
+
+    it "scales the point if given a CGSize" do
+      size = CGSizeMake(2, 4)
+      (CGPointZero * size).should == CGPointZero
+      (CGPointZero * size).should.is_a CGPoint
+      (CGPointMake(1, 1) * size).should =~ size
+      (CGPointMake(3, 5) * size).should == CGPointMake(6, 20)
+    end
+
+    it "scales the point if given a CGPoint" do
+      point = CGPointMake(2, 4)
+      (CGPointZero * point).should == CGPointZero
+      (CGPointZero * point).should.is_a CGPoint
+      (CGPointMake(1, 1) * point).should == point
+      (CGPointMake(3, 5) * point).should == CGPointMake(6, 20)
+    end
+
+    it "applies a transform if given" do
+      (CGPointZero * CGAffineTransform.scale(5)).should == CGPointZero
+      point = CGPointMake(1, 2)
+      (point * CGAffineTransform.scale(5)).should == point * 5
+    end
+
+    it "raises if given another type" do
+      lambda { CGPointZero * "abc" }.should.raise(TypeError)
+    end
+  end
+
+  describe "#distance_to(other)" do
+    it "returns 0.0 for the same points" do
+      (CGPointMake(1, 1).distance_to CGPointMake(1, 1)).should == 0.0
+      (CGPointMake(-1234, -1234).distance_to CGPointMake(-1234, -1234)).should == 0.0
+    end
+
+    it "returns the absolute distance" do
+      (CGPointMake(1, 0).distance_to CGPointZero).should =~ 1.0
+      (CGPointMake(0, 1).distance_to CGPointZero).should =~ 1.0
+      (CGPointZero.distance_to CGPointMake(1, 0)).should =~ 1.0
+      (CGPointZero.distance_to CGPointMake(0, 1)).should =~ 1.0
+    end
+
+    it "returns the distance to the given other point as float" do
+      (CGPointMake(1, 1).distance_to CGPointZero).should =~ Math.sqrt(2.0)
+      (CGPointMake(-1, -1).distance_to CGPointZero).should =~ Math.sqrt(2.0)
+    end
+
+    it "raises if given no point" do
+      lambda { CGPointZero.distance_to "abc" }.should.raise(TypeError)
+    end
+  end
+
+  describe '#clamp_to_rect(rect)' do
+    it "limits the point coordinates to the given rect" do
+      rect = CGRectMake(0, 0, 1, 1)
+      CGPointZero.clamp_to_rect(rect).should == CGPointZero
+      CGPointMake(1, 1).clamp_to_rect(rect).should == CGPointMake(1, 1)
+      CGPointMake(0.5, 0.5).clamp_to_rect(rect).should == CGPointMake(0.5, 0.5)
+      CGPointMake(-1, -1).clamp_to_rect(rect).should == CGPointZero
+      CGPointMake(2, 2).clamp_to_rect(rect).should == CGPointMake(1, 1)
+    end
+
+    it "raises if given no rect" do
+      lambda { CGPointZero.clamp_to_rect "abc" }.should.raise(TypeError)
+    end
+  end
+
+  describe '#round' do
+    it "returns the point rounded to next integer coordinates" do
+      CGPointMake(0.1, 0.1).round.should == CGPointZero
+      CGPointMake(-0.1, -0.1).round.should == CGPointZero
+      CGPointMake(12.34, 12.34).round.should == CGPointMake(12, 12)
+      CGPointMake(34.56, 34.56).round.should == CGPointMake(35, 35)
+    end
+  end
+
+  describe '#floor' do
+    it "returns the point rounded down to integer coordinates" do
+      CGPointMake(0.1, 0.1).floor.should == CGPointZero
+      CGPointMake(-0.1, -0.1).floor.should == CGPointMake(-1, -1)
+      CGPointMake(12.34, 12.34).floor.should == CGPointMake(12, 12)
+      CGPointMake(34.56, 34.56).floor.should == CGPointMake(34, 34)
+    end
+  end
+
+  # describe "#angle" do
+  #   it "should work"
+  # end
+
+  describe "#apply(transform)" do
+    it "returns a new point with the given transform applied" do
+      p = CGPointMake(1, 1)
+      scale = CGAffineTransform.scale(2.0, 2.0)
+      p = p.apply(scale)
+      p.should == CGPointMake(2, 2)
+    end
+
+    it "raises if given no transform" do
+      lambda { CGPointZero.clamp_to_rect "abc" }.should.raise(TypeError)
+    end
+  end
+
+  describe "#to_dictionary" do
+    it "returns a dictionary" do
+      CGPointMake(1, 1).to_dictionary.should.is_a(NSDictionary)
+    end
+  end
+
+  describe "#to_value" do
+    it "returns a correct NSValue" do
+      value = CGPointMake(1, 1).to_value
+      value.CGPointValue.should == CGPointMake(1, 1)
+    end
+  end
+
+  describe "#to_size" do
+    it "returns a CGSize" do
+      size = CGPointMake(1, 2).to_size
+      size.should.is_a(CGSize)
+      size.should == CGSizeMake(1, 2)
+    end
+  end
+
+  describe "#to_s" do
+    it "should return a sensible string" do
+      CGPointMake(23, 42).to_s.should == "{23, 42}"
+    end
+  end
+
+end