vector2d 2.2.3 → 2.2.4

data/lib/vector2d/transformations.rb

@@ -1,14 +1,11 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 class Vector2d
   module Transformations
-    include Contracts
-
     # Rounds vector to up nearest integer.
     #
     #   Vector2d(2.4, 3.6).ceil # => Vector2d(3,4)
     #
-    Contract None => Vector2d
     def ceil
       self.class.new(x.ceil, y.ceil)
     end
@@ -17,7 +14,6 @@ class Vector2d
     #
     #   Vector2d(2.4, 3.6).floor # => Vector2d(2,3)
     #
-    Contract None => Vector2d
     def floor
       self.class.new(x.floor, y.floor)
     end
@@ -28,7 +24,6 @@ class Vector2d
     #   vector.normalize        # => Vector2d(0.5547.., 0.8320..)
     #   vector.normalize.length # => 1.0
     #
-    Contract None => Vector2d
     def normalize
       resize(1.0)
     end
@@ -37,7 +32,6 @@ class Vector2d
     #
     #   Vector2d(2, 3).perpendicular # => Vector2d(-3,2)
     #
-    Contract None => Vector2d
     def perpendicular
       Vector2d.new(-y, x)
     end
@@ -46,16 +40,14 @@ class Vector2d
     #
     #   Vector2d(2, 3).resize(1.0) # => Vector2d(0.5547.., 0.8320..)
     #
-    Contract Num => Vector2d
     def resize(new_length)
-      self * (new_length / self.length)
+      self * (new_length / length)
     end
 
     # Reverses the vector.
     #
     #   Vector2d(2, 3).reverse # => Vector2d(-2,-3)
     #
-    Contract None => Vector2d
     def reverse
       self.class.new(-x, -y)
     end
@@ -64,11 +56,10 @@ class Vector2d
     #
     #   Vector2d(1, 0).rotate(Math:PI/2) => Vector2d(1,0)
     #
-    Contract Num => Vector2d
     def rotate(angle)
       Vector2d.new(
-        x * Math.cos(angle) - y * Math.sin(angle),
-        x * Math.sin(angle) + y * Math.cos(angle)
+        (x * Math.cos(angle)) - (y * Math.sin(angle)),
+        (x * Math.sin(angle)) + (y * Math.cos(angle))
       )
     end
 
@@ -77,8 +68,7 @@ class Vector2d
     #   Vector2d(2.4, 3.6).round # => Vector2d(2,4)
     #   Vector2d(2.4444, 3.666).round(2) # => Vector2d(2.44, 3.67)
     #
-    Contract Or[None, Num] => Vector2d
-    def round(digits=0)
+    def round(digits = 0)
       self.class.new(x.round(digits), y.round(digits))
     end
 
@@ -88,9 +78,8 @@ class Vector2d
     #   vector.truncate(5.0) # => Vector2d(2.0, 3.0)
     #   vector.truncate(1.0) # => Vector2d(0.5547.., 0.8320..)
     #
-    Contract Num => Vector2d
     def truncate(max)
-      resize([max, self.length].min)
+      resize([max, length].min)
     end
   end
 end

data/lib/vector2d/version.rb

@@ -1,5 +1,5 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 class Vector2d
-  VERSION = "2.2.3"
+  VERSION = "2.2.4"
 end

data/lib/vector2d.rb

@@ -1,25 +1,11 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require "contracts"
-
-class Vector2d
-  include Contracts
-  VectorLike = Or[
-    [Num, Num],
-    { x: Num, y: Num },
-    { 'x' => Num, 'y' => Num },
-    Num,
-    String,
-    Vector2d
-  ]
-end
-
-require 'vector2d/calculations'
-require 'vector2d/coercions'
-require 'vector2d/fitting'
-require 'vector2d/properties'
-require 'vector2d/transformations'
-require 'vector2d/version'
+require "vector2d/calculations"
+require "vector2d/coercions"
+require "vector2d/fitting"
+require "vector2d/properties"
+require "vector2d/transformations"
+require "vector2d/version"
 
 class Vector2d
   extend Vector2d::Calculations::ClassMethods
@@ -41,55 +27,44 @@ class Vector2d
     #   Vector2d.parse({x: 150, y: 100})
     #   Vector2d.parse({"x" => 150.0, "y" => 100.0})
     #   Vector2d.parse(Vector2d(150, 100))
-    Contract VectorLike, Maybe[Num] => Vector2d
     def parse(arg, second_arg = nil)
       if second_arg.nil?
         parse_single_arg(arg)
       else
-        self.new(arg, second_arg)
+        new(arg, second_arg)
       end
     end
 
     private
 
-    Contract VectorLike => Vector2d
     def parse_single_arg(arg)
-      case arg
-      when Vector2d
-        arg
-      when Array
-        self.parse(*arg)
-      when String
-        parse_str(arg)
-      when Hash
-        parse_hash(arg.dup)
-      else
-        self.new(arg, arg)
-      end
+      return arg if arg.is_a?(Vector2d)
+      return parse(*arg) if arg.is_a?(Array)
+      return parse_str(arg) if arg.is_a?(String)
+      return parse_hash(arg.dup) if arg.is_a?(Hash)
+
+      new(arg, arg)
     end
 
-    Contract Hash => Vector2d
     def parse_hash(hash)
-      hash[:x] ||= hash['x'] if hash.has_key?('x')
-      hash[:y] ||= hash['y'] if hash.has_key?('y')
-      self.new(hash[:x], hash[:y])
+      hash[:x] ||= hash["x"] if hash.key?("x")
+      hash[:y] ||= hash["y"] if hash.key?("y")
+      new(hash[:x], hash[:y])
     end
 
-    Contract String => Vector2d
     def parse_str(str)
-      if str =~ /^[\s]*[\d\.]*[\s]*x[\s]*[\d\.]*[\s]*$/
-        x, y = str.split("x")
-        new(x.to_f, y.to_f)
-      else
-        fail ArgumentError, "not a valid string input"
-      end
+      raise ArgumentError, "not a valid string input" unless /^\s*[\d.]*\s*x\s*[\d.]*\s*$/.match?(str)
+
+      x, y = str.split("x")
+      new(x.to_f, y.to_f)
     end
   end
 
   attr_reader :x, :y
 
   def initialize(x, y)
-    @x, @y = x, y
+    @x = x
+    @y = y
   end
 
   # Compares two vectors
@@ -97,9 +72,8 @@ class Vector2d
   #   Vector2d(2, 3) == Vector2d(2, 3) # => true
   #   Vector2d(2, 3) == Vector2d(1, 0) # => false
   #
-  Contract Vector2d => Bool
-  def ==(comp)
-    comp.x === x && comp.y === y
+  def ==(other)
+    other.x == x && other.y == y
   end
 end
 

data/spec/lib/vector2d/calculations_spec.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Vector2d::Calculations do
   subject(:vector) { Vector2d.new(2, 3) }
@@ -8,6 +8,7 @@ describe Vector2d::Calculations do
   describe ".cross_product" do
     let(:v1) { Vector2d.new(2, 3) }
     let(:v2) { Vector2d.new(4, 5) }
+
     it "calculates the cross product between two vectors" do
       expect(Vector2d.cross_product(v1, v2)).to eq(-2.0)
     end
@@ -16,6 +17,7 @@ describe Vector2d::Calculations do
   describe ".dot_product" do
     let(:v1) { Vector2d.new(2, 3) }
     let(:v2) { Vector2d.new(4, 5) }
+
     it "calculates the dot product between two vectors" do
       expect(Vector2d.dot_product(v1, v2)).to eq(23)
     end
@@ -24,6 +26,7 @@ describe Vector2d::Calculations do
   describe ".angle_between" do
     let(:v1) { Vector2d.new(2, 3) }
     let(:v2) { Vector2d.new(4, 5) }
+
     it "calculates the angle between two vectors" do
       expect(Vector2d.angle_between(v1, v2)).to be_within(0.0001).of(0.0867)
     end
@@ -32,12 +35,15 @@ describe Vector2d::Calculations do
   describe "*" do
     context "with vector" do
       subject(:vector) { Vector2d.new(2, 3) * Vector2d.new(3, 4) }
+
       it "multiplies the vectors" do
         expect(vector).to eq(Vector2d.new(6, 12))
       end
     end
+
     context "with number" do
       subject(:vector) { Vector2d.new(2, 3) * 3 }
+
       it "multiplies both members" do
         expect(vector).to eq(Vector2d.new(6, 9))
       end
@@ -47,12 +53,15 @@ describe Vector2d::Calculations do
   describe "/" do
     context "with vector" do
       subject(:vector) { Vector2d.new(6, 12) / Vector2d.new(2, 3) }
+
       it "divides the vectors" do
         expect(vector).to eq(Vector2d.new(3, 4))
       end
     end
+
     context "with number" do
       subject(:vector) { Vector2d.new(6, 12) / 3 }
+
       it "divides both members" do
         expect(vector).to eq(Vector2d.new(2, 4))
       end
@@ -62,12 +71,15 @@ describe Vector2d::Calculations do
   describe "+" do
     context "with vector" do
       subject(:vector) { Vector2d.new(2, 3) + Vector2d.new(3, 4) }
+
       it "adds the vectors" do
         expect(vector).to eq(Vector2d.new(5, 7))
       end
     end
+
     context "with number" do
       subject(:vector) { Vector2d.new(2, 3) + 2 }
+
       it "adds to both members" do
         expect(vector).to eq(Vector2d.new(4, 5))
       end
@@ -77,12 +89,15 @@ describe Vector2d::Calculations do
   describe "-" do
     context "with vector" do
       subject(:vector) { Vector2d.new(3, 5) - Vector2d.new(1, 2) }
+
       it "subtracts the vectors" do
         expect(vector).to eq(Vector2d.new(2, 3))
       end
     end
+
     context "with number" do
       subject(:vector) { Vector2d.new(2, 3) - 2 }
+
       it "subtracts from both members" do
         expect(vector).to eq(Vector2d.new(0, 1))
       end
@@ -91,13 +106,17 @@ describe Vector2d::Calculations do
 
   describe "#cross_product" do
     let(:comp) { Vector2d.new(3, 4) }
+
     it "calulates the cross product" do
-      expect(vector.cross_product(comp)).to eq(Vector2d.cross_product(vector, comp))
+      expect(
+        vector.cross_product(comp)
+      ).to eq(Vector2d.cross_product(vector, comp))
     end
   end
 
   describe "#distance" do
     let(:comp) { Vector2d.new(3, 4) }
+
     it "returns the distance between two vectors" do
       expect(vector.distance(comp)).to be_within(0.0001).of(1.4142)
     end
@@ -105,6 +124,7 @@ describe Vector2d::Calculations do
 
   describe "#squared_distance" do
     let(:comp) { Vector2d.new(5, 6) }
+
     it "returns the squared distance between two vectors" do
       expect(vector.squared_distance(comp)).to eq(18)
     end
@@ -112,6 +132,7 @@ describe Vector2d::Calculations do
 
   describe "#dot_product" do
     let(:comp) { Vector2d.new(3, 4) }
+
     it "calulates the dot product" do
       expect(vector.dot_product(comp)).to eq(Vector2d.dot_product(vector, comp))
     end
@@ -119,8 +140,11 @@ describe Vector2d::Calculations do
 
   describe "#angle_between" do
     let(:comp) { Vector2d.new(3, 4) }
+
     it "calculates the angle between vectors" do
-      expect(vector.angle_between(comp)).to eq(Vector2d.angle_between(vector, comp))
+      expect(
+        vector.angle_between(comp)
+      ).to eq(Vector2d.angle_between(vector, comp))
     end
   end
-end
+end

data/spec/lib/vector2d/coercions_spec.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Vector2d::Coercions do
   subject(:vector) { Vector2d.new(2, 3) }
@@ -18,38 +18,42 @@ describe Vector2d::Coercions do
   end
 
   describe "#to_f_vector" do
-    it "returns a float vector" do
-      expect(vector.to_f_vector.x).to be_a(Float)
-      expect(vector.to_f_vector.y).to be_a(Float)
-    end
+    subject { vector.to_f_vector }
+
+    its(:x) { is_expected.to be_a(Float) }
+    its(:y) { is_expected.to be_a(Float) }
   end
 
   describe "#to_hash" do
     it "returns a hash" do
-      expect(vector.to_hash).to eq({x: 2, y: 3})
+      expect(vector.to_hash).to eq(x: 2, y: 3)
     end
   end
 
   describe "#to_i_vector" do
-    subject(:vector) { Vector2d.new(2.0, 3.0) }
-    it "returns a fixnum vector" do
-      expect(vector.to_i_vector.x).to be_a(Fixnum)
-      expect(vector.to_i_vector.y).to be_a(Fixnum)
-    end
+    subject { vector.to_i_vector }
+
+    let(:vector) { Vector2d.new(2.0, 3.0) }
+
+    its(:x) { is_expected.to be_a(Integer) }
+    its(:y) { is_expected.to be_a(Integer) }
   end
 
   describe "#to_s" do
     context "when fixnum" do
       subject(:vector) { Vector2d.new(2, 3) }
+
       it "renders a string" do
-        expect(vector.to_s).to eq('2x3')
+        expect(vector.to_s).to eq("2x3")
       end
     end
+
     context "when float" do
       subject(:vector) { Vector2d.new(2.0, 3.0) }
+
       it "renders a string" do
-        expect(vector.to_s).to eq('2.0x3.0')
+        expect(vector.to_s).to eq("2.0x3.0")
       end
     end
   end
-end
+end

data/spec/lib/vector2d/fitting_spec.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Vector2d::Fitting do
   let(:original) { Vector2d.new(300, 300) }
@@ -10,26 +10,23 @@ describe Vector2d::Fitting do
 
     context "when vector is smaller" do
       let(:comp) { Vector2d.new(150, 100) }
-      it "should not change it" do
-        expect(vector.x).to eq(150)
-        expect(vector.y).to eq(100)
-      end
+
+      its(:x) { is_expected.to eq(150) }
+      its(:y) { is_expected.to eq(100) }
     end
 
     context "when vector is wider" do
       let(:comp) { Vector2d.new(400, 300) }
-      it "should scale it down" do
-        expect(vector.x).to eq(300)
-        expect(vector.y).to eq(225)
-      end
+
+      its(:x) { is_expected.to eq(300) }
+      its(:y) { is_expected.to eq(225) }
     end
 
     context "when vector is higher" do
       let(:comp) { Vector2d.new(300, 400) }
-      it "should scale it down" do
-        expect(vector.x).to eq(225)
-        expect(vector.y).to eq(300)
-      end
+
+      its(:x) { is_expected.to eq(225) }
+      its(:y) { is_expected.to eq(300) }
     end
   end
 
@@ -38,39 +35,36 @@ describe Vector2d::Fitting do
 
     context "when scaling by height" do
       let(:comp) { Vector2d.new(200, 150) }
-      it "should fit within the other vector" do
-        expect(vector.x).to eq(150)
-        expect(vector.y).to eq(150)
-      end
+
+      its(:x) { is_expected.to eq(150) }
+      its(:y) { is_expected.to eq(150) }
     end
 
     context "when scaling by width" do
       let(:comp) { Vector2d.new(150, 200) }
-      it "should fit within the other vector" do
-        expect(vector.x).to eq(150)
-        expect(vector.y).to eq(150)
-      end
+
+      its(:x) { is_expected.to eq(150) }
+      its(:y) { is_expected.to eq(150) }
     end
   end
 
   describe "#fit_either" do
-    let(:original) { Vector2d.new(300, 300) }
     subject(:vector) { original.fit_either(comp) }
 
+    let(:original) { Vector2d.new(300, 300) }
+
     context "when width is largest" do
       let(:comp) { Vector2d.new(200, 150) }
-      it "should be the same width" do
-        expect(vector.x).to eq(200)
-        expect(vector.y).to eq(200)
-      end
+
+      its(:x) { is_expected.to eq(200) }
+      its(:y) { is_expected.to eq(200) }
     end
 
     context "when height is largest" do
       let(:comp) { Vector2d.new(150, 200) }
-      it "should be the same height" do
-        expect(vector.x).to eq(200)
-        expect(vector.y).to eq(200)
-      end
+
+      its(:x) { is_expected.to eq(200) }
+      its(:y) { is_expected.to eq(200) }
     end
   end
-end
+end

data/spec/lib/vector2d/properties_spec.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Vector2d::Properties do
   subject(:vector) { Vector2d.new(2, 3) }
@@ -31,13 +31,17 @@ describe Vector2d::Properties do
 
   describe "#normalized?" do
     subject { vector.normalized? }
+
     context "when vector is normalized" do
       let(:vector) { Vector2d.new(2, 3).normalize }
-      it { is_expected.to eq(true) }
+
+      it { is_expected.to be(true) }
     end
+
     context "when vector isn't normalized" do
       let(:vector) { Vector2d.new(2, 3) }
-      it { is_expected.to eq(false) }
+
+      it { is_expected.to be(false) }
     end
   end
 end

data/spec/lib/vector2d/transformations_spec.rb

@@ -1,12 +1,13 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Vector2d::Transformations do
   subject(:vector) { Vector2d.new(2, 3) }
 
   describe "#ceil" do
     subject(:vector) { Vector2d.new(2.3, 3.3) }
+
     it "rounds the vector up" do
       expect(vector.ceil).to eq(Vector2d.new(3, 4))
     end
@@ -14,16 +15,17 @@ describe Vector2d::Transformations do
 
   describe "#floor" do
     subject(:vector) { Vector2d.new(2.7, 3.6) }
+
     it "rounds the vector down" do
       expect(vector.floor).to eq(Vector2d.new(2, 3))
     end
   end
 
   describe "#normalize" do
-    it "normalizes the vector" do
-      expect(vector.normalize.x).to be_within(0.0001).of(0.5547)
-      expect(vector.normalize.y).to be_within(0.0001).of(0.8320)
-    end
+    subject { vector.normalize }
+
+    its(:x) { is_expected.to be_within(0.0001).of(0.5547) }
+    its(:y) { is_expected.to be_within(0.0001).of(0.8320) }
   end
 
   describe "#perpendicular" do
@@ -34,9 +36,16 @@ describe Vector2d::Transformations do
 
   describe "#resize" do
     subject(:resized) { vector.resize(2.0) }
+
     it "modifies the vector length" do
       expect(resized.length).to be_within(0.0001).of(2.0)
+    end
+
+    it "modifies the x property" do
       expect(resized.x).to be_within(0.0001).of(1.1094)
+    end
+
+    it "modifies the y property" do
       expect(resized.y).to be_within(0.0001).of(1.6641)
     end
   end
@@ -48,37 +57,66 @@ describe Vector2d::Transformations do
   end
 
   describe "#rotate" do
+    subject { vector.rotate(rotation).round(3) }
+
     let(:vector) { Vector2d.new(1, 0) }
-    it "rotates the vector" do
-      expect(vector.rotate(Math::PI).round(1)).to eq(Vector2d.new(-1, 0))
-      expect(vector.rotate(Math::PI/2).round(1)).to eq(Vector2d.new(0, 1))
-      expect(vector.rotate(-Math::PI/2).round(1)).to eq(Vector2d.new(0, -1))
-      expect(vector.rotate(Math::PI/4).round(3)).to eq(Vector2d.new(0.707, 0.707))
+
+    context "when roating by PI" do
+      let(:rotation) { Math::PI }
+
+      it { is_expected.to eq(Vector2d.new(-1, 0)) }
+    end
+
+    context "when roating by PI/2" do
+      let(:rotation) { Math::PI / 2 }
+
+      it { is_expected.to eq(Vector2d.new(0, 1)) }
+    end
+
+    context "when roating by -PI/2" do
+      let(:rotation) { -Math::PI / 2 }
+
+      it { is_expected.to eq(Vector2d.new(0, -1)) }
+    end
+
+    context "when roating by PI/4" do
+      let(:rotation) { Math::PI / 4 }
+
+      it { is_expected.to eq(Vector2d.new(0.707, 0.707)) }
     end
   end
 
   describe "#round" do
-    subject(:vector) { Vector2d.new(2.3333, 3.666) }
-    it "rounds the vector" do
-      expect(vector.round).to eq(Vector2d.new(2, 4))
-      expect(vector.round(2)).to eq (Vector2d.new(2.33, 3.67))
+    let(:vector) { Vector2d.new(2.3333, 3.666) }
+
+    context "without argument" do
+      subject { vector.round }
+
+      it { is_expected.to eq(Vector2d.new(2, 4)) }
+    end
+
+    context "with precision" do
+      subject { vector.round(2) }
+
+      it { is_expected.to eq(Vector2d.new(2.33, 3.67)) }
     end
   end
 
   describe "#truncate" do
     context "when argument is longer than length" do
       let(:arg) { 5.0 }
+
       it "does not change the length" do
         expect(vector.truncate(arg).length).to be_within(0.0001).of(3.6055)
       end
     end
+
     context "when argument is shorter than length" do
       let(:arg) { 2.5 }
+
       it "changes the length" do
         expect(vector.truncate(arg).length).to be_within(0.0001).of(arg)
       end
     end
   end
-
-
-end
+end