eaglecad 0 → 1

data/lib/eaglecad/drawing.rb

@@ -0,0 +1,124 @@
+require 'rexml/document'
+
+require_relative 'board'
+require_relative 'layer'
+require_relative 'schematic'
+
+module EagleCAD
+    class Drawing
+	attr_accessor :board, :schematic
+	attr_reader :layers
+
+	# Grid attributes
+	attr_accessor :distance, :unitdistance, :unit, :style, :multiple, :display, :altdistance, :altunitdist, :altunit
+
+	# Settings attributes
+	attr_accessor :always_vector_font, :vertical_text
+
+	# @param element [REXML::Element]
+	def self.from_xml(element)
+	    self.new.tap do |drawing|
+		element.elements.each do |element|
+		    case element.name
+			when 'board'
+			    raise StandardError, "Drawing files must contain only one Board element" if drawing.board
+			    drawing.board = Board.from_xml(element)
+
+			when 'grid'
+			    element.attributes.each do |name, value|
+				case name
+				    when 'altdistance'  then drawing.altdistance = value.to_f
+				    when 'altunit'	then drawing.altunit = value.to_sym
+				    when 'altunitdist'  then drawing.altunitdist = value.to_sym
+				    when 'display'	then drawing.display = ('no' != value)
+				    when 'distance'	then drawing.distance = value.to_f
+				    when 'unit'		then drawing.unit = value.to_sym
+				    when 'unitdist'	then drawing.unitdistance = value.to_sym
+				    when 'multiple'	then drawing.multiple = value.to_i
+				    when 'style'	then drawing.style = value.to_sym
+				end
+			    end
+
+			when 'layers'
+			    element.elements.each {|element| drawing.layers.push Layer.from_xml(element) }
+
+			when 'schematic'
+			    raise StandardError, "Drawing files must contain only one Schematic element" if drawing.schematic
+			    drawing.schematic = Schematic.from_xml(element)
+
+			when 'settings'
+			    element.elements.each do |element|
+				element.attributes.each do |name, value|
+				    case name
+					when 'alwaysvectorfont' then drawing.always_vector_font = ('no' != value)
+					when 'verticaltext'	    then drawing.vertical_text = value.to_sym
+				    end
+				end
+			    end
+
+			else
+			    raise StandardError, "Unrecognized Drawing element '#{element.name}'"
+		    end
+		end
+	    end
+	end
+
+	def initialize()
+	    @layers = []
+	    self.vertical_text = :up
+
+	    self.display = false
+	    self.multiple = 1
+	    self.style = :lines
+	end
+
+	# Generate XML for the {Drawing} element
+	# @return [REXML::element]
+	def to_xml
+	    drawing_element = REXML::Element.new 'drawing'
+
+	    settings = REXML::Element.new 'settings', drawing_element
+	    settings.add_element 'setting', {'alwaysvectorfont' => (always_vector_font ? 'yes' : 'no')}
+	    settings.add_element 'setting', {'verticaltext' => vertical_text}
+
+	    grid_element = REXML::Element.new 'grid', drawing_element
+	    grid_element.add_attributes({   'altdistance'   => altdistance,
+					    'altunit'	    => altunit,
+					    'altunitdist'   => altunitdist,
+					    'display'	    => (display ? 'yes' : 'no'),
+					    'distance'	    => distance,
+					    'multiple'	    => multiple,
+					    'unit'	    => unit,
+					    'unitdist'	    => unitdistance,
+					    'style'	    => style,
+					 })
+
+	    layers_element = REXML::Element.new 'layers', drawing_element
+	    layers.each {|layer| layers_element.add_element layer.to_xml }
+
+	    drawing_element.add_element(board.to_xml) if board
+	    drawing_element.add_element(schematic.to_xml) if schematic
+
+	    drawing_element
+	end
+
+	# @param filename [String] The path to write the output to
+	def write(output)
+	    document = REXML::Document.new('<?xml version="1.0" encoding="utf-8"?><!DOCTYPE eagle SYSTEM "eagle.dtd">')
+
+	    eagle = REXML::Element.new('eagle')
+	    eagle.add_attribute('version', '6.0')
+	    eagle.add_element to_xml
+	    document.add eagle
+
+	    output = File.open(output, 'w') if output.is_a? String
+
+	    # This is a hack to force REXML to output PCDATA text inline with the enclosing element. Eagle has problems with the extra newlines that REXML tends to add.
+	    formatter = REXML::Formatters::Pretty.new(0)
+	    formatter.compact = true
+	    formatter.write(document, output)
+
+	    output.close
+	end
+    end
+end

data/lib/eaglecad/geometry.rb

@@ -0,0 +1,259 @@
+require 'rexml/document'
+
+require 'geometry'
+
+module EagleCAD
+    module Geometry
+	Point = ::Geometry::Point
+
+	class Circle < ::Geometry::Circle
+	    attr_accessor :line_width
+
+	    # Create a {Circle} from an {REXML::Element}
+	    # @param [Element] element	The {REXML::Element} to parse
+	    def self.from_xml(element)
+		self.new center:Geometry.point_from(element, 'x', 'y'), radius:element.attributes['radius'].to_f, line_width:element.attributes['width'].to_f
+	    end
+
+	    def initialize(options={})
+		@line_width = options.delete(:line_width)
+		super options[:center], options[:radius]
+	    end
+
+	    # @return [REXML::Element]
+	    def to_xml
+		REXML::Element.new('circle').tap {|element| element.add_attributes({'x' => Geometry.format(center.x), 'y' => Geometry.format(center.y), 'radius' => Geometry.format(radius), 'width' => line_width}) }
+	    end
+	end
+
+	Hole = Struct.new :origin, :drill do
+	    def self.from_xml(element)
+		Geometry::Hole.new Geometry.point_from(element, 'x', 'y'), element.attributes['drill']
+	    end
+
+	    # @return [REXML::Element]
+	    def to_xml
+		REXML::Element.new('hole').tap {|element| element.add_attributes({'x' => Geometry.format(origin.x), 'y' => Geometry.format(origin.y), 'drill' => drill}) }
+	    end
+	end
+
+	class Line < ::Geometry::TwoPointLine
+	    attr_accessor :cap, :curve, :line_width
+
+	    # Create a {Line} from an {REXML::Element}
+	    # @param [Element] element	The {REXML::Element} to parse
+	    def self.from_xml(element)
+	    self.new(from:Geometry.point_from(element, 'x1', 'y1'), to:Geometry::point_from(element, 'x2', 'y2'), line_width:element.attributes['width'].to_f, cap: element.attributes['cap'], curve: element.attributes['curve'].to_f)
+	    end
+
+	    def initialize(options={})
+		@cap = options.delete :cap
+		@curve = options.delete :curve
+		@line_width = options.delete(:line_width)
+		super options[:from], options[:to]
+	    end
+
+	    # @return [REXML::Element]
+	    def to_xml
+		REXML::Element.new('wire').tap do |element|
+		    element.add_attributes({'x1' => Geometry.format(first.x), 'y1' => Geometry.format(first.y), 'x2' => Geometry.format(last.x), 'y2' => Geometry.format(last.y), 'width' => line_width})
+		    element.add_attribute('cap', cap) unless 'round' == cap
+		    element.add_attribute('curve', curve) unless  0 == curve
+		end
+	    end
+	end
+
+	Pad = Struct.new :diameter, :drill, :name, :origin, :rotation, :shape do
+	    def self.from_xml(element)
+		origin = Geometry.point_from(element, 'x', 'y')
+		Geometry::Pad.new(element.attributes['diameter'], element.attributes['drill'], element.attributes['name'], origin, element.attributes['rot'], element.attributes['shape'])
+	    end
+
+	    # @return [REXML::Element]
+	    def to_xml
+		REXML::Element.new('pad').tap do |element|
+		    element.add_attributes({'name' => name, 'x' => Geometry.format(origin.x), 'y' => Geometry.format(origin.y), 'diameter' => diameter, 'drill' => drill, 'shape' => shape})
+		    element.add_attribute('rot', rotation) unless 'R0' == rotation
+		end
+	    end
+	end
+
+	Pin = Struct.new :direction, :function, :length, :name, :origin, :swaplevel, :rotation, :visible do
+	    def self.from_xml(element)
+		origin = Geometry.point_from(element, 'x', 'y')
+		Geometry::Pin.new(element.attributes['direction'], element.attributes['function'], element.attributes['length'], element.attributes['name'], origin, element.attributes['swaplevel'], element.attributes['rot'], element.attributes['visible'])
+	    end
+
+	    # @return [REXML::Element]
+	    def to_xml
+		REXML::Element.new('pin').tap do |element|
+		    element.add_attributes({'name' => name,
+					    'x' => Geometry.format(origin.x),
+					    'y' => Geometry.format(origin.y),
+					    'direction' => direction,
+					    'function' => function,
+					    'length' => length,
+					    'swaplevel' => swaplevel,
+					    'rot' => rotation,
+					    'visible' => visible})
+		end
+	    end
+	end
+
+	class Polygon < ::Geometry::Polygon
+	    attr_accessor :line_width
+
+	    # Create a {Polygon} from an {REXML::Element}
+	    # @param [Element] element	The {REXML::Element} to parse
+	    def self.from_xml(element)
+		width = element.attributes['width']
+		vertices = element.elements.map {|vertex| Geometry::point_from(vertex, 'x', 'y') }
+		self.new(*vertices, line_width:width)
+	    end
+
+	    def initialize(*args)
+		options, args = args.partition {|a| a.is_a? Hash}
+		options = options.reduce({}, :merge)
+
+		@line_width = options.delete(:line_width)
+
+		super *args
+	    end
+
+	    # @return [REXML::Element]
+	    def to_xml
+		REXML::Element.new('polygon').tap do |element|
+		    element.add_attribute 'width', line_width
+		    vertices.each {|vertex| element.add_element('vertex', {'x' => Geometry.format(vertex.x), 'y' => Geometry.format(vertex.y)}) }
+		end
+	    end
+	end
+
+	class Rectangle < ::Geometry::Rectangle
+	    # Create a {Rectangle} from an {REXML::Element}
+	    # @param [Element] element	The {REXML::Element} to parse
+	    def self.from_xml(element)
+		first = Geometry.point_from(element, 'x1', 'y1')
+		last = Geometry.point_from(element, 'x2', 'y2')
+		self.new(first, last)
+	    end
+
+	    # @return [REXML::Element]
+	    def to_xml
+		REXML::Element.new('rectangle').tap {|element| element.add_attributes({'x1' => Geometry.format(origin.x),
+										       'y1' => Geometry.format(origin.y),
+										       'x2' => Geometry.format(max.x),
+										       'y2' => Geometry.format(max.y)}) }
+	    end
+	end
+
+	class SMD < ::Geometry::SizedRectangle
+	    attr_accessor :cream, :name, :roundness, :rotation, :stop, :thermals
+
+	    # Create a {SMD} from an {REXML::Element}
+	    # @param [Element] element	The {REXML::Element} to parse
+	    def self.from_xml(element)
+		size = Size[element.attributes['dx'].to_f, element.attributes['dy'].to_f]
+		SMD.new(origin:Geometry.point_from(element, 'x', 'y'), size:size).tap do |smd|
+		    smd.cream = ('no' != element.attributes['cream'])
+		    smd.name = element.attributes['name']
+		    smd.rotation = element.attributes['rot']
+		    smd.roundness = element.attributes['roundness'].to_i
+		    smd.stop = ('no' != element.attributes['stop'])
+		    smd.thermals = ('no' != element.attributes['thermals'])
+		end
+	    end
+
+	    # @return [REXML::Element]
+	    def to_xml
+		REXML::Element.new('smd').tap do |element|
+		    element.add_attributes({'name' => name,
+					    'x' => Geometry.format(origin.x),
+					    'y' => Geometry.format(origin.y),
+					    'dx' => Geometry.format(size.width),
+					    'dy' => Geometry.format(size.height)})
+		    element.add_attribute('cream', 'no') unless cream
+		    element.add_attribute('rot', rotation) if rotation
+		    element.add_attribute('roundness', Geometry.format(roundness)) unless 0 == roundness
+		    element.add_attribute('stop', 'no') unless stop
+		    element.add_attribute('thermals', 'no') unless thermals
+		end
+	    end
+	end
+
+	class Text
+	    attr_accessor :align, :distance, :origin, :font, :layer, :ratio, :rotation, :size, :text
+
+	    def self.from_xml(element)
+		Geometry::Text.new(Geometry.point_from(element, 'x', 'y'), element.attributes['layer'], element.attributes['size'].to_f, element.text).tap do |object|
+		    object.align = element.attributes['align'] || object.align
+		    object.distance = element.attributes['distance'] || object.distance
+		    object.font = element.attributes['font'] || object.font
+		    object.ratio = element.attributes['ratio'] || object.ratio
+		    object.rotation = element.attributes['rot'] || object.rotation
+		end
+	    end
+
+	    def initialize(origin, layer, size, text, options={})
+		@origin = origin
+		@layer = layer
+		@size = size
+		@text = text
+
+		@align = options['align'] || 'bottom-left'
+		@distance = options['distance'] || 50
+		@font = options['font'] || 'proportional'
+		@ratio = options['ratio'] || 8
+		@rotation = options['rot'] || 'R0'
+	    end
+
+	    # @return [REXML::Element]
+	    def to_xml
+		REXML::Element.new('text').tap do |element|
+		    element.add_attributes({'x' => Geometry.format(origin.x), 'y' => Geometry.format(origin.y), 'layer' => layer, 'size' => Geometry.format(size)})
+		    element.add_attribute('align', align)
+		    element.add_attribute('distance', distance)
+		    element.add_attribute('font', font)
+		    element.add_attribute('ratio', ratio)
+		    element.add_attribute('rot', rotation)
+		    element.text = text
+		end
+	    end
+	end
+
+	def self.from_xml(element)
+	    case element.name
+		when 'circle'
+		    Geometry::Circle.from_xml(element)
+		when 'hole'
+		    Geometry::Hole.from_xml(element)
+		when 'pad'
+		    Geometry::Pad.from_xml(element)
+		when 'pin'
+		    Geometry::Pin.from_xml(element)
+		when 'polygon'
+		    Geometry::Polygon.from_xml(element)
+		when 'rectangle'
+		    Geometry::Rectangle.from_xml(element)
+		when 'smd'
+		    Geometry::SMD.from_xml(element)
+		when 'text'
+		    Geometry::Text.from_xml(element)
+		when 'wire'
+		    Geometry::Line.from_xml(element)
+	    end
+	end
+
+	# Create a {Point} from the given {REXML::Element} using the passed attribute names
+	# @param [REXML::Element] element  The {REXML::Element} to parse
+	# @param [String] x_name    The name of the attribute containing the X coordinate
+	# @param [String] y_name    The name of the attribute containing the Y coordinate
+	def self.point_from(element, x_name='x', y_name='y')
+	    Point[element.attributes[x_name].to_f, element.attributes[y_name].to_f]
+	end
+
+	def self.format(value)
+	    "%g" % value
+	end
+    end
+end

data/lib/eaglecad/layer.rb

@@ -0,0 +1,40 @@
+require 'rexml/document'
+
+module EagleCAD
+    class Layer
+	attr_accessor :active, :color, :fill, :name, :number, :visible
+
+	def self.from_xml(element)
+	    self.new(element.attributes['name'], element.attributes['number'], element.attributes['color'], element.attributes['fill']).tap do |layer|
+		element.attributes.each do |name, value|
+		    case name
+			when 'active'	then layer.active = ('no' != value)
+			when 'visible'	then layer.visible = ('no' != value)
+		    end
+		end
+	    end
+	end
+
+	def initialize(name, number, color, fill)
+	    @active = true
+	    @color = color
+	    @fill = fill
+	    @name = name
+	    @number = number
+	    @visible = true
+	end
+
+	# @return [REXML::Element]
+	def to_xml
+	    element = REXML::Element.new 'layer'
+	    element.add_attributes({'number' => number,
+				    'name' => name,
+				    'color' => color,
+				    'fill' => fill,
+				   })
+	    element.add_attribute('active', active ? 'yes' : 'no')
+	    element.add_attribute('visible', visible ? 'yes' : 'no')
+	    element
+	end
+    end
+end

data/lib/eaglecad/library.rb

@@ -0,0 +1,73 @@
+require 'rexml/document'
+
+require_relative 'deviceset'
+require_relative 'package'
+require_relative 'symbol'
+
+module EagleCAD
+    class Library
+	attr_accessor :description, :name, :packages, :symbols, :device_sets
+
+	# Create a new {Library} from an {REXML::Element}
+	# @param [REXML::Element] element	The {REXML::Element} to parse
+	def self.from_xml(element)
+	    Library.new(name:element.attributes['name']).tap do |library|
+		library.description = element.elements['description']
+
+		element.elements.each do |element|
+		    case element.name
+			when 'devicesets'
+			    element.elements.each {|symbol| library.push DeviceSet.from_xml(symbol) }
+			when 'packages'
+			    element.elements.each {|package| library.push Package.from_xml(package) }
+			when 'symbols'
+			    element.elements.each {|symbol| library.push Symbol.from_xml(symbol) }
+		    end
+		end
+	    end
+	end
+
+	def initialize(options={})
+	    options.each {|k,v| send("#{k}=", v) }
+
+	    @device_sets = []
+	    @packages = {}
+	    @symbols = []
+	end
+
+	def push(arg)
+	    case arg
+		when DeviceSet
+		    @device_sets.push arg
+		when Package
+		    @packages[arg.name] = arg
+		when Symbol
+		    @symbols.push arg
+	    end
+	end
+
+	# Generate XML for the {Library} element
+	# @return [REXML::Element]
+	def to_xml
+	    REXML::Element.new('library').tap do |element|
+		element.add_attribute 'name', name
+
+		# Packages must be output before devicesets or Eagle will fail to load the file
+		element.add_element('packages').tap do |packages_element|
+		    packages.each {|name, package| packages_element.add_element package.to_xml }
+		end
+
+		# Symbols must be output before devicessets or Eagle will fail to load the file
+		element.add_element('symbols').tap do |symbols_element|
+		    symbols.each {|symbol| symbols_element.add_element symbol.to_xml }
+		end
+
+		if device_sets and device_sets.count
+		    element.add_element('devicesets').tap do |devicesets_element|
+			device_sets.each {|deviceset| devicesets_element.add_element deviceset.to_xml }
+		    end
+		end
+	    end
+	end
+    end
+end