aurora-sketch 0.0.1

data/lib/sketch/builder.rb

@@ -0,0 +1,100 @@
+require_relative 'dsl'
+require_relative 'group'
+require_relative 'builder/polyline'
+
+class Sketch
+    class Builder
+	attr_reader :sketch
+
+	include Sketch::DSL
+
+	# @group Convenience constants
+	Point = Geometry::Point
+	Rectangle = Geometry::Rectangle
+	Size = Geometry::Size
+	# @endgroup
+
+	def initialize(sketch=nil, &block)
+	    @sketch = sketch || Sketch.new
+	    evaluate(&block) if block_given?
+	end
+
+	# Evaluate a block and return a new {Path}
+	#  Use the trick found here http://www.dan-manges.com/blog/ruby-dsls-instance-eval-with-delegation
+	#  to allow the DSL block to call methods in the enclosing *lexical* scope
+	# @return [Sketch]	A new {Sketch} initialized with the given block
+	def evaluate(&block)
+	    if block_given?
+		@self_before_instance_eval = eval "self", block.binding
+		self.instance_eval &block
+	    end
+	    @sketch
+	end
+
+	# The second half of the instance_eval delegation trick mentioned at
+	#   http://www.dan-manges.com/blog/ruby-dsls-instance-eval-with-delegation
+	def method_missing(method, *args, &block)
+	    add_symbol = ('add_' + method.to_s).to_sym
+	    if @sketch.respond_to? add_symbol
+		@sketch.send(add_symbol, *args, &block)
+	    elsif @sketch.respond_to? method
+		@sketch.send method, *args, &block
+	    elsif @self_before_instance_eval.respond_to? method
+		@self_before_instance_eval.send method, *args, &block
+	    else
+		super if defined?(super)
+	    end
+	end
+
+# @group Accessors
+
+	# !@attribute [r] elements
+	#   @return [Array] The current list of elements
+	def elements
+	    @sketch.elements
+	end
+
+# @endgroup
+
+	# Define a named parameter
+	# @param [Symbol] name	The name of the parameter
+	# @param [Proc] block	A block that evaluates to the value of the parameter
+	def let name, &block
+	    @sketch.define_parameter name, &block
+	end
+
+	# @group Command handlers
+
+	# Create a {Group} with an optional name and transformation
+	def group(*args, &block)
+	    @sketch.push Sketch::Builder.new(Group.new(*args)).evaluate(&block)
+	end
+
+	# Use the given block to build a {Polyline} and then append it to the {Sketch}
+	def polyline(&block)
+	    push Builder::Polyline.new.evaluate(&block)
+	end
+
+	# Append a new object (with optional transformation) to the {Sketch}
+	# @return [Sketch]  the {Sketch} that was appended to
+	def push(*args)
+	    @sketch.push *args
+	end
+
+	# Create a {Rectangle} from the given arguments and append it to the {Sketch}
+	def rectangle(*args)
+	    @sketch.push Rectangle.new(*args)
+	    last
+	end
+
+	# Create a {Group} using the given translation
+	# @param [Point] point	The distance by which to translate the enclosed geometry
+	def translate(*args, &block)
+	    point = Point[*args]
+	    raise ArgumentError, 'Translation is limited to 2 dimensions' if point.size > 2
+	    group(origin:point, &block)
+	end
+
+	# @endgroup
+    end
+end

data/lib/sketch/builder/path.rb

@@ -0,0 +1,16 @@
+require_relative 'polyline'
+
+class Sketch
+    Path = Geometry::Path
+
+    class Builder
+	class Path < Builder::Polyline
+	    # Evaluate a block and return a new {Path}
+	    # @return [Path]	A new {Path} initialized with the given block
+	    def evaluate(&block)
+		super
+		Sketch::Path.new(*@elements)
+	    end
+	end
+    end
+end

data/lib/sketch/builder/polygon.rb

@@ -0,0 +1,15 @@
+require_relative 'polyline'
+
+class Sketch
+    Polygon = Geometry::Polygon
+
+    class Builder
+	class Polygon < Builder::Polyline
+	    # @return [Polygon] the {Polygon} resulting from evaluating the given block
+	    def evaluate(&block)
+		super
+		Sketch::Polygon.new *@elements
+	    end
+	end
+    end
+end

data/lib/sketch/builder/polyline.rb

@@ -0,0 +1,51 @@
+require 'geometry/dsl/polyline'
+
+class Sketch
+    Polyline = Geometry::Polyline
+
+    class Builder
+	class Polyline
+	    include Geometry::DSL::Polyline
+
+	    def initialize(*args)
+		@elements = args || []
+	    end
+
+	    # Evaluate a block and return a new {Path}
+	    #  Use the trick found here http://www.dan-manges.com/blog/ruby-dsls-instance-eval-with-delegation
+	    #  to allow the DSL block to call methods in the enclosing *lexical* scope
+	    # @return [Polyline]	A new {Polyline} initialized with the given block
+	    def evaluate(&block)
+		if block_given?
+		    @self_before_instance_eval = eval "self", block.binding
+		    self.instance_eval &block
+		end
+		Sketch::Polyline.new(*@elements)
+	    end
+
+	    # The second half of the instance_eval delegation trick mentioned at
+	    #   http://www.dan-manges.com/blog/ruby-dsls-instance-eval-with-delegation
+	    def method_missing(method, *args, &block)
+		@self_before_instance_eval.send method, *args, &block
+	    end
+
+	    # @return [Point]   the first vertex of the {Polyline}
+	    def first
+		@elements.first
+	    end
+
+	    # @return [Point]   the last, or most recently added, vertex of the {Polyline}
+	    def last
+		@elements.last
+	    end
+
+	    # Push the given object
+	    # @param [Geometry] arg A {Geometry} object to apped to the {Path}
+	    # @return [Geometry]    The appended object
+	    def push(arg)
+		@elements.push arg
+		self
+	    end
+	end
+    end
+end

data/lib/sketch/dsl.rb

@@ -0,0 +1,56 @@
+require 'geometry'
+
+require_relative 'builder'
+require_relative 'layout'
+
+# Syntactic sugar for building a {Sketch}
+class Sketch
+    module DSL
+    # @group Accessors
+	# @attribute [r] first
+	#   @return [Geometry] the first Geometry element of the {Sketch}
+	def first
+	    elements.first
+	end
+
+	# @attribute [r] last
+	#  @return [Geometry] the last Geometry element of the {Sketch}
+	def last
+	    elements.last
+	end
+    # @endgroup
+
+	# Create a {RegularPolygon} with 6 sides
+	# @return [RegularPolygon]
+	def hexagon(options={})
+	    options[:sides] = 6
+	    Geometry::RegularPolygon.new(options).tap {|a| push a }
+	end
+
+	# Create a layout
+	# @param direction [Symbol] The layout direction (either :horizontal or :vertical)
+	# @option options [Symbol] align    :top, :bottom, :left, or :right
+	# @option options [Number] spacing  The spacing between each element
+	# @return [Group]
+	def layout(direction, *args, &block)
+	    Builder.new(Layout.new(direction, *args)).evaluate(&block).tap {|a| push a}
+	end
+
+	# Create a {Path}
+	# @return [Path]
+	def path(*args, &block)
+	    Builder::Path.new(*args).evaluate(&block).tap {|a| push a }
+	end
+
+	# Create a Polygon with the given vertices, or using a block.
+	# See {PolygonBuilder}
+	def polygon(*args, &block)
+	    if block_given?
+		push Builder::Polygon.new.evaluate(&block)
+	    else
+		push Sketch::Polygon.new(*args)
+	    end
+	    last
+	end
+    end
+end

data/lib/sketch/group.rb

@@ -0,0 +1,38 @@
+require 'geometry/transformation'
+
+=begin
+{Group} is a container for grouping elements of a {Sketch} with an optional
+{Geometry::Transformation Transformation} property.
+
+    sketch :ExampleModel do
+	group origin:[4,2] do
+	    circle diameter:5.meters
+	end
+    end
+=end
+class Sketch
+    class Group < Sketch
+	attr_reader :transformation
+
+	def initialize(*args, &block)
+	    super &block
+
+	    options, args = args.partition {|a| a.is_a? Hash}
+	    options = options.reduce({}, :merge)
+
+	    @transformation = options.delete(:transformation) || Geometry::Transformation.new(options)
+	end
+
+	def rotation
+	    @transformation.rotation
+	end
+
+	def scale
+	    @transformation.scale
+	end
+
+	def translation
+	    @transformation.translation
+	end
+    end
+end

data/lib/sketch/layout.rb

@@ -0,0 +1,118 @@
+require_relative 'group'
+
+=begin
+{Layout} is a container that arranges its child elements in the specified
+direction and, optionally, with the specified spacing.
+
+For example, to create two adjacent squares along the X-axis, use:
+
+    Layout.new :horizontal do
+        square size:5
+        square size:6
+    end
+
+=end
+class Sketch
+    class Layout < Group
+	# @return [Symbol] alignment	the layout alignment
+	attr_reader :alignment
+
+	# @return [Symbol] direction    the layout direction (either :horizontal or :vertical)
+	attr_reader :direction
+
+	# @return [Number] spacing  spacing to add between each element
+	attr_reader :spacing
+
+	def initialize(direction=:horizontal, *args)
+	    super
+
+	    options, args = args.partition {|a| a.is_a? Hash}
+	    options = options.reduce({}, :merge)
+
+	    @alignment = options.delete(:align)
+	    @spacing = options.delete(:spacing) || 0
+
+	    @direction = direction
+	end
+
+	# Any pushed element that doesn't have a transformation property will be wrapped in a {Group}.
+	# @param element [Geometry] the geometry element to append
+	# @return [Layout]
+	def push(element, *args)
+	    max = last ? last.max : Point.zero
+
+	    offset = make_offset(element, element.min, max)
+
+	    if offset == Point.zero
+		super element, *args
+	    else
+		if element.respond_to?(:transformation=)
+		    super element, *args
+		else
+		    super Group.new.push element, *args
+		end
+
+		last.transformation = Geometry::Transformation.new(origin:offset) + last.transformation
+	    end
+
+	    self
+	end
+
+	private
+
+	def make_offset(element, min, max)
+	    case direction
+		when :horizontal
+		    y_offset = case alignment
+			when :bottom
+			    -min.y
+			when :top
+			    height = element.size.y
+			    if height > max.y
+				# Translate everything up by reparenting into a new group
+				if elements.size != 0
+				    alignment_group = Group.new
+				    alignment_group.transformation = Geometry::Transformation.new(origin: [0, height - max.y])
+				    elements.each {|a| alignment_group.push a }
+				    elements.replace [alignment_group]
+				end
+
+				-min.y	# Translate the new element to the x-axis
+			    else
+				# Translate the new element to align with the previous element
+				max.y - height
+			    end
+			else
+			    0
+		    end
+
+		    Point[max.x - min.x + ((elements.size != 0) ? spacing : 0), y_offset]
+		when :vertical
+		    x_offset = case alignment
+			when :left
+			    -min.x
+			when :right
+			    width = element.size.x
+			    if width > max.x
+				# Translate everything right by reparenting into a new group
+				if elements.size != 0
+				    alignment_group = Group.new
+				    alignment_group.transformation = Geometry::Transformation.new(origin: [width - max.x, 0])
+				    elements.each {|a| alignment_group.push a }
+				    elements.replace [alignment_group]
+				end
+
+				-min.x	# Translate the new element to the y-axis
+			    else
+				# Translate the new element to align with the previous element
+				max.x - width
+			    end
+			else
+			    0
+		    end
+
+		    Point[x_offset, max.y - min.y + ((elements.size != 0) ? spacing : 0)]
+	    end
+	end
+    end
+end

data/lib/sketch/point.rb

@@ -0,0 +1,7 @@
+require 'geometry'
+require 'matrix'
+
+class Sketch
+    class Point < Geometry::Point
+    end
+end

data/test/geometry/dsl/polyline.rb

@@ -0,0 +1,81 @@
+require 'minitest/autorun'
+require 'geometry/dsl/polyline'
+
+class Fake
+    attr_accessor :elements
+
+    include Geometry::DSL::Polyline
+
+    def initialize
+	@elements = []
+    end
+
+    def first
+	@elements.first
+    end
+
+    def last
+	@elements.last
+    end
+
+    def push(arg)
+	@elements.push arg
+    end
+end
+
+describe Geometry::DSL::Polyline do
+    subject { Fake.new }
+
+    it 'must have a start command' do
+	subject.start_at [1,2]
+	subject.last.must_equal Point[1,2]
+    end
+
+    describe 'when started' do
+	before do
+	    subject.start_at [1,2]
+	end
+
+	it 'must refuse to start again' do
+	    -> { subject.start_at [2,3] }.must_raise Geometry::DSL::Polyline::BuildError
+	end
+
+	it 'must have a close command' do
+	    subject.move_to [3,4]
+	    subject.move_to [4,4]
+	    subject.close
+	    subject.last.must_equal Point[1,2]
+	end
+
+	it 'must have a move_to command' do
+	    subject.move_to [3,4]
+	    subject.last.must_equal Point[3,4]
+	end
+
+	it 'must have a relative horizontal move command' do
+	    subject.move_x 3
+	    subject.last.must_equal Point[4,2]
+	end
+
+	it 'must have a relative vertical move command' do
+	    subject.move_y 4
+	    subject.last.must_equal Point[1,6]
+	end
+
+	it 'must have an up command' do
+	    subject.up(3).last.must_equal Point[1,5]
+	end
+
+	it 'must have a down command' do
+	    subject.down(3).last.must_equal Point[1,-1]
+	end
+
+	it 'must have a left command' do
+	    subject.left(3).last.must_equal Point[-2,2]
+	end
+
+	it 'must have a right command' do
+	    subject.right(3).last.must_equal Point[4,2]
+	end
+    end
+end