eaglecad 0 → 1

data/lib/eaglecad/package.rb

@@ -0,0 +1,74 @@
+require 'rexml/document'
+
+require_relative 'geometry'
+
+module EagleCAD
+    Point = ::Geometry::Point
+    Size = ::Geometry::Size
+
+    class Package
+	attr_accessor :name, :description
+	attr_reader :holes, :layers, :pads
+
+	# Create a new {Package} from an {REXML::Element}
+	# @param [REXML::Element] element	The {REXML::Element} to parse
+	def self.from_xml(element)
+	    package = Package.new element.attributes['name']
+
+	    element.elements.each do |element|
+		layer_number = element.attributes['layer'].to_i if element.attributes.has_key?('layer')
+		case element.name
+		    when 'description'
+			package.description = element.text
+		    when 'hole'
+			package.holes.push Geometry::Hole.from_xml(element)
+		    when 'pad'
+			package.pads.push Geometry::Pad.from_xml(element)
+		    else
+			g = Geometry.from_xml(element)
+			if g
+			    package.push layer_number, g
+			else
+			    raise StandardError, "Unrecognized package element '#{element.name}'"
+			end
+		end
+	    end
+
+	    package
+	end
+
+	# @param [String] name	The name of the {Package}
+	def initialize(name)
+	    @holes = []
+	    @layers = {}
+	    @layers.default_proc = proc {|hash, key| hash[key] = []}
+	    @name = name
+	    @pads = []
+	end
+
+	# Push a new element to the given layer number
+	# @param [Numeric] layer_number	The layer to add the element to
+	# @param [Object] element   The thing to push
+	def push(layer_number, element)
+	    layer = @layers[layer_number]
+	    layer.push element
+	end
+
+	# Generate XML for the {Package} element
+	# @return [REXML::Element]
+	def to_xml
+	    REXML::Element.new('package').tap do |element|
+		element.add_attribute('name', name)
+		element.add_element('description').text = description
+
+		holes.each {|hole| element.add_element hole.to_xml }
+		pads.each {|pad| element.add_element pad.to_xml }
+
+		layers.each do |number, layer|
+		    layer.each {|obj| element.add_element(obj.to_xml, {'layer' => number}) }
+		end
+	    end
+	end
+
+    end
+end

data/lib/eaglecad/part.rb

@@ -0,0 +1,29 @@
+require 'rexml/document'
+
+module EagleCAD
+    class Part
+	attr_accessor :name, :library, :deviceset, :device, :technology, :value
+
+	def self.from_xml(element)
+	    Part.new(element.attributes['name'], element.attributes['library'], element.attributes['deviceset'], element.attributes['device']).tap do |part|
+		part.technology = element.attributes['technology'] if element.attributes['technology']
+		part.value = element.attributes['value'] if element.attributes['value']
+	    end
+	end
+
+	def initialize(name, library, deviceset, device)
+	    @name = name
+	    @library = library
+	    @deviceset = deviceset
+	    @device = device
+	    @technology = ''
+	end
+
+	def to_xml
+	    REXML::Element.new('part').tap do |element|
+		element.add_attributes({'name' => name, 'library' => library, 'deviceset' => deviceset, 'device' => device, 'technology' => technology})
+		element.add_attribute('value', value) if value
+	    end
+	end
+    end
+end

data/lib/eaglecad/schematic.rb

@@ -0,0 +1,83 @@
+require 'rexml/document'
+
+require_relative 'attribute'
+require_relative 'clearance'
+require_relative 'geometry'
+require_relative 'library'
+require_relative 'part'
+require_relative 'sheet'
+
+module EagleCAD
+    class Schematic
+	attr_accessor :description
+	attr_reader :attributes, :classes, :libraries, :parts, :sheets
+
+	# Create a new {Schematic} from an {REXML::Element}
+	# @param [REXML::Element] element	The {REXML::Element} to parse
+    	def self.from_xml(element)
+	    Schematic.new.tap do |schematic|
+		element.elements.each do |element|
+		    case element.name
+			when 'attributes'
+			    element.elements.each {|attribute| schematic.attributes.push Attribute.from_xml(attribute) }
+			when 'classes'
+			    element.elements.each {|clearance| schematic.classes.push Clearance.from_xml(clearance) }
+			when 'description'
+			    schematic.description = element.text
+			when 'libraries'
+			    element.elements.each {|library| schematic.libraries[library.attributes['name']] = Library.from_xml(library) }
+			when 'parts'
+			    element.elements.each {|part| schematic.parts.push Part.from_xml(part) }
+			when 'sheets'
+			    element.elements.each {|sheet| schematic.sheets.push Sheet.from_xml(sheet) }
+			when 'variantdefs'
+			else
+			    raise StandardError, "Unrecognized element '#{element.name}'"
+		    end
+		end
+	    end
+	end
+
+	def initialize
+	    @attributes = []
+	    @classes = []
+	    @libraries = {}
+	    @parts = []
+	    @sheets = []
+	end
+
+	# Generate XML for the {Schematic} element
+	# @return [REXML::Element]
+	def to_xml
+	    REXML::Element.new('schematic').tap do |element|
+		element.add_element('description').text = description if description
+
+		# Libraries must be output before parts or Eagle will fail to load the file
+		element.add_element('libraries').tap do |libraries_element|
+		    libraries.each do |name, library|
+			libraries_element.add_element library.to_xml
+		    end
+		end
+
+		REXML::Element.new('attributes').tap do |attributes_element|
+		    attributes.each {|attribute| attributes_element.add_element attribute.to_xml }
+		    element.add_element(attributes_element) if attributes_element.has_elements?
+		end
+
+		element.add_element('variantdefs')
+
+		element.add_element('classes').tap do |classes_element|
+		    classes.each {|object| classes_element.add_element object.to_xml }
+		end
+
+		element.add_element('parts').tap do |parts_element|
+		    parts.each {|part| parts_element.add_element part.to_xml }
+		end
+
+		element.add_element('sheets').tap do |sheets_element|
+		    sheets.each {|sheet| sheets_element.add_element sheet.to_xml }
+		end
+	    end
+	end
+    end
+end

data/lib/eaglecad/sheet.rb

@@ -0,0 +1,256 @@
+require_relative 'attribute'
+require_relative 'geometry'
+
+module EagleCAD
+    class Sheet
+	attr_accessor :description
+	attr_reader :busses, :instances, :nets
+
+	PinReference = Struct.new :part, :gate, :pin do
+	    def self.from_xml(element)
+		Sheet::PinReference.new element.attributes['part'], element.attributes['gate'], element.attributes['pin']
+	    end
+
+	    def to_xml
+		REXML::Element.new('pinref').tap do |element|
+		    element.add_attributes('gate' => gate, 'part' => part, 'pin' => pin)
+		end
+	    end
+	end
+
+	class Bus
+	    attr_accessor :name
+	    attr_reader :segments
+
+	    def self.from_xml(element)
+		Bus.new(element.attributes['name']).tap do |bus|
+		    element.elements.each {|segment| bus.segments.push Segment.from_xml(segment) }
+		end
+	    end
+
+	    def initialize(name)
+		@name = name
+		@segments = []
+	    end
+
+	    def to_xml
+		REXML::Element.new('bus').tap do |element|
+		    element.add_attribute 'name', name
+		    segments.each {|segment| element.add_element segment.to_xml }
+		end
+	    end
+	end
+
+	class Instance
+	    attr_accessor :part, :gate, :origin, :smashed, :rotation
+	    attr_reader :attributes
+
+	    def self.from_xml(element)
+		Instance.new(element.attributes['part'], element.attributes['gate'], Geometry.point_from(element)).tap do |instance|
+		    element.attributes.each do |name, value|
+			case name
+			    when 'smashed'  then instance.smashed = ('no' != element.attributes['smashed'])
+			    when 'rot'	    then instance.rotation = element.attributes['rot']
+			    when 'part', 'gate', 'x', 'y'	# Ignore; already handled
+			    else
+				raise StandardError, "Unrecognized Instance attribute '#{name}'"
+			end
+		    end
+
+		    element.elements.each {|attribute| instance.attributes.push Attribute.from_xml(attribute) }
+		end
+	    end
+
+	    def initialize(part, gate, origin)
+		@attributes = []
+		@part = part
+		@gate = gate
+		@origin = origin
+		@smashed = false
+		@rotation = 'R0'
+	    end
+
+	    def to_xml
+		REXML::Element.new('instance').tap do |element|
+		    element.add_attributes({'part' => part, 'gate' => gate, 'x' => origin.x, 'y' => origin.y})
+		    element.add_attribute('smashed', 'yes') if smashed
+		    element.add_attribute('rot', rotation)
+
+		    attributes.each {|attribute| element.add_element attribute.to_xml }
+		end
+	    end
+	end
+
+	class Label
+	    attr_accessor :origin, :size, :layer_number, :font, :ratio, :rotation, :cross_reference
+
+	    def self.from_xml(element)
+		Label.new(Geometry.point_from(element), element.attributes['size'].to_f, element.attributes['layer'].to_i).tap do |label|
+		    element.attributes.each do |name, value|
+			case name
+			    when 'font'	    then label.font = value.to_sym
+			    when 'ratio'    then label.ratio = value.to_i
+			    when 'rot'	    then label.rotation = value
+			    when 'xref'	    then label.cross_reference = ('no' != value)
+			end
+		    end
+		end
+	    end
+
+	    def initialize(origin, size, layer_number)
+		@origin = origin
+		@size = size
+		@layer_number = layer_number
+		@font = :proportional
+		@ratio = 8
+		@rotation = 'R0'
+		@cross_reference = false
+	    end
+
+	    def to_xml
+		REXML::Element.new('label').tap do |element|
+		    element.add_attributes({'x' => origin.x, 'y' => origin.y, 'layer' => layer_number ,'size' => size})
+		    element.add_attribute('font', font)
+		    element.add_attribute('ratio', ratio) unless 8 == ratio
+		    element.add_attribute('rot', rotation)
+		    element.add_attribute('xref', cross_reference) if cross_reference
+		end
+	    end
+	end
+
+	class Net
+	    attr_accessor :clearance_class, :name
+	    attr_reader :segments
+
+	    def self.from_xml(element)
+		Net.new(element.attributes['name'], element.attributes['class'].to_i).tap do |net|
+		    element.elements.each {|segment| net.segments.push Segment.from_xml(segment) }
+		end
+	    end
+
+	    def initialize(name, clearance_class)
+		@clearance_class = clearance_class
+		@name = name
+		@segments = []
+	    end
+
+	    def to_xml
+		REXML::Element.new('net').tap do |element|
+		    element.add_attribute('name', name)
+		    element.add_attribute('class', clearance_class) unless 0 == clearance_class
+
+		    segments.each {|segment| element.add_element segment.to_xml }
+		end
+	    end
+	end
+
+	class Segment
+	    attr_reader :elements, :layers
+
+	    def self.from_xml(element)
+		Segment.new.tap do |segment|
+		    element.elements.each do |element|
+			case element.name
+			    when 'junction'
+				segment.elements.push Geometry.point_from(element)
+			    when 'label'
+				segment.push element.attributes['layer'], Label.from_xml(element)
+			    when 'pinref'
+				segment.elements.push PinReference.from_xml(element)
+			    when 'wire'
+				segment.push element.attributes['layer'], Geometry::Line.from_xml(element)
+			    else
+				raise StandardError, "Unrecognized Segment element '#{element.name}"
+			end
+		    end
+		end
+	    end
+
+	    def initialize
+		@elements = []
+		@layers = {}
+		@layers.default_proc = proc {|hash, key| hash[key] = []}
+	    end
+
+	    # Push a new element to the given layer number
+	    # @param [Numeric] layer_number	The layer to add the element to
+	    # @param [Object] element   The thing to push
+	    def push(layer_number, element)
+		layer = @layers[layer_number]
+		layer.push element
+	    end
+
+	    def to_xml
+		REXML::Element.new('segment').tap do |element|
+		    elements.each do |object|
+			if object.is_a? Point
+			    element.add_element('junction', {'x' => object.x, 'y' => object.y})
+			else
+			    element.add_element object.to_xml
+			end
+		    end
+
+		    layers.each do |number, layer|
+			layer.each {|obj| element.add_element(obj.to_xml, {'layer' => number}) }
+		    end
+		end
+	    end
+	end
+
+	def self.from_xml(element)
+	    Sheet.new.tap do |sheet|
+		element.elements.each do |element|
+		    case element.name
+			when 'busses'
+			    element.elements.each {|bus| sheet.push Bus.from_xml(bus) }
+			when 'description'
+			    sheet.description = element.text
+			when 'instances'
+			    element.elements.each {|instance| sheet.push Instance.from_xml(instance) }
+			when 'nets'
+			    element.elements.each {|part| sheet.push Net.from_xml(part) }
+			when 'plain' #Ignore
+			else
+			    raise StandardError, "Unrecognized Sheet element '#{element.name}'"
+		    end
+		end
+	    end
+	end
+
+	def initialize
+	    @busses = []
+	    @instances = []
+	    @nets = []
+	    @parts = []
+	end
+
+	# Add the passed {Sheet} element to the {Sheet}
+	def push(arg)
+	    case arg
+		when Bus	then busses.push arg
+		when Instance	then instances.push arg
+		when Net	then nets.push arg
+		else
+		    raise ArgumentError, "Unrecognized object '#{arg.class}'"
+	    end
+	end
+
+	def to_xml
+	    REXML::Element.new('sheet').tap do |element|
+		element.add_element('description').text = description
+
+		element.add_element('instances').tap do |instances_element|
+		    instances.each {|instance| instances_element.add_element instance.to_xml }
+		end
+
+		element.add_element('busses').tap do |busses_element|
+		    busses.each {|bus| busses_element.add_element bus.to_xml }
+		end
+
+		element.add_element('nets').tap do |nets_element|
+		    nets.each {|net| nets_element.add_element net.to_xml }
+		end
+	    end
+	end
+    end
+end

data/lib/eaglecad/symbol.rb

@@ -0,0 +1,73 @@
+require 'rexml/document'
+
+require_relative 'geometry'
+
+module EagleCAD
+    class Symbol
+	attr_accessor :name, :description
+	attr_reader :layers, :pins
+
+	# Create a new {Symbol} from an {REXML::Element}
+	# @param [Element] element  The {REXML::Element} to parse
+	def self.from_xml(element)
+	    symbol = Symbol.new element.attributes['name']
+
+	    element.elements.each do |element|
+		layer_number = element.attributes['layer'].to_i if element.attributes.has_key?('layer')
+		case element.name
+		    when 'circle'
+			symbol.push layer_number, Geometry::Circle.from_xml(element)
+		    when 'description'
+			symbol.description = element.text
+		    when 'pin'
+			symbol.pins.push Geometry::Pin.from_xml(element)
+		    when 'polygon'
+			symbol.push layer_number, Geometry::Polygon.from_xml(element)
+		    when 'rectangle'
+			symbol.push layer_number, Geometry::Rectangle.from_xml(element)
+		    when 'smd'
+			symbol.push layer_number, Geometry::SMD.from_xml(element)
+		    when 'text'
+			symbol.push layer_number, Geometry::Text.from_xml(element)
+		    when 'wire'
+			symbol.push layer_number, Geometry::Line.from_xml(element)
+		    else
+			raise StandardError, "Unrecognized symbol element '#{element.name}'"
+		end
+	    end
+
+	    symbol
+	end
+
+	# @param [String] name	The name of the {Package}
+	def initialize(name)
+	    @layers = {}
+	    @layers.default_proc = proc {|hash, key| hash[key] = []}
+	    @name = name
+	    @pins = []
+	end
+
+	# Push a new element to the given layer number
+	# @param [Numeric] layer_number	The layer to add the element to
+	# @param [Object] element   The thing to push
+	def push(layer_number, element)
+	    layer = @layers[layer_number]
+	    layer.push element
+	end
+
+	# Generate XML for the {Symbol} element
+	# @return [REXML::Element]
+	def to_xml
+	    REXML::Element.new('symbol').tap do |element|
+		element.add_attribute 'name', name
+		element.add_element('description').text = description if description
+
+		pins.each {|pin| element.add_element pin.to_xml }
+
+		layers.each do |number, layer|
+		    layer.each {|obj| element.add_element(obj.to_xml, {'layer' => number}) }
+		end
+	    end
+	end
+    end
+end