rubysl-yaml 2.0.4 → 2.1.0

data/lib/syck/baseemitter.rb

@@ -1,242 +0,0 @@
-#
-# BaseEmitter
-#
-
-require 'syck/constants'
-require 'syck/encoding'
-require 'syck/error'
-
-module Syck
-  module BaseEmitter
-    def options( opt = nil )
-      if opt
-        @options[opt] || DEFAULTS[opt]
-      else
-        @options
-      end
-    end
-
-    def options=( opt )
-      @options = opt
-    end
-
-    #
-    # Emit binary data
-    #
-    def binary_base64( value )
-      self << "!binary "
-      self.node_text( [value].pack("m"), '|' )
-    end
-
-    #
-    # Emit plain, normal flowing text
-    #
-    def node_text( value, block = nil )
-      @seq_map = false
-      valx = value.dup
-      unless block
-        block =
-          if options(:UseBlock)
-            '|'
-          elsif not options(:UseFold) and valx =~ /\n[ \t]/ and not valx =~ /#{ESCAPE_CHAR}/
-            '|'
-          else
-            '>'
-          end
-        indt = $&.to_i if block =~ /\d+/
-        if valx =~ /(\A\n*[ \t#]|^---\s+)/
-          indt = options(:Indent) unless indt.to_i > 0
-          block += indt.to_s
-        end
-
-        block +=
-          if valx =~ /\n\Z\n/
-            "+"
-          elsif valx =~ /\Z\n/
-            ""
-          else
-            "-"
-          end
-      end
-      block += "\n"
-      if block[0] == ?"
-        esc_skip = ( "\t\n" unless valx =~ /^[ \t]/ ) || ""
-        valx = fold( Syck.escape( valx, esc_skip ) + "\"" ).chomp
-        self << '"' + indent_text( valx, indt, false )
-      else
-        if block[0] == ?>
-          valx = fold( valx )
-        end
-        #p [block, indt]
-        self << block + indent_text( valx, indt )
-      end
-    end
-
-    #
-    # Emit a simple, unqouted string
-    #
-    def simple( value )
-      @seq_map = false
-      self << value.to_s
-    end
-
-    #
-    # Emit double-quoted string
-    #
-    def double( value )
-      "\"#{Syck.escape( value )}\""
-    end
-
-    #
-    # Emit single-quoted string
-    #
-    def single( value )
-      "'#{value}'"
-    end
-
-    #
-    # Write a text block with the current indent
-    #
-    def indent_text( text, mod, first_line = true )
-      return "" if text.to_s.empty?
-      spacing = indent( mod )
-      text = text.gsub( /\A([^\n])/, "#{ spacing }\\1" ) if first_line
-      return text.gsub( /\n^([^\n])/, "\n#{spacing}\\1" )
-    end
-
-    #
-    # Write a current indent
-    #
-    def indent( mod = nil )
-      #p [ self.id, level, mod, :INDENT ]
-      if level <= 0
-        mod ||= 0
-      else
-        mod ||= options(:Indent)
-        mod += ( level - 1 ) * options(:Indent)
-      end
-      return " " * mod
-    end
-
-    #
-    # Add indent to the buffer
-    #
-    def indent!
-      self << indent
-    end
-
-    #
-    # Folding paragraphs within a column
-    #
-    def fold( value )
-      value.gsub( /(^[ \t]+.*$)|(\S.{0,#{options(:BestWidth) - 1}})(?:[ \t]+|(\n+(?=[ \t]|\Z))|$)/ ) do
-        $1 || $2 + ( $3 || "\n" )
-      end
-    end
-
-    #
-    # Quick mapping
-    #
-    def map( type, &e )
-      val = Mapping.new
-      e.call( val )
-      self << "#{type} " if type.length.nonzero?
-
-      #
-      # Empty hashes
-      #
-      if val.length.zero?
-        self << "{}"
-        @seq_map = false
-      else
-        # FIXME
-        # if @buffer.length == 1 and options(:UseHeader) == false and type.length.zero?
-        #     @headless = 1
-        # end
-
-        defkey = @options.delete( :DefaultKey )
-        if defkey
-          seq_map_shortcut
-          self << "= : "
-          defkey.to_yaml( :Emitter => self )
-        end
-
-        #
-        # Emit the key and value
-        #
-        val.each { |v|
-          seq_map_shortcut
-          if v[0].is_complex_yaml?
-            self << "? "
-          end
-          v[0].to_yaml( :Emitter => self )
-          if v[0].is_complex_yaml?
-            self << "\n"
-            indent!
-          end
-          self << ": "
-          v[1].to_yaml( :Emitter => self )
-        }
-      end
-    end
-
-    def seq_map_shortcut
-      # FIXME: seq_map needs to work with the new anchoring system
-      # if @seq_map
-      #     @anchor_extras[@buffer.length - 1] = "\n" + indent
-      #     @seq_map = false
-      # else
-      self << "\n"
-      indent!
-      # end
-    end
-
-    #
-    # Quick sequence
-    #
-    def seq( type, &e )
-      @seq_map = false
-      val = Sequence.new
-      e.call( val )
-      self << "#{type} " if type.length.nonzero?
-
-      #
-      # Empty arrays
-      #
-      if val.length.zero?
-        self << "[]"
-      else
-        # FIXME
-        # if @buffer.length == 1 and options(:UseHeader) == false and type.length.zero?
-        #     @headless = 1
-        # end
-
-        #
-        # Emit the key and value
-        #
-        val.each { |v|
-          self << "\n"
-          indent!
-          self << "- "
-          @seq_map = true if v.class == Hash
-          v.to_yaml( :Emitter => self )
-        }
-      end
-    end
-  end
-
-  #
-  # Emitter helper classes
-  #
-  class Mapping < Array
-    def add( k, v )
-      push [k, v]
-    end
-  end
-
-  class Sequence < Array
-    def add( v )
-      push v
-    end
-  end
-end

data/lib/syck/basenode.rb

@@ -1,227 +0,0 @@
-#
-# YAML::BaseNode class
-#
-
-module Syck
-    #
-    # YAML Generic Model container
-    #
-    module BaseNode
-
-        #
-        # Search for YPath entry and return
-        # qualified nodes.
-        #
-        def select( ypath_str )
-            warn "#{caller[0]}: select is deprecated" if $VERBOSE
-            matches = match_path( ypath_str )
-
-            #
-            # Create a new generic view of the elements selected
-            #
-            if matches
-                result = []
-                matches.each { |m|
-                    result.push m.last
-                }
-                Syck.transfer( 'seq', result )
-            end
-        end
-
-        #
-        # Search for YPath entry and return
-        # transformed nodes.
-        #
-        def select!( ypath_str )
-            warn "#{caller[0]}: select!() is deprecated" if $VERBOSE
-            matches = match_path( ypath_str )
-
-            #
-            # Create a new generic view of the elements selected
-            #
-            if matches
-                result = []
-                matches.each { |m|
-                    result.push m.last.transform
-                }
-                result
-            end
-        end
-
-        #
-        # Search for YPath entry and return a list of
-        # qualified paths.
-        #
-        def search( ypath_str )
-            warn "#{caller[0]}: search() is deprecated" if $VERBOSE
-            matches = match_path( ypath_str )
-
-            if matches
-                matches.collect { |m|
-                    path = []
-                    m.each_index { |i|
-                        path.push m[i] if ( i % 2 ).zero?
-                    }
-                    "/" + path.compact.join( "/" )
-                }
-            end
-        end
-
-        def at( seg )
-            warn "#{caller[0]}: at() is deprecated" if $VERBOSE
-            if Hash === @value
-                self[seg]
-            elsif Array === @value and seg =~ /\A\d+\Z/ and @value[seg.to_i]
-                @value[seg.to_i]
-            end
-        end
-
-        #
-        # YPath search returning a complete depth array
-        #
-        def match_path( ypath_str )
-            warn "#{caller[0]}: match_path is deprecated" if $VERBOSE
-            require 'syck/ypath'
-            matches = []
-            YPath.each_path( ypath_str ) do |ypath|
-                seg = match_segment( ypath, 0 )
-                matches += seg if seg
-            end
-            matches.uniq
-        end
-
-        #
-        # Search a node for a single YPath segment
-        #
-        def match_segment( ypath, depth )
-            warn "#{caller[0]}: match_segment is deprecated" if $VERBOSE
-            deep_nodes = []
-            seg = ypath.segments[ depth ]
-            if seg == "/"
-                unless String === @value
-                    idx = -1
-                    @value.collect { |v|
-                        idx += 1
-                        if Hash === @value
-                            match_init = [v[0].transform, v[1]]
-                            match_deep = v[1].match_segment( ypath, depth )
-                        else
-                            match_init = [idx, v]
-                            match_deep = v.match_segment( ypath, depth )
-                        end
-                        if match_deep
-                            match_deep.each { |m|
-                                deep_nodes.push( match_init + m )
-                            }
-                        end
-                    }
-                end
-                depth += 1
-                seg = ypath.segments[ depth ]
-            end
-            match_nodes =
-                case seg
-                when "."
-                    [[nil, self]]
-                when ".."
-                    [["..", nil]]
-                when "*"
-                    if @value.is_a? Enumerable
-                        idx = -1
-                        @value.collect { |h|
-                            idx += 1
-                            if Hash === @value
-                                [h[0].transform, h[1]]
-                            else
-                                [idx, h]
-                            end
-                        }
-                    end
-                else
-                    if seg =~ /^"(.*)"$/
-                        seg = $1
-                    elsif seg =~ /^'(.*)'$/
-                        seg = $1
-                    end
-                    if ( v = at( seg ) )
-                        [[ seg, v ]]
-                    end
-                end
-            return deep_nodes unless match_nodes
-            pred = ypath.predicates[ depth ]
-            if pred
-                case pred
-                when /^\.=/
-                    pred = $'   # '
-                    match_nodes.reject! { |n|
-                        n.last.value != pred
-                    }
-                else
-                    match_nodes.reject! { |n|
-                        n.last.at( pred ).nil?
-                    }
-                end
-            end
-            return match_nodes + deep_nodes unless ypath.segments.length > depth + 1
-
-            #puts "DEPTH: #{depth + 1}"
-            deep_nodes = []
-            match_nodes.each { |n|
-                if n[1].is_a? BaseNode
-                    match_deep = n[1].match_segment( ypath, depth + 1 )
-                    if match_deep
-                        match_deep.each { |m|
-                            deep_nodes.push( n + m )
-                        }
-                    end
-                else
-                    deep_nodes = []
-                end
-            }
-            deep_nodes = nil if deep_nodes.length == 0
-            deep_nodes
-        end
-
-        #
-        # We want the node to act like as Hash
-        # if it is.
-        #
-        def []( *key )
-            if Hash === @value
-                v = @value.detect { |k,| k.transform == key.first }
-                v[1] if v
-            elsif Array === @value
-                @value.[]( *key )
-            end
-        end
-
-        def children
-            if Hash === @value
-                @value.values.collect { |c| c[1] }
-            elsif Array === @value
-                @value
-            end
-        end
-
-        def children_with_index
-            warn "#{caller[0]}: children_with_index is deprecated, use children" if $VERBOSE
-            if Hash === @value
-                @value.keys.collect { |i| [self[i], i] }
-            elsif Array === @value
-                i = -1; @value.collect { |v| i += 1; [v, i] }
-            end
-        end
-
-        def emit
-            transform.to_yaml
-        end
-    end
-
-    #
-    # Mixin BaseNode functionality
-    #
-    class Node
-      include Syck::BaseNode
-    end
-end
-