rubysl-yaml 0.0.1 → 1.0.1

data/lib/yaml.rb

@@ -0,0 +1 @@
+require "rubysl/yaml"

data/lib/yaml/baseemitter.rb

@@ -0,0 +1,247 @@
+#
+# BaseEmitter
+#
+
+require 'yaml/constants'
+require 'yaml/encoding'
+require 'yaml/error'
+
+module YAML
+
+    module BaseEmitter
+
+        def options( opt = nil )
+            if opt
+                @options[opt] || YAML::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 =~ /#{YAML::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( YAML::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 )
+			"\"#{YAML.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/yaml/basenode.rb

@@ -0,0 +1,216 @@
+#
+# YAML::BaseNode class
+#
+require 'yaml/ypath'
+
+module YAML
+
+    #
+    # YAML Generic Model container
+    #
+    module BaseNode
+
+        #
+        # Search for YPath entry and return
+        # qualified nodes.
+        #
+        def select( ypath_str )
+            matches = match_path( ypath_str )
+
+            #
+            # Create a new generic view of the elements selected
+            #
+            if matches
+                result = []
+                matches.each { |m|
+                    result.push m.last
+                }
+                YAML.transfer( 'seq', result )
+            end
+        end
+
+        #
+        # Search for YPath entry and return
+        # transformed nodes.
+        #
+        def select!( ypath_str )
+            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 )
+            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 )
+            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 )
+            depth = 0
+            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 )
+            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
+            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
+