xmlscan 0.2.3 → 0.3.0preb

data/Rakefile

@@ -3,6 +3,9 @@
 
 require 'rubygems'
 require 'bundler'
+require 'xmlscan/version'
+
+VERSION = XMLScan::VERSION # File.exist?('VERSION') ? File.read('VERSION') : ""
 
 begin
   Bundler.setup(:default, :development)
@@ -15,10 +18,11 @@ end
 require 'rake'
 
 begin
+  include XMLScan
     require 'jeweler'
     Jeweler::Tasks.new do |gem|
-      gem.name = "xmlscan"
-      gem.version = '0.2.3'
+      gem.name = 'xmlscan'
+      gem.version = XMLScan::VERSION
       gem.license = "MIT"
       gem.summary = "The fastest XML parser written in 100% pure Ruby."
       gem.email = "gerryg@inbox.com"
@@ -56,10 +60,9 @@ task :default => :spec
 
 require 'rdoc/task'
 Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
 
   rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "xmlscan #{version}"
+  rdoc.title = "xmlscan #{VERSION}"
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end

data/VERSION

@@ -1 +1 @@
-0.2.3
+0.3.0preb

data/lib/xmlscan/htmlscan.rb

@@ -47,7 +47,7 @@ module XMLScan
       raise "[BUG] this method must be never called"
     end
 
-    def on_stag_end_empty(name)
+    def on_stag_end_empty(name, *a)
       raise "[BUG] this method must be never called"
     end
 
@@ -127,7 +127,7 @@ module XMLScan
             return found_empty_stag
           else
             parse_error "parse error at `<'"
-            return on_chardata('<')
+            return on_chardata '<'
           end
         end
         on_stag name
@@ -142,7 +142,7 @@ module XMLScan
           if @src.close_tag then
             s << '>'
           end
-          return on_chardata('<' << s)
+          return on_chardata '<'+s
         end
         on_stag name
         begin
@@ -156,9 +156,9 @@ module XMLScan
                 qmark = val.slice!(0,1)
                 if val[-1] == qmark[0] then
                   val.chop!
-                  scan_attvalue val unless val.empty?
+                  scan_attr_value val unless val.empty?
                 else
-                  scan_attvalue val unless val.empty?
+                  scan_attr_value val unless val.empty?
                   begin
                     s = @src.get
                     unless s then
@@ -167,8 +167,8 @@ module XMLScan
                     end
                     c = s[0]
                     val, s = s.split(qmark, 2)
-                    scan_attvalue '>' unless c == ?< or c == ?>
-                    scan_attvalue val if c
+                    scan_attr_value '>' unless c == ?< or c == ?>
+                    scan_attr_value val if c
                   end until s
                   continue = s
                 end

data/lib/xmlscan/namespace.rb

@@ -54,16 +54,16 @@ module XMLScan
     #       on_stag_end_empty_ns ('foo:bar', { 'foo' => '', ... })
     #
 
-    def on_stag_ns(qname, prefix, localpart)
+    def on_stag_ns(qname, prefix, localpart, *a)
     end
 
-    def on_attribute_ns(qname, prefix, localpart)
+    def on_attribute_ns(qname, prefix, localpart, *a)
     end
 
-    def on_stag_end_ns(qname, namespaces)
+    def on_stag_end_ns(qname, namespaces, *a)
     end
 
-    def on_stag_end_empty_ns(qname, namespaces)
+    def on_stag_end_empty_ns(qname, namespaces, *a)
     end
 
   end
@@ -99,7 +99,7 @@ module XMLScan
     end
 
 
-    def on_start_document
+    def on_start_document(*a)
       @namespace = {} #PredefinedNamespace.dup
       @ns_hist = []
       @ns_undeclared = {}     # for checking undeclared namespace prefixes.
@@ -107,14 +107,14 @@ module XMLScan
       @dont_same = []         # ditto.
       @xmlns = NamespaceDeclaration.new(self)
       @orig_visitor = @visitor
-      @visitor.on_start_document
+      @visitor.on_start_document *a
     end
 
 
-    def on_stag(name)
+    def on_stag(name, *a)
       @ns_hist.push nil
       unless /:/n =~ name then
-        @visitor.on_stag_ns name, '', name
+        @visitor.on_stag_ns name, '', name, *a
       else
         prefix, localpart = $`, $'
         if localpart.include? ?: then
@@ -131,12 +131,12 @@ module XMLScan
             @ns_undeclared[prefix] = true
           end
         end
-        @visitor.on_stag_ns name, prefix, localpart
+        @visitor.on_stag_ns name, prefix, localpart, *a
       end
     end
 
 
-    def on_attribute(name)
+    def on_attribute(name, *a)
       if /:/n =~ name then
         prefix, localpart = $`, $'
         if localpart.include? ?: then
@@ -157,13 +157,13 @@ module XMLScan
             @dont_same.push [ prev, prefix, localpart ]
           end
           @prev_prefix[localpart] = prefix
-          @visitor.on_attribute_ns name, prefix, localpart
+          @visitor.on_attribute_ns name, prefix, localpart, *a
         end
       elsif name == 'xmlns' then
         @visitor = @xmlns
         @xmlns.on_xmlns_start ''
       else
-        @visitor.on_attribute_ns name, nil, name
+        @visitor.on_attribute_ns name, nil, name, *a
       end
     end
 
@@ -176,36 +176,36 @@ module XMLScan
         @parent = parent
       end
 
-      def on_xmlns_start(prefix)
+      def on_xmlns_start(prefix, *a)
         @prefix = prefix
         @nsdecl = ''
       end
 
-      def on_attr_value(str)
+      def on_attr_value(str, *a)
         @nsdecl << str
       end
 
-      def on_attr_entityref(ref)
+      def on_attr_entityref(ref, *a)
         @parent.ns_wellformed_error \
           "xmlns includes undeclared entity reference"
       end
 
-      def on_attr_charref(code)
+      def on_attr_charref(code, *a)
         @nsdecl << [code].pack('U')
       end
 
-      def on_attr_charref_hex(code)
+      def on_attr_charref_hex(code, *a)
         @nsdecl << [code].pack('U')
       end
 
-      def on_attribute_end(name)
+      def on_attribute_end(name, *a)
         @parent.on_xmlns_end @prefix, @nsdecl
       end
 
     end
 
 
-    def on_xmlns_end(prefix, uri)
+    def on_xmlns_end(prefix, uri, *a)
       @visitor = @orig_visitor
       if PredefinedNamespace.key? prefix then
         if prefix == 'xmlns' then
@@ -254,54 +254,54 @@ module XMLScan
     end
 
 
-    def on_stag_end(name)
+    def on_stag_end(name, *a)
       fix_namespace
-      @visitor.on_stag_end_ns name, @namespace
+      @visitor.on_stag_end_ns name, @namespace, *a
     end
 
 
-    def on_etag(name)
+    def on_etag(name, *a)
       h = @ns_hist.pop and @namespace.update h
-      @visitor.on_etag name
+      @visitor.on_etag name, *a
     end
 
 
-    def on_stag_end_empty(name)
+    def on_stag_end_empty(name, *a)
       fix_namespace
-      @visitor.on_stag_end_empty_ns name, @namespace
+      @visitor.on_stag_end_empty_ns name, @namespace, *a
       h = @ns_hist.pop and @namespace.update h
     end
 
 
-    def on_doctype(root, pubid, sysid)
+    def on_doctype(root, pubid, sysid, *a)
       if root.count(':') > 1 then
         ns_parse_error "qualified name `#{root}' includes `:'"
       end
-      @visitor.on_doctype root, pubid, sysid
+      @visitor.on_doctype root, pubid, sysid, *a
     end
 
 
-    def on_pi(target, pi)
+    def on_pi(target, pi, *a)
       if target.include? ?: then
         ns_parse_error "PI target `#{target}' includes `:'"
       end
-      @visitor.on_pi target, pi
+      @visitor.on_pi target, pi, *a
     end
 
 
-    def on_entityref(ref)
+    def on_entityref(ref, *a)
       if ref.include? ?: then
         ns_parse_error "entity reference `#{ref}' includes `:'"
       end
-      @visitor.on_entityref ref
+      @visitor.on_entityref ref, *a
     end
 
 
-    def on_attr_entityref(ref)
+    def on_attr_entityref(ref, *a)
       if ref.include? ?: then
         ns_parse_error "entity reference `#{ref}' includes `:'"
       end
-      @visitor.on_attr_entityref ref
+      @visitor.on_attr_entityref ref, *a
     end
 
   end

data/lib/xmlscan/parser.rb

@@ -43,7 +43,7 @@ module XMLScan
 
     private
 
-    def on_xmldecl_version(str)
+    def on_xmldecl_version(str, *a)
       unless str == '1.0' then
         warning "unsupported XML version `#{str}'"
       end
@@ -51,7 +51,7 @@ module XMLScan
     end
 
 
-    def on_xmldecl_standalone(str)
+    def on_xmldecl_standalone(str, *a)
       if str == 'yes' then
         @standalone = true
       elsif str == 'no' then
@@ -63,7 +63,7 @@ module XMLScan
     end
 
 
-    def on_doctype(name, pubid, sysid)
+    def on_doctype(name, pubid, sysid, *a)
       if pubid and not sysid then
         parse_error "public external ID must have both public ID and system ID"
       end
@@ -71,12 +71,12 @@ module XMLScan
     end
 
 
-    def on_prolog_space(s)
+    def on_prolog_space(s, *a)
       # just ignore it.
     end
 
 
-    def on_pi(target, pi)
+    def on_pi(target, pi, *a)
       if target.downcase == 'xml' then
         parse_error "reserved PI target `#{target}'"
       end
@@ -114,39 +114,43 @@ module XMLScan
     #end
 
 
-    def on_stag(name)
+    def on_stag(name, *a)
       @elem.push name
       @visitor.on_stag name
       @attr.clear
     end
 
-    def on_attribute(name)
+    def on_attribute(name, *a)
       unless @attr.check_unique name then
         wellformed_error "doubled attribute `#{name}'"
       end
       @visitor.on_attribute name
     end
 
-    def on_attr_value(str)
+    def on_attr_value(str, *a)
       str.tr! "\t\r\n", ' '   # normalize
       @visitor.on_attr_value str
     end
 
-    def on_stag_end_empty(name)
+    def on_stag_end(name, *a)
+      @visitor.on_stag_end name, *a
+    end
+
+    def on_stag_end_empty(name, *a)
       # @visitor.on_stag_end name
       # @elem.pop
       # @visitor.on_etag name
-      @visitor.on_stag_end_empty name
+      @visitor.on_stag_end_empty name, *a
       @elem.pop
     end
 
-    def on_etag(name)
+    def on_etag(name, *a)
       last = @elem.pop
       if last == name then
-        @visitor.on_etag name
+        @visitor.on_etag name, *a
       elsif last then
         wellformed_error "element type `#{name}' is not matched"
-        @visitor.on_etag last
+        @visitor.on_etag last, *a
       else
         parse_error "end tag `#{name}' appears alone"
       end

data/lib/xmlscan/processor.rb

@@ -0,0 +1,109 @@
+# encoding: UTF-8
+require 'xmlscan/parser'
+require 'xmlscan/visitor'
+
+module XMLScan
+  module ElementProcessor
+    include XMLScan::Visitor
+
+    SKIP = [:on_chardata, :on_stag, :on_etag, :on_attribute, :on_attr_entityref,
+      :on_attr_value, :on_start_document, :on_end_document, :on_attribute_end,
+      :on_stag_end, :on_stag_end_empty, :on_attr_charref, :on_attr_charref_hex]
+
+    MY_METHODS = XMLScan::Visitor.instance_methods.to_a - SKIP
+
+    def initialize(opts={}, mod=nil)
+      raise "No module" unless mod
+      STDERR << "init Element Processer #{mod}\n"
+      (MY_METHODS - mod.instance_methods).each do |i|
+        self.class.class_eval %{def #{i}(d, *a) d&&(@out << d) end}, __FILE__, __LINE__
+      end
+      self.class.send :include, mod
+
+      @element = opts[:element] || raise("need an element")
+      @key = opts[:key] || raise("need a key")
+      @extras = (ex = opts[:extras]) ? ex.map(&:to_sym) : []
+
+      @pairs = []    # output [name, content, value] * 1 or more
+      @context = ''  # current key(name) of the element (card)
+      @stack = []    # stack of containing context cards
+      @out = []      # current output for name(card)
+      @parser = XMLScan::XMLParser.new(self)
+      self
+    end
+
+  end
+
+  class XMLProcessor
+    include ElementProcessor
+
+    def self.process(io, opts={}, mod=nil)
+      mod ||= ElementProcessing
+      STDERR << "process #{io.inspect}, #{opts.inspect}\n"
+      io = case io
+          when String; open(io)
+          when IO, StringIO; io
+          else raise "bad type file input #{io.inspect}"
+        end
+
+      visitor = new(opts, mod)
+      visitor.parser.parse(io)
+      visitor.pairs
+    end
+  end
+
+
+  module ElementProcessing
+    def on_chardata(s) @out << s end
+    def on_stag_end(name, s, h, *a)
+      if name.to_sym == @element
+        # starting a new context, first output our substitute string
+        key= h&&h[@key.to_s]||'*no-name*'
+        @tmpl = ":transclude|{{:name}}" # def: "{{:key}}"
+        STDERR << "templ #{@tmpl.inspect}\n"
+        #STDERR << "x> #{x.inspect}, #{h.inspect}, #{(!(/:\w[\w\d]*/ =~ x)) || h[$&[1..-1].to_s] }\n"
+        sub =
+          @tmpl.split('|').find {|x| !(/:\w[\w\d]*/ =~ x) ||
+          h[$&[1..-1].to_s] }.gsub(/:\w[\w\d]*/) {|m|
+            STDERR << "templ sub match #{m.inspect}, #{h[m[1..-1]]}\n"
+            h[m[1..-1]] }
+        #sub = h['transclude'] || "{{#{key}}}"
+        @out << sub
+        # then push the current context and initialize this one
+        @stack.push([@context, @out, *@ex])
+        @context = key; @out = []
+        @ex = @extras.map {|e| h[e]}
+      else @out << s end # pass through tags we aren't processing
+    end
+
+    def on_etag(name, s=nil)
+      if name.to_sym == @element
+        # output a card (name, content, type)
+        @pairs << [@context, @out, @stack[-1][0], *@ex]
+        # restore previous context from stack
+        last = @stack.pop
+        @context, @out, @ex = last.shift, last.shift, *last
+      else @out << s end
+    end
+
+    def on_stag_empty_end(name, s=nil, h={}, *a)
+      if name.to_sym == @element
+
+        key= h&&h[@key.to_s]||'*no-name*'
+        ex = @extras.map {|e| h[e]}
+        @pairs << [key, [], @context, *ex]
+      else @out << s end
+    end
+
+    attr_reader :pairs, :parser
+  end
+
+end
+ARGV.each do |a|
+  pairs = XMLScan::XMLProcessor.process(a, {:key=>:name, :element=>:card, :extras=>[:type]}, XMLScan::ElementProcessing)
+  STDOUT << "Result\n"
+  STDOUT << pairs.map do |p| n,o,c,t = p
+      "#{c&&c.size>0&&"#{c}::"||''}#{n}#{t&&"[#{t}]"}=>#{o*''}"
+    end * "\n"
+  STDOUT << "\nDone\n"
+end