aurora-dxf 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a03bc384bb55b21b7c1bd910b73985797191fa05
+  data.tar.gz: bcebe25e0f79bd3cafc2fd0eed0486d4dc77c113
+SHA512:
+  metadata.gz: d08d53dc672d2e65f8e1e767cb60dc880255548065255b2e1de0ce2e8ffa1c3a2c8b8e58be855df7ab8a393ae5ab232920d4dd937ccec4cb72fcf0d81018816e
+  data.tar.gz: b3ff2a61715effb1505ca73ce49c39782a54139167e85752f585ca30e0b51d8772b868fc52e736973a1601885f0f772e23bac532f79052cf6cffdc7a2d9f18d3

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'aurora-sketch'
+gem 'units', github: 'bfoz/units-ruby'
+
+group :test do
+    gem 'rake'
+end

data/README.markdown

@@ -0,0 +1,33 @@
+# DXF
+
+[![Build Status](https://travis-ci.org/bfoz/dxf-ruby.png)](https://travis-ci.org/bfoz/dxf-ruby)
+
+Tools for working with the popular DXF file format
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'DXF'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dxf
+
+## Usage
+
+```ruby
+require 'dxf'
+
+# To export the my_sketch object in inches
+DXF.write('filename.dxf', my_sketch, :inches)
+```
+
+License
+-------
+
+Copyright 2012-2013 Brandon Fosdick <bfoz@bfoz.net> and released under the BSD license.

data/Rakefile

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

data/aurora-dxf.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |gem|
+  gem.name          = "aurora-dxf"
+  gem.version       = '0.0.3'
+  gem.authors       = ["Brandon Fosdick", "Meseker Yohannes"]
+  gem.email         = ["meseker.yohannes@gmail.com"]
+  gem.description   = %q{Read and write DXF files using Ruby}
+  gem.summary       = %q{Tools for working with the popular DXF file format}
+  gem.homepage      = "http://github.com/meseker/dxf-ruby"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+    gem.add_dependency	'aurora-geometry'
+    gem.add_dependency  'aurora-sketch'
+    gem.add_dependency	'units', '~> 2.2'
+end

data/lib/dxf.rb

@@ -0,0 +1,25 @@
+require_relative 'dxf/parser'
+require_relative 'dxf/unparser'
+
+module DXF
+=begin
+Reading and writing of files using AutoCAD's {http://en.wikipedia.org/wiki/AutoCAD_DXF Drawing Interchange File} format.
+
+    {http://usa.autodesk.com/adsk/servlet/item?siteID=123112&id=12272454&linkID=10809853 DXF Specifications}
+=end
+
+    # Export a {Sketch} to a DXF file
+    # @param [String] filename	The path to write to
+    # @param [Sketch] sketch	The {Sketch} to export
+    # @param [Symbol] units	Convert all values to the specified units (:inches or :mm)
+    def self.write(filename, sketch, units=:mm)
+	File.open(filename, 'w') {|f| Unparser.new(units).unparse(f, sketch)}
+    end
+
+    # Read a DXF file
+    # @param [String] filename	The path to the file to read
+    # @return [DXF] the resulting {DXF} object
+    def self.read(filename)
+	File.open(filename, 'r') {|f| DXF::Parser.new.parse(f) }
+    end
+end

data/lib/dxf/cluster_factory.rb

@@ -0,0 +1,15 @@
+# Include this module in the base class of a class cluster to handle swizzling
+# of ::new
+module ClusterFactory
+    def self.included(parent)
+	class << parent
+	    alias :original_new :new
+
+	    def inherited(subclass)
+		class << subclass
+		    alias :new :original_new
+		end
+	    end
+	end
+    end
+end

data/lib/dxf/entity.rb

@@ -0,0 +1,97 @@
+require 'geometry'
+
+require_relative 'cluster_factory'
+
+module DXF
+    # {Entity} is the base class for everything that can live in the ENTITIES block
+    class Entity
+	TypeError = Class.new(StandardError)
+
+	include ClusterFactory
+
+	attr_accessor :handle
+	attr_accessor :layer
+
+	def self.new(type)
+	    case type
+		when 'CIRCLE'	then Circle.new
+		when 'LINE'	then Line.new
+		else
+		    raise TypeError, "Unrecognized entity type '#{type}'"
+	    end
+	end
+
+	def parse_pair(code, value)
+	    # Handle group codes that are common to all entities
+	    #  These are from the table that starts on page 70 of specification
+	    case code
+		when '5'
+		    handle = value
+		when '8'
+		    layer = value
+		else
+		    p "Unrecognized entity group code: #{code} #{value}"
+	    end
+	end
+
+	private
+
+	def point_from_values(*args)
+	    Geometry::Point[args.flatten.reverse.drop_while {|a| not a }.reverse]
+	end
+    end
+
+    class Circle < Entity
+	attr_accessor :x, :y, :z
+	attr_accessor :radius
+
+	def parse_pair(code, value)
+	    case code
+		when '10'   then self.x = value.to_f
+		when '20'   then self.y = value.to_f
+		when '30'   then self.z = value.to_f
+		when '40'   then self.radius = value.to_f
+		else
+		    super   # Handle common and unrecognized codes
+	    end
+	end
+
+	# @!attribute [r] center
+	#   @return [Point]  the composed center of the {Circle}
+	def center
+	    a = [x, y, z]
+	    a.pop until a.last
+	    Geometry::Point[*a]
+	end
+    end
+
+    class Line < Entity
+	attr_accessor :x1, :y1, :z1
+	attr_accessor :x2, :y2, :z2
+
+	def parse_pair(code, value)
+	    case code
+		when '10'   then self.x1 = value.to_f
+		when '20'   then self.y1 = value.to_f
+		when '30'   then self.z1 = value.to_f
+		when '11'   then self.x2 = value.to_f
+		when '21'   then self.y2 = value.to_f
+		when '31'   then self.z2 = value.to_f
+		else
+		    super   # Handle common and unrecognized codes
+	    end
+	end
+
+	# @!attribute [r] first
+	#   @return [Point]  the starting point of the {Line}
+	def first
+	    point_from_values x1, y1, z1
+	end
+
+	# @!attribute [r] last
+	#   @return [Point]  the end point of the {Line}
+	def last
+	    point_from_values x2, y2, z2
+	end
+    end
+end

data/lib/dxf/parser.rb

@@ -0,0 +1,98 @@
+require_relative 'entity'
+
+module DXF
+    class Parser
+	ParseError = Class.new(StandardError)
+
+	# @!attribute entities
+	#   @return [Array]  the entities that comprise the drawing
+	attr_accessor :entities
+
+	# @!attribute header
+	#   @return [Hash]  the header variables
+	attr_accessor :header
+
+	def initialize(units=:mm)
+	    @entities = []
+	    @header = {}
+	end
+
+	def parse(io)
+	    parse_pairs io do |code, value|
+		raise ParseError, "DXF files must begin with group code 0, not #{code}" unless '0' == code
+		raise ParseError, "Expecting a SECTION, not #{value}" unless 'SECTION' == value
+		parse_section(io)
+	    end
+	    self
+	end
+
+	private
+
+	def read_pair(io)
+	    [io.gets.chomp, io.gets.chomp]
+	end
+
+	def parse_pairs(io, &block)
+	    while not io.eof?
+		code, value = read_pair(io)
+		case [code, value]
+		    when ['0', 'ENDSEC']    then return
+		    when ['0', 'EOF']	    then return
+		    else
+			yield code, value
+		end
+	    end
+	end
+
+	def parse_section(io)
+	    code, value = read_pair(io)
+	    raise ParseError, 'SECTION must be followed by a section type' unless '2' == code
+
+	    case value
+#		when 'BLOCKS'
+#		when 'CLASSES'
+		when 'ENTITIES'
+		    parse_entities(io)
+		when 'HEADER'
+		    parse_header(io)
+#		when 'OBJECTS'
+#		when 'TABLES'
+#		when 'THUMBNAILIMAGE'
+		else
+		    raise ParseError, "Unrecognized section type '#{value}'"
+	    end
+	end
+
+	# Parse the ENTITIES section
+	def parse_entities(io)
+	    parse_pairs io do |code, value|
+		if '0' == code
+		    entities.push Entity.new(value)
+		else
+		    entities.last.parse_pair(code, value)
+		end
+	    end
+	end
+
+	# Parse the HEADER section
+	def parse_header(io)
+	    variable_name = nil
+	    parse_pairs io do |code, value|
+		case code
+		    when '9'
+			variable_name = value
+		    else
+			header[variable_name] = parse_header_value(code, value)
+		end
+	    end
+	end
+
+	def parse_header_value(code, value)
+	    case code
+		when '2'    then value	# String
+		else
+		    raise ParseError, "Unrecognized header value: #{code} '#{value}'"
+	    end
+	end
+    end
+end

data/lib/dxf/unparser.rb

@@ -0,0 +1,105 @@
+require 'geometry'
+require 'sketch'
+require 'units'
+require 'stringio'
+
+module DXF
+    class Unparser
+	attr_accessor :container
+
+	# Initialize with a Sketch
+	# @param [String,Symbol] units	The units to convert length values to (:inches or :millimeters)
+	def initialize(units=:mm)
+	    @units = units
+	end
+
+	def to_s
+	    io = StringIO.new
+	    unparse(io, container)
+	    io.string
+	end
+
+# @group Element Formatters
+	# Convert a {Geometry::Line} into group codes
+	def line(first, last, layer=0, transformation=nil)
+	    first, last = Geometry::Point[first], Geometry::Point[last]
+	    first, last = [first, last].map {|point| transformation.transform(point) } if transformation
+
+	    [ 0, 'LINE',
+	    8, layer,
+	    10, format_value(first.x),
+	    20, format_value(first.y),
+	    11, format_value(last.x),
+	    21, format_value(last.y)]
+	end
+# @endgroup
+
+# @group Property Converters
+	# Convert the given value to the correct units and return it as a formatted string
+	# @return [String]
+	def format_value(value)
+	    if value.is_a? Units::Numeric
+		"%g" % value.send("to_#{@units}".to_sym)
+	    else
+		"%g" % value
+	    end
+	end
+
+	# Emit the group codes for the center property of an element
+	# @param [Point] point	The center point to format
+	def center(point, transformation)
+	    point = transformation.transform(point) if transformation
+	    [10, format_value(point.x), 20, format_value(point.y)]
+	end
+
+	# Emit the group codes for the radius property of an element
+	def radius(element, transformation=nil)
+	    [40, format_value(transformation ? transformation.transform(element.radius) : element.radius)]
+	end
+
+	def section_end
+	    [0, 'ENDSEC']
+	end
+
+	def section_start(name)
+	    [0, 'SECTION', 2, name]
+	end
+# @endgroup
+
+	# Convert an element to an Array
+	# @param [Transformation] transformation    The transformation to apply to each geometry element
+	# @return [Array]
+	def to_array(element, transformation=nil)
+	    layer = 0;
+	    case element
+		when Geometry::Arc
+		    [ 0, 'ARC', center(element.center, transformation), radius(element),
+		    50, format_value(element.start_angle),
+		    51, format_value(element.end_angle)]
+		when Geometry::Circle
+		    [0, 'CIRCLE', 8, layer, center(element.center, transformation), radius(element)]
+		when Geometry::Edge, Geometry::Line
+		    line(element.first, element.last, layer, transformation)
+		when Geometry::Polyline
+		    element.edges.map {|edge| line(edge.first, edge.last, layer, transformation) }
+		when Geometry::Rectangle
+		    element.edges.map {|edge| line(edge.first, edge.last, layer, transformation) }
+		when Geometry::Square
+		    points = element.points
+		    points.each_cons(2).map {|p1,p2| line(p1,p2, layer, transformation) } + line(points.last, points.first, layer, transformation)
+		when Sketch
+		    transformation = transformation ? (transformation + element.transformation) : element.transformation
+		    element.geometry.map {|e| to_array(e, transformation)}
+	    end
+	end
+
+	# Convert a {Sketch} to a DXF file and write it to the given output
+	# @param [IO] output    A writable IO-like object
+	# @param [Sketch] sketch	The {Sketch} to unparse
+	def unparse(output, sketch)
+	    output << (section_start('HEADER') + section_end +
+		       section_start('ENTITIES') + to_array(sketch) + section_end +
+		       [0, 'EOF']).join("\n")
+	end
+    end
+end

data/test/dxf/parser.rb

@@ -0,0 +1,35 @@
+require 'minitest/autorun'
+require 'dxf/parser'
+
+describe DXF::Parser do
+    it 'must read from an IO stream' do
+	File.open('test/fixtures/circle.dxf', 'r') {|f| DXF::Parser.new.parse(f) }
+    end
+
+    it 'must parse a file with a circle' do
+	parser = File.open('test/fixtures/circle.dxf', 'r') {|f| DXF::Parser.new.parse(f) }
+	parser.entities.length.must_equal 1
+	circle = parser.entities.last
+	circle.must_be_instance_of(DXF::Circle)
+	circle.center.must_equal Geometry::Point[0,0]
+	circle.radius.must_equal 1
+    end
+
+    it 'must parse a file with a translated circle' do
+	parser = File.open('test/fixtures/circle_translate.dxf', 'r') {|f| DXF::Parser.new.parse(f) }
+	parser.entities.length.must_equal 1
+	circle = parser.entities.last
+	circle.must_be_instance_of(DXF::Circle)
+	circle.center.must_equal Geometry::Point[1,1]
+	circle.radius.must_equal 1
+    end
+
+    it 'must parse a file with a square' do
+	parser = File.open('test/fixtures/square_inches.dxf', 'r') {|f| DXF::Parser.new.parse(f) }
+	parser.entities.length.must_equal 4
+	line = parser.entities.last
+	line.must_be_instance_of(DXF::Line)
+	line.first.must_equal Geometry::Point[0, 1]
+	line.last.must_equal Geometry::Point[0, 0]
+    end
+end

data/test/dxf/unparser.rb

@@ -0,0 +1,213 @@
+require 'minitest/autorun'
+require 'dxf'
+
+describe DXF::Unparser do
+    subject { DXF::Unparser.new }
+    let(:builder)   { DXF::Unparser.new }
+    let(:eof)	    { ['0', 'EOF'] }
+    let(:empty_header) {['0', 'SECTION',
+			 '2', 'HEADER',
+			 '0', 'ENDSEC']}
+    let(:end_section)	    { ['0', 'ENDSEC'] }
+    let(:entities_header)   { ['0', 'SECTION',
+			       '2', 'ENTITIES'] }
+
+    describe "when give an empty Sketch object" do
+	it "must export a minimal file" do
+	    builder.container = Sketch.new
+	    builder.to_s.must_equal (empty_header + entities_header + end_section + eof).join("\n")
+	end
+    end
+
+    describe "when exporting a Sketch" do
+	let(:sketch) { Sketch.new }
+	let(:square_lines) {
+	    ['0', 'LINE',
+	     '8', '0',
+	     '10', '0',
+	     '20', '0',
+	     '11', '1',
+	     '21', '0',
+	     '0', 'LINE',
+	     '8', '0',
+	     '10', '1',
+	     '20', '0',
+	     '11', '1',
+	     '21', '1',
+	     '0', 'LINE',
+	     '8', '0',
+	     '10', '1',
+	     '20', '1',
+	     '11', '0',
+	     '21', '1',
+	     '0', 'LINE',
+	     '8', '0',
+	     '10', '0',
+	     '20', '1',
+	     '11', '0',
+	     '21', '0']
+	}
+
+	before do
+	    subject.container = sketch
+	    builder.container = sketch
+	end
+
+	it "with a single Arc" do
+	    sketch.push Geometry::Arc.new center:[0,0], radius:1, start:0, end:45
+	    builder.to_s.must_equal (empty_header + entities_header + ['0', 'ARC',
+				     '10', '0',
+				     '20', '0',
+				     '40', '1',
+				     '50', '0',
+				     '51', '45'] + end_section + eof).join("\n")
+	end
+
+	it "with a single Circle" do
+	    sketch.push Geometry::Circle.new [0,0], 1
+	    builder.to_s.must_equal File.read('test/fixtures/circle.dxf')
+	end
+
+	it "with a single Line" do
+	    sketch.push Geometry::Line[[0,0], [1,1]]
+	    builder.to_s.must_equal (empty_header + entities_header +
+				     ['0', 'LINE',
+				      '8', '0',
+				      '10', '0',
+				      '20', '0',
+				      '11', '1',
+				      '21', '1'] +
+				     end_section + eof).join("\n")
+	end
+
+	it "with a single Polygon" do
+	    sketch.push Geometry::Polygon.new [0,0], [1,0], [1,1], [0,1]
+	    builder.to_s.must_equal (empty_header + entities_header +
+				     square_lines +
+				     end_section + eof).join("\n")
+	end
+
+	it "with a single Polyline" do
+	    sketch.push Geometry::Polyline.new [0,0], [1,0], [1,1], [0,1]
+	    builder.to_s.must_equal (empty_header + entities_header +
+				     square_lines[0, 36] +
+				     end_section + eof).join("\n")
+	end
+
+	it "with a single Rectangle" do
+	    sketch.push Geometry::Rectangle.new [0,0], [1,1]
+	    builder.to_s.must_equal (empty_header + entities_header + square_lines +
+				     end_section + eof).join "\n"
+	end
+
+	it "with a single Square" do
+	    sketch.push Geometry::Rectangle.new [0,0], [1,1]
+	    builder.to_s.must_equal (empty_header + entities_header + square_lines +
+				     end_section + eof).join "\n"
+	end
+
+	it "with a group" do
+	    Sketch::Builder.new(sketch).evaluate do
+		group origin:[1,1] do
+		    circle center:[0,0], radius:1
+		end
+	    end
+	    subject.to_s.must_equal File.read('test/fixtures/circle_translate.dxf')
+	end
+
+	describe "when the sketch has a transformation" do
+	    before do
+		sketch.transformation = Geometry::Transformation.new(origin:[2,2])
+	    end
+
+	    it "and a group" do
+		Sketch::Builder.new(sketch).evaluate do
+		    group origin:[-1,-1] do
+			circle center:[0,0], radius:1
+		    end
+		end
+		subject.to_s.must_equal File.read('test/fixtures/circle_translate.dxf')
+	    end
+	end
+
+	describe "with a Sketch" do
+	    let(:circle_sketch) { Sketch.new { push Geometry::Circle.new(center:[0,0], radius:1) } }
+
+	    describe "without a transformation" do
+		it "must unparse correctly" do
+		    sketch.push circle_sketch
+		    builder.to_s.must_equal File.read('test/fixtures/circle.dxf')
+		end
+	    end
+
+	    describe "with a transformation" do
+		it "must unparse correctly" do
+		    sketch.push circle_sketch, origin:[1,1]
+		    builder.to_s.must_equal File.read('test/fixtures/circle_translate.dxf')
+		end
+	    end
+	end
+
+	describe "when the sketch has units" do
+	    let(:sketch) { Sketch.new }
+
+	    describe "when exporting to inches" do
+		subject { DXF::Unparser.new :inches }
+		let(:square_inches) { File.read('test/fixtures/square_inches.dxf') }
+
+		before do
+		    subject.container = sketch
+		end
+
+		describe "when the units are all inches" do
+		    before do
+			sketch.push Geometry::Polygon.new [0.inches, 0.inches], [1.inches, 0.inches], [1.inches, 1.inches], [0.inches, 1.inches]
+		    end
+
+		    it "must not convert the values" do
+			subject.to_s.must_equal square_inches
+		    end
+		end
+
+		describe "when the units are all metric" do
+		    before do
+			sketch.push Geometry::Polygon.new [0.mm, 0.mm], [25.4.mm, 0.mm], [25.4.mm, 25.4.mm], [0.mm, 25.4.mm]
+		    end
+
+		    it "must convert the values" do
+			subject.to_s.must_equal square_inches
+		    end
+		end
+	    end
+
+	    describe "when exporting to millimeters" do
+		subject { DXF::Unparser.new :mm }
+		let(:square_millimeters) { File.read('test/fixtures/square_millimeters.dxf') }
+
+		before do
+		    subject.container = sketch
+		end
+
+		describe "when the units are all inches" do
+		    before do
+			sketch.push Geometry::Polygon.new [0.inches, 0.inches], [1.inches, 0.inches], [1.inches, 1.inches], [0.inches, 1.inches]
+		    end
+
+		    it "must convert the values" do
+			subject.to_s.must_equal square_millimeters
+		    end
+		end
+
+		describe "when the units are all metric" do
+		    before do
+			sketch.push Geometry::Polygon.new [0.mm, 0.mm], [25.4.mm, 0.mm], [25.4.mm, 25.4.mm], [0.mm, 25.4.mm]
+		    end
+
+		    it "must not convert the values" do
+			subject.to_s.must_equal square_millimeters
+		    end
+		end
+	    end
+	end
+    end
+end

data/test/fixtures/circle.dxf

@@ -0,0 +1,24 @@
+0
+SECTION
+2
+HEADER
+0
+ENDSEC
+0
+SECTION
+2
+ENTITIES
+0
+CIRCLE
+8
+0
+10
+0
+20
+0
+40
+1
+0
+ENDSEC
+0
+EOF

data/test/fixtures/circle_translate.dxf

@@ -0,0 +1,24 @@
+0
+SECTION
+2
+HEADER
+0
+ENDSEC
+0
+SECTION
+2
+ENTITIES
+0
+CIRCLE
+8
+0
+10
+1
+20
+1
+40
+1
+0
+ENDSEC
+0
+EOF

data/test/fixtures/square_inches.dxf

@@ -0,0 +1,62 @@
+0
+SECTION
+2
+HEADER
+0
+ENDSEC
+0
+SECTION
+2
+ENTITIES
+0
+LINE
+8
+0
+10
+0
+20
+0
+11
+1
+21
+0
+0
+LINE
+8
+0
+10
+1
+20
+0
+11
+1
+21
+1
+0
+LINE
+8
+0
+10
+1
+20
+1
+11
+0
+21
+1
+0
+LINE
+8
+0
+10
+0
+20
+1
+11
+0
+21
+0
+0
+ENDSEC
+0
+EOF

data/test/fixtures/square_millimeters.dxf

@@ -0,0 +1,62 @@
+0
+SECTION
+2
+HEADER
+0
+ENDSEC
+0
+SECTION
+2
+ENTITIES
+0
+LINE
+8
+0
+10
+0
+20
+0
+11
+25.4
+21
+0
+0
+LINE
+8
+0
+10
+25.4
+20
+0
+11
+25.4
+21
+25.4
+0
+LINE
+8
+0
+10
+25.4
+20
+25.4
+11
+0
+21
+25.4
+0
+LINE
+8
+0
+10
+0
+20
+25.4
+11
+0
+21
+0
+0
+ENDSEC
+0
+EOF

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: aurora-dxf
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Brandon Fosdick
+- Meseker Yohannes
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aurora-geometry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: aurora-sketch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: units
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.2'
+description: Read and write DXF files using Ruby
+email:
+- meseker.yohannes@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.markdown
+- Rakefile
+- aurora-dxf.gemspec
+- lib/dxf.rb
+- lib/dxf/cluster_factory.rb
+- lib/dxf/entity.rb
+- lib/dxf/parser.rb
+- lib/dxf/unparser.rb
+- test/dxf/parser.rb
+- test/dxf/unparser.rb
+- test/fixtures/circle.dxf
+- test/fixtures/circle_translate.dxf
+- test/fixtures/square_inches.dxf
+- test/fixtures/square_millimeters.dxf
+homepage: http://github.com/meseker/dxf-ruby
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Tools for working with the popular DXF file format
+test_files:
+- test/dxf/parser.rb
+- test/dxf/unparser.rb
+- test/fixtures/circle.dxf
+- test/fixtures/circle_translate.dxf
+- test/fixtures/square_inches.dxf
+- test/fixtures/square_millimeters.dxf