vector2d 2.2.3 → 2.3.0

data/lib/vector2d/coercions.rb

@@ -1,10 +1,7 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 class Vector2d
   module Coercions
-    include Contracts
-
-    Contract VectorLike => [Vector2d, Vector2d]
     def coerce(other)
       case other
       when Vector2d
@@ -20,7 +17,6 @@ class Vector2d
     #
     #   Vector2d(2, 3).inspect # => "Vector2d(2,3)"
     #
-    Contract None => String
     def inspect
       "Vector2d(#{x},#{y})"
     end
@@ -29,7 +25,6 @@ class Vector2d
     #
     #   Vector2d(2, 3).to_a # => [2,3]
     #
-    Contract None => [Num, Num]
     def to_a
       [x, y]
     end
@@ -38,7 +33,6 @@ class Vector2d
     #
     #   Vector2d(2, 3).to_hash # => {x: 2, y: 3}
     #
-    Contract None => Hash
     def to_hash
       { x: x, y: y }
     end
@@ -47,7 +41,6 @@ class Vector2d
     #
     #   Vector2d(2.0, 3.0).to_i_vector # => Vector2d(2,3)
     #
-    Contract None => Vector2d
     def to_i_vector
       self.class.new(x.to_i, y.to_i)
     end
@@ -56,7 +49,6 @@ class Vector2d
     #
     #   Vector2d(2, 3).to_f_vector # => Vector2d(2.0,3.0)
     #
-    Contract None => Vector2d
     def to_f_vector
       self.class.new(x.to_f, y.to_f)
     end
@@ -65,7 +57,6 @@ class Vector2d
     #
     #   Vector2d.new(150, 100).to_s # => "150x100"
     #
-    Contract None => String
     def to_s
       "#{x}x#{y}"
     end

data/lib/vector2d/fitting.rb

@@ -1,9 +1,7 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 class Vector2d
   module Fitting
-    include Contracts
-
     # Scales down the given vector unless it fits inside.
     #
     #   vector = Vector2d(20, 20)
@@ -11,46 +9,52 @@ class Vector2d
     #   vector.contain(Vector2d(40, 20)) # => Vector2d(20,10)
     #   vector.contain(Vector2d(20, 40)) # => Vector2d(10,20)
     #
-    Contract VectorLike => Vector2d
     def contain(other)
-      v, _ = coerce(other)
-      (v.x > x || v.y > y) ? other.fit(self) : other
+      v, = coerce(other)
+      v.x > x || v.y > y ? other.fit(self) : other
     end
 
-    # Scales the vector to fit inside another vector, retaining the aspect ratio.
+    # Scales the vector to fit inside another vector, retaining the
+    # aspect ratio.
     #
     #   vector = Vector2d(20, 10)
     #   vector.fit(Vector2d(10, 10)) # => Vector2d(10,5)
     #   vector.fit(Vector2d(20, 20)) # => Vector2d(20,10)
     #   vector.fit(Vector2d(40, 40)) # => Vector2d(40,20)
     #
-    # Note: Either axis will be disregarded if zero or nil. This is a feature, not a bug.
+    # Note: Either axis will be disregarded if zero or nil. This is a
+    # feature, not a bug.
     #
-    Contract VectorLike => Vector2d
     def fit(other)
-      v, _ = coerce(other)
+      v, = coerce(other)
       scale = v.to_f_vector / self
-      self * ((scale.y == 0 || (scale.x > 0 && scale.x < scale.y)) ? scale.x : scale.y)
+      self * (
+        if scale.y.zero? || (scale.x.positive? && scale.x < scale.y)
+          scale.x
+        else
+          scale.y
+        end
+      )
     end
-    alias_method :constrain_both, :fit
+    alias constrain_both fit
 
-    # Constrain/expand so that one of the coordinates fit within (the square implied by) another vector.
+    # Constrain/expand so that one of the coordinates fit within (the
+    # square implied by) another vector.
     #
     #   constraint = Vector2d(5, 5)
     #   Vector2d(20, 10).fit_either(constraint) # => Vector2d(10,5)
     #   Vector2d(10, 20).fit_either(constraint) # => Vector2d(5,10)
     #
-    Contract VectorLike => Vector2d
     def fit_either(other)
-      v, _ = coerce(other)
+      v, = coerce(other)
       scale = v.to_f_vector / self
-      if (scale.x > 0 && scale.y > 0)
-        scale = (scale.x < scale.y) ? scale.y : scale.x
+      if scale.x.positive? && scale.y.positive?
+        scale = [scale.x, scale.y].max
         self * scale
       else
         fit(v)
       end
     end
-    alias_method :constrain_one, :fit_either
+    alias constrain_one fit_either
   end
 end

data/lib/vector2d/properties.rb

@@ -1,14 +1,11 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 class Vector2d
   module Properties
-    include Contracts
-
     # Angle of vector.
     #
     #   Vector2d(2, 3).angle # => 0.9827..
     #
-    Contract None => Num
     def angle
       Math.atan2(y, x)
     end
@@ -17,16 +14,14 @@ class Vector2d
     #
     #   Vector2d(2, 3).aspect_ratio # => 0.6667..
     #
-    Contract None => Num
     def aspect_ratio
-      (x.to_f / y.to_f).abs
+      (x.to_f / y).abs
     end
 
     # Length of vector.
     #
     #   Vector2d(2, 3).length # => 3.6055..
     #
-    Contract None => Num
     def length
       Math.sqrt(squared_length)
     end
@@ -35,9 +30,8 @@ class Vector2d
     #
     #   Vector2d(2, 3).squared_length # => 13
     #
-    Contract None => Num
     def squared_length
-      x * x + y * y
+      (x * x) + (y * y)
     end
 
     # Is this a normalized vector?
@@ -45,9 +39,8 @@ class Vector2d
     #   Vector2d(0, 1).normalized? # => true
     #   Vector2d(2, 3).normalized? # => false
     #
-    Contract None => Bool
     def normalized?
-      self.length.to_f == 1.0
+      (length.to_f - 1.0).abs < Float::EPSILON
     end
   end
 end

data/lib/vector2d/transformations.rb

@@ -1,23 +1,32 @@
-# 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
 
+    # Clamps the vector between two others, one axis at a time.
+    # The bounds are coerced, so scalars work too.
+    #
+    #   vector = Vector2d(2, 8)
+    #   vector.clamp(Vector2d(3, 3), Vector2d(6, 6)) # => Vector2d(3,6)
+    #   vector.clamp(3, 6)                           # => Vector2d(3,6)
+    #
+    def clamp(min, max)
+      min_v, = coerce(min)
+      max_v, = coerce(max)
+      self.class.new(x.clamp(min_v.x, max_v.x), y.clamp(min_v.y, max_v.y))
+    end
+
     # Rounds vector to up nearest integer.
     #
     #   Vector2d(2.4, 3.6).floor # => Vector2d(2,3)
     #
-    Contract None => Vector2d
     def floor
       self.class.new(x.floor, y.floor)
     end
@@ -28,7 +37,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 +45,6 @@ class Vector2d
     #
     #   Vector2d(2, 3).perpendicular # => Vector2d(-3,2)
     #
-    Contract None => Vector2d
     def perpendicular
       Vector2d.new(-y, x)
     end
@@ -46,16 +53,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 +69,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 +81,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 +91,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.3.0"
 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
 
@@ -107,6 +81,6 @@ end
 #
 #   Vector2d(2, 3) # => Vector2d(2,3)
 #
-def Vector2d(*args)
-  Vector2d.parse(*args)
+def Vector2d(*)
+  Vector2d.parse(*)
 end

data/release-please-config.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json",
+  "packages": {
+    ".": {
+      "release-type": "ruby",
+      "package-name": "vector2d",
+      "version-file": "lib/vector2d/version.rb"
+    }
+  }
+}

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