yaxml 0.0.7

data/doc/rdoc/rdoc-style.css

@@ -0,0 +1,208 @@
+
+body {
+    font-family: Verdana,Arial,Helvetica,sans-serif;
+    font-size:   90%;
+    margin: 0;
+    margin-left: 40px;
+    padding: 0;
+    background: white;
+}
+
+h1,h2,h3,h4 { margin: 0; color: #efefef; background: transparent; }
+h1 { font-size: 150%; }
+h2,h3,h4 { margin-top: 1em; }
+
+a { background: #eef; color: #039; text-decoration: none; }
+a:hover { background: #039; color: #eef; }
+
+/* Override the base stylesheet's Anchor inside a table cell */
+td > a {
+  background: transparent;
+  color: #039;
+  text-decoration: none;
+}
+
+/* and inside a section title */
+.section-title > a {
+  background: transparent;
+  color: #eee;
+  text-decoration: none;
+}
+
+/* === Structural elements =================================== */
+
+div#index {
+    margin: 0;
+    margin-left: -40px;
+    padding: 0;
+    font-size: 90%;
+}
+
+
+div#index a {
+    margin-left: 0.7em;
+}
+
+div#index .section-bar {
+   margin-left: 0px;
+   padding-left: 0.7em;
+   background: #ccc;
+   font-size: small;
+}
+
+
+div#classHeader, div#fileHeader {
+    width: auto;
+    color: white;
+    padding: 0.5em 1.5em 0.5em 1.5em;
+    margin: 0;
+    margin-left: -40px;
+    border-bottom: 3px solid #006;
+}
+
+div#classHeader a, div#fileHeader a {
+    background: inherit;
+    color: white;
+}
+
+div#classHeader td, div#fileHeader td {
+    background: inherit;
+    color: white;
+}
+
+
+div#fileHeader {
+    background: #057;
+}
+
+div#classHeader {
+    background: #048;
+}
+
+
+.class-name-in-header {
+  font-size:  180%;
+  font-weight: bold;
+}
+
+
+div#bodyContent {
+    padding: 0 1.5em 0 1.5em;
+}
+
+div#description {
+    padding: 0.5em 1.5em;
+    background: #efefef;
+    border: 1px dotted #999;
+}
+
+div#description h1,h2,h3,h4,h5,h6 {
+    color: #125;;
+    background: transparent;
+}
+
+div#validator-badges {
+    text-align: center;
+}
+div#validator-badges img { border: 0; }
+
+div#copyright {
+    color: #333;
+    background: #efefef;
+    font: 0.75em sans-serif;
+    margin-top: 5em;
+    margin-bottom: 0;
+    padding: 0.5em 2em;
+}
+
+
+/* === Classes =================================== */
+
+table.header-table {
+    color: white;
+    font-size: small;
+}
+
+.type-note {
+    font-size: small;
+    color: #DEDEDE;
+}
+
+.xxsection-bar {
+    background: #eee;
+    color: #333;
+    padding: 3px;
+}
+
+.section-bar {
+   color: #333;
+   border-bottom: 1px solid #999;
+    margin-left: -20px;
+}
+
+
+.section-title {
+    background: #79a;
+    color: #eee;
+    padding: 3px;
+    margin-top: 2em;
+    margin-left: -30px;
+    border: 1px solid #999;
+}
+
+.top-aligned-row {  vertical-align: top }
+.bottom-aligned-row { vertical-align: bottom }
+
+/* --- Context section classes ----------------------- */
+
+.context-row { }
+.context-item-name { font-family: monospace; font-weight: bold; color: black; }
+.context-item-value { font-size: small; color: #448; }
+.context-item-desc { color: #333; padding-left: 2em; }
+
+/* --- Method classes -------------------------- */
+.method-detail {
+    background: #efefef;
+    padding: 0;
+    margin-top: 0.5em;
+    margin-bottom: 1em;
+    border: 1px dotted #ccc;
+}
+.method-heading {
+  color: black;
+  background: #ccc;
+  border-bottom: 1px solid #666;
+  padding: 0.2em 0.5em 0 0.5em;
+}
+.method-signature { color: black; background: inherit; }
+.method-name { font-weight: bold; }
+.method-args { font-style: italic; }
+.method-description { padding: 0 0.5em 0 0.5em; }
+
+/* --- Source code sections -------------------- */
+
+a.source-toggle { font-size: 90%; }
+div.method-source-code {
+    background: #262626;
+    color: #ffdead;
+    margin: 1em;
+    padding: 0.5em;
+    border: 1px dashed #999;
+    overflow: hidden;
+}
+
+div.method-source-code pre { color: #ffdead; overflow: hidden; }
+
+/* --- Ruby keyword styles --------------------- */
+
+.standalone-code { background: #221111; color: #ffdead; overflow: hidden; }
+
+.ruby-constant  { color: #7fffd4; background: transparent; }
+.ruby-keyword { color: #00ffff; background: transparent; }
+.ruby-ivar    { color: #eedd82; background: transparent; }
+.ruby-operator  { color: #00ffee; background: transparent; }
+.ruby-identifier { color: #ffdead; background: transparent; }
+.ruby-node    { color: #ffa07a; background: transparent; }
+.ruby-comment { color: #b22222; font-weight: bold; background: transparent; }
+.ruby-regexp  { color: #ffa07a; background: transparent; }
+.ruby-value   { color: #7fffd4; background: transparent; }

data/lib/simple_test.xml

@@ -0,0 +1,12 @@
+<root xmlns:yaml='http://yaml.org/xml'>
+	<three>
+		<_>apple</_>
+		<_>pear</_>
+	</three>
+      <two> 2.0 </two>
+	<one>1</one>
+	<four>
+		<bb>22</bb>
+		<aa>11</aa>
+	</four>
+</root>

data/lib/simple_test.yml

@@ -0,0 +1,9 @@
+one: 1
+two: 2.0 
+three:
+  - apple
+  - pear
+four: 
+  aa: 11
+  bb: 22
+

data/lib/yaxml.rb

@@ -0,0 +1,354 @@
+####################################################
+# 
+# YAXML Module
+# 
+# This code is released under LGPL.
+#
+# This module make the next conversions:
+#
+# * YAML -> YAXML
+# * JSON -> YAXML
+# * YAXML -> YAML
+# * YAXML -> JSON
+#
+# All conversions can use a file or a string as source.
+#
+# You can use this module in two ways:
+#
+# 1) Creating a Yaxml object
+#    xml = Yaxml.new 'file.yml'
+#    xml.write( $stdout, 2)
+#    xml.to_json
+#    xml.to_yaml
+#
+# 2) Using static methods of Yaxml module
+#    xml = Yaxml::yaml2yaxml( 'file.yml' )
+#    xml.write( $stdout, 2)
+#
+#    Also, you can use:
+#    xml  = Yaxml::json2yaxml( { numbers: [ 1, 2, 3 ]} )
+#    yaml = Yaxml::yaxml2yaml( 'file.yaxml' )
+#    json = Yaxml::yaxml2json( 'file.yaxml' )
+#
+# Author:: Diego Moreno (dmoreno@dit.upm.es)
+# License:: GNU Lesser General Public License (aka LGPL)
+#
+
+#require 'ruby-debug'
+
+require "rexml/document"
+require 'yaml'
+
+module YAXML
+  
+  # Default root name
+  DEFAULT_ROOT_NAME = "root"
+  
+  # Namespace for YAXML
+  NAMESPACE = "http://yaml.org/xml"
+  
+  class Yaxml < REXML::Document
+    
+    # Constructor
+    # source::
+    #   It can be a String or a file name.
+    # options::
+    #   It is possible to pass the next options:
+    # * <tt>:root_name</tt> It is the name of the root tag in the YAXML document. Defaults to +DEFAULT_ROOT_NAME+
+    # * <tt>:from_yaxml</tt> If true, the source will be considered as YAXML input. If false, the source will be considered as YAML input. Defaults to :+false+
+    #
+    # Example of use:
+    #   xml = Yaxml.new 'file.yml'
+    #   xml.write( $stdout, 2)
+    #   xml.to_json
+    #   xml.to_yaml
+    def initialize( source, options={} )
+      super()
+      
+      if options[:from_yaxml]
+        content = extract_content source
+        doc = REXML::Document.new content
+        self.add_element( doc.elements[1] ) if doc.elements[1]
+        
+      else #default is from_yaml
+        options[:root_name] ||= DEFAULT_ROOT_NAME
+        doc = YAXML::yaml2yaxml( source, options )
+        
+        self.add_element( doc.elements[1] ) if doc.elements[1]
+      end
+    
+    end
+	
+    # The output is a YAML representation of YAXML object.
+    def to_yaml
+      YAXML::yaxml2yaml self
+    end
+	
+    # The output is a JSON representation of YAXML object.
+    def to_json
+      YAXML::yaxml2json self
+    end
+    
+    # The output is a YAXML representation of YAXML object.
+    def to_yaxml
+      self.to_s
+    end
+    
+    private
+    def extract_content source
+      if File.exist?source
+        File.open( source, "r" ).read # is a file
+      else
+        source # is a string
+      end
+    end
+  
+  end
+  
+  
+  #################################################
+  # From ANY To YAXML
+  #################################################
+  
+  # Conversion YAML -> YAXML
+  # 
+  # source::
+  #   It can be a YAML file in a String or a file name.
+  # options::
+  # * <tt>:root_name</tt> It is the name of the root tag in the YAXML document. Defaults to +DEFAULT_ROOT_NAME+
+  #
+  # Example of use:
+  #   test.yml content
+  #      one: 1
+  #      two: 2.0 
+  #      three:
+  #        - apple
+  #        - pear
+  #      four: 
+  #        aa: 11
+  #        bb: 22
+  #
+  #   doc = YAXML.yaml2yaxml "test.yml"
+  #   doc.write( $stdout, 2 )
+  #   #-> <root xmlns:yaml='http://yaml.org/xml'>
+  #         <three>
+  #           <_>apple</_>
+  #           <_>pear</_>
+  #         </three>
+  #         <two>2.0</two>
+  #         <one>1</one>
+  #         <four>
+  #           <bb>22</bb>
+  #           <aa>11</aa>
+  #         </four>
+  #       </root>
+  def self.yaml2yaxml( source, options={} )
+
+    options[:root_name] ||= DEFAULT_ROOT_NAME
+
+    json = if source.is_a?String
+             if File.exist?source
+               YAML::load_file( source ) # is a file
+             else
+               YAML::load( source ) # is a string
+             end
+           elsif source.is_a?(Hash) || source.is_a?(Array)
+             source
+           end
+
+    el = self.json2yaxml( json, options )
+    doc = REXML::Document.new
+    doc.add_element el
+    doc
+
+  end
+  
+  # Conversion JSON -> YAXML
+  #
+  # source::
+  #   It can be a Array or Hash object or a file name.
+  # options::
+  # * <tt>:root_name</tt> It is the name of the root tag in the YAXML document. Defaults to +DEFAULT_ROOT_NAME+
+  #
+  # Example of use:
+  #   
+  #   json = {"one" => 1, "two" => 2.0, "three" => [ "apple", "pear"], "four" => {"aa" => 11, "bb" => 22}}
+  #   doc = YAXML.json2yaxml json
+  #   doc.write( $stdout, 2 )
+  #   #-> <root xmlns:yaml='http://yaml.org/xml'>
+  #         <three>
+  #           <_>apple</_>
+  #           <_>pear</_>
+  #         </three>
+  #         <two>2.0</two>
+  #         <one>1</one>
+  #         <four>
+  #           <bb>22</bb>
+  #           <aa>11</aa>
+  #         </four>
+  #       </root>
+  def self.json2yaxml( json_to_encode, options={} )
+    return nil unless json_to_encode
+    
+    options[:root_name] ||= DEFAULT_ROOT_NAME
+    unless options[:parent]
+      options[:parent] = REXML::Element.new options[:root_name]
+      options[:parent].attributes["xmlns:yaml"] = NAMESPACE
+    end
+    
+    parent = options[:parent]
+    
+    if json_to_encode.is_a?Hash
+      json_to_encode.each_pair do | key, value |
+        key.to_s if key.is_a?Symbol
+        el = REXML::Element.new key.to_s
+        result = self.json2yaxml( value, {:parent => el} )
+        parent.add result if result
+      end
+     
+    elsif json_to_encode.is_a?Array
+      json_to_encode.each do | x |
+        el = REXML::Element.new "_"
+        result = self.json2yaxml( x, {:parent => el})
+        parent.add result if result
+      end
+      
+    elsif json_to_encode.is_a?String
+      parent.text = json_to_encode
+
+    elsif json_to_encode.is_a?(Integer) || json_to_encode.is_a?(Float) || json_to_encode.is_a?(Date) || json_to_encode.is_a?(Symbol)
+      parent.text = json_to_encode.to_s
+     
+    end
+     
+    parent
+  end
+
+
+  #################################################
+  # From YAXML To ANY
+  #################################################
+
+  # Conversion YAXML -> YAML
+  # 
+  # source::
+  #   It can be a YAXML file in a String or a file name.
+  #
+  # Example of use:
+  #   test.xml content
+  #       <root xmlns:yaml='http://yaml.org/xml'>
+  #         <three>
+  #           <_>apple</_>
+  #           <_>pear</_>
+  #         </three>
+  #         <two>2.0</two>
+  #         <one>1</one>
+  #         <four>
+  #           <bb>22</bb>
+  #           <aa>11</aa>
+  #         </four>
+  #       </root>
+  #
+  #   yaml = YAXML.yaxml2yaml "test.xml"
+  #   puts yaml
+  #   #-> one: 1
+  #       two: 2.0 
+  #       three:
+  #         - apple
+  #         - pear
+  #       four: 
+  #         aa: 11
+  #         bb: 22
+  def self.yaxml2yaml( source )
+    self.yaxml2json( source ).to_yaml
+  end
+
+  # Conversion YAXML -> JSON
+  # 
+  # source::
+  #   It can be a YAXML file in a String or a file name.
+  #
+  # Example of use:
+  #   test.xml content
+  #       <root xmlns:yaml='http://yaml.org/xml'>
+  #         <three>
+  #           <_>apple</_>
+  #           <_>pear</_>
+  #         </three>
+  #         <two>2.0</two>
+  #         <one>1</one>
+  #         <four>
+  #           <bb>22</bb>
+  #           <aa>11</aa>
+  #         </four>
+  #       </root>
+  #
+  #   json = YAXML.yaxml2json "test.xml"
+  #   puts json.inspect
+  #   #-> {"one" => 1, "two" => 2.0, "three" => [ "apple", "pear"], "four" => {"aa" => 11, "bb" => 22}}
+  def self.yaxml2json( source )
+    return nil unless source
+
+    xml_node = if source.kind_of?String
+                 if File.exist?source
+                   yaxml_string = File.open( source, "r" ).read
+                 else
+                   yaxml_string = source
+                 end        
+                 REXML::Document.new yaxml_string
+
+               elsif source.kind_of?REXML::Element
+                 source.elements[1] if source.elements[1]
+                 
+               else
+                 nil
+               end
+     
+    self.yaxmlnode2json xml_node
+  end
+
+  private
+  def self.yaxmlnode2json xml_node
+    parent ||= if first_element = xml_node.elements[1]
+                 if first_element.name == "_"
+                   Array.new
+                 else
+                   Hash.new
+                 end
+               end
+
+    xml_node.elements.each do |el|
+      new_element = (el.has_elements?)? self.yaxmlnode2json( el ) : el.text.strip
+      self.add_to_parent( new_element, parent, first_element, el.name )
+    end
+    
+    parent
+  end
+  
+  def self.add_to_parent( element_value, parent, first_element, element_key=nil )
+    is_array_list = ( first_element.name == "_" )
+    if is_array_list
+      parent << element_value
+    else
+      parent[element_key] = element_value
+    end
+  end
+  
+end
+
+#doc = YAXML::yaml2yaxml "simple_test.yml"
+#puts doc.to_s
+#doc.write( $stdout, 2 )
+
+#doc = YAXML.yaxml2yaml_from_file "test.xml"
+#puts doc.inspect
+
+#yaxml = YAXML::Yaxml.new 'test2.yml'
+#puts yaxml.to_s
+
+#doc = REXML::Document.new yaxml.to_s
+#doc.write( $stdout, 2 )
+
+#yaxml.write( $stdout, 2 )
+#puts yaxml.to_json.inspect
+#puts yaxml.to_yaml