eaglecad 0 → 1

data/Gemfile

@@ -1,3 +1,7 @@
 source 'https://rubygems.org'
-
 gemspec
+
+group :test do
+    gem 'rake'
+end
+

data/README.markdown

@@ -0,0 +1,29 @@
+# EagleCAD
+
+[![Build Status](https://travis-ci.org/bfoz/eaglecad-ruby.png)](https://travis-ci.org/bfoz/eaglecad-ruby)
+
+The EagleCAD gem provides tools for working with the files generated by the popular [EagleCAD](http://www.cadsoftusa.com/) PCB design software. 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'eaglecad'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install eaglecad
+
+## Usage
+
+```ruby
+require 'eaglecad'
+
+drawing = EagleCAD.read('my_schematic.sch')
+
+drawing.write('cloned_schematic.sch')
+```

data/Rakefile

@@ -1 +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/eaglecad.gemspec

@@ -4,12 +4,12 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
     spec.name          = "eaglecad"
-    spec.version       = '0'
+    spec.version       = '1'
     spec.authors       = ["Brandon Fosdick"]
     spec.email         = ["bfoz@bfoz.net"]
     spec.description   = %q{Everything you need to bend Eagle CAD projects to your will}
     spec.summary       = %q{Read and write Eagle CAD files}
-    spec.homepage      = "http://github.com/bfoz/ruby-eaglecad"
+    spec.homepage      = "http://github.com/bfoz/eaglecad-ruby"
     spec.license       = "BSD"
 
     spec.files         = `git ls-files`.split($/)
@@ -19,4 +19,6 @@ Gem::Specification.new do |spec|
 
     spec.add_development_dependency "bundler", "~> 1.3"
     spec.add_development_dependency "rake"
+
+    spec.add_dependency 'geometry', '~> 6'
 end

data/lib/eaglecad.rb

@@ -1,3 +1,17 @@
+require 'rexml/document'
+
+require_relative 'eaglecad/drawing'
+
 module EagleCAD
-  # Your code goes here...
+    # Load and parse the given {Schematic} or {Board} file
+    # @return [Drawing]	A new {EagleCAD::Drawing}
+    def self.read(filename)
+	parse(REXML::Document.new File.open(filename))
+    end
+
+    # @param [REXML::Document]	An XML document to parse
+    # @return [Drawing]	A new {EagleCAD::Drawing}, or nil if there was an error
+    def self.parse(document)
+	Drawing.from_xml(document.root.elements['drawing'])
+    end
 end

data/lib/eaglecad/attribute.rb

@@ -0,0 +1,47 @@
+require_relative 'geometry'
+
+module EagleCAD
+    Attribute = Struct.new :name, :value, :origin, :size, :layer_number, :font, :ratio, :rotation, :display, :constant do
+	def self.from_xml(element)
+	    Attribute.new.tap do |attribute|
+		attribute.name = element.attributes['name']
+		attribute.value = element.attributes['value']
+		attribute.origin = Geometry.point_from(element)
+		attribute.size = element.attributes['size']
+		attribute.layer_number = element.attributes['layer']
+		attribute.ratio = element.attributes['ratio'].to_i
+		attribute.rotation = element.attributes['rot']
+
+		element.attributes.each do |name, value|
+		    case name
+			when 'constant'	then attribute.constant = ('yes' == element.attribute['constant'])
+			when 'display'	then attribute.display = value
+			when 'font'	then attribute.font = value
+		    end
+		end
+	    end
+	end
+
+	def initialize
+	    super
+	    @display = 'value'
+	end
+
+	# @return [REXML::Element]
+	def to_xml
+	    REXML::Element.new('attribute').tap do |element|
+		element.add_attribute('name', name)
+		element.add_attribute('value', value)
+		element.add_attribute('x', origin.x)
+		element.add_attribute('y', origin.y)
+		element.add_attribute('size', size)
+		element.add_attribute('layer', layer_number)
+		element.add_attribute('ratio', ratio) unless 0 == ratio
+		element.add_attribute('rot', rotation)
+		element.add_attribute('constant', 'yes') if constant
+		element.add_attribute('display', display)
+		element.add_attribute('font', font)
+	    end
+	end
+    end
+end

data/lib/eaglecad/board.rb

@@ -0,0 +1,184 @@
+require 'rexml/document'
+
+require_relative 'attribute'
+require_relative 'clearance'
+require_relative 'design_rules'
+require_relative 'library'
+
+module EagleCAD
+    class Board
+	attr_accessor :design_rules, :description
+	attr_reader :attributes, :classes, :elements, :libraries, :passes, :plain
+
+	ContactReference = Struct.new :element, :pad, :route, :route_tag
+	Via = Struct.new :origin, :extent, :drill
+
+	class Element
+	    attr_accessor :name, :library, :package, :value, :origin, :locked, :smashed, :rotation
+	    attr_reader :attributes, :variants
+
+	    def self.from_xml(element)
+		self.new(element.attributes['name'], element.attributes['library'], element.attributes['package'], element.attributes['value'], Geometry.point_from(element)).tap do |object|
+		    element.elements.each do |element|
+			case element.name
+			    when 'attribute'
+				object.attributes.push Attribute.from_xml(element)
+			    when 'variant'
+				variants = {}
+				element.attributes.each {|name, value| variants[name] = value }
+				object.variants.push variants
+			    else
+				raise StandardError, "Unrecognized Element element '#{element.name}'"
+			end
+		    end
+		end
+	    end
+
+	    def initialize(name, library, package, value, origin)
+		@name = name
+		@library = library
+		@package = package
+		@value = value
+		@origin = origin
+		@locked = false
+		@smashed = false
+		@rotation = 0
+
+		@attributes = []
+		@variants = []
+	    end
+
+	    # @return [REXML::Element]
+	    def to_xml
+		REXML::Element.new('element').tap do |element|
+		    element.add_attributes({'name' => name, 'library' => library, 'package' => package, 'value' => value, 'x' => origin.x, 'y' => origin.y})
+		    element.add_attribute('rot', "R#{rotation}") if 0 != rotation
+		    element.add_attribute('locked', 'yes') if locked
+		    element.add_attribute('smashed', 'yes') if smashed
+
+		    attributes.each {|attribute| element.add_element attribute.to_xml }
+		    variants.each {|variant| element.add_element('variant', variant)}
+		end
+	    end
+	end
+
+	class Signal
+	    attr_accessor :air_wires_hidden, :clearance_class, :name
+	    attr_reader :contact_references, :vias
+
+	    def self.from_xml(element)
+		self.new(element.attributes['name']).tap do |signal|
+		    element.attributes.each do |name, value|
+			case name
+			    when 'airwireshidden'
+				signal.air_wires_hidden = ('no' != value)
+			    when 'class'
+				signal.clearance_class = value.to_i
+			    when 'name'	# Ignore; already handled
+			    else
+				raise StandardError, "Unrecognized Signal element '#{element.name}'"
+			end
+		    end
+
+		    element.elements.each do |element|
+			case element.name
+			    when 'contactref'
+				signal.contact_references.push ContactReference.new element.attributes['element'], element.attributes['pad'], element.attributes['route'], element.attributes['routetag']
+			    when 'polygon', 'wire'
+				signal.push Geometry.from_xml(element)
+			    when 'via'
+				signal.vias.push Via.new Geometry.from_point(element), element.attributes['extent'], element.attributes['drill']
+			end
+		    end
+		end
+	    end
+
+	    def initialize(name)
+		@contact_references = []
+		@name = name
+		@vias = []
+	    end
+	end
+
+	def self.from_xml(element)
+	    Board.new.tap do |board|
+		element.elements.each do |element|
+		    case element.name
+			when 'attributes'
+			    element.elements.each {|attribute| board.attributes.push Attribute.from_xml(attribute) }
+			when 'autorouter'
+			    element.elements.each do |pass_element|
+				pass = board.passes[pass_element.attributes['name']]
+				pass_element.elements.each {|parameter| pass[parameter.attributes['name']] = parameter.attributes['value'] }
+			    end
+			when 'classes'
+			    element.elements.each {|clearance| board.classes.push Clearance.from_xml(clearance) }
+			when 'description'
+			    board.description = element.text
+			when 'designrules'
+			    board.design_rules = DesignRules.from_xml(element)
+			when 'elements'
+			    element.elements.each {|object| board.elements.push Element.from_xml(object) }
+			when 'libraries'
+			    element.elements.each {|library| board.libraries[library.attributes['name']] = Library.from_xml(library) }
+			when 'plain'
+			    element.elements.each {|object| board.plain.push Geometry.from_xml(object) }
+			when 'signals'
+			when 'variantdefs'
+			else
+			    raise StandardError, "Unrecognized Board element '#{element.name}'"
+		    end
+		end
+	    end
+	end
+
+	def initialize
+	    @attributes = []
+	    @classes = []
+	    @contact_references = []
+	    @elements = []
+	    @libraries = {}
+	    @passes = Hash.new {|hash, key| hash[key] = Hash.new }
+	    @plain = []
+	end
+
+	# @return [REXML::Element]
+	def to_xml
+	    REXML::Element.new('board').tap do |element|
+		element.add_element('attributes').tap do |attribute_element|
+		    attributes.each {|attribute| attribute_element.add_element attribute.to_xml }
+		end
+
+		element.add_element('description').text = description
+
+		element.add_element('autorouter').tap do |autorouter_element|
+		    passes.each do |name, pass|
+			autorouter_element.add_element('pass', {'name' => name}).tap do |pass_element|
+			    pass.each {|name, value| pass_element.add_element('param', {'name' => name, 'value' => value})}
+			end
+		    end
+		end
+
+		element.add_element('classes').tap do |classes_element|
+		    classes.each do |clearance|
+			classes_element.add_element clearance.to_xml
+		    end
+		end
+
+		element.add_element(design_rules.to_xml) if design_rules
+
+		element.add_element('elements').tap do |element_element|
+		    elements.each {|object| element_element.add_element object.to_xml }
+		end
+
+		element.add_element('libraries').tap do |libraries_element|
+		    libraries.each {|name, library| libraries_element.add_element library.to_xml }
+		end
+
+		element.add_element('plain').tap do |plain_element|
+		    plain.each {|object| plain_element.add_element object.to_xml }
+		end
+	    end
+	end
+    end
+end

data/lib/eaglecad/clearance.rb

@@ -0,0 +1,31 @@
+require 'rexml/document'
+
+module EagleCAD
+    class Clearance
+	attr_accessor :name, :number, :width, :drill
+	attr_reader :values
+
+	def self.from_xml(element)
+	    Clearance.new(element.attributes['name'], element.attributes['number'].to_i).tap do |clearance|
+		clearance.width = (element.attributes['width'] || 0).to_f
+		clearance.drill = (element.attributes['drill'] || 0).to_f
+
+		element.elements.each {|element| clearance.values.push (element.text || 0).to_f }
+	    end
+	end
+
+	def initialize(name, number)
+	    @name = name
+	    @number = number
+	    @values = []
+	end
+
+	# @param [REXML::Element]
+	def to_xml
+	    REXML::Element.new('class').tap do |element|
+		element.add_attributes({'name' => name, 'number' => number, 'width' => width, 'drill' => drill})
+		values.each {|value| element.add_element('clearance', {'class' => number, 'value' => value})}
+	    end
+	end
+    end
+end

data/lib/eaglecad/design_rules.rb

@@ -0,0 +1,38 @@
+require 'rexml/document'
+
+module EagleCAD
+    class DesignRules
+	attr_accessor :description, :name
+	attr_reader :parameters
+
+	def self.from_xml(element)
+	    self.new(element.attributes['name']).tap do |rule|
+		element.elements.each do |element|
+		    case element.name
+			when 'description'
+			    rule.description = element.text
+			when 'param'
+			    rule.parameters[element.attributes['name']] = element.attributes['value']
+			else
+			    raise StandardError, "Unrecognized Design Rule element '#{element.name}'"
+		    end
+		end
+	    end
+	end
+
+	def initialize(name)
+	    @name = name
+	    @parameters = {}
+	end
+
+	# @return [REXML::Element]
+	def to_xml
+	    REXML::Element.new('designrules').tap do |element|
+		element.add_attribute 'name', name
+		element.add_element('description').text = description if description
+
+		parameters.each {|key, value| element.add_element('param', {'name' => key, 'value' => value})}
+	    end
+	end
+    end
+end

data/lib/eaglecad/deviceset.rb

@@ -0,0 +1,113 @@
+require 'rexml/document'
+
+require_relative 'geometry'
+
+module EagleCAD
+    class DeviceSet
+	attr_accessor :description, :name, :prefix, :uservalue
+	attr_reader :devices, :gates
+
+	Connect = Struct.new :gate, :pin, :pad, :route do
+	    def self.from_xml(element)
+		Connect.new element.attributes['gate'], element.attributes['pin'], element.attributes['pad'], element.attributes['route']
+	    end
+
+	    # @return [REXML::Element]
+	    def to_xml
+		REXML::Element.new('connect').tap {|element| element.add_attributes({'gate' => gate, 'pad' => pad, 'pin' => pin}) }
+	    end
+	end
+	
+	class Device
+	    attr_accessor :name, :package
+	    attr_reader :connects, :technologies
+
+	    def self.from_xml(element)
+		Device.new(element.attributes['name']).tap do |device|
+		    device.package = element.attributes['package']
+
+		    element.elements.each do |element|
+			case element.name
+			    when 'connects'
+				element.elements.each {|connect| device.connects.push Connect.from_xml(connect) }
+			    when 'technologies'
+				element.elements.each {|technology| device.technologies.push technology.attributes['name'] }
+			end
+		    end
+		end
+	    end
+
+	    def initialize(name)
+		@connects = []
+		@name = name
+		@technologies = []
+	    end
+
+	    # Generate XML for the {DeviceSet} element
+	    # @return [REXML::Element]
+	    def to_xml
+		REXML::Element.new('device').tap do |element|
+		    element.add_attributes({'name' => name, 'package' => package})
+
+		    connects_element = element.add_element('connects')
+		    connects.each {|connect| connects_element.add_element connect.to_xml }
+
+		    technologies_element = element.add_element('technologies')
+		    technologies.each {|technology| technologies_element.add_element('technology', {'name' => technology}) }
+		end
+	    end
+	end
+
+	Gate = Struct.new :name, :symbol, :origin, :addlevel, :swaplevel do
+	    def self.from_xml(element)
+		Gate.new element.attributes['name'], element.attributes['symbol'], Geometry.point_from(element, 'x', 'y'), element.attributes['addlevel'], element.attributes['swaplevel']
+	    end
+
+	    # @return [REXML::Element]
+	    def to_xml
+		REXML::Element.new('gate').tap {|element| element.add_attributes({'name' => name, 'symbol' => symbol, 'x' => origin.x, 'y' => origin.y, 'addlevel' => addlevel, 'swaplevel' => swaplevel}) }
+            end
+	end
+
+	# Create a new {DeviceSet} from an {REXML::Element}
+	# @param [Element] element  The {REXML::Element} to parse
+	def self.from_xml(element)
+	    DeviceSet.new(element.attributes['name']).tap do |deviceset|
+		deviceset.prefix = element.attributes['prefix']
+		deviceset.uservalue = ('yes' == element.attributes['uservalue'])
+
+		element.elements.each do |element|
+		    case element.name
+			when 'devices'
+			    element.elements.each {|device| deviceset.devices.push Device.from_xml(device) }
+			when 'description'
+			    deviceset.description = element.text
+			when 'gates'
+			     element.elements.each {|gate| deviceset.gates.push Gate.from_xml(gate) }
+		    end
+		end
+	    end
+	end
+
+	def initialize(name)
+	    @devices = []
+	    @gates = []
+	    @name = name
+	end
+
+	# Generate XML for the {DeviceSet} element
+	# @return [REXML::Element]
+	def to_xml
+	    REXML::Element.new('deviceset').tap do |element|
+		element.add_attributes({'name' => name, 'prefix' => prefix, 'uservalue' => (uservalue ? 'yes' : 'no')})
+		element.add_element('description').text = description
+
+		gates_element = element.add_element('gates')
+		gates.each {|gate| gates_element.add_element gate.to_xml }
+
+		devices_element = element.add_element('devices')
+		devices.each {|device| devices_element.add_element device.to_xml }
+	    end
+	end
+    end
+end