engineering 0 → 0.1

data/Gemfile

@@ -2,3 +2,5 @@ source "http://rubygems.org"
 
 # Specify your gem's dependencies in engineering.gemspec
 gemspec
+
+gem 'units', github: 'bfoz/units'

data/README.markdown

@@ -0,0 +1,109 @@
+Engineering for Ruby
+====================
+
+This is a meta-gem for all things related to engineering (particularly CAD stuff). The Engineering module
+is your one stop shop for all of the tools you need for your latest mad-engineering project.
+
+Activating a dormant volcano? Adding death rays to your secret moon base? Plotting world domination? No problem! There's a gem for that, and you've found it right here.
+
+If your latest and greatest project, and even your older ones, need something
+that isn't in Engineering, either let me know, or fork and add it yourself (and
+send me a pull request). Or feel free to create your own gem that reopens
+the module and adds whatever is missing, if that's more your style.
+
+License
+-------
+
+Copyright 2012-2013 Brandon Fosdick <bfoz@bfoz.net> and released under the BSD license.
+
+Dependencies
+------------
+
+- DXF [GitHub](http://github.com/bfoz/ruby-dxf) [RubyGems](https://rubygems.org/gems/dxf)
+- Units [GitHub](https://github.com/bfoz/units)
+- Geometry [GitHub](https://github.com/bfoz/geometry) [RubyGems](https://rubygems.org/gems/geometry)
+- Sketch [GitHub](https://github.com/bfoz/sketch)
+- Model [GitHub](https://github.com/bfoz/model)
+
+Installation
+------------
+
+Engineering has a number of dependencies. Some of which are hosted on rubygems.org
+and can therefore be handled by the gem utility, but others must be installed
+manually. The easiest option is to use [Bundler](http://gembundler.com/), but
+*gem* can be used if you're willing to install the *units* gem manually.
+
+### Using Bundler
+
+Installing the *engineering* gem using bundler is very easy, although a little more involved than normal.
+
+Start with the normal gem command:
+
+    gem install engineering
+
+Unfortunately, this will either fail, or it will grab the wrong version of the *units* gem. But, not to worry, we can use bundler to fix it:
+
+    bundle install
+
+And that's it. You're done. Get on with taking over the world already.
+
+If you happen to be part of the 0.001% of Mad Engineers who don't already have bundler installed, it's very easy to get:
+
+    gem install bundler
+
+### Using Rubygems
+
+Sadly, the *units* gem hosted on [Rubygems](http://rubygems.org) is a bit out-of-date, and generally not the gem we're looking for. So, after *gem* does its thing, we need to do a little cleanup.
+
+Start with the normal gem command:
+
+    gem install engineering
+
+Then uninstall the bogus *units* gem:
+
+    gem uninstall units
+
+Clone the gem we're looking for:
+
+    git clone git://github.com/bfoz/units.git
+
+Install it:
+
+    cd units && rake install
+
+You do have [rake](http://rake.rubyforge.org/) installed, right? If not, do this before the previous step:
+
+    gem install rake
+
+And you should be good to go. If you made it through all of that, then I expect to hear about your machinations on the evening news any day now.
+
+Examples
+--------
+
+Creating a custom Cube class, the hard way:
+
+    require 'engineering'
+
+    model :MyCube do
+        extrusion 10.cm do
+            square 10.cm
+        end
+    end
+    
+    MyCube.new
+
+Of course, this is ruby, so there's always another way to do it
+
+    extrusion :MyCube do
+        rectangle Size[10.cm, 10.cm]
+    end
+    
+    MyCube.new length:10.cm
+
+### Exporting
+
+Once a Model has been defined, it can be instantiated and exported to SketchUp with a single line
+
+    SketchUp.write('MyCube.su', MyCube.new)
+
+Then, launch SketchUp, open the _Ruby Console_ (it's in the Window menu), and _load 'MyCube.su'_. Your new geometry will replace whatever was already in the SketchUp document (a person if you just opened it), so be careful.

data/Rakefile

@@ -1 +1,8 @@
 require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+    t.libs.push "lib"
+    t.test_files = FileList['test/**/*.rb']
+    t.verbose = true
+end

data/engineering.gemspec

@@ -2,22 +2,23 @@
 $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
-  s.name        = "engineering"
-  s.version     = '0'
-  s.authors     = ["Brandon Fosdick"]
-  s.email       = ["bfoz@bfoz.net"]
-  s.homepage    = "http://github.com/bfoz/engineering"
-  s.summary     = %q{Engineering tools}
-  s.description = %q{Tools for Engineers and those who want to be}
+    s.name        = "engineering"
+    s.version     = 0.1
+    s.authors     = ["Brandon Fosdick"]
+    s.email       = ["bfoz@bfoz.net"]
+    s.homepage    = "http://github.com/bfoz/engineering"
+    s.summary     = %q{Mad Engineering, Ruby style}
+    s.description = %q{Tools for Mad Engineers and those who want to be}
 
-  s.rubyforge_project = "engineering"
+    s.rubyforge_project = "engineering"
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+    s.files         = `git ls-files`.split("\n")
+    s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+    s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+    s.require_paths = ["lib"]
 
-  # specify any dependencies here; for example:
-  # s.add_development_dependency "rspec"
-  # s.add_runtime_dependency "rest-client"
+    s.add_dependency	'dxf'
+    s.add_dependency	'model'
+    s.add_dependency	'sketch'
+    s.add_dependency	'units', '>= 2'
 end

data/lib/engineering.rb

@@ -1,3 +1,82 @@
+require 'mathn'
+
+require 'dxf'
+require 'model'
+require 'sketch'
+require 'units'
+
+require_relative 'sketchup'
+
+=begin
+A meta-gem for wayward engineering-related gems. Here you can find everything 
+you'll need for your latest engineering project.
+=end
+
 module Engineering
-  # Your code goes here...
+    module DSL
+	private
+
+	# Create a new {Extrusion} subclass and initialize it with the given block
+	# @param [Symbol] symbol    The name of the resulting subclass
+	# @return [Extrusion]
+	def extrusion(symbol=nil, &block)
+	    klass = Class.new(Model::Extrusion)
+	    klass.const_set(:INITIALIZER_BLOCK, block)
+	    klass.class_eval %q[
+		def initialize(*args)
+		    super
+		    Model::Extrusion::Builder.new(self).evaluate(&INITIALIZER_BLOCK)
+		end
+	    ]
+	    symbol ? Object.const_set(symbol, klass) : klass
+	end
+
+	# Create a new {Model} subclass and initialize it with the given block
+	# @param [Symbol]   symbol  The name of the {Model} subclass
+	# @return [Model]
+	def model(symbol=nil, &block)
+	    klass = Class.new(Model)
+	    klass.const_set(:INITIALIZER_BLOCK, block)
+	    klass.class_eval %q[
+		def initialize(*args)
+		    super
+		    Model::Builder.new(self).evaluate(&INITIALIZER_BLOCK)
+		end
+	    ]
+	    symbol ? Object.const_set(symbol, klass) : klass
+	end
+
+	# Create a new {Sketch} subclass and initialize it with the given block
+	# @param [Symbol]   symbol  The name of the {Sketch} subclass
+	def sketch(symbol=nil, &block)
+	    klass = Class.new(Sketch)
+	    klass.const_set(:INITIALIZER_BLOCK, block)
+	    klass.class_eval %q[
+		def initialize(*args)
+		    super
+		    Sketch::Builder.new(self).evaluate(&INITIALIZER_BLOCK)
+		end
+	    ]
+	    symbol ? Object.const_set(symbol, klass) : klass
+	end
+
+	class Geometry::Polygon
+	    # Build a {Polygon} instance using the {Sketch} DSL
+	    # @return [Polygon]
+	    def self.build(&block)
+		Sketch::PolygonBuilder.new.evaluate(&block)
+	    end
+	end
+
+	class Geometry::Polyline
+	    # Build a {Polyline} instance using the {Sketch} DSL
+	    # @return [Polyline]
+	    def self.build(&block)
+		Sketch::PolylineBuilder.new.evaluate(&block)
+	    end
+	end
+    end
 end
+
+self.extend Engineering::DSL
+include Geometry	# Make Geometry types more readily available

data/lib/sketchup.rb

@@ -0,0 +1,164 @@
+require 'geometry'
+require 'model'
+require 'sketch'
+require 'units'
+
+module SketchUp
+=begin
+    Export to a Ruby script that can be executed by SketchUp to recreate the geometry
+=end
+
+    HEADER_LINES = [
+	'model = Sketchup.active_model',
+	'model.entities.clear!',
+	'model.definitions.purge_unused',
+    ]
+
+    SKETCHUP_UNITS = {
+	'kilometer' => 'km',    'meter' => 'm',	    'centimeter'=> 'cm',    'millimeter'=> 'mm',
+	'mile'	    => 'mile',	'yard'  => 'yard',  'feet'	=> 'feet',  'inch'	=> 'inch',
+	'radian'    => 'radians',
+	'degrees'   => 'degrees',
+    }
+
+    class Builder
+	attr_accessor :container
+
+	# Initialize with a Sketch or a Model
+	def initialize(container=nil)
+	    @container = container
+	    @definition_names = {}
+	end
+
+	def to_a
+	    a = to_array(@container)	# Generates the definitions as a side effect
+	    HEADER_LINES + @definition_names.values.flatten + a
+	end
+
+	def to_s
+	    to_a.join("\n") << "\n"
+	end
+
+	private
+
+	def name_for_container(container)
+	    case container
+		when Model::Extrusion
+		    container.class.to_s +  "(#{name_for_container(container.sketch)})_#{to_sketchup(container.length)}"
+		when Model::Group
+		    container.class.to_s +  "(#{container.object_id.to_s})"
+		when Model  # !!! Must be after all subclasses of Model
+		    s = container.class.to_s
+		    (s == 'Model') ? s + "(#{container.object_id.to_s})" : s
+		when Sketch
+		    s = container.class.to_s
+		    (s == 'Sketch') ? s + ":#{container.object_id.to_s}" : s
+	    end
+	end
+
+	def to_definition(container, definition_name)
+	    case container
+		when Model::Extrusion
+		    lines = to_array(container.sketch, 'd.entities').map {|l| "#{l}.pushpull(#{to_sketchup(-container.length)})"}
+		    elements = lines.flatten.join("\n\t")
+		    "lambda {|d|\n\t#{elements}\n}.call(model.definitions.add('#{definition_name}'))"
+		when Model::Group
+		    lines = container.elements.map {|element| to_array(element, 'g.entities') }.flatten
+		    elements = lines.flatten.join("\n\t")
+		    "lambda {|g|\n\t#{elements}\n}.call(model.definitions.add('#{definition_name}'))"
+		when Model  # !!! Must be after all subclasses of Model
+		    elements = container.elements.map {|element| to_array(element, 'm.entities') }.flatten.join("\n\t")
+		    "lambda {|m|\n\t#{elements}\n}.call(model.definitions.add('#{definition_name}'))"
+	    end
+	end
+
+	def add_instance(parent, container)
+	    definition_name = name_for_container(container)
+	    unless @definition_names.key?(definition_name)
+		@definition_names[definition_name] = to_definition(container, definition_name)
+	    end
+	    ["#{parent}.add_instance(model.definitions['#{definition_name}'], #{to_sketchup(container.transformation)})"]
+	end
+
+	# Convert the given container to an array of strings that SketchUp can read
+	def to_array(container, parent='model.entities', transformation=nil)
+	    case container
+		when Model::Extrusion
+		    if container.transformation and not container.transformation.identity?
+			add_instance(parent, container)
+		    else
+			to_array(container.sketch, parent, container.transformation).map {|l| "#{l}.pushpull(#{to_sketchup(-container.length)})"}
+		    end
+		when Model::Group
+		    if container.transformation and not container.transformation.identity?
+			add_instance(parent, container)
+		    else
+			container.elements.map {|element| to_array(element, parent) }.flatten
+		    end
+		when Model  # !!! Must be after all subclasses of Model
+		    if container.transformation and not container.transformation.identity?
+			add_instance(parent, container)
+		    else
+			container.elements.map {|element| to_array(element, parent) }.flatten
+		    end
+		when Sketch
+		    container.geometry.map {|element| to_sketchup(element, parent, transformation) }
+	    end
+	end
+
+	# Convert the given entity to a string that SketchUp can read
+	def to_sketchup(entity, parent='model.entities', transformation=nil)
+	    case entity
+		when Array
+		    entity.map {|v| to_sketchup(v, parent, transformation) }.join(', ')
+		when Geometry::Arc
+		    "#{parent}.add_arc(#{to_sketchup(entity.center)}, [1,0,0], [0,0,1], #{to_sketchup(entity.radius)}, #{to_sketchup(entity.start_angle)}, #{to_sketchup(entity.end_angle)})"
+		when Geometry::Circle
+		    "lambda{ points = #{parent}.add_circle(#{to_sketchup(entity.center)}, [0,0,1], #{to_sketchup(entity.radius)}); points[0].find_faces; points[0].faces[0]}.call"
+		when Geometry::Edge
+		    "#{parent}.add_edges(#{to_sketchup(entity.first)}, #{to_sketchup(entity.last)})"
+		when Geometry::Line
+		    "#{parent}.add_line(#{to_sketchup(entity.first)}, #{to_sketchup(entity.last)})"
+		when Geometry::Path
+		    edges = entity.elements.map {|e| to_sketchup(e, parent, transformation) }.flatten.join '+'
+		    "#{parent}.add_face(#{edges})"
+		when Geometry::Polyline
+		    vertices = entity.vertices.map {|v| to_sketchup(v, parent, transformation) }.join ', '
+		    method = entity.is_a?(Geometry::Polygon) ? 'add_face' : 'add_curve'
+		    "#{parent}.#{method}(#{vertices})"
+		when Geometry::Point
+		    if transformation and not transformation.identity?
+			'Geom::Point3d.new(' + to_sketchup(entity.to_a) + ').transform!(' + to_sketchup(transformation) + ')'
+		    else
+			'[' + to_sketchup(entity.to_a) + ']'
+		    end
+		when Geometry::Polygon
+		    "#{parent}.add_face(#{to_sketchup(entity.points, parent, transformation)})"
+		when Geometry::Rectangle
+		    "#{parent}.add_face(#{to_sketchup(entity.points, parent, transformation)})"
+		when Geometry::Transformation
+		    pt = '[' + (entity.translation ? to_sketchup(entity.translation.to_a) : '0,0,0') + ']'
+		    x_axis = '[' + (entity.rotation.x ? to_sketchup(entity.rotation.x.to_a) : '1,0,0') + ']'
+		    y_axis = '[' + (entity.rotation.y ? to_sketchup(entity.rotation.y.to_a) : '0,1,0') + ']'
+		    "Geom::Transformation.new(#{[pt,x_axis,y_axis].join(',')})"
+		when Geometry::Triangle
+		    "#{parent}.add_face(#{to_sketchup(entity.points, parent, transformation)})"
+		when Float
+		    entity.to_s
+		when Rational
+		    [entity.to_f, entity.respond_to?(:units) ? entity.units : nil].compact.map {|a| to_sketchup(a)}.join '.'
+		when Units
+		    s = entity.to_s
+		    SKETCHUP_UNITS[s] or raise "SketchUp won't recognize '#{s}'"
+		when Units::Literal
+		    [entity.value, entity.units].compact.map {|a| to_sketchup(a)}.join '.'
+		else
+		    entity.to_s
+	    end
+	end
+    end
+
+    def self.write(filename, container)
+	File.write(filename, Builder.new(container).to_s)
+    end
+end

data/test/engineering.rb

@@ -0,0 +1,203 @@
+require 'minitest/autorun'
+require 'engineering'
+
+#LENGTH = 42
+
+describe Engineering do
+    include Engineering::DSL
+
+    after do
+	# Cleanup the class constants created by each test
+	ObjectSpace.each_object(Class).select {|k| (k < Model) or (k < Sketch)}.each {|klass|
+	    begin
+		Object.send(:remove_const, klass.name.to_sym)
+	    rescue NameError
+	    end
+	}
+    end
+
+    describe "when creating a named Model subclass" do
+	before do
+	    model :TestModel do
+		extrude length:10 do
+		    square 5
+		end
+	    end
+	end
+	let(:testModel) { TestModel.new }
+
+	it "must create a global constant" do
+	    Object.constants.include?(:TestModel).must_equal true
+	end
+
+	it "must support creating instances of the subclass" do
+	    TestModel.new.must_be_kind_of Model
+	    TestModel.new.must_be_kind_of TestModel
+	end
+
+	it "must call the initializer block when constructed" do
+	    TestModel.new.elements.count.must_equal 1
+	    TestModel.new.elements.first.must_be_instance_of Model::Extrusion
+	    TestModel.new.elements.first.length.must_equal 10
+	end
+
+	describe "when another model class is created with a new name" do
+	    before do
+		model :TestModel2 do
+		    extrude length:5 do
+			square 10
+		    end
+		end
+	    end
+	    let(:testModel2) { TestModel2.new }
+
+	    it "must be able to make new instances" do
+		testModel2.must_be_kind_of Model
+		testModel2.must_be_instance_of TestModel2
+		testModel2.wont_be_instance_of TestModel
+	    end
+
+	    it "must call the correct initializer block when constructed" do
+		testModel2.elements.count.must_equal 1
+		testModel2.elements.first.must_be_instance_of Model::Extrusion
+		testModel2.elements.first.length.must_equal 5
+	    end
+
+	    describe "when the original Model class is used again" do
+		let(:anotherTestModel) { TestModel.new }
+
+		it "must call the correct initializer block when constructed" do
+		    anotherTestModel.elements.count.must_equal 1
+		    anotherTestModel.elements.first.must_be_instance_of Model::Extrusion
+		    anotherTestModel.elements.first.length.must_equal 10
+		end
+	    end
+	end
+    end
+
+    describe "when creating an Extrusion subclass" do
+	after do
+	    Object.send(:remove_const, :TestExtrusion)
+	end
+
+	before do
+	    extrusion :TestExtrusion do
+		square 5
+	    end
+	end
+
+	it "must create a global constant" do
+	    Object.constants.include?(:TestExtrusion).must_equal true
+	end
+
+	it "must be a subclass of Extrusion" do
+	    (TestExtrusion < Model::Extrusion).must_equal true
+	end
+
+	describe "when initializing a new instance" do
+	    subject { TestExtrusion.new(length: 5) }
+
+	    it "must create instances of the proper class" do
+		subject.must_be_kind_of Model::Extrusion
+	    end
+
+	    it "must call the initializer block" do
+		subject.length.must_equal 5
+	    end
+	end
+    end
+
+    describe "when creating a Model that uses global constants" do
+	before do
+	    LENGTH = 5
+	    model :TestModel3 do
+		extrude length: LENGTH do
+		    square 5
+		end
+	    end
+	end
+
+	it "must not complain" do
+	    TestModel3.new
+	end
+
+    end
+
+    describe "when creating a named Sketch subclass" do
+	before do
+	    sketch :TestSketch do
+		square 5
+	    end
+	end
+	let(:testSketch) { TestSketch.new }
+
+	it "must create a global constant" do
+	    Object.constants.include?(:TestSketch).must_equal true
+	end
+
+	it "must support creating instances of the subclass" do
+	    testSketch.must_be_kind_of Sketch
+	    testSketch.must_be_kind_of TestSketch
+	end
+
+	it "must call the initializer block when constructed" do
+	    testSketch.elements.count.must_equal 1
+	    testSketch.elements.first.must_be_kind_of Geometry::Square
+	end
+
+	describe "when another sketch class is created with a new name" do
+	    before do
+		sketch :TestSketch2 do
+		    square 10
+		end
+	    end
+	    let(:testSketch2) { TestSketch2.new }
+
+	    it "must be able to make new instances" do
+		testSketch2.must_be_kind_of Sketch
+		testSketch2.must_be_kind_of TestSketch2
+		testSketch2.wont_be_kind_of TestSketch
+	    end
+
+	    it "must call the correct initializer block when constructed" do
+		testSketch2.elements.count.must_equal 1
+		testSketch2.elements.first.must_be_kind_of Geometry::Square
+	    end
+
+	    describe "when the original Sketch class is used again" do
+		let(:anotherTestSketch) { TestSketch.new }
+
+		it "must call the correct initializer block when constructed" do
+		    anotherTestSketch.elements.count.must_equal 1
+		    anotherTestSketch.elements.first.must_be_kind_of Geometry::Square
+		end
+	    end
+	end
+    end
+
+    describe "when creating a Polygon" do
+	it "must create a Polygon" do
+	    polygon = Polygon.build do
+		start_at [0,0]
+		right	1
+		up	1
+		left	1
+		down	1
+	    end
+	    polygon.must_be_instance_of(Geometry::Polygon)
+	end
+    end
+
+    describe "when creating a Polyline" do
+	it "must create a Polyline" do
+	    polyline = Polyline.build do
+		start_at [0,0]
+		right	1
+		up	1
+		left	1
+		down	1
+	    end
+	    polyline.must_be_instance_of(Geometry::Polyline)
+	end
+    end
+end

data/test/fixtures/translated_extrusion.su

@@ -0,0 +1,7 @@
+model = Sketchup.active_model
+model.entities.clear!
+model.definitions.purge_unused
+lambda {|d|
+	d.entities.add_face\(\[-5.0, -10.0\], \[-5.0, 10.0\], \[5.0, 10.0\], \[5.0, -10.0\]\).pushpull\(-5\)
+}.call\(model.definitions.add\('Model::Extrusion\(Sketch:\d+\)_5'\)\)
+model.entities.add_instance\(model.definitions\['Model::Extrusion\(Sketch:\d+\)_5'\], Geom::Transformation.new\(\[1, 2, 3\],\[1,0,0\],\[0,1,0\]\)\)

data/test/geometry.rb

@@ -0,0 +1,22 @@
+require 'minitest/autorun'
+require 'geometry'
+require 'units'
+
+# This is a bit of integration testing to ensure that the Units gem doesn't break
+#  any of the other gems. None of the individual gems know about each other so
+#  there's no way to test their integration at a lower level.
+
+describe Geometry do
+    let(:pointA) { Point[2.meters, 3.meters] }
+    let(:pointB) { Point[4.meters, 5.meters] }
+    let(:sizeA) { Size[2.meters, 3.meters] }
+    let(:sizeB) { Size[4.meters, 5.meters] }
+
+    describe "Point and Size arithmetic" do
+	it "should add" do
+	    sum = (pointA + sizeA)
+	    sum.must_be_instance_of(Point)
+	    sum.must_equal Point[4.meters, 6.meters]
+	end
+    end
+end

data/test/geometry/edge.rb

@@ -0,0 +1,23 @@
+require 'minitest/autorun'
+require 'geometry'
+require 'units'
+
+# This is a bit of integration testing to ensure that the Units gem doesn't break
+#  any of the other gems. None of the individual gems know about each other so
+#  there's no way to test their integration at a lower level.
+
+describe Geometry::Edge do
+    Edge = Geometry::Edge
+
+    let(:pointA) { Point[2.meters, 3.meters] }
+    let(:pointB) { Point[4.meters, 5.meters] }
+    
+    describe "should construct an Edge from Points with Units" do
+	let(:edge) { Edge.new(pointA, pointB) }
+
+	it "should preserve the units" do
+	    edge.first.must_equal Point[2.meters, 3.meters]
+	    edge.last.must_equal Point[4.meters, 5.meters]
+	end
+    end
+end

data/test/geometry/point.rb

@@ -0,0 +1,39 @@
+require 'minitest/autorun'
+require 'geometry'
+require 'units'
+
+# This is a bit of integration testing to ensure that the Units gem doesn't break
+#  any of the other gems. None of the individual gems know about each other so
+#  there's no way to test their integration at a lower level.
+
+describe Geometry::Point do
+    Point = Geometry::Point
+
+    it "should not break normal Point construction" do
+	Point[1,2].must_be_instance_of(Point)
+    end
+    
+    describe "when the elements have units" do
+	let(:pointA) { Point[2.meters, 3.meters] }
+	let(:pointB) { Point[4.meters, 5.meters] }
+	
+	describe "arithmetic" do
+	    it "should add" do
+		(pointA+pointB).must_equal Point[6.meters, 8.meters]
+	    end
+	    
+	    it "should subtract" do
+		(pointB-pointA).must_equal Point[2.meters, 2.meters]
+	    end
+	    
+	    it "should multiply by a constant" do
+		(pointA * 2).must_equal Point[4.meters, 6.meters]
+	    end
+	    
+	    it "should divide by a constant" do
+		(pointB / 2).must_equal Point[2.meters, 2.5.meters]
+		(pointB / 2.0).must_equal Point[2.0.meters, 2.5.meters]
+	    end
+	end
+    end
+end

data/test/geometry/size.rb

@@ -0,0 +1,39 @@
+require 'minitest/autorun'
+require 'geometry'
+require 'units'
+
+# This is a bit of integration testing to ensure that the Units gem doesn't break
+#  any of the other gems. None of the individual gems know about each other so
+#  there's no way to test their integration at a lower level.
+
+describe Geometry::Size do
+    Size = Geometry::Size
+    
+    it "should not break normal Size construction" do
+	Size[1,2].must_be_instance_of(Size)
+    end
+    
+    describe "when the elements have units" do
+	let(:sizeA) { Size[2.meters, 3.meters] }
+	let(:sizeB) { Size[4.meters, 5.meters] }
+	
+	describe "arithmetic" do
+	    it "should add" do
+		(sizeA+sizeB).must_equal Size[6.meters, 8.meters]
+	    end
+	    
+	    it "should subtract" do
+		(sizeB-sizeA).must_equal Size[2.meters, 2.meters]
+	    end
+	    
+	    it "should multiply by a constant" do
+		(sizeA * 2).must_equal Size[4.meters, 6.meters]
+	    end
+	    
+	    it "should divide by a constant" do
+		(sizeB / 2).must_equal Size[2.meters, 2.5.meters]
+		(sizeB / 2.0).must_equal Size[2.0.meters, 2.5.meters]
+	    end
+	end
+    end
+end

data/test/model/builder.rb

@@ -0,0 +1,35 @@
+require 'minitest/autorun'
+require 'model/builder'
+require 'units'
+
+# This is a bit of integration testing to ensure that the Units gem doesn't break
+#  any of the other gems. None of the individual gems know about each other so
+#  there's no way to test their integration at a lower level.
+
+describe Model::Builder do
+    Builder = Model::Builder
+
+    let(:builder) { Builder.new }
+
+    describe "when adding an Extrusion with a length with units" do
+	before do
+	    builder.evaluate do
+		extrude length:10.meters, sketch:Sketch.new do
+		    rectangle 5, 6
+		end
+	    end
+	end
+	
+	it "should have an Extrusion element" do
+	    builder.model.elements.last.must_be_instance_of Model::Extrusion
+	    builder.model.elements.last.length.must_equal 10.meters
+	end
+	
+	it "should make a Rectangle in the Extrusion's Sketch" do
+	    extrusion = builder.model.elements.last
+	    sketch = extrusion.sketch
+	    sketch.elements.last.must_be_kind_of Geometry::Rectangle
+	end
+    end
+
+end

data/test/model/extrusion.rb

@@ -0,0 +1,32 @@
+require 'minitest/autorun'
+require 'model/extrusion'
+require 'units'
+
+# This is a bit of integration testing to ensure that the Units gem doesn't break
+#  any of the other gems. None of the individual gems know about each other so
+#  there's no way to test their integration at a lower level.
+
+describe Model::Extrusion do
+    Extrusion = Model::Extrusion
+    
+    it "must not break normal construction" do
+	Extrusion.new(length:5, sketch:Sketch.new).must_be_instance_of(Extrusion)
+    end
+
+    describe  "when the length parameter has units" do
+	let(:extrusionA) { Extrusion.new length:5.meters, sketch:Sketch.new }
+	
+	it "must preserve the units" do
+	    extrusionA.length.must_equal 5.meters
+	end
+    end
+    
+    describe  "when the length parameter is a variable with units" do
+	let(:length) { 6.meters }
+	let(:extrusionA) { Extrusion.new length:6.meters, sketch:Sketch.new }
+	
+	it "must preserve the units" do
+	    extrusionA.length.must_equal 6.meters
+	end
+    end
+end

data/test/sketchup.rb

@@ -0,0 +1,7 @@
+require 'minitest/autorun'
+
+describe SketchUp do
+    before do
+    	@SketchUp = SketchUp.new
+    end
+end

data/test/sketchup/builder.rb

@@ -0,0 +1,117 @@
+require 'minitest/autorun'
+require 'sketchup'
+
+describe SketchUp::Builder do
+    subject { SketchUp::Builder.new }
+
+    before do
+    	@builder = SketchUp::Builder.new
+    end
+
+    let(:empty_fixture)		    { File.read('test/fixtures/sketchup/empty.su') }
+    let(:rectangle_sketch_fixture)  { File.read('test/fixtures/sketchup/rectangle_sketch.su') }
+
+    it "should keep private methods private" do
+	@builder.wont_respond_to :to_array
+	@builder.wont_respond_to :to_sketchup
+    end
+
+    it "should not break Point's to_s method" do
+	5.cm.to_s.must_equal "5"
+    end
+
+    it "should not break Point's inspect method" do
+	5.cm.inspect.must_equal "5 centimeter"
+    end
+
+    describe "when given an empty Model object" do
+	before do
+	    model = Model.new
+	    model.add_extrusion Model::Extrusion.new(length:5, sketch:Sketch.new)
+	    @builder.container = model
+	end
+
+	it "should export the correct file" do
+	    @builder.to_s.must_equal empty_fixture
+	end
+    end
+
+    describe "when given a Model of a translated Extrusion" do
+	sketch = Sketch.new
+	sketch.add_rectangle 10, 20
+	before do
+	    subject.container = Model.new do
+		add_extrusion Model::Extrusion.new(length:5, sketch:sketch, transformation:Geometry::Transformation.new(origin:[1,2,3]))
+	    end
+	end
+
+	it "must generate the correct text" do
+	    subject.to_s.must_match Regexp.new(File.read('test/fixtures/translated_extrusion.su'))
+	end
+    end
+
+    it "should generate the correct text from a Model of a simple extrusion" do
+	sketch = Sketch.new
+	sketch.add_rectangle 10, 20
+	model = Model.new do
+	    add_extrusion Model::Extrusion.new(length:5, sketch:sketch)
+	end
+	@builder.container = model
+	@builder.to_s.must_equal File.read('test/fixtures/sketchup/simple_extrusion.su')
+    end
+
+    it "should generate the correct text from a Model of a simple extrusion with units" do
+	sketch = Sketch.new
+	sketch.add_rectangle 1.meter, 10
+	model = Model.new
+	model.add_extrusion Model::Extrusion.new(length:5.meters, sketch:sketch)
+	@builder.container = model
+	@builder.to_s.must_equal File.read('test/fixtures/sketchup/simple_extrusion_units.su')
+    end
+
+    it "should generate correct text from an empty Sketch" do
+	@builder.container = Sketch.new
+	@builder.to_s.must_equal empty_fixture
+    end
+
+    it "should generate correct text from a simple Sketch object" do
+	sketch = Sketch.new
+	sketch.add_line [0,0], [1,0]
+	@builder.container = sketch
+	@builder.to_s.must_equal File.read('test/fixtures/sketchup/line_sketch.su')
+    end
+
+    it "should generate correct text from a Sketch object with a single Rectangle" do
+	sketch = Sketch.new
+	sketch.add_rectangle [0,0], Geometry::Size[1,1]
+	@builder.container = sketch
+	@builder.to_s.must_equal rectangle_sketch_fixture
+    end
+
+    it "should generate correct text from a Sketch object with a single Polygon" do
+	sketch = Sketch.new
+	sketch.add_polygon [0,0], [0,1], [1,1], [1,0], [0,0]
+	@builder.container = sketch
+	@builder.to_s.must_equal rectangle_sketch_fixture
+    end
+
+    it "must handle a Group" do
+	builder = SketchUp::Builder.new( Model::Builder.new.evaluate { group :origin => [1,2,3] })
+	builder.container.elements.count.must_equal 1
+	builder.container.elements.first.must_be_instance_of(Model::Group)
+	builder.to_s.must_match %r{model = Sketchup.active_model\nmodel.entities.clear!\nmodel.definitions.purge_unused\nlambda {|g|\n\t\n}.call(model.definitions.add('Model::Group()'))\nmodel.entities.add_instance(model.definitions\['Model::Group(\d+)'\], Geom::Transformation.new(\[1, 2, 3\],\[1,0,0\],\[0,1,0\]))}
+    end
+
+    it "must handle a sub-model" do
+	builder = SketchUp::Builder.new( Model::Builder.new.evaluate { push Model.new, :origin => [3,2,1] })
+	builder.container.elements.count.must_equal 1
+	builder.container.elements.first.must_be_instance_of(Model)
+	builder.to_s.must_match %r{model = Sketchup.active_model\nmodel.entities.clear!\nmodel.definitions.purge_unused\nlambda {|m|\n\t\n}.call(model.definitions.add('Model(\d+)'))\nmodel.entities.add_instance(model.definitions\['Model(\d+)'\], Geom::Transformation.new(\[3, 2, 1\],\[1,0,0\],\[0,1,0\]))}
+    end
+
+    it "Path" do
+	sketch = Sketch.new
+	sketch.add_path [0,0], Geometry::Arc.new([0,0],5,0,90*Math::PI/180), [0,0]
+	builder = SketchUp::Builder.new( Model::Builder.new.evaluate { extrude length:5, sketch:sketch })
+    end
+end

data/test/units/literal.rb

@@ -0,0 +1,31 @@
+require 'minitest/autorun'
+require 'mathn'
+require 'units'
+
+# This is a bit of integration testing to ensure that the mathn gem doesn't break
+#  the units gems. Mathn changes a number of the default arithmetic operators,
+#  which tends to cause trouble for Units. Neither gem knows about the other so
+#  there's no good way to test their integration at a lower level.
+
+def Literal(*args)
+    Units::Literal.new(*args)
+end
+
+describe Units::Literal do
+    let(:one_meter)	{ Literal(1, :meter) }
+    let(:three_meters)	{ Literal(3, :meters) }
+    let(:four_meters)	{ Literal(4, :meters) }
+
+    describe "coerced arithmetic" do
+	it "division" do
+	    (0 / one_meter).must_equal 0
+	    (0 / three_meters).must_equal 0
+#	    (4 / three_meters).must_equal Rational(4,3).meters
+	    (12.0 / three_meters).must_equal four_meters
+	end
+
+	it "must divide a Rational" do
+	    (Rational(2,1) / one_meter).must_equal Rational(2,1).meters(-1)
+	end
+    end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: engineering
 version: !ruby/object:Gem::Version
-  version: '0'
+  version: '0.1'
   prerelease: 
 platform: ruby
 authors:
@@ -9,9 +9,73 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-29 00:00:00.000000000 Z
-dependencies: []
-description: Tools for Engineers and those who want to be
+date: 2013-04-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dxf
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: model
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sketch
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: units
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '2'
+description: Tools for Mad Engineers and those who want to be
 email:
 - bfoz@bfoz.net
 executables: []
@@ -20,10 +84,22 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - Gemfile
-- README
+- README.markdown
 - Rakefile
 - engineering.gemspec
 - lib/engineering.rb
+- lib/sketchup.rb
+- test/engineering.rb
+- test/fixtures/translated_extrusion.su
+- test/geometry.rb
+- test/geometry/edge.rb
+- test/geometry/point.rb
+- test/geometry/size.rb
+- test/model/builder.rb
+- test/model/extrusion.rb
+- test/sketchup.rb
+- test/sketchup/builder.rb
+- test/units/literal.rb
 homepage: http://github.com/bfoz/engineering
 licenses: []
 post_install_message: 
@@ -44,9 +120,20 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: engineering
-rubygems_version: 1.8.17
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
-summary: Engineering tools
-test_files: []
+summary: Mad Engineering, Ruby style
+test_files:
+- test/engineering.rb
+- test/fixtures/translated_extrusion.su
+- test/geometry.rb
+- test/geometry/edge.rb
+- test/geometry/point.rb
+- test/geometry/size.rb
+- test/model/builder.rb
+- test/model/extrusion.rb
+- test/sketchup.rb
+- test/sketchup/builder.rb
+- test/units/literal.rb
 has_rdoc: