concordia-publishing-house-syck 1.0.0.4

data/lib/syck/baseemitter.rb

@@ -0,0 +1,242 @@
+#
+# 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

@@ -0,0 +1,222 @@
+#
+# 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
+
+end
+