draught 0.1.0

data/lib/draught/curve.rb

@@ -0,0 +1,66 @@
+require_relative './pointlike'
+
+module Draught
+  # An abstract representation of a curve in a pointlike fashion, in the way
+  # a CubicBezier is pointlike
+  class Curve
+    include Pointlike
+
+    attr_reader :point
+    protected :point
+
+    def initialize(args = {})
+      @point = args.fetch(:point)
+      @cubic_beziers = args.fetch(:cubic_beziers).dup.freeze
+    end
+
+    def x
+      @point.x
+    end
+
+    def y
+      @point.y
+    end
+
+    def point_type
+      :curve
+    end
+
+    def as_cubic_beziers
+      @cubic_beziers
+    end
+
+    def ==(other)
+      other.point_type == point_type && other.point == point &&
+        other.as_cubic_beziers == as_cubic_beziers
+    end
+
+    def approximates?(other, delta)
+      other.point_type == point_type &&
+        point.approximates?(other.point, delta) &&
+        number_of_segments == other.number_of_segments &&
+        as_cubic_beziers.zip(other.as_cubic_beziers).all? { |a, b|
+          a.approximates?(b, delta)
+        }
+    end
+
+    def number_of_segments
+      @cubic_beziers.length
+    end
+    protected :number_of_segments
+
+    def translate(vector)
+      self.class.new({
+        point: @point.translate(vector),
+        cubic_beziers: @cubic_beziers.map { |c| c.translate(vector) }
+      })
+    end
+
+    def transform(transformer)
+      self.class.new({
+        point: @point.transform(transformer),
+        cubic_beziers: @cubic_beziers.map { |c| c.transform(transformer) }
+      })
+    end
+  end
+end

data/lib/draught/line.rb

@@ -0,0 +1,272 @@
+require_relative './path'
+require_relative './pathlike'
+require_relative './boxlike'
+require_relative './point'
+require_relative './transformations'
+
+module Draught
+  class Line
+    DEGREES_90 = Math::PI / 2
+    DEGREES_180 = Math::PI
+    DEGREES_270 = Math::PI * 1.5
+    DEGREES_360 = Math::PI * 2
+
+    include Boxlike
+    include Pathlike
+
+    class << self
+      def horizontal(width)
+        build(end_point: Point.new(width, 0))
+      end
+
+      def vertical(height)
+        build(end_point: Point.new(0, height))
+      end
+
+      def build(args = {})
+        builder_class = args.has_key?(:end_point) ? LineBuilderFromPoint : LineBuilderFromAngles
+        line_args = builder_class.new(args).line_args
+        new(line_args)
+      end
+
+      def from_path(path)
+        if path.number_of_points != 2
+          raise ArgumentError, "path must contain exactly 2 points, this contained #{path.number_of_points}"
+        end
+        build(start_point: path.first, end_point: path.last)
+      end
+    end
+
+    attr_reader :start_point, :end_point, :length, :radians
+
+    def initialize(args)
+      @start_point = args.fetch(:start_point, Point::ZERO)
+      @end_point = args.fetch(:end_point)
+      @length = args.fetch(:length)
+      @radians = args.fetch(:radians)
+    end
+
+    def points
+      @points ||= [start_point, end_point]
+    end
+
+    def extend(args = {})
+      default_args = {at: :end}
+      args = default_args.merge(args)
+      new_length = args[:to] || length + args[:by]
+      new_line = self.class.build({
+        start_point: start_point, length: new_length, radians: radians
+      })
+      args[:at] == :start ? shift_line(new_line) : new_line
+    end
+
+    def [](index_start_or_range, length = nil)
+      if length.nil?
+        case index_start_or_range
+        when Range
+          Path.new(points[index_start_or_range])
+        when Numeric
+          points[index_start_or_range]
+        else
+          raise TypeError, "requires a Range or Numeric in single-arg form"
+        end
+      else
+        Path.new(points[index_start_or_range, length])
+      end
+    end
+
+    def translate(vector)
+      self.class.build(Hash[
+        transform_args_hash.map { |arg, point| [arg, point.translate(vector)] }
+      ])
+    end
+
+    def transform(transformation)
+      self.class.build(Hash[
+        transform_args_hash.map { |arg, point| [arg, point.transform(transformation)] }
+      ])
+    end
+
+    def lower_left
+      @lower_left ||= Point.new(x_min, y_min)
+    end
+
+    def width
+      @width ||= x_max - x_min
+    end
+
+    def height
+      @height ||= y_max - y_min
+    end
+
+    private
+
+    def shift_line(new_line)
+      translation = Vector.translation_between(new_line.end_point, end_point)
+      self.class.new({
+        start_point: start_point.translate(translation),
+        end_point: new_line.end_point.translate(translation),
+        length: new_line.length,
+        radians: radians
+      })
+    end
+
+    def transform_args_hash
+      {start_point: start_point, end_point: end_point}
+    end
+
+    def x_max
+      @x_max ||= points.map(&:x).max || 0
+    end
+
+    def x_min
+      @x_min ||= points.map(&:x).min || 0
+    end
+
+    def y_max
+      @y_max ||= points.map(&:y).max || 0
+    end
+
+    def y_min
+      @y_min ||= points.map(&:y).min || 0
+    end
+
+    class LineBuilderFromAngles
+      attr_reader :start_point, :length, :radians
+      private :start_point, :length, :radians
+
+      def initialize(args)
+        @start_point = args.fetch(:start_point, Point::ZERO)
+        @length = args.fetch(:length)
+        @radians = args.fetch(:radians)
+      end
+
+      def line_args
+        {length: length, radians: radians, start_point: start_point, end_point: end_point}
+      end
+
+      private
+
+      def end_point
+        end_point_from_zero.translate(Vector.translation_between(Point::ZERO, start_point))
+      end
+
+      def end_point_from_zero
+        hardwired_end_points.fetch(restricted_radians) {
+          single_quadrant_end_point.transform(Transformations.rotate(remaining_angle))
+        }
+      end
+
+      def restricted_radians
+        @restricted_radians ||= restrict_to_360_degrees(radians)
+      end
+
+      def restrict_to_360_degrees(radians)
+        radians % DEGREES_360
+      end
+
+      def hardwired_end_points
+        {
+          0 => Point.new(length,0),
+          DEGREES_90 => Point.new(0,length),
+          DEGREES_180 => Point.new(-length,0),
+          DEGREES_270 => Point.new(0,-length),
+          DEGREES_360 => Point.new(length,0)
+        }
+      end
+
+      def single_quadrant_end_point
+        Point.new(x, y)
+      end
+
+      def x
+        Math.cos(single_quadrant_angle) * length
+      end
+
+      def y
+        Math.sin(single_quadrant_angle) * length
+      end
+
+      def single_quadrant_angle
+        @single_quadrant_angle ||= restricted_radians - remaining_angle
+      end
+
+      def remaining_angle
+        @remaining_angle ||= begin
+          [DEGREES_270, DEGREES_180, DEGREES_90, 0].find { |angle|
+            restricted_radians > angle
+          } || 0
+        end
+      end
+    end
+
+    class LineBuilderFromPoint
+      attr_reader :start_point, :end_point
+      private :start_point, :end_point
+
+      def initialize(args)
+        @start_point = args.fetch(:start_point, Point::ZERO)
+        @end_point = args.fetch(:end_point)
+      end
+
+      def line_args
+        {length: length, radians: radians, start_point: start_point, end_point: end_point}
+      end
+
+      private
+
+      def end_point_from_zero
+        @end_point_from_zero ||= end_point.translate(Vector.translation_between(start_point, Point::ZERO))
+      end
+
+
+      def length
+        @length ||= begin
+          if x_length == 0 || y_length == 0
+            x_length + y_length
+          else
+            Math.sqrt(x_length ** 2 + y_length ** 2)
+          end
+        end
+      end
+
+      def radians
+        @radians ||= begin
+          if x_length == 0 || y_length == 0
+            angle_to_start_of_quadrant
+          else
+            angle_to_start_of_quadrant + angle_ignoring_quadrant
+          end
+        end
+      end
+
+      def x_length
+        @x_length = end_point_from_zero.x.abs
+      end
+
+      def y_length
+        @y_length ||= end_point_from_zero.y.abs
+      end
+
+      def angle_to_start_of_quadrant
+        which_side_of_x = end_point_from_zero.x <=> 0
+        which_side_of_y = end_point_from_zero.y <=> 0
+
+        case [which_side_of_x, which_side_of_y]
+        when [1,0], [1, 1] # 0-90º
+          0
+        when [0,1], [-1, 1] # 90-180º
+          DEGREES_90
+        when [-1, 0], [-1, -1] # 180-270º
+          DEGREES_180
+        when [0, -1], [1, -1] # 270-360º
+          DEGREES_270
+        end
+      end
+
+      def angle_ignoring_quadrant
+        Math.acos(y_length.to_f/length)
+      end
+    end
+  end
+end

data/lib/draught/path.rb

@@ -0,0 +1,89 @@
+require 'forwardable'
+require_relative './boxlike'
+require_relative './pathlike'
+
+module Draught
+  class Path
+    include Boxlike
+    include Pathlike
+
+    attr_reader :points
+
+    def initialize(points = [])
+      @points = points.dup.freeze
+    end
+
+    def <<(point)
+      append(point)
+    end
+
+    def append(*paths_or_points)
+      paths_or_points.inject(self) { |path, point_or_path| path.add_points(point_or_path.points) }
+    end
+
+    def prepend(*paths_or_points)
+      paths_or_points.inject(Path.new) { |path, point_or_path|
+        path.add_points(point_or_path.points)
+      }.add_points(self.points)
+    end
+
+    def [](index_start_or_range, length = nil)
+      if length.nil?
+        case index_start_or_range
+        when Range
+          self.class.new(points[index_start_or_range])
+        when Numeric
+          points[index_start_or_range]
+        else
+          raise TypeError, "requires a Range or Numeric in single-arg form"
+        end
+      else
+        self.class.new(points[index_start_or_range, length])
+      end
+    end
+
+    def lower_left
+      @lower_left ||= Point.new(x_min, y_min)
+    end
+
+    def width
+      @width ||= x_max - x_min
+    end
+
+    def height
+      @height ||= y_max - y_min
+    end
+
+    def translate(vector)
+      self.class.new(points.map { |p| p.translate(vector) })
+    end
+
+    def transform(transformer)
+      self.class.new(points.map { |p| p.transform(transformer) })
+    end
+
+    protected
+
+    def add_points(points)
+      self.class.new(@points + points)
+    end
+
+    private
+
+    def x_max
+      @x_max ||= points.map(&:x).max || 0
+    end
+
+    def x_min
+      @x_min ||= points.map(&:x).min || 0
+    end
+
+    def y_max
+      @y_max ||= points.map(&:y).max || 0
+    end
+
+    def y_min
+      @y_min ||= points.map(&:y).min || 0
+    end
+  end
+end

data/lib/draught/path_builder.rb

@@ -0,0 +1,39 @@
+require_relative 'path'
+
+module Draught
+  class PathBuilder
+    def self.build
+      builder = new
+      yield(builder)
+      builder.send(:path)
+    end
+
+    def self.connect(*paths)
+      paths = paths.reject(&:empty?)
+      build { |p|
+        p << paths.shift
+        paths.inject(p.last) { |point, path|
+          translation = Vector.translation_between(path.first, point)
+          p << path.translate(translation)[1..-1]
+          p.last
+        }
+      }
+    end
+
+    attr_reader :path
+    private :path
+
+    def initialize
+      @path = Path.new
+    end
+
+    def <<(path_or_point)
+      @path = path << path_or_point
+      self
+    end
+
+    def last
+      path.last
+    end
+  end
+end