pipa-xmlnuts 0.0.2

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Igor Gunko
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,5 @@
+== xmlnuts
+
+
+
+Released under the MIT license (included)

data/lib/xmlnuts.rb

@@ -0,0 +1 @@
+require 'xmlnuts/nuts'

data/lib/xmlnuts/converters.rb

@@ -0,0 +1,115 @@
+module XmlNuts
+  module Converters
+    def self.lookup(type)
+      lookup!(type)
+    rescue ArgumentError
+      nil
+    end
+
+    def self.lookup!(type)
+      const_get("Convert_#{type}")
+    rescue NameError
+      raise ArgumentError, "converter not found for #{type}"
+    end
+
+    def self.create(type, options)
+      create!(type, options)
+    rescue ArgumentError
+      nil
+    end
+
+    def self.create!(type, options)
+      lookup!(type).new(options)
+    end
+
+    class Convert_string #:nodoc:
+      def initialize(options)
+        @whitespace = options[:whitespace] || :trim
+      end
+
+      def to_xml(string)
+        string
+      end
+
+      def from_xml(string)
+        return nil unless string
+        string = case @whitespace
+        when :trim then string.strip
+        when :preserve then string
+        when :collapse then string.gsub(/\s+/, ' ').strip
+        end
+      end
+    end
+
+    class Convert_boolean < Convert_string #:nodoc:
+      def initialize(options)
+        super
+        @format = options[:format] || :truefalse
+        raise ArgumentError, "unrecognized format #{@format}" unless [:truefalse, :yesno, :numeric].include?(@format)
+      end
+
+      def to_xml(flag)
+        return nil if flag.nil?
+        case @format
+        when :truefalse then flag ? 'true' : 'false'
+        when :yesno then flag ? 'yes' : 'no'
+        when :numeric then flag ? '0' : '1'
+        end
+      end
+
+      def from_xml(string)
+        return nil unless string
+        case string = super(string)
+        when '1', 'true', 'yes' then true
+        when '0', 'false', 'no' then false
+        else
+          raise ArgumentError, "invalid value for boolean: #{string.inspect}"
+        end
+      end
+    end
+
+    class Convert_integer < Convert_string #:nodoc:
+      def initialize(options)
+        super
+      end
+
+      def to_xml(int)
+        int.to_s
+      end
+
+      def from_xml(string)
+        string && Integer(super(string))
+      end
+    end
+
+    class Convert_datetime < Convert_string #:nodoc:
+      def initialize(options)
+        super
+        @fraction_digits = options[:fraction_digits] || 0
+      end
+
+      def to_xml(time)
+        time && time.xmlschema(@fraction_digits)
+      end
+
+      def self.from_xml(string)
+        string && Time.parse(super(string, options))
+      end
+    end
+
+    class Convert_list #:nodoc:
+      def initialize(options)
+        @item_type = options[:item_type] || :string
+        @item_converter = Converters.create!(@item_type, options)
+      end
+
+      def to_xml(array)
+        array.map {|x| @item_converter.to_xml(x) } * ' '
+      end
+
+      def from_xml(string)
+        string && string.split.map! {|x| @item_converter.from_xml(x)}
+      end
+    end
+  end
+end

data/lib/xmlnuts/mappings.rb

@@ -0,0 +1,137 @@
+module XmlNuts
+  class Mapping
+    attr_reader :name, :xmlname, :type, :options, :converter
+
+    def initialize(name, type, options)
+      @name, @xmlname, @type, @options = name.to_sym, (options.delete(:xmlname) || name).to_s, type, options
+      @setter = :"#{name}="
+      @converter = Converters.create(type, options)
+    end
+
+    def to_xml(nut, node)
+      setxml(node, toxml(get(nut)))
+    end
+
+    def from_xml(nut, node)
+      set(nut, froxml(getxml(node)))
+    end
+
+    private
+    def get(nut) #:doc:
+      nut.send(name)
+    end
+
+    def set(nut, value) #:doc:
+      nut.send(@setter, value)
+    end
+
+    def toxml(value) #:doc:
+      value
+    end
+
+    def froxml(text) #:doc:
+      text
+    end
+  end
+
+  class PrimitiveMapping < Mapping
+    def initialize(name, type, options)
+      if type.is_a?(Array)
+        raise ArgumentError, "invalid value for type: #{type}" if type.length != 1
+        type, options[:item_type] = :list, type.first
+      end
+      super
+      raise ArgumentError, "converter absent for type #{type.inspect}" unless converter
+    end
+
+    private
+    def toxml(value) #:doc:
+      converter.to_xml(value)
+    end
+
+    def froxml(text) #:doc:
+      converter.from_xml(text)
+    end
+  end
+
+  class ElementMapping < PrimitiveMapping
+    private
+    def getxml(node) #:doc:
+      (e = node.elements[xmlname]) && e.text
+    end
+
+    def setxml(node, value) #:doc:
+      (node.elements[xmlname] ||= REXML::Element.new(xmlname)).text = value
+    end
+  end
+
+  class AttributeMapping < PrimitiveMapping
+    private
+    def getxml(node) #:doc:
+      node.attributes[xmlname]
+    end
+
+    def setxml(node, value) #:doc:
+      node.add_attribute(xmlname, value)
+    end
+  end
+
+  module NestedMany
+    private
+    def toxml(nested_nuts) #:doc:
+      nested_nuts && nested_nuts.map {|x| super(x) }
+    end
+
+    def froxml(nested_nodes) #:doc:
+      nested_nodes && nested_nodes.map {|x| super(x) }
+    end
+  end
+
+  class ElementsMapping < PrimitiveMapping
+    include NestedMany
+
+    private
+    def getxml(node) #:doc:
+      (e = node.get_elements(xmlname)) && e.map {|x| x.text }
+    end
+
+    def setxml(node, values) #:doc:
+      values.each {|x| node.add_element(xmlname).text = x } if values
+    end
+  end
+
+  class NestedMapping < Mapping
+    private
+    def toxml(nested_nut) #:doc:
+      type.build_node(nested_nut, Element.new(xmlname))
+    end
+
+    def froxml(nested_node) #:doc:
+      type.parse_node(type.new, nested_node)
+    end
+  end
+
+  class NestedOneMapping < NestedMapping
+    private
+    def getxml(node) #:doc:
+      node.elements[xmlname]
+    end
+
+    def setxml(node, nested_node) #:doc:
+      node.elements << nested_node if nested_node
+    end
+  end
+
+  class NestedManyMapping < NestedMapping
+    include NestedMany
+
+    private
+    def getxml(node) #:doc:
+      node.get_elements(xmlname)
+    end
+
+    def setxml(node, nested_nodes) #:doc:
+      nested_nodes.each {|x| node.add_element(x) }
+    end
+  end
+end

data/lib/xmlnuts/nuts.rb

@@ -0,0 +1,72 @@
+require 'rexml/document'
+require 'time'
+require 'xmlnuts/converters'
+require 'xmlnuts/mappings'
+
+module XmlNuts #:nodoc:
+  module Nut
+    def self.included(other) #:nodoc:
+      other.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def element(name, type = :string, options = {})
+        mappings << (type.is_a?(Class) ? NestedOneMapping : ElementMapping).new(name, type, options)
+        attr_accessor name
+      end
+
+      def elements(name, type = :string, options = {})
+        mappings << (type.is_a?(Class) ? NestedManyMapping : ElementsMapping).new(name, type, options)
+        attr_accessor name
+      end
+
+      def attribute(name, type = :string, options = {})
+        mappings << AttributeMapping.new(name, type, options)
+        attr_accessor name
+      end
+
+      def mappings
+        @mappings ||= []
+      end
+
+      def build(nut, destination = nil)
+        case destination
+        when nil
+          destination = REXML::Document.new
+          e = destination.add_element('root')
+          build_node(nut, e)
+        when REXML::Node
+          build_node(nut, destination)
+        end
+        destination
+      end
+
+      def parse(source)
+        case source
+        when nil
+          nil
+        when REXML::Node
+          parse_node(new, source)
+        when String
+          doc = REXML::Document.new(source)
+          (root = doc.root) ? parse_node(new, root) : nil
+        end
+      end
+
+      def build_node(nut, node)
+        callem(:to_xml, nut, node)
+        node
+      end
+
+      def parse_node(nut, node)
+        callem(:from_xml ,nut, node)
+        nut
+      end
+
+      private
+      def callem(method, nut, node)
+        mappings.each {|m| m.send(method, nut, node) }
+      end
+    end
+  end
+end

data/test/parsing_test.rb

@@ -0,0 +1,85 @@
+#$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'shoulda'
+require 'lib/xmlnuts'
+
+class Cheezburger
+  include XmlNuts::Nut
+
+  attribute :weight, :integer
+end
+
+class Pet
+  include XmlNuts::Nut
+
+  element :eats, [:string], :xmlname => :ration
+  element :species, :string, :whitespace => :collapse
+  elements :paws, :string, :xmlname => :paw
+
+  attribute :has_tail, :boolean, :xmlname => 'has-tail'
+  attribute :height, :integer
+
+  element :cheezburger, Cheezburger
+end
+
+class ParsingTest < Test::Unit::TestCase
+  context "Old McDonald's pet" do
+    setup do
+      @xml_fragment = <<-EOS
+        <mypet height=' 12 ' has-tail=' yes  '>
+          <species>   silly
+              mouse
+          </species>
+          <ration>  tigers
+                    lions
+          </ration>
+          <paw>  one</paw>
+          <paw> two </paw>
+          <paw>three</paw>
+          <paw>four</paw>
+          <cheezburger weight='2'>
+          </cheezburger>
+          <cub age='4'>
+          </cub>
+        </mypet>
+      EOS
+      @pet = Pet.parse(@xml_fragment)
+    end
+
+    should 'be a silly mouse' do
+      assert_equal 'silly mouse', @pet.species
+    end
+
+    should 'eat tigers and lions' do
+      assert_equal ['tigers', 'lions'], @pet.eats
+    end
+
+    should 'be 12 meters tall' do
+      assert_equal 12, @pet.height
+    end
+
+    should 'have tail' do
+      assert_equal true, @pet.has_tail
+    end
+
+    should 'have four paws' do
+      assert_not_nil @pet.paws
+      assert_equal 4, @pet.paws.length
+      assert_equal %w(one two three four), @pet.paws
+    end
+
+    context 'should has cheezburger' do
+      setup do
+        assert_not_nil @burger = @pet.cheezburger
+        assert_kind_of Cheezburger, @pet.cheezburger
+      end
+
+      context 'that' do
+        should 'weigh 2 kg' do
+          assert_equal 2, @burger.weight
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: pipa-xmlnuts
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Igor Gunko
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-14 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: XmlNuts is an XML to ruby object and back again mapping library.
+email: tekmon@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- MIT-LICENSE
+files: 
+- README
+- MIT-LICENSE
+- lib/xmlnuts.rb
+- lib/xmlnuts/nuts.rb
+- lib/xmlnuts/mappings.rb
+- lib/xmlnuts/converters.rb
+has_rdoc: true
+homepage: http://github.com/pipa/xmlnuts
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Making xml<->ruby binding easy
+test_files: 
+- test/parsing_test.rb