saxerator 0.9.5 → 0.9.8

data/lib/saxerator/builder/hash_element.rb

@@ -1,21 +1,20 @@
 require 'saxerator/builder/array_element'
+require 'delegate'
 
 module Saxerator
   module Builder
-    class HashElement < Hash
+    class HashElement < DelegateClass(Hash)
       attr_accessor :attributes
       attr_accessor :name
 
-      def initialize(name, attributes)
-        self.name = name
-        self.attributes = attributes
+      def initialize(name = nil, attributes = nil)
+        @name = name
+        @attributes = attributes
+        super({})
       end
 
       def to_a
-        array = ArrayElement.new
-        array.name = name
-        array.concat super
-        array
+        ArrayElement.new(super, name)
       end
 
       def to_h; self end

data/lib/saxerator/builder/string_element.rb

@@ -1,22 +1,20 @@
 require 'saxerator/builder/array_element'
+require 'delegate'
 
 module Saxerator
   module Builder
-    class StringElement < String
+    class StringElement < DelegateClass(String)
       attr_accessor :attributes
       attr_accessor :name
 
       def initialize(str, name, attributes)
-        self.name = name
-        self.attributes = attributes
+        @name = name
+        @attributes = attributes
         super(str)
       end
 
       def to_a
-        array = ArrayElement.new
-        array << self
-        array.name = name
-        array
+        ArrayElement.new(self, name)
       end
     end
   end

data/lib/saxerator/builder/xml_builder.rb

@@ -1,3 +1,5 @@
+require 'rexml/document'
+
 module Saxerator
   module Builder
     class XmlBuilder
@@ -17,20 +19,22 @@ module Saxerator
       end
 
       def to_xml(builder)
+        element = REXML::Element.new(name, nil, attribute_quote: :quote)
+        element.add_attributes(@attributes)
         if @text
-          builder.send("#{name}_", @attributes, @children.join)
+          element.add_text(@children.join)
         else
-          builder.send("#{name}_", @attributes) do |xml|
-            @children.each { |child| child.to_xml(xml) }
-          end
+          @children.each { |child| child.to_xml(element) }
         end
+        builder.elements << element
       end
 
       def block_variable
-        builder = Nokogiri::XML::Builder.new
+        builder = REXML::Document.new
+        builder << REXML::XMLDecl.new('1.0', 'UTF-8')
         to_xml(builder)
-        builder.doc
+        builder
       end
     end
   end
-end
+end

data/lib/saxerator/configuration.rb

@@ -1,26 +1,45 @@
 module Saxerator
   class Configuration
-    attr_reader :output_type
     attr_writer :hash_key_generator
+    attr_reader :output_type
+
+    ADAPTER_TYPES = [:ox, :nokogiri, :rexml]
 
     def initialize
+      @adapter = :rexml
       @output_type = :hash
       @put_attributes_in_hash = false
       @ignore_namespaces = false
     end
 
+    def adapter=(name)
+      unless ADAPTER_TYPES.include?(name)
+        raise ArgumentError, "Unknown adapter '#{name.inspect}'"
+      end
+      @adapter = name
+    end
+
+    def adapter
+      require "saxerator/adapters/#{@adapter}"
+      Saxerator::Adapters.const_get(@adapter.to_s.capitalize, false)
+    end
+
     def output_type=(val)
-      raise ArgumentError.new("Unknown output_type '#{val.inspect}'") unless Builder.valid?(val)
+      raise ArgumentError, "Unknown output_type '#{val.inspect}'" unless Builder.valid?(val)
       @output_type = val
       raise_error_if_using_put_attributes_in_hash_with_xml
     end
 
+    def output_type
+      @_output_type ||= Builder.to_class(@output_type)
+    end
+
     def generate_key_for(val)
       hash_key_generator.call val
     end
 
     def hash_key_normalizer
-      @hash_key_normalizer ||= lambda { |x| x.to_s }
+      @hash_key_normalizer ||= -> (x) { x.to_s }
     end
 
     def hash_key_generator
@@ -28,15 +47,15 @@ module Saxerator
     end
 
     def symbolize_keys!
-      @hash_key_generator = lambda { |x| hash_key_normalizer.call(x).to_sym }
+      @hash_key_generator = -> (x) { hash_key_normalizer.call(x).to_sym }
     end
 
     def strip_namespaces!(*namespaces)
       if namespaces.any?
         matching_group = namespaces.join('|')
-        @hash_key_normalizer = lambda { |x| x.to_s.gsub(/(#{matching_group}):/, '') }
+        @hash_key_normalizer = -> (x) { x.to_s.gsub(/(#{matching_group}):/, '') }
       else
-        @hash_key_normalizer = lambda { |x| x.to_s.gsub(/\w+:/, '') }
+        @hash_key_normalizer = -> (x) { x.to_s.gsub(/\w+:/, '') }
       end
     end
 
@@ -59,7 +78,8 @@ module Saxerator
 
     def raise_error_if_using_put_attributes_in_hash_with_xml
       if @output_type != :hash && @put_attributes_in_hash
-        raise ArgumentError.new("put_attributes_in_hash! is only valid when using output_type = :hash (the default)'")
+        raise ArgumentError, "put_attributes_in_hash! is only valid \
+                              when using output_type = :hash (the default)'"
       end
     end
   end

data/lib/saxerator/document_fragment.rb

@@ -10,13 +10,11 @@ module Saxerator
     end
 
     def each(&block)
-      reader = Parser::LatchedAccumulator.new(@config, @latches, block)
-      parser = Nokogiri::XML::SAX::Parser.new(reader)
-
       # Always have to start at the beginning of a File
       @source.rewind if @source.respond_to?(:rewind)
 
-      parser.parse(@source)
+      reader = Parser::LatchedAccumulator.new(@config, @latches, block)
+      @config.adapter.parse(@source, reader)
     end
   end
-end
+end

data/lib/saxerator/dsl.rb

@@ -5,7 +5,7 @@ module Saxerator
     end
 
     def for_tags(tags)
-      raise ArgumentError.new('#for_tags requires an Array argument') unless tags.is_a? Array
+      raise ArgumentError, '#for_tags requires an Array argument' unless tags.is_a? Array
       specify Latches::ForTags.new(tags.map(&:to_s))
     end
 
@@ -22,21 +22,22 @@ module Saxerator
     end
 
     def with_attribute(name, value = nil)
-      specify Latches::WithAttributes.new({name.to_s => !!value ? value.to_s : nil })
+      specify Latches::WithAttributes.new(name.to_s => !value.nil? ? value.to_s : nil)
     end
 
     def with_attributes(attrs)
       if attrs.is_a? Array
-        attrs = Hash[attrs.map { |k| [k, nil]}]
+        attrs = Hash[attrs.map { |k| [k, nil] }]
       elsif attrs.is_a? Hash
-        attrs = Hash[attrs.map{ |k, v| [k.to_s, v ? v.to_s : v]}]
+        attrs = Hash[attrs.map { |k, v| [k.to_s, v ? v.to_s : v] }]
       else
-        raise ArgumentError.new("attributes should be a Hash or Array")
+        raise ArgumentError, 'attributes should be a Hash or Array'
       end
       specify Latches::WithAttributes.new(attrs)
     end
 
     private
+
     def specify(predicate)
       DocumentFragment.new(@source, @config, @latches + [predicate])
     end

data/lib/saxerator/full_document.rb

@@ -12,4 +12,4 @@ module Saxerator
       DocumentFragment.new(@source, @config, @latches).first
     end
   end
-end
+end

data/lib/saxerator/latches/abstract_latch.rb

@@ -1,6 +1,6 @@
 module Saxerator
   module Latches
-    class AbstractLatch < Nokogiri::XML::SAX::Document
+    class AbstractLatch < ::Saxerator::SaxHandler
       def open
         @open = true
       end

data/lib/saxerator/latches/at_depth.rb

@@ -1,6 +1,6 @@
 module Saxerator
   module Latches
-    class AtDepth < Nokogiri::XML::SAX::Document
+    class AtDepth < ::Saxerator::SaxHandler
       def initialize(depth)
         @target_depth = depth
         @current_depth = -1
@@ -19,4 +19,4 @@ module Saxerator
       end
     end
   end
-end
+end

data/lib/saxerator/latches/child_of.rb

@@ -1,25 +1,20 @@
 module Saxerator
   module Latches
-    class ChildOf < Nokogiri::XML::SAX::Document
+    class ChildOf < ::Saxerator::SaxHandler
       def initialize(name)
         @name = name
         @depths = []
       end
 
-      def start_element name, _
-        if depth_within_element > 0
-          increment_depth(1)
-        end
-        if @name == name
-          @depths.push 1
-        end
+      def start_element(name, _)
+        increment_depth(1) if depth_within_element > 0
+        @depths.push 1 if @name == name
       end
 
-      def end_element _
-        if depth_within_element > 0
-          increment_depth(-1)
-          @depths.pop if @depths.last == 0
-        end
+      def end_element(_)
+        return unless depth_within_element > 0
+        increment_depth(-1)
+        @depths.pop if @depths[-1] == 0
       end
 
       def open?
@@ -31,7 +26,7 @@ module Saxerator
       end
 
       def depth_within_element
-        @depths.size > 0 ? @depths.last : 0
+        !@depths.empty? ? @depths[-1] : 0
       end
     end
   end

data/lib/saxerator/latches/for_tags.rb

@@ -7,11 +7,11 @@ module Saxerator
         @names = names
       end
 
-      def start_element name, _
+      def start_element(name, _)
         @names.include?(name) ? open : close
       end
 
-      def end_element name
+      def end_element(name)
         close if @names.include?(name)
       end
     end

data/lib/saxerator/latches/with_attributes.rb

@@ -7,7 +7,7 @@ module Saxerator
         @attrs = attrs
       end
 
-      def start_element _, attributes
+      def start_element(_, attributes)
         attributes = Hash[attributes]
         if @attrs.all? { |k, v| attributes[k] && (v.nil? || attributes[k] == v) }
           open
@@ -16,7 +16,7 @@ module Saxerator
         end
       end
 
-      def end_element _
+      def end_element(_)
         close
       end
     end

data/lib/saxerator/latches/within.rb

@@ -1,21 +1,17 @@
 module Saxerator
   module Latches
-    class Within < Nokogiri::XML::SAX::Document
+    class Within < ::Saxerator::SaxHandler
       def initialize(name)
         @name = name
         @depth_within_element = 0
       end
 
-      def start_element name, _
-        if name == @name || @depth_within_element > 0
-          @depth_within_element += 1
-        end
+      def start_element(name, _)
+        @depth_within_element += 1 if name == @name || @depth_within_element > 0
       end
 
-      def end_element _
-        if @depth_within_element > 0
-          @depth_within_element -= 1
-        end
+      def end_element(_)
+        @depth_within_element -= 1 if @depth_within_element > 0
       end
 
       def open?
@@ -23,4 +19,4 @@ module Saxerator
       end
     end
   end
-end
+end

data/lib/saxerator/parser/accumulator.rb

@@ -1,35 +1,32 @@
 module Saxerator
   module Parser
-    class Accumulator < Nokogiri::XML::SAX::Document
+    class Accumulator < ::Saxerator::SaxHandler
       def initialize(config, block)
         @stack = []
         @config = config
         @block = block
-        @builder = Builder.to_class(@config.output_type)
       end
 
       def start_element(name, attrs = [])
-        @stack.push @builder.new(@config, name, Hash[*attrs.flatten])
+        @stack.push @config.output_type.new(@config, name, Hash[attrs])
       end
 
       def end_element(_)
         if @stack.size > 1
           last = @stack.pop
-          @stack.last.add_node last
+          @stack[-1].add_node last
         else
           @block.call(@stack.pop.block_variable)
         end
       end
 
       def characters(string)
-        @stack.last.add_node(string) unless string.strip.length == 0
+        @stack[-1].add_node(string) unless string.strip.length == 0
       end
 
-      alias cdata_block characters
-
       def accumulating?
-        @stack.size > 0
+        !@stack.empty?
       end
     end
   end
-end
+end

data/lib/saxerator/parser/latched_accumulator.rb

@@ -1,6 +1,6 @@
 module Saxerator
   module Parser
-    class LatchedAccumulator < Nokogiri::XML::SAX::Document
+    class LatchedAccumulator < ::Saxerator::SaxHandler
       def initialize(config, latches, block)
         @latches = latches
         @accumulator = Accumulator.new(config, block)
@@ -9,22 +9,7 @@ module Saxerator
 
       def check_latches_and_passthrough(method, *args)
         @latches.each { |latch| latch.send(method, *args) }
-        if @accumulator.accumulating? ||
-            @latches.all? { |latch| latch.open? }
-          @accumulator.send(method, *args)
-        end
-      end
-
-      def xmldecl(version, encoding, standalone)
-        check_latches_and_passthrough(:xmldecl, version, encoding, standalone)
-      end
-
-      def start_document
-        check_latches_and_passthrough(:start_document)
-      end
-
-      def end_document
-        check_latches_and_passthrough(:end_document)
+        @accumulator.send(method, *args) if @accumulator.accumulating? || @latches.all?(&:open?)
       end
 
       def start_element(name, attrs = [])
@@ -35,42 +20,12 @@ module Saxerator
         check_latches_and_passthrough(:end_element, name)
       end
 
-      def start_element_namespace(name, attrs = [], prefix = nil, uri = nil, ns = [])
-        if @ignore_namespaces
-          prefix, uri, ns = nil, nil, []
-          attrs.each do |attr|
-            attr.prefix = nil if attr.respond_to? :prefix
-            attr.uri = nil if attr.respond_to? :uri
-          end
-        end
-        check_latches_and_passthrough(:start_element_namespace, name, attrs, prefix, uri, ns)
-      end
-
-      def end_element_namespace(name, prefix = nil, uri = nil)
-        if @ignore_namespaces
-          prefix, uri = nil
-        end
-        check_latches_and_passthrough(:end_element_namespace, name, prefix, uri)
-      end
-
       def characters(string)
         check_latches_and_passthrough(:characters, string)
       end
 
-      def comment(string)
-        check_latches_and_passthrough(:comment, string)
-      end
-
-      def warning(string)
-        check_latches_and_passthrough(:warning, string)
-      end
-
-      def error(string)
-        check_latches_and_passthrough(:error, string)
-      end
-
-      def cdata_block(string)
-        check_latches_and_passthrough(:cdata_block, string)
+      def ignore_namespaces?
+        @ignore_namespaces
       end
     end
   end