kicad 0.8.0 → 0.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ea6528c30596177b5286780246f20331ff0a82109b527d0c311e5aca88d6b42
-  data.tar.gz: b439278fbd1dd60ff5f931f67d7f6009517b179937b16cf0998de12beb3d8e1e
+  metadata.gz: 2a91d99c4c831dbc121717ef0609e05c8fe07c20d1b2044bfddda163c75c6620
+  data.tar.gz: 9110254e21b4e2913160100ec75f2887ea327107a0fefb257a23e77a9dfba362
 SHA512:
-  metadata.gz: 57e43e2a123bb69b0497b7fd62cf66a54e5fcec279b3047dfdc7701bf8ae7016c33bfdc63fb298c28628a90a6e232b601e2eb0729495d8c4c8b4000dd9bb13f7
-  data.tar.gz: 7a4474f86498962aa00c14aee3dc89a4a8c7d0d73aa66eee185cd526928b0286fd15a08762cd8604ce1fdcde651c65ed3348ba1a3e960c3bf5e034ca19d78871
+  metadata.gz: 44681ff57b45bebeea66e8a0dc92932e8219354dd2545e2dd4a9b4feb614aa7d2d528aff3946875c4373ff701e95015961e7865d0cc12a527404b84d29ae4b74
+  data.tar.gz: f2af698d30cd4b24a700a03a937f7a7a6c9913250c63aa99b3d75828191bb7d589d6fa06acd4a342f66c7d8a585d48ed8487aa0d1059e69a70262b2ce0da54cc

data/.gitignore

@@ -1,3 +1,2 @@
 sample.*
 *.swp
-lib/kicad/grammar.rb

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    kicad (0.8.0)
+    kicad (0.8.1)
       irb (~> 1.14, >= 1.14)
       treetop (~> 1.6, >= 1.6.9)
 
@@ -9,7 +9,6 @@ GEM
   remote: https://rubygems.org/
   specs:
     date (3.4.1)
-    diff-lcs (1.6.1)
     io-console (0.8.0)
     irb (1.15.2)
       pp (>= 0.6.0)
@@ -27,19 +26,6 @@ GEM
       psych (>= 4.0.0)
     reline (0.6.1)
       io-console (~> 0.5)
-    rspec (3.13.0)
-      rspec-core (~> 3.13.0)
-      rspec-expectations (~> 3.13.0)
-      rspec-mocks (~> 3.13.0)
-    rspec-core (3.13.3)
-      rspec-support (~> 3.13.0)
-    rspec-expectations (3.13.4)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.13.0)
-    rspec-mocks (3.13.3)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.13.0)
-    rspec-support (3.13.3)
     stringio (3.1.7)
     treetop (1.6.14)
       polyglot (~> 0.3)
@@ -51,8 +37,7 @@ PLATFORMS
 DEPENDENCIES
   bundler (>= 1.11)
   kicad!
-  rake (>= 13)
-  rspec (~> 3.3)
+  rake (~> 13)
 
 BUNDLED WITH
    2.6.2

data/README.md

@@ -4,29 +4,31 @@ Parse, load, modify and rewrite Kicad (s-epression) files into a convenient tree
 
 ## Installation
 
-    ```ruby
-    gem 'kicad'
-    ```
-
-or
-
     gem install kicad
 
 ## Usage
 
     $ irb -r kicad
-    irb(main):001> k = KiCad.load("my_file.kicad_lib").value
-    irb(main):001> k.children.filter{|c| c === KiCad::AST::Symbol}.map{|c| c.values[1]}
+    irb(main):001> k = KiCad.load("my_file.kicad_sym").value
+    irb(main):001> k.children.filter{|c| KiCad::AST::Symbol === c }.map{|c| c.values[1]}
     ["BC107", "CD4046"]
     irb(main):001> puts k.emit
     ...
 
 ## Development
 
-After checking out the repo, run `bundle` to install dependencies. Then, run `rake spec` to run the tests.
+After checking out the repo, run `bundle` to install dependencies.
 
 To install this gem onto your local machine from local source code, run `rake install`.
 
+## Resources
+
+KiCad uses a version of the Cadence SPECCTRA Design Language, defined in https://cdn.hackaday.io/files/1666717130852064/specctra.pdf
+
+KiCad's documentation of this is at https://dev-docs.kicad.org/en/file-formats/sexpr-intro/
+
+A related Rust library that was not consulted while building this is https://github.com/adom-inc/kicad_lib/tree/main/kicad_sexpr
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/cjheath/kicad-rb

data/kicad.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
   # spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "bundler", ">= 1.11"
   spec.add_development_dependency "rake", "~> 13"
 
   spec.add_runtime_dependency "treetop", ["~> 1.6", ">= 1.6.9"]

data/lib/kicad/ast.rb

@@ -11,136 +11,390 @@ module KiCad
       def emit depth = 0
         "\t"*depth +
         '(' +
-        @values.map{|v| value(v) }*' ' +
+        @values.map{|v| String === v ? v.inspect : v.to_s }*' ' +
         (@children.size == 0 ? '' : "\n" + @children.map{|c| c.emit(depth+1) }*''+"\t"*depth) +
         ")\n"
       end
 
-      def value(v)
-        case v
-        when ::Symbol
-          v.to_s
-        when String
-          v.inspect
-        when Float, Integer
-          v.to_s
-        else
-          "Internal error"
+      # Define setter and getter methods for each value type this class allows
+      def self.value_types vts
+        i = 1   # @values[0] is always the class symbol
+        vts.each do |k, v|
+          # puts "#{self.name} attribute #{k.to_s} => #{v.inspect}"
+          # puts "attr_accessor #{self.name}.#{k} (values #{v.inspect}) is stored in @values[#{i}]"
+          begin
+            o = i # Avoid capturing i after the loop ends
+            define_method(:"#{k}") do
+              # puts "accessing #{self.class.name}.#{k} as @values[#{o}]"
+              @values[o]
+            end
+            define_method(:"#{k}=") do |v|
+              # puts "setting #{self.class.name}.#{k} as @values[#{o}]"
+              # REVISIT: Check valid data type matching v
+              @values[o] = v
+            end
+          end
+          i = i+1
+        end
+      end
+
+      def children_of_type *cts  # cts is an array of AST class symbols or strings
+        class_names = cts.flatten.map{|k| 'KiCad::AST::'+self.class.to_class_name(k)}
+        @children.filter{|h| class_names.include?(h.class.name) }
+      end
+
+      # Define methods for each child type this class allows
+      def self.child_types *cts
+        # puts "#{self.name} allows child types #{cts.inspect}"
+        cts.each do |c|
+          if Array === c
+            define_method(:"all_#{c[0].to_s}") do
+              # puts "Looking for all [#{class_names*', '}] in #{@children.map{|q| q.class.name}.inspect}"
+              children_of_type(c)
+            end
+            # REVISIT: Allow deleting and adding instances to the array
+            # new_child = KiCad.parse('(some new node)').value
+            # @children.append(new_child)
+          else
+            class_name = 'KiCad::AST::'+to_class_name(c)
+            define_method(:"#{c}") do
+              # puts "Looking for first #{class_name} in #{@children.map{|q| q.class.name}.inspect}"
+              a = children_of_type(c)
+              puts "Choosing first #{self.class.name}.#{c} of #{a.size}" if a.size > 1
+              a.first
+            end
+            # Allow deleting this instance
+            define_method(:"unset_#{c.to_s}") do
+              child = send(:"#{c}")
+              @children = @children - [child] if child
+              child ? true : nil
+            end
+          end
         end
       end
+
+      def self.to_class_name sym
+        sym.to_s.gsub(/\A[a-z]|_[a-z]/) {|from| from[-1].upcase }
+      end
+
+      def self.to_symbol class_name
+        class_name.to_s.gsub(/[A-Z]/) {|from| '_'+from[-1].downcase }.sub(/\A_/,'')
+      end
     end
 
     class KicadSymbolLib < Node
-      def initialize values, children
-        super
-      end
+      child_types :version, :generator, :generator_version, [:symbol]
     end
 
-    # Uncomment or add whatever class you need to customise:
+    class Generator < Node
+    end
 
-    class Symbol < Node
+    class GeneratorVersion < Node
     end
 
-=begin
+    class Version < Node
+    end
+
+    # Uncomment or add whatever class you need to customise:
+
+    # Position Identifier
     class At < Node
+      value_types :x => Float, :y => Float, :angle => Float
     end
 
-    class Center < Node
+    # Coordinate Point List
+    class Pts < Node
+      value_types({})
+      child_types [:xy]
     end
 
-    class Circle < Node
+    class Xy < Node
+      value_types :x => Float, :y => Float
     end
 
-    class Effects < Node
+    # Stroke Definition
+    class Stroke < Node
+      child_types :width, :type, :color
     end
 
-    class EmbeddedFonts < Node
+    class Width < Node
+      value_types :width => Float
     end
 
-    class End < Node
+    class Type < Node
+      value_types :type => [:dash, :dash_dot, :dash_dot_dot, :dot, :default, :solid]
     end
 
-    class ExcludeFromSim < Node
+    class Color < Node
+      value_types :r => Integer, :g => Integer, :b => Integer, :a => Integer
     end
 
-    class Fill < Node
+    # Text Effects
+    class Effects < Node
+      child_types :font, :justify, :hide
     end
 
     class Font < Node
+      child_types :face, :size, :thickness, :bold, :italic, :line_spacing
     end
 
-    class Generator < Node
+    class Face < Node
+      value_types :face_name => String
     end
 
-    class GeneratorVersion < Node
+    class Size < Node
+      value_types :height => Float, :width => Float
     end
 
-    class Hide < Node
+    class Thickness < Node
+      value_types :thickness => Float
     end
 
-    class InBom < Node
+    class Bold < Node
+      value_types :bold => [:no, :yes]
     end
 
-    class Length < Node
+    class Italic < Node
+      value_types :bold => [:no, :yes]
     end
 
-    class Name < Node
+    class LineSpacing < Node
+      value_types :line_spacing => Float
     end
 
-    class Number < Node
+    class Justify < Node
+      value_types :justify => [[:right, :left, :top, :bottom, :mirror]]   # Can have multiple
     end
 
-    class Offset < Node
+    class Hide < Node
+      value_types :hide => [:no, :yes]
     end
 
-    class OnBoard < Node
+    # Page Settings
+    class Paper < Node
+      # REVISIT: Either paper_size or width/height
+      value_types :paper_size => [:A0, :A1, :A2, :A3, :A4, :A5, :A, :B, :C, :D, :E],
+          :width => Float, :height => Float,
+          :portrait => [:portrait]
     end
 
-    class Pin < Node
+    # Title Block
+    class TitleBlock < Node
+      child_types :title, :date, :rev, :company,        # All take one string as value
+          [:comment]                                    # N (1..9) and String # REVISIT: Implement Comment
     end
 
-    class PinNames < Node
+    # Properties
+    class Property < Node
+      value_types :key => String, :value => String
+      child_types :at, :effects
+
+      # Set or clear (hide) on the property_node
+      def hide=(h = true)
+        v = (h ? :yes : :no)
+        if !effects
+          # puts "No effects yet"
+          prop = KiCad.parse(%Q{(effects(hide #{v}))})&.value
+          @children.append(prop) if prop
+        elsif (existing = effects.hide)
+          # puts "Effects and hide already"
+          existing.hide = v
+        else
+          # Create new (hide) node:
+          # puts "Effects but no hide"
+          prop = KiCad.parse(%Q{(hide #{v})})&.value
+          @children.append(prop) if prop
+        end
+      end
     end
 
-    class PinNumbers < Node
+    # Universally Unique Identifier
+    class Uuid < Node
+      value_types :uuid => String
     end
 
-    class Polyline < Node
+    # Images
+    class Image < Node
+      child_types :at, :scale, :layer, :uuid, :data
     end
 
-    class Property < Node
+    class Data < Node
+      value_types :data => String    # REVISIT: Base64 data - not encoded as a string I think?
     end
 
-    class Pts < Node
+    class Circle < Node
+      child_types :center, :radius, :stroke, :fill
+    end
+
+    class Center < Xy
+      # value_types :x => Float, :y => Float
     end
 
     class Radius < Node
+      value_types :radius => Float
+    end
+
+    class Fill < Node
+      value_types :fill => [:no, :yes]
+    end
+
+    class Arc < Node
+      child_types :start, :mid, :end, :stroke, :fill
+    end
+
+    class Start < Xy
+      # value_types :x => Float, :y => Float
+    end
+
+    class Mid < Xy
+      # value_types :x => Float, :y => Float
+    end
+
+    class End < Xy
+      # value_types :x => Float, :y => Float
     end
 
     class Rectangle < Node
+      child_types :start, :end, :stroke, :fill
     end
 
-    class Size < Node
+    class Polyline < Node
+      child_types :pts, :stroke, :fill
     end
 
-    class Start < Node
+    class Text < Node
+      value_types :text => String
+      child_types :at, :effects
     end
 
-    class Stroke < Node
+    class Offset < Xy
+      # value_types :x => Float, :y => Float
     end
 
-    class Type < Node
+    # Symbol Pins
+    class Pin < Node
+      value_types :electrical_type => [
+            :input,                             # Pin is an input.
+            :output,                            # Pin is an output.
+            :bidirectional,                     # Pin can be both input and output.
+            :tri_state,                         # Pin is a tri-state output.
+            :passive,                           # Pin is electrically passive.
+            :free,                              # Not internally connected.
+            :unspecified,                       # Pin does not have a specified electrical type.
+            :power_in,                          # Pin is a power input.
+            :power_out,                         # Pin is a power output.
+            :open_collector,                    # Pin is an open collector output.
+            :open_emitter,                      # Pin is an open emitter output.
+            :no_connect,                        # Pin has no electrical connection.
+          ], :graphic_style => [
+            :line,
+            :inverted,
+            :clock,
+            :inverted_clock,
+            :input_low,
+            :clock_low,
+            :output_low,
+            :edge_clock_high,
+            :non_logic
+          ]
+      child_types :length, :name, :number
     end
 
-    class Version < Node
+    class Length < Node
+      value_types :length => Float
     end
 
-    class Width < Node
+    class Name < Node
+      value_types :name => String
+      child_types :effects
     end
 
-    class Xy < Node
+    class Number < Node
+      value_types :number => String
+      child_types :effects
+    end
+
+    class Polygon < Node
+      child_types :pts, :stroke, :fill
+    end
+
+    # Symbols
+    class Symbol < Node
+      value_types :id => String
+      child_types :extends, :exclude_from_sym, :pin_numbers, :pin_names, :in_bom, :on_board,
+        [:property],
+        [:shape, :circle, :rectangle, :text, :polyline, :arc],  # REVISIT: Lots more types of graphic items here...
+        [:pin],
+        [:symbol],      # Child symbols (units) embedded in a parent
+        :unit_name,
+        :embedded_fonts
+
+      # Get or set Property values by key, or as a Hash
+      def property_node k
+        self.all_property.detect{|p| p.key == k}
+      end
+
+      def property k = nil
+        if k
+          property_node(k)&.value
+        else  # Return all properties as a Hash
+          Hash[*self.all_property.map{|p| [p.key, p.value] }.flatten]
+        end
+      end
+
+      def [](k)
+        property[k]
+      end
+
+      def []=(k, v)
+        puts "Setting property #{k} to #{v.inspect}"
+        if (p = property_node)
+          p.send(:"#{self.class.to_symbol k}=", v)
+        else  # Create new Property using the parser:
+          prop = KiCad.parse(%Q{
+            (property "#{k}" #{String === v ? v.inspect : v.to_s}
+              (at 0 0 0)
+              (effects(font(size 1.27 1.27)))
+              (hide yes)
+            )
+          })&.value
+          @children.append(prop) if prop
+        end
+      end
+    end
+
+    class Extends < Node
+      value_types :library_id => String
+    end
+
+    class PinNumbers < Node
+      value_types :hide => [:no, :yes]
+    end
+
+    class PinNames < Node
+      child_types :offset
+      value_types :hide => [:no, :yes]
+    end
+
+    class InBom < Node
+      value_types :in_bom => [:no, :yes]
+    end
+
+    class OnBoard < Node
+      value_types :on_board => [:no, :yes]
+    end
+
+    class UnitName < Node
+      value_types :name => String
+    end
+
+    class EmbeddedFonts < Node
+      value_types :embedded_fonts => [:no, :yes]
+    end
+
+    class ExcludeFromSim < Node
+      value_types :exclude_from_sim => [:no, :yes]
     end
-=end
 
   end
 end

data/lib/kicad/grammar.rb

@@ -0,0 +1,547 @@
+# Autogenerated from a Treetop grammar. Edits may be lost.
+
+
+require 'kicad/ast'
+
+module KiCad
+  module SExpr
+    include Treetop::Runtime
+
+    def root
+      @root ||= :node
+    end
+
+    module Node0
+      def value
+        elements[0]
+      end
+
+      def s
+        elements[1]
+      end
+    end
+
+    module Node1
+      def node
+        elements[0]
+      end
+
+      def s
+        elements[1]
+      end
+    end
+
+    module Node2
+      def s1
+        elements[0]
+      end
+
+      def s2
+        elements[2]
+      end
+
+      def values
+        elements[3]
+      end
+
+      def nodes
+        elements[4]
+      end
+
+      def s3
+        elements[6]
+      end
+    end
+
+    module Node3
+      def value
+               klass_name = values.elements[0].value.value
+               klass = KiCad::AST::Node
+               if klass_name.is_a? ::Symbol  # See if we have a defined class for this node type
+                 klass_name = klass_name.to_s.gsub(/\A[a-z]|_[a-z]/) {|from| from[-1].upcase }
+                 klass = KiCad::AST.const_get(klass_name, false) rescue KiCad::AST::Node
+               end
+               klass.new values.elements.map(&:value).map(&:value),
+                         nodes.elements.map(&:node).map(&:value)
+             end
+    end
+
+    def _nt_node
+      start_index = index
+      if node_cache[:node].has_key?(index)
+        cached = node_cache[:node][index]
+        if cached
+          node_cache[:node][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0, s0 = index, []
+      r1 = _nt_s
+      s0 << r1
+      if r1
+        if (match_len = has_terminal?('(', false, index))
+          r2 = true
+          @index += match_len
+        else
+          terminal_parse_failure('\'(\'')
+          r2 = nil
+        end
+        s0 << r2
+        if r2
+          r3 = _nt_s
+          s0 << r3
+          if r3
+            s4, i4 = [], index
+            loop do
+              i5, s5 = index, []
+              r6 = _nt_value
+              s5 << r6
+              if r6
+                r7 = _nt_s
+                s5 << r7
+              end
+              if s5.last
+                r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+                r5.extend(Node0)
+              else
+                @index = i5
+                r5 = nil
+              end
+              if r5
+                s4 << r5
+              else
+                break
+              end
+            end
+            if s4.empty?
+              @index = i4
+              r4 = nil
+            else
+              r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+            end
+            s0 << r4
+            if r4
+              s8, i8 = [], index
+              loop do
+                i9, s9 = index, []
+                r10 = _nt_node
+                s9 << r10
+                if r10
+                  r11 = _nt_s
+                  s9 << r11
+                end
+                if s9.last
+                  r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
+                  r9.extend(Node1)
+                else
+                  @index = i9
+                  r9 = nil
+                end
+                if r9
+                  s8 << r9
+                else
+                  break
+                end
+              end
+              r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
+              s0 << r8
+              if r8
+                if (match_len = has_terminal?(')', false, index))
+                  r12 = true
+                  @index += match_len
+                else
+                  terminal_parse_failure('\')\'')
+                  r12 = nil
+                end
+                s0 << r12
+                if r12
+                  r13 = _nt_s
+                  s0 << r13
+                end
+              end
+            end
+          end
+        end
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(Node2)
+        r0.extend(Node3)
+      else
+        @index = i0
+        r0 = nil
+      end
+
+      node_cache[:node][start_index] = r0
+
+      r0
+    end
+
+    def _nt_value
+      start_index = index
+      if node_cache[:value].has_key?(index)
+        cached = node_cache[:value][index]
+        if cached
+          node_cache[:value][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0 = index
+      r1 = _nt_string
+      if r1
+        r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+        r0 = r1
+      else
+        r2 = _nt_number
+        if r2
+          r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+          r0 = r2
+        else
+          r3 = _nt_symbol
+          if r3
+            r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+            r0 = r3
+          else
+            @index = i0
+            r0 = nil
+          end
+        end
+      end
+
+      node_cache[:value][start_index] = r0
+
+      r0
+    end
+
+    module Symbol0
+      def value; :"#{text_value}"; end
+    end
+
+    def _nt_symbol
+      start_index = index
+      if node_cache[:symbol].has_key?(index)
+        cached = node_cache[:symbol][index]
+        if cached
+          node_cache[:symbol][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      s0, i0 = [], index
+      loop do
+        if has_terminal?(@regexps[gr = '\A[a-zA-Z_]'] ||= Regexp.new(gr), :regexp, index)
+          r1 = true
+          @index += 1
+        else
+          terminal_parse_failure('[a-zA-Z_]')
+          r1 = nil
+        end
+        if r1
+          s0 << r1
+        else
+          break
+        end
+      end
+      if s0.empty?
+        @index = i0
+        r0 = nil
+      else
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(Symbol0)
+        r0.extend(Symbol0)
+      end
+
+      node_cache[:symbol][start_index] = r0
+
+      r0
+    end
+
+    module String0
+    end
+
+    module String1
+      def contents
+        elements[1]
+      end
+
+    end
+
+    module String2
+      def value; contents.text_value.force_encoding(Encoding::UTF_8); end
+    end
+
+    def _nt_string
+      start_index = index
+      if node_cache[:string].has_key?(index)
+        cached = node_cache[:string][index]
+        if cached
+          node_cache[:string][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0, s0 = index, []
+      if (match_len = has_terminal?('"', false, index))
+        r1 = true
+        @index += match_len
+      else
+        terminal_parse_failure('\'"\'')
+        r1 = nil
+      end
+      s0 << r1
+      if r1
+        s2, i2 = [], index
+        loop do
+          i3 = index
+          if (match_len = has_terminal?('\\"', false, index))
+            r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+            @index += match_len
+          else
+            terminal_parse_failure('\'\\\\"\'')
+            r4 = nil
+          end
+          if r4
+            r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
+            r3 = r4
+          else
+            i5, s5 = index, []
+            i6 = index
+            if (match_len = has_terminal?('"', false, index))
+              r7 = true
+              @index += match_len
+            else
+              terminal_parse_failure('\'"\'')
+              r7 = nil
+            end
+            if r7
+              @index = i6
+              r6 = nil
+              terminal_parse_failure('\'"\'', true)
+            else
+              @terminal_failures.pop
+              @index = i6
+              r6 = instantiate_node(SyntaxNode,input, index...index)
+            end
+            s5 << r6
+            if r6
+              if index < input_length
+                r8 = true
+                @index += 1
+              else
+                terminal_parse_failure("any character")
+                r8 = nil
+              end
+              s5 << r8
+            end
+            if s5.last
+              r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+              r5.extend(String0)
+            else
+              @index = i5
+              r5 = nil
+            end
+            if r5
+              r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
+              r3 = r5
+            else
+              @index = i3
+              r3 = nil
+            end
+          end
+          if r3
+            s2 << r3
+          else
+            break
+          end
+        end
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        s0 << r2
+        if r2
+          if (match_len = has_terminal?('"', false, index))
+            r9 = true
+            @index += match_len
+          else
+            terminal_parse_failure('\'"\'')
+            r9 = nil
+          end
+          s0 << r9
+        end
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(String1)
+        r0.extend(String2)
+      else
+        @index = i0
+        r0 = nil
+      end
+
+      node_cache[:string][start_index] = r0
+
+      r0
+    end
+
+    module Number0
+    end
+
+    module Number1
+    end
+
+    module Number2
+      def value; eval(text_value); end
+    end
+
+    def _nt_number
+      start_index = index
+      if node_cache[:number].has_key?(index)
+        cached = node_cache[:number][index]
+        if cached
+          node_cache[:number][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0, s0 = index, []
+      if (match_len = has_terminal?('-', false, index))
+        r2 = true
+        @index += match_len
+      else
+        terminal_parse_failure('\'-\'')
+        r2 = nil
+      end
+      if r2
+        r1 = r2
+      else
+        r1 = instantiate_node(SyntaxNode,input, index...index)
+      end
+      s0 << r1
+      if r1
+        s3, i3 = [], index
+        loop do
+          if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
+            r4 = true
+            @index += 1
+          else
+            terminal_parse_failure('[0-9]')
+            r4 = nil
+          end
+          if r4
+            s3 << r4
+          else
+            break
+          end
+        end
+        if s3.empty?
+          @index = i3
+          r3 = nil
+        else
+          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+        end
+        s0 << r3
+        if r3
+          i6, s6 = index, []
+          if (match_len = has_terminal?('.', false, index))
+            r7 = true
+            @index += match_len
+          else
+            terminal_parse_failure('\'.\'')
+            r7 = nil
+          end
+          s6 << r7
+          if r7
+            s8, i8 = [], index
+            loop do
+              if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
+                r9 = true
+                @index += 1
+              else
+                terminal_parse_failure('[0-9]')
+                r9 = nil
+              end
+              if r9
+                s8 << r9
+              else
+                break
+              end
+            end
+            r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
+            s6 << r8
+          end
+          if s6.last
+            r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+            r6.extend(Number0)
+          else
+            @index = i6
+            r6 = nil
+          end
+          if r6
+            r5 = r6
+          else
+            r5 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s0 << r5
+        end
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(Number1)
+        r0.extend(Number2)
+      else
+        @index = i0
+        r0 = nil
+      end
+
+      node_cache[:number][start_index] = r0
+
+      r0
+    end
+
+    def _nt_s
+      start_index = index
+      if node_cache[:s].has_key?(index)
+        cached = node_cache[:s][index]
+        if cached
+          node_cache[:s][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      s0, i0 = [], index
+      loop do
+        if has_terminal?(@regexps[gr = '\A[ \\t\\r\\n]'] ||= Regexp.new(gr), :regexp, index)
+          r1 = true
+          @index += 1
+        else
+          terminal_parse_failure('[ \\t\\r\\n]')
+          r1 = nil
+        end
+        if r1
+          s0 << r1
+        else
+          break
+        end
+      end
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+
+      node_cache[:s][start_index] = r0
+
+      r0
+    end
+
+
+    class Parser < Treetop::Runtime::CompiledParser
+      include SExpr
+    end
+  end
+
+  SExprParser = SExpr::Parser
+
+end

data/lib/kicad/grammar.tt

@@ -3,13 +3,12 @@ require 'kicad/ast'
 module KiCad
   grammar SExpr
     rule node
-      '(' s values:( value s)+ nodes:(node s)* ')' s
+      s '(' s values:( value s)+ nodes:(node s)* ')' s
       { def value
           klass_name = values.elements[0].value.value
           klass = KiCad::AST::Node
-          if klass_name.is_a? ::Symbol
-	    # See if we have a defined class for this node type
-	    klass_name = klass_name.to_s.gsub(/\A[a-z]|_[a-z]/) {|from| from[-1].upcase }
+          if klass_name.is_a? ::Symbol  # See if we have a defined class for this node type
+            klass_name = klass_name.to_s.gsub(/\A[a-z]|_[a-z]/) {|from| from[-1].upcase }
             klass = KiCad::AST.const_get(klass_name, false) rescue KiCad::AST::Node
           end
           klass.new values.elements.map(&:value).map(&:value),
@@ -28,8 +27,8 @@ module KiCad
     end
 
     rule string
-      '"' ('\\"' / !'"' .)* '"'
-        { def value; eval(text_value); end }  # REVISIT: Risk of evaluating code
+      '"' contents:( ('\\"' / !'"' .)* ) '"'
+        { def value; contents.text_value.force_encoding(Encoding::UTF_8); end }
     end
 
     rule number

data/lib/kicad/parser.rb

@@ -12,7 +12,7 @@ module KiCad
   end
 
   def self.load filename
-    self.parse File.read(filename)
+    self.parse File.read(filename, :encoding => 'iso-8859-1')
   end
 
   class Parser < KiCad::SExprParser

data/lib/kicad/version.rb

@@ -1,3 +1,3 @@
 module KiCad
-  VERSION = "0.8.0"
+  VERSION = "0.9.3"
 end

metadata

@@ -1,26 +1,26 @@
 --- !ruby/object:Gem::Specification
 name: kicad
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.3
 platform: ruby
 authors:
 - Clifford Heath
 bindir: bin
 cert_chain: []
-date: 2025-05-05 00:00:00.000000000 Z
+date: 2025-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.11'
 - !ruby/object:Gem::Dependency
@@ -92,6 +92,7 @@ files:
 - kicad.gemspec
 - lib/kicad.rb
 - lib/kicad/ast.rb
+- lib/kicad/grammar.rb
 - lib/kicad/grammar.tt
 - lib/kicad/parser.rb
 - lib/kicad/version.rb