shoesgem 0.1424.0

data/shoes/ruby/lib/xmlrpc/utils.rb

@@ -0,0 +1,165 @@
+#
+# Defines ParserWriterChooseMixin, which makes it possible to choose a
+# different XML writer and/or XML parser then the default one.
+# The Mixin is used in client.rb (class Client) and server.rb (class 
+# BasicServer)
+# 
+# Copyright (C) 2001, 2002, 2003 by Michael Neumann (mneumann@ntecs.de)
+#
+# $Id: utils.rb 19657 2008-10-01 13:46:53Z mame $ 
+#
+
+module XMLRPC
+
+  #
+  # This module enables a user-class to be marshalled
+  # by XML-RPC for Ruby into a Hash, with one additional
+  # key/value pair "___class___" => ClassName
+  # 
+  module Marshallable
+  end
+
+
+  module ParserWriterChooseMixin
+
+    def set_writer(writer)
+      @create = Create.new(writer)
+      self
+    end
+
+    def set_parser(parser)
+      @parser = parser
+      self
+    end
+
+    private
+
+    def create
+      # if set_writer was not already called then call it now
+      if @create.nil? then
+        set_writer(Config::DEFAULT_WRITER.new)
+      end
+      @create
+    end
+
+    def parser
+      # if set_parser was not already called then call it now
+      if @parser.nil? then
+        set_parser(Config::DEFAULT_PARSER.new)
+      end
+      @parser
+    end
+
+  end # module ParserWriterChooseMixin
+
+
+  module Service
+
+  #
+  # base class for Service Interface definitions, used
+  # by BasicServer#add_handler
+  #
+
+  class BasicInterface
+    attr_reader :prefix, :methods
+
+    def initialize(prefix)
+      @prefix = prefix
+      @methods = []
+    end
+
+    def add_method(sig, help=nil, meth_name=nil)
+      mname = nil
+      sig = [sig] if sig.kind_of? String
+
+      sig = sig.collect do |s| 
+        name, si = parse_sig(s)
+        raise "Wrong signatures!" if mname != nil and name != mname 
+        mname = name
+        si
+      end
+
+      @methods << [mname, meth_name || mname, sig, help]
+    end
+
+    private # ---------------------------------
+  
+    def parse_sig(sig)
+      # sig is a String
+      if sig =~ /^\s*(\w+)\s+([^(]+)(\(([^)]*)\))?\s*$/
+        params = [$1]
+        name   = $2.strip 
+        $4.split(",").each {|i| params << i.strip} if $4 != nil
+        return name, params
+      else
+        raise "Syntax error in signature"
+      end
+    end
+
+  end # class BasicInterface
+
+  #
+  # class which wraps a Service Interface definition, used
+  # by BasicServer#add_handler
+  #
+  class Interface < BasicInterface
+    def initialize(prefix, &p)
+      raise "No interface specified" if p.nil?
+      super(prefix)
+      instance_eval(&p)
+    end
+
+    def get_methods(obj, delim=".") 
+      prefix = @prefix + delim
+      @methods.collect { |name, meth, sig, help| 
+        [prefix + name, obj.method(meth).to_proc, sig, help] 
+      }
+    end
+
+    private # ---------------------------------
+
+    def meth(*a)
+      add_method(*a)
+    end
+
+  end # class Interface
+
+  class PublicInstanceMethodsInterface < BasicInterface
+    def initialize(prefix)
+      super(prefix)
+    end
+
+    def get_methods(obj, delim=".")
+      prefix = @prefix + delim
+      obj.class.public_instance_methods(false).collect { |name|
+        [prefix + name, obj.method(name).to_proc, nil, nil] 
+      }
+    end
+  end
+
+
+  end # module Service
+
+
+  # 
+  # short-form to create a Service::Interface
+  #
+  def self.interface(prefix, &p)
+    Service::Interface.new(prefix, &p)  
+  end
+
+  # short-cut for creating a PublicInstanceMethodsInterface
+  def self.iPIMethods(prefix)
+    Service::PublicInstanceMethodsInterface.new(prefix) 
+  end
+
+
+  module ParseContentType
+    def parse_content_type(str)
+      a, *b = str.split(";")
+      return a.strip.downcase, *b
+    end
+  end
+
+end # module XMLRPC
+

data/shoes/ruby/lib/yaml/baseemitter.rb

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

data/shoes/ruby/lib/yaml/constants.rb

@@ -0,0 +1,45 @@
+#
+# Constants used throughout the library
+#
+module YAML
+
+	#
+	# Constants
+	#
+	VERSION = '0.60'
+	SUPPORTED_YAML_VERSIONS = ['1.0']
+
+	#
+	# Parser tokens
+	#
+	WORD_CHAR = 'A-Za-z0-9'
+	PRINTABLE_CHAR = '-_A-Za-z0-9!?/()$\'". ' 
+	NOT_PLAIN_CHAR = '\x7f\x0-\x1f\x80-\x9f'
+	ESCAPE_CHAR = '[\\x00-\\x09\\x0b-\\x1f]'
+	INDICATOR_CHAR = '*&!|\\\\^@%{}[]='
+	SPACE_INDICATORS = '-#:,?'
+	RESTRICTED_INDICATORS = '#:,}]'
+	DNS_COMP_RE = "\\w(?:[-\\w]*\\w)?"
+	DNS_NAME_RE = "(?:(?:#{DNS_COMP_RE}\\.)+#{DNS_COMP_RE}|#{DNS_COMP_RE})"
+	ESCAPES = %w{\x00   \x01	\x02	\x03	\x04	\x05	\x06	\a
+			     \x08	\t		\n		\v		\f		\r		\x0e	\x0f
+				 \x10	\x11	\x12	\x13	\x14	\x15	\x16	\x17
+				 \x18	\x19	\x1a	\e		\x1c	\x1d	\x1e	\x1f
+			    }
+	UNESCAPES = {
+				'a' => "\x07", 'b' => "\x08", 't' => "\x09", 
+				'n' => "\x0a", 'v' => "\x0b", 'f' => "\x0c",
+				'r' => "\x0d", 'e' => "\x1b", '\\' => '\\',
+			    }
+
+	#
+	# Default settings
+	#
+	DEFAULTS = {
+		:Indent => 2, :UseHeader => false, :UseVersion => false, :Version => '1.0',
+		:SortKeys => false, :AnchorFormat => 'id%03d', :ExplicitTypes => false,
+		:WidthType => 'absolute', :BestWidth => 80,
+		:UseBlock => false, :UseFold => false, :Encoding => :None
+	}
+
+end