saxophone 1.0.0

data/lib/saxophone/config/sax_element.rb

@@ -0,0 +1,65 @@
+module Saxophone
+  class SAXConfig
+    class ElementConfig
+      attr_reader :name, :as, :setter, :data_class, :collection, :default
+
+      def initialize(name, options)
+        @name = name.to_s
+        @with = options.fetch(:with, {})
+
+        @value = if options.has_key?(:value)
+          options[:value].to_s
+        else
+          nil
+        end
+
+        @as = options[:as]
+        @collection = options[:collection]
+        @default = options[:default]
+
+        @setter = if @collection
+          "add_#{options[:as]}"
+        else
+          "#{@as}="
+        end
+
+        @data_class = options[:class]
+        @required = options[:required]
+      end
+
+      def value_configured?
+        !@value.nil?
+      end
+
+      def to_s
+        "name: #{@name} dataclass: #{@data_class} setter: #{@setter} required: #{@required} value: #{@value} as:#{@as} collection: #{@collection} with: #{@with}"
+      end
+
+      def column
+        @as || @name.to_sym
+      end
+
+      def required?
+        !!@required
+      end
+
+      def value_from_attrs(attrs)
+        attrs.fetch(@value, nil)
+      end
+
+      def attrs_match?(attrs)
+        @with.all? do |key, value|
+          value === attrs[key.to_s]
+        end
+      end
+
+      def has_value_and_attrs_match?(attrs)
+        !@value.nil? && attrs_match?(attrs)
+      end
+
+      def collection?
+        !!@collection
+      end
+    end
+  end
+end

data/lib/saxophone/config/sax_element_value.rb

@@ -0,0 +1,23 @@
+module Saxophone
+  class SAXConfig
+    class ElementValueConfig
+      attr_reader :name, :setter, :data_class
+
+      def initialize(name, options)
+        @name     = name.to_s
+        @as       = options[:as]
+        @setter   = "#{@as}="
+        @required = options[:required]
+        @data_class = options[:class]
+      end
+
+      def column
+        @as || @name.to_sym
+      end
+
+      def required?
+        !!@required
+      end
+    end
+  end
+end

data/lib/saxophone/handlers/sax_abstract_handler.rb

@@ -0,0 +1,200 @@
+require 'time'
+
+module Saxophone
+  module SAXAbstractHandler
+    NO_BUFFER = :no_buffer
+
+    class StackNode < Struct.new(:object, :config, :buffer)
+      def initialize(object, config = nil, buffer = NO_BUFFER)
+        self.object = object
+        self.config = config
+        self.buffer = buffer
+      end
+    end
+
+    def sax_parse(xml_input)
+      raise NotImplementedError
+    end
+
+    def _initialize(object, on_error = nil, on_warning = nil)
+      @stack = [ StackNode.new(object) ]
+      @parsed_configs = {}
+      @on_error = on_error
+      @on_warning = on_warning
+    end
+
+    def _characters(data)
+      node = stack.last
+
+      if node.buffer == NO_BUFFER
+        node.buffer = data.dup
+      else
+        node.buffer << data
+      end
+    end
+
+    def _start_element(name, attrs = [])
+      name   = normalize_name(name)
+      node   = stack.last
+      object = node.object
+
+      sax_config = sax_config_for(object)
+
+      if sax_config
+        attrs = Hash[attrs]
+
+        if collection_config = sax_config.collection_config(name, attrs)
+          object     = collection_config.data_class.new
+          sax_config = sax_config_for(object)
+
+          stack.push(StackNode.new(object, collection_config))
+
+          set_attributes_on(object, attrs)
+        end
+
+        sax_config.element_configs_for_attribute(name, attrs).each do |ec|
+          unless parsed_config?(object, ec)
+            value = data_class_value(ec.data_class, ec.value_from_attrs(attrs))
+            object.send(ec.setter, value)
+            mark_as_parsed(object, ec)
+          end
+        end
+
+        if !collection_config && element_config = sax_config.element_config_for_tag(name, attrs)
+          new_object =
+            case element_config.data_class.to_s
+            when "Integer" then 0
+            when "Float"   then 0.0
+            when "Symbol"  then nil
+            when "Time"    then Time.at(0)
+            when ""        then object
+            else
+              element_config.data_class.new
+            end
+
+          stack.push(StackNode.new(new_object, element_config))
+
+          set_attributes_on(new_object, attrs)
+        end
+      end
+    end
+
+    def _end_element(name)
+      name = normalize_name(name)
+
+      start_tag = stack[-2]
+      close_tag = stack[-1]
+
+      return unless start_tag && close_tag
+
+      object  = start_tag.object
+      element = close_tag.object
+      config  = close_tag.config
+      value   = close_tag.buffer
+
+      return unless config.name == name
+
+      unless parsed_config?(object, config)
+        if (element_value_config = element_values_for(config))
+          element_value_config.each { |evc| element.send(evc.setter, value) }
+        end
+
+        if config.respond_to?(:accessor)
+          subconfig = sax_config_for(element)
+
+          if econf = subconfig.element_config_for_tag(name, [])
+            element.send(econf.setter, value) unless econf.value_configured?
+          end
+
+          object.send(config.accessor) << element
+        else
+          value = data_class_value(config.data_class, value) || element
+          object.send(config.setter, value) if value != NO_BUFFER
+          mark_as_parsed(object, config)
+        end
+
+        # try to set the ancestor
+        if (sax_config = sax_config_for(element))
+          sax_config.ancestors.each do |ancestor|
+            element.send(ancestor.setter, object)
+          end
+        end
+      end
+
+      stack.pop
+    end
+
+    def _error(string)
+      if @on_error
+        @on_error.call(string)
+      end
+    end
+
+    def _warning(string)
+      if @on_warning
+        @on_warning.call(string)
+      end
+    end
+
+    private
+
+    def mark_as_parsed(object, element_config)
+      unless element_config.collection?
+        @parsed_configs[[object.object_id, element_config.object_id]] = true
+      end
+    end
+
+    def parsed_config?(object, element_config)
+      @parsed_configs[[object.object_id, element_config.object_id]]
+    end
+
+    def sax_config_for(object)
+      if object.class.respond_to?(:sax_config)
+        object.class.sax_config
+      end
+    end
+
+    def element_values_for(config)
+      if config.data_class.respond_to?(:sax_config)
+        config.data_class.sax_config.element_values_for_element
+      end
+    end
+
+    def normalize_name(name)
+      name.to_s.tr("-", "_")
+    end
+
+    def set_attributes_on(object, attributes)
+      config = sax_config_for(object)
+
+      if config
+        config.attribute_configs_for_element(attributes).each do |ac|
+          value = data_class_value(ac.data_class, ac.value_from_attrs(attributes))
+          object.send(ac.setter, value)
+        end
+      end
+    end
+
+    def data_class_value(data_class, value)
+      case data_class.to_s
+      when "String"  then value != NO_BUFFER ? value.to_s : value
+      when "Integer" then value != NO_BUFFER ? value.to_i : value
+      when "Float"   then value != NO_BUFFER ? value.to_s.gsub(",",".").to_f : value
+      when "Symbol"  then
+        if value != NO_BUFFER
+          value.to_s.empty? ? nil : value.to_s.downcase.to_sym
+        else
+          value
+        end
+      # Assumes that time elements will be string-based and are not
+      # something else, e.g. seconds since epoch
+      when "Time"    then value != NO_BUFFER ? Time.parse(value.to_s) : value
+      when ""        then value
+      end
+    end
+
+    def stack
+      @stack
+    end
+  end
+end

data/lib/saxophone/handlers/sax_nokogiri_handler.rb

@@ -0,0 +1,23 @@
+require 'saxophone/handlers/sax_abstract_handler'
+require 'nokogiri'
+
+module Saxophone
+  class SAXNokogiriHandler < Nokogiri::XML::SAX::Document
+    include SAXAbstractHandler
+
+    def sax_parse(xml_input)
+      parser = Nokogiri::XML::SAX::Parser.new(self)
+      parser.parse(xml_input) do |ctx|
+        ctx.replace_entities = true
+      end
+    end
+
+    alias_method :initialize, :_initialize
+    alias_method :characters, :_characters
+    alias_method :cdata_block, :_characters
+    alias_method :start_element, :_start_element
+    alias_method :end_element, :_end_element
+    alias_method :error, :_error
+    alias_method :warning, :_warning
+  end
+end

data/lib/saxophone/handlers/sax_oga_handler.rb

@@ -0,0 +1,39 @@
+require 'saxophone/handlers/sax_abstract_handler'
+require 'oga'
+
+module Saxophone
+  class SAXOgaHandler
+    include SAXAbstractHandler
+
+    def initialize(*args)
+      _initialize(*args)
+    end
+
+    def sax_parse(xml_input)
+      Oga.sax_parse_xml(self, xml_input)
+    rescue LL::ParserError => e
+      on_error(e.message)
+    end
+
+    def on_element(namespace, name, attrs)
+      _start_element(node_name(namespace, name), attrs)
+    end
+
+    def after_element(namespace, name)
+      _end_element(node_name(namespace, name))
+    end
+
+    def on_error(*args)
+      _error(args.join(" "))
+    end
+
+    alias_method :on_text, :_characters
+    alias_method :on_cdata, :_characters
+
+    private
+
+    def node_name(namespace, name)
+      namespace ? "#{namespace}:#{name}" : name
+    end
+  end
+end

data/lib/saxophone/handlers/sax_ox_handler.rb

@@ -0,0 +1,56 @@
+require 'saxophone/handlers/sax_abstract_handler'
+require 'ox'
+
+module Saxophone
+  class SAXOxHandler < Ox::Sax
+    include SAXAbstractHandler
+
+    def initialize(*args)
+      _initialize(*args)
+      _reset_element
+    end
+
+    def sax_parse(xml_input)
+      # Ox requires input to be streamable
+      xml_input = StringIO.new(xml_input) if xml_input.is_a?(String)
+
+      Ox.sax_parse(self, xml_input,
+        symbolize: false,
+        convert_special: true,
+        skip: :skip_return,
+      )
+    end
+
+    def attr(name, str)
+      @attrs[name] = str
+    end
+
+    def attrs_done
+      _start_element(@element, @attrs)
+      _reset_element
+    end
+
+    def start_element(name)
+      @element = name
+    end
+
+    def text(value)
+      _characters(value) if value && !value.empty?
+    end
+
+    alias_method :cdata, :text
+
+    def error(message, line, column)
+      _error("#{message} on line #{line} column #{column}")
+    end
+
+    alias_method :end_element, :_end_element
+
+    private
+
+    def _reset_element
+      @attrs = {}
+      @element = ""
+    end
+  end
+end

data/lib/saxophone/sax_config.rb

@@ -0,0 +1,78 @@
+require "saxophone/config/sax_element_value"
+require "saxophone/config/sax_attribute"
+require "saxophone/config/sax_element"
+require "saxophone/config/sax_collection"
+require "saxophone/config/sax_ancestor"
+
+module Saxophone
+  class SAXConfig
+    attr_accessor :top_level_elements, :top_level_attributes, :top_level_element_value, :collection_elements, :ancestors
+
+    def initialize
+      # Default value is an empty array
+      @top_level_elements = Hash.new { |hash, key| hash[key] = [] }
+      @top_level_attributes  = []
+      @top_level_element_value = []
+      @collection_elements = Hash.new { |hash, key| hash[key] = [] }
+      @ancestors = []
+    end
+
+    def columns
+      @top_level_elements.map { |_, ecs| ecs }.flatten
+    end
+
+    def initialize_copy(sax_config)
+      super
+
+      @top_level_elements = sax_config.top_level_elements.clone
+      @top_level_attributes = sax_config.top_level_attributes.clone
+      @top_level_element_value = sax_config.top_level_element_value.clone
+      @collection_elements = sax_config.collection_elements.clone
+      @ancestors = sax_config.ancestors.clone
+    end
+
+    def add_top_level_element(name, options)
+      @top_level_elements[name.to_s] << ElementConfig.new(name, options)
+    end
+
+    def add_top_level_attribute(name, options)
+      @top_level_attributes << AttributeConfig.new(options.delete(:name), options)
+    end
+
+    def add_top_level_element_value(name, options)
+      @top_level_element_value << ElementValueConfig.new(options.delete(:name), options)
+    end
+
+    def add_collection_element(name, options)
+      @collection_elements[name.to_s] << CollectionConfig.new(name, options)
+    end
+
+    def add_ancestor(name, options)
+      @ancestors << AncestorConfig.new(name, options)
+    end
+
+    def collection_config(name, attrs)
+      @collection_elements[name.to_s].detect { |cc| cc.attrs_match?(attrs) }
+    end
+
+    def attribute_configs_for_element(attrs)
+      @top_level_attributes.select { |aa| aa.attrs_match?(attrs) }
+    end
+
+    def element_values_for_element
+      @top_level_element_value
+    end
+
+    def element_configs_for_attribute(name, attrs)
+      return [] unless @top_level_elements.has_key?(name.to_s)
+
+      @top_level_elements[name.to_s].select { |ec| ec.has_value_and_attrs_match?(attrs) }
+    end
+
+    def element_config_for_tag(name, attrs)
+      return unless @top_level_elements.has_key?(name.to_s)
+
+      @top_level_elements[name.to_s].detect { |ec| ec.attrs_match?(attrs) }
+    end
+  end
+end