peanuts 1.0 → 2.0.7

data/lib/peanuts/mappings.rb

@@ -1,49 +1,86 @@
-require 'enumerator'
-require 'peanuts/backend'
+require 'forwardable'
 require 'peanuts/converters'
 
 module Peanuts
-  module Mappings
-    class Mapping
-      attr_reader :xmlname, :xmlns, :options
+  class Mapping
+    attr_reader :local_name, :namespace_uri, :prefix, :options
 
-      def initialize(xmlname, options)
-        @xmlname, @xmlns, @options = xmlname.to_s, options.delete(:xmlns), options
-      end
+    def initialize(local_name, options)
+      @local_name, @namespace_uri, @prefix, @options = local_name.to_s, options.delete(:ns), options.delete(:prefix), options
+    end
+
+    def matches?(reader)
+      node_type == reader.node_type &&
+        local_name == reader.local_name &&
+        namespace_uri == reader.namespace_uri
     end
 
+    def self.node_type(node_type)
+      define_method(:node_type) { node_type }
+    end
+  end
+
+  module Mappings # :nodoc:
     class Root < Mapping
-      def initialize(xmlname, options = {})
-        super
+      node_type :element
+
+      def write(writer, &block)
+        writer.write(node_type, local_name, namespace_uri, prefix, &block)
       end
     end
 
     class MemberMapping < Mapping
-      include XmlBackend
-
       attr_reader :name, :type, :converter
 
       def initialize(name, type, options)
-        super(options.delete(:xmlname) || name, options)
-        case type
+        @bare_name = name.to_s.sub(/\?\z/, '')
+
+        super(options.delete(:name) || @bare_name, options)
+
+        @type = type
+        @converter = case type
+        when Symbol
+          Converter.create!(type, options)
+        when Class
+          if type < Converter
+            @type = nil
+            Converter.create!(type, options)
+          end
         when Array
-          raise ArgumentError, "invalid value for type: #{type}" if type.length != 1
+          raise ArgumentError, "invalid value for type: #{type.inspect}" if type.length != 1
           options[:item_type] = type.first
-          @converter = Converter.create!(:list, options)
-        when Class
-          options[:object_type] = type
+          Converter.create!(:list, options)
         else
-          @converter = Converter.create!(type, options)
+          raise ArgumentError, "invalid value for type: #{type.inspect}"
         end
-        @name, @setter, @type = name.to_sym, :"#{name}=", type
+        @name, @setter = name.to_sym, :"#{@bare_name}="
       end
 
-      def to_xml(nut, node)
-        setxml(node, get(nut))
+      def define_accessors(type)
+        raise ArgumentError, "#{name}: method already defined or reserved" if type.method_defined?(name)
+        raise ArgumentError, "#{@setter}: method already defined or reserved" if type.method_defined?(@setter)
+
+        ivar = :"@#{@bare_name}"
+        raise ArgumentError, "#{ivar}: instance variable already defined" if type.instance_variable_defined?(ivar)
+
+        type.send(:define_method, name) do
+          instance_variable_get(ivar)
+        end
+        type.send(:define_method, @setter) do |value|
+          instance_variable_set(ivar, value)
+        end
       end
 
-      def from_xml(nut, node)
-        set(nut, getxml(node))
+      def read(nut, reader)
+        set(nut, read_it(reader, get(nut)))
+      end
+
+      def write(nut, writer)
+        write_it(writer, get(nut))
+      end
+
+      def clear(nut)
+        set(nut, nil)
       end
 
       private
@@ -55,99 +92,117 @@ module Peanuts
         nut.send(@setter, value)
       end
 
-      def toxml(value)
+      def to_xml(value)
         @converter ? @converter.to_xml(value) : value
       end
 
-      def froxml(text)
+      def from_xml(text)
         @converter ? @converter.from_xml(text) : text
       end
 
-      def each_element(node, &block)
-        node && backend.each_element(node, xmlname, xmlns, &block)
-        nil
+      def write_node(writer, &block)
+        writer.write(node_type, local_name, namespace_uri, prefix, &block)
       end
+    end
 
-      def add_element(node, value = nil)
-        backend.add_element(node, xmlname, xmlns, value)
+    module SingleMapping
+      private
+      def read_it(reader, acc)
+        read_value(reader)
       end
 
-      def value(node)
-        backend.value(node)
+      def write_it(writer, value)
+        write_node(writer) {|w| write_value(w, value) } if value
       end
+    end
 
-      def parse(node)
-        type.parse_node(type.new, node)
+    module MultiMapping
+      def read_it(reader, acc)
+        (acc || []) << read_value(reader)
       end
 
-      def build(node, nut, dest_node)
-        nut && type.build_node(nut, dest_node)
+      def write_it(writer, values)
+        values.each {|value| write_node(writer) {|w| write_value(w, value) } } if values
       end
     end
 
-    class ElementValue < MemberMapping
+    module ValueMapping
       private
-      def getxml(node)
-        each_element(node) {|e| return froxml(value(e)) }
+      def read_value(reader)
+        from_xml(reader.value)
       end
 
-      def setxml(node, value)
-        add_element(node, toxml(value))
+      def write_value(writer, value)
+        writer.write_value(to_xml(value))
       end
     end
 
-    class Element < MemberMapping
+    module ObjectMapping
       private
-      def getxml(node)
-        each_element(node) {|e| return parse(e) }
+      def read_value(reader)
+        type.mapper.read(type.new, reader)
       end
 
-      def setxml(node, value)
-        build(node, value, add_element(node))
+      def write_value(writer, value)
+        type.mapper.write_children(value, writer)
       end
     end
 
+    class ElementValue < MemberMapping
+      include SingleMapping
+      include ValueMapping
+
+      node_type :element
+    end
+
+    class Element < MemberMapping
+      include SingleMapping
+      include ObjectMapping
+
+      node_type :element
+    end
+
     class Attribute < MemberMapping
-      private
-      def getxml(node)
-        froxml(backend.attribute(node, xmlname, xmlns))
-      end
+      include SingleMapping
+      include ValueMapping
 
-      def setxml(node, value)
-        backend.set_attribute(node, xmlname, xmlns, toxml(value))
+      node_type :attribute
+
+      def initialize(name, type, options)
+        super
+        raise ArgumentError, 'a namespaced attribute must have namespace prefix' if namespace_uri && !prefix
       end
     end
 
     class ElementValues < MemberMapping
-      private
-      def each_value(node)
-        each_element(node) {|x| yield froxml(value(x)) }
-      end
-
-      def getxml(node)
-        enum_for(:each_value, node).to_a
-      end
+      include MultiMapping
+      include ValueMapping
 
-      def setxml(node, values)
-        unless node
-          raise 'fuck'
-        end
-        values.each {|v| add_element(node, toxml(v)) } if values
-      end
+      node_type :element
     end
 
     class Elements < MemberMapping
-      private
-      def each_object(node)
-        each_element(node) {|e| yield parse(e) }
+      include MultiMapping
+      include ObjectMapping
+
+      node_type :element
+    end
+
+    class ShallowElement < Element
+      def read(nut, reader)
+        type.mapper.read(nut, reader)
+      end
+
+      def write(nut, writer)
+        write_node(writer) {|w| type.mapper.write_children(nut, w) }
       end
 
-      def getxml(node)
-        enum_for(:each_object, node)
+      def clear(nut)
+        type.mapper.clear(nut)
       end
 
-      def setxml(node, elements)
-        elements.each {|e| build(node, e, add_element(node)) } if elements
+      def define_accessors(type)
+        self.type.mapper.define_accessors(type)
       end
     end
   end

data/lib/peanuts/xml/libxml.rb

@@ -0,0 +1,231 @@
+require 'libxml'
+require 'forwardable'
+require 'uri'
+require 'stringio'
+require 'peanuts/xml'
+
+module Peanuts
+  module XML
+    module LibXML
+      def self.libxml_opt(options, default = {})
+        h = default.merge(options)
+        h.update(h.from_namespace!(:libxml))
+      end
+
+      class Writer < Peanuts::XML::Writer
+        DEFAULT_OPTIONS = {}
+
+        def initialize(dest, options = {})
+          @dest = case dest
+          when :string
+            ''
+          when :document
+            ::LibXML::XML::Document.new
+          when ::LibXML::XML::Document
+            dest
+          else
+            raise ArgumentError, "unsupported destination #{dest.inspect}" unless dest.respond_to?(:<<)
+            dest
+          end
+          @options = LibXML.libxml_opt(options, DEFAULT_OPTIONS)
+        end
+
+        def result
+          @dest
+        end
+
+        def write_value(value)
+          case @node
+          when ::LibXML::XML::Attr
+            @node.value = value || ''
+          else
+            @node.content = value || ''
+          end
+        end
+
+        def write_namespaces(namespaces)
+          for prefix, uri in namespaces
+            mkns(@node, uri, prefix)
+          end
+        end
+
+        def write(node_type, local_name = nil, namespace_uri = nil, prefix = nil)
+          case node_type
+          when :element
+            @node = ::LibXML::XML::Node.new(local_name)
+            @parent << @node if @parent
+            if namespace_uri || prefix
+              unless namespace_uri
+                defns = @node.namespaces.default
+                namespace_uri = defns ? defns.href : ''
+              end
+              @node.namespaces.namespace = mkns(@node, namespace_uri, prefix)
+            end
+          when :attribute
+            @node = ::LibXML::XML::Attr.new(@parent, local_name, '', namespace_uri && mkns(@parent, namespace_uri, prefix))
+          else
+            raise "unsupported node type #{node_type.inspect}"
+          end
+
+          exparent, @parent = @parent, @node
+
+          yield self
+
+          if exparent.nil?
+            case @dest
+            when ::LibXML::XML::Document
+              @dest.root = @parent
+            else
+              @dest << @parent.to_s(@options)
+            end
+          end
+
+          @parent = exparent
+        end
+
+        private
+        def mkns(node, namespace_uri, prefix)
+          prefix = nil if prefix && (prefix = prefix.to_s).empty?
+          newns = proc { ::LibXML::XML::Namespace.new(node, prefix, namespace_uri) }
+          node.namespaces.find(newns) {|ns| ns.prefix == prefix && ns.href == namespace_uri }
+        end
+      end
+
+      class Reader < Peanuts::XML::Reader
+        extend Forwardable
+
+        SCHEMAS = {:xml_schema => :schema, :relax_ng => :relax_ng}
+
+        RD = ::LibXML::XML::Reader
+
+        NODE_TYPES = [
+          nil,
+          :element,
+          :attribute,
+          :text,
+          :cdata,
+          :entity_reference,
+          :entity,
+          :processing_instruction,
+          :comment,
+          :document,
+          :document_type,
+          :document_fragment,
+          :notation,
+          :whitespace,
+          :significant_whitespace,
+          :end_element,
+          :end_entity,
+          :xml_declaration
+        ].freeze
+
+        DEFAULT_OPTIONS = {}
+
+        def initialize(source, options = {})
+          super()
+          options = options.dup
+          @schema = options.delete(:schema)
+          options = LibXML.libxml_opt(options, DEFAULT_OPTIONS)
+          @reader = case source
+          when String
+            RD.string(source.to_s, options)
+          when URI
+            RD.file(source.to_s, options)
+          when ::LibXML::XML::Document
+            RD.document(source)
+          else
+            raise "unsupported source #{source.inspect}" unless source.respond_to?(:read)
+            RD.io(source, options)
+          end
+          @reader.send("#{SCHEMAS[schema.type]}_validate", schema.schema) if @schema
+        end
+
+        def close
+          @reader.close
+        end
+
+        def_delegators :@reader, :name, :local_name, :namespace_uri, :depth
+
+        def node_type
+          NODE_TYPES[@reader.node_type]
+        end
+
+        def value
+          case @reader.node_type
+          when RD::TYPE_ELEMENT
+            @reader.read_string
+          else
+            @reader.has_value? ? @reader.value : nil
+          end
+        end
+
+        def each
+          depth = self.depth
+          if read
+            while self.depth > depth
+              yield self
+              break unless next_sibling
+            end
+          end
+        end
+
+        def find_element
+          until @reader.node_type == RD::TYPE_ELEMENT
+            return nil unless read
+          end
+          self
+        end
+
+        private
+        def read
+          case @reader.node_type
+          when RD::TYPE_ATTRIBUTE
+            @reader.move_to_next_attribute > 0 || @reader.read
+          else
+            @reader.move_to_first_attribute > 0 || @reader.read
+          end
+        end
+
+        def next_sibling
+          case @reader.node_type
+          when RD::TYPE_ATTRIBUTE
+            @reader.move_to_next_attribute > 0 || @reader.read
+          else
+            @reader.next > 0
+          end
+        end
+      end
+
+      def self.schema(schema_type, source)
+        schema_class = case schema_type
+        when :xml_schema
+          ::LibXML::XML::Schema
+        when :relax_ng
+          ::LibXML::XML::RelaxNG
+        else
+          raise ArgumentError, "unrecognized schema type #{schema_type}"
+        end
+        schema = case source
+        when IO
+          schema_class.string(source.read)
+        when URI
+          schema_class.new(source.to_s)
+        when ::LibXML::XML::Document
+          schema_class.document(source)
+        else
+          schema_class.string(source)
+        end
+
+        Schema.new(schema_type, schema)
+      end
+
+      class Schema
+        attr_reader :type, :handle
+
+        def initialize(type, handle)
+          @type, @handle = type, handle
+        end
+      end
+    end
+  end
+end

data/lib/peanuts/xml.rb

@@ -0,0 +1,60 @@
+require 'enumerator'
+
+class Hash
+  def from_namespace(ns)
+    rx = /^#{Regexp.quote(ns.to_s)}_(.*)$/
+    inject({}) do |a, p|
+      a[$1.to_sym] = p[1] if p[0].to_s =~ rx
+      a
+    end
+  end
+
+  def from_namespace!(ns)
+    h = from_namespace(ns)
+    h.each_key {|k| delete(:"#{ns}_#{k}") }
+    h
+  end
+end
+
+module Peanuts
+  module XML
+    autoload :LibXML, 'peanuts/xml/libxml'
+
+    def self.default
+      @@default ||= LibXML
+    end
+
+    def self.schema(schema_type, source)
+      default.schema(schema_type, source)
+    end
+
+    def self.method_missing(method, *args, &block)
+      case method.to_s
+      when /^(.*)_schema_from_(.*)$/
+        XML.schema($1.to_sym, args.first)
+      else
+        super
+      end
+    end
+
+    class Reader
+      include Enumerable
+
+      def self.new(*args, &block)
+        cls = self == Reader ? XML.default::Reader : self
+        obj = cls.allocate
+        obj.send(:initialize, *args, &block)
+        obj
+      end
+    end
+
+    class Writer
+      def self.new(*args, &block)
+        cls = self == Writer ? XML.default::Writer : self
+        obj = cls.allocate
+        obj.send(:initialize, *args, &block)
+        obj
+      end
+    end
+  end
+end

data/lib/peanuts.rb

@@ -1 +1,7 @@
-require 'peanuts/nuts'
+require 'peanuts/mappable'
+
+module Peanuts #:nodoc:
+  def self.included(other)
+    other.send(:include, MappableObject)
+  end
+end