RbYAML 0.0.2 → 0.1.0

data/lib/rbyaml/reader.rb.~1.1.1.1.~

@@ -0,0 +1,127 @@
+# This is a more or less straight translation of PyYAML3000 to Ruby
+
+# the big difference in this implementation is that unicode support is not here...
+
+require 'rbyaml/error'
+
+module RbYAML
+
+  # Reader:
+  # - checks if characters are in allowed range,
+  # - adds '\0' to the end.
+  # Reader accepts
+  #  - a String object
+  #  - a duck-typed IO object
+  module Reader
+    def initialize_reader(stream)
+      @stream = nil
+      @stream_pointer = 0
+      @eof = true
+      @buffer = ""
+      @pointer = 0
+      @index = 0
+      @line = 0
+      @column = 0
+      if String === stream
+        @name = "<string>"
+        @raw_buffer = stream
+      else
+        @stream = stream
+        @name = stream.respond_to?(:path) ? stream.path : stream.inspect
+        @eof = false
+        @raw_buffer = ""
+      end
+    end
+
+    def peek(index=0)
+      update(index+1) if @pointer+index+1 >= @buffer.length
+      @buffer[@pointer+index]
+    end
+    
+    def prefix(length=1)
+      update(length) if @pointer+length >= @buffer.length
+      @buffer[@pointer...@pointer+length]
+    end
+
+    def forward(length=1)
+      update(length+1) if @pointer+length+1 >= @buffer.length
+      length.times { |k|
+        ch = @buffer[@pointer]
+        @pointer += 1
+        @index += 1
+        if "\n\x85".include?(ch) || (ch == ?\r && @buffer[@pointer+1] != ?\n)
+          @line += 1
+          @column = 0
+        else
+          @column += 1
+        end
+      }
+    end
+    
+    def get_mark
+      if @stream.nil?
+        Mark.new(@name,@index,@line,@column,@buffer,@pointer)
+      else
+        Mark.new(@name,@index,@line,@column,nil,nil)
+      end
+    end
+    
+    NON_PRINTABLE = /[^\x09\x0A\x0D\x20-\x7E\x85\xA0-\xFF]/
+    def check_printable(data)
+      if NON_PRINTABLE =~ data
+        position = @index+@buffer.length-@pointer+($~.offset(0)[0])
+        raise ReaderError.new(@name, position, $&,"unicode","special characters are not allowed"),"special characters are not allowed"
+      end
+    end
+
+    def update(length)
+      return if @raw_buffer.nil?
+      @buffer = @buffer[@pointer..-1]
+      @pointer = 0
+      while @buffer.length < length
+        unless @eof
+          update_raw
+        end
+        data = @raw_buffer
+        converted = data.length
+        check_printable(data)
+        @buffer << data
+        @raw_buffer = @raw_buffer[converted..-1]
+        if @eof
+          @buffer << ?\0
+          @raw_buffer = nil
+          break
+        end
+      end
+    end
+
+    def update_raw(size=1024)
+      data = @stream.read(size)
+      if data && !data.empty?
+        @raw_buffer << data
+        @stream_pointer += data.length
+      else
+        @eof = true
+      end
+    end
+  end
+
+  class ReaderError < YAMLError
+    def initialize(name, position, character, encoding, reason)
+      @name = name
+      @position = position
+      @character = character
+      @encoding = encoding
+      @reason = reason
+    end
+
+    def to_s
+      if String === @character
+        "'#{@encoding}' codec can't decode byte #x%02x: #{@reason}\n  in \"#{@name}\", position #{@position}" % @character.to_i
+      else
+        "unacceptable character #x%04x: #{@reason}\n  in \"#{@name}\", position #{@position}" % @character.to_i
+      end
+    end
+  end
+end
+

data/lib/rbyaml/representer.rb

@@ -8,11 +8,12 @@ module RbYAML
   class RepresenterError < YAMLError
   end
 
-  module BaseRepresenter
+  class BaseRepresenter
     @@yaml_representers = {}
     @@yaml_multi_representers = {}
 
-    def initialize_representer(default_style=nil, default_flow_style=nil)
+    def initialize(serializer, default_style=nil, default_flow_style=nil)
+      @serializer = serializer
       @default_style = default_style
       @default_flow_style = default_flow_style
       @represented_objects = {}
@@ -20,7 +21,7 @@ module RbYAML
 
     def represent(data)
       node = represent_data(data)
-      serialize(node)
+      @serializer.serialize(node)
       represented_objects = {}
     end
     
@@ -100,7 +101,7 @@ module RbYAML
       best_style = true
       value = sequence.map {|item| 
         node_item = represent_data(item)
-        best_style = false if !ScalarNode === node_item && !node_item.style
+        best_style = false if !node_item.__is_scalar && !node_item.flow_style
         node_item
       }
       flow_style ||= (@flow_default_style || best_style)
@@ -114,8 +115,8 @@ module RbYAML
         for item_key,item_value in mapping
           node_key = represent_data(item_key)
           node_value = represent_data(item_value)
-          best_style = false if !ScalarNode === node_key && !node_key.style
-          best_style = false if !ScalarNode === node_value && !node_value.style
+          best_style = false if !node_key.__is_scalar && !node_key.flow_style
+          best_style = false if !node_value.__is_scalar && !node_value.flow_style
           value[node_key] = node_value
         end
       else
@@ -123,8 +124,8 @@ module RbYAML
         for item_key, item_value in mapping
           node_key = represent_data(item_key)
           node_value = represent_data(item_value)
-          best_style = false if !ScalarNode === node_key && !node_key.style
-          best_style = false if !ScalarNode === node_value && !node_value.style
+          best_style = false if !node_key.__is_scalar && !node_key.flow_style
+          best_style = false if !node_value.__is_scalar && !node_value.flow_style
           value << [node_key, node_value]
         end
       end
@@ -137,11 +138,10 @@ module RbYAML
     end
   end
 
-  module SafeRepresenter
-    include BaseRepresenter
+  class SafeRepresenter < BaseRepresenter
 
     def ignore_aliases(data)
-      data.nil? || String === data || TrueClass === data || FalseClass === data || Integer === data || Float === data
+      data.nil? || data.__is_str || TrueClass === data || FalseClass === data || data.__is_int || Float === data
     end
 
     def represent_none(data)
@@ -158,7 +158,7 @@ module RbYAML
 
     def represent_bool(data)
       value = data ? "true" : "false"
-      represent_scalar(data.taguri,value)
+      represent_scalar('tag:yaml.org,2002:bool',value)
     end
 
     def represent_int(data)
@@ -206,15 +206,24 @@ module RbYAML
       represent_scalar(data.taguri, value)
     end
     
-    def represent_yaml_object(tag, data, flow_style=nil)
+    def represent_ruby(data)
       state = data.to_yaml_properties
-      mapping = {}
+      map = {}
       state.each do |m|
         map[m[1..-1]] = data.instance_variable_get(m)
       end
-      represent_mapping(tag, mapping, flow_style)
+      represent_mapping("!ruby/object:#{data.class.yaml_tag_class_name}", map,nil)
     end
     
+    def represent_yaml_object(tag, data, flow_style=nil)
+      state = data.to_yaml_properties
+      map = {}
+      state.each do |m|
+        map[m[1..-1]] = data.instance_variable_get(m)
+      end
+      represent_mapping(tag, map, flow_style)
+    end
+
     def represent_undefined(data)
       raise RepresenterError.new("cannot represent an object: #{data}")
     end
@@ -231,9 +240,9 @@ module RbYAML
   BaseRepresenter.add_representer(Hash,:represent_dict)
   BaseRepresenter.add_representer(Set,:represent_set)
   BaseRepresenter.add_representer(Time,:represent_datetime)
+  BaseRepresenter.add_representer(Object,:represent_ruby)
   BaseRepresenter.add_representer(nil,:represent_undefined)
   
-  module Representer
-    include SafeRepresenter
+  class Representer < SafeRepresenter
   end
 end

data/lib/rbyaml/representer.rb.~1.2.~

@@ -0,0 +1,239 @@
+
+require 'set'
+
+require 'rbyaml/error'
+require 'rbyaml/nodes'
+
+module RbYAML
+  class RepresenterError < YAMLError
+  end
+
+  module BaseRepresenter
+    @@yaml_representers = {}
+    @@yaml_multi_representers = {}
+
+    def initialize_representer(default_style=nil, default_flow_style=nil)
+      @default_style = default_style
+      @default_flow_style = default_flow_style
+      @represented_objects = {}
+    end
+
+    def represent(data)
+      node = represent_data(data)
+      serialize(node)
+      represented_objects = {}
+    end
+    
+    CLASSOBJ_TYPE = Class
+    INSTANCE_TYPE = Object
+    FUNCTION_TYPE = Method
+    BUILTIN_FUNCTION_TYPE = Method
+    MODULE_TYPE = Module
+
+    def get_classobj_bases(cls)
+      [cls] + cls.ancestors
+    end
+    
+    def represent_data(data)
+      if ignore_aliases(data)
+        alias_key = nil
+      else
+        alias_key = data.object_id
+      end
+      
+      if !alias_key.nil?
+        if @represented_objects.include?(alias_key)
+          node = @represented_objects[alias_key]
+          raise RepresenterError.new("recursive objects are not allowed: #{data}") if node.nil?
+          return node
+        end
+        @represented_objects[alias_key] = nil
+      end
+      
+      data_types = data.class.ancestors
+      data_types = get_classobj_bases(data.class) + data_types if INSTANCE_TYPE === data
+
+      if @@yaml_representers.include?(data_types[0])
+        node = send(@@yaml_representers[data_types[0]],data)
+      else
+        rerun = true
+        for data_type in data_types
+          if @@yaml_multi_representers.include?(data_type)
+            node = send(@@yaml_multi_representers[data_type],data)
+            rerun = false
+            break
+          elsif @@yaml_representers.include?(data_type)
+            node = send(@@yaml_representers[data_type],data)
+            rerun = false
+            break
+          end
+        end
+        if rerun
+          if @@yaml_multi_representers.include?(nil)
+            node = send(@@yaml_multi_representers[nil],data)
+          elsif @@yaml_representers.include?(nil)
+            node = send(@@yaml_representers[nil],data)
+          else
+            node = ScalarNode.new(nil, data)
+          end
+        end
+      end
+        
+      @represented_objects[alias_key] = node if !alias_key.nil?
+      node
+    end
+    
+    def self.add_representer(data_type, representer)
+      @@yaml_representers[data_type] = representer
+    end
+
+    def self.add_multi_representer(data_type, representer)
+      @@yaml_multi_representers[data_type] = representer
+    end
+    
+    def represent_scalar(tag, value, style=nil)
+      style ||= @default_style
+      ScalarNode.new(tag, value, style)
+    end
+
+    def represent_sequence(tag, sequence, flow_style=nil)
+      best_style = true
+      value = sequence.map {|item| 
+        node_item = represent_data(item)
+        best_style = false if !ScalarNode === node_item && !node_item.style
+        node_item
+      }
+      flow_style ||= (@flow_default_style || best_style)
+      SequenceNode.new(tag, value, flow_style)
+    end
+
+    def represent_mapping(tag, mapping, flow_style=nil)
+      best_style = true
+      if mapping.respond_to?(:keys)
+        value = {}
+        for item_key,item_value in mapping
+          node_key = represent_data(item_key)
+          node_value = represent_data(item_value)
+          best_style = false if !ScalarNode === node_key && !node_key.style
+          best_style = false if !ScalarNode === node_value && !node_value.style
+          value[node_key] = node_value
+        end
+      else
+        value = []
+        for item_key, item_value in mapping
+          node_key = represent_data(item_key)
+          node_value = represent_data(item_value)
+          best_style = false if !ScalarNode === node_key && !node_key.style
+          best_style = false if !ScalarNode === node_value && !node_value.style
+          value << [node_key, node_value]
+        end
+      end
+      flow_style ||= (@flow_default_style || best_style)
+      MappingNode.new(tag, value, flow_style)
+    end
+
+    def ignore_aliases(data)
+      false
+    end
+  end
+
+  module SafeRepresenter
+    include BaseRepresenter
+
+    def ignore_aliases(data)
+      data.nil? || String === data || TrueClass === data || FalseClass === data || Integer === data || Float === data
+    end
+
+    def represent_none(data)
+      represent_scalar(data.taguri,"null")
+    end
+
+    def represent_str(data)
+      represent_scalar(data.taguri,data,nil)
+    end
+
+    def represent_symbol(data)
+      represent_scalar(data.taguri,data.to_s)
+    end
+
+    def represent_bool(data)
+      value = data ? "true" : "false"
+      represent_scalar(data.taguri,value)
+    end
+
+    def represent_int(data)
+      represent_scalar(data.taguri,data.to_s)
+    end
+
+    def represent_float(data)
+      if data.infinite? == 1
+        value = ".inf"
+      elsif data.infinite? == -1
+        value = "-.inf"
+      elsif data.nan? || data != data
+        value = ".nan"
+      else
+        value = data.to_s
+      end
+      represent_scalar(data.taguri, value)
+    end
+    
+    def represent_list(data)
+#no support for pairs right now. should probably be there, though...
+      represent_sequence(data.taguri, data)
+    end
+
+    def represent_dict(data)
+      represent_mapping(data.taguri, data)
+    end
+
+    def represent_set(data)
+      value = {}
+      for key in data
+        value[key] = nil
+      end
+      represent_mapping(data.taguri, value)
+    end
+    
+    def represent_datetime(data)
+      value = "%04d-%02d-%02d %02d:%02d:%02d" % [data.year, data.month, data.day, data.hour, data.min, data.sec]
+      if data.usec != 0
+        value += "." + (data.usec/1000000.0).to_s.split(/\./)[1]
+      end
+      if data.utc_offset != 0
+        value += data.utc_offset.to_s
+      end
+      represent_scalar(data.taguri, value)
+    end
+    
+    def represent_yaml_object(tag, data, flow_style=nil)
+      state = data.to_yaml_properties
+      mapping = {}
+      state.each do |m|
+        map[m[1..-1]] = data.instance_variable_get(m)
+      end
+      represent_mapping(tag, mapping, flow_style)
+    end
+    
+    def represent_undefined(data)
+      raise RepresenterError.new("cannot represent an object: #{data}")
+    end
+  end
+
+  BaseRepresenter.add_representer(NilClass,:represent_none)
+  BaseRepresenter.add_representer(String,:represent_str)
+  BaseRepresenter.add_representer(Symbol,:represent_symbol)
+  BaseRepresenter.add_representer(TrueClass,:represent_bool)
+  BaseRepresenter.add_representer(FalseClass,:represent_bool)
+  BaseRepresenter.add_representer(Integer,:represent_int)
+  BaseRepresenter.add_representer(Float,:represent_float)
+  BaseRepresenter.add_representer(Array,:represent_list)
+  BaseRepresenter.add_representer(Hash,:represent_dict)
+  BaseRepresenter.add_representer(Set,:represent_set)
+  BaseRepresenter.add_representer(Time,:represent_datetime)
+  BaseRepresenter.add_representer(nil,:represent_undefined)
+  
+  module Representer
+    include SafeRepresenter
+  end
+end