Ruby » Ruby master

      end

      options = name

        raise ArgumentError, "`name' required"

      end

        name = CGI.unescape(name)

        values ||= ""

        values = values.split('&').collect{|v| CGI.unescape(v,@@accept_charset) }

          values = cookies[name].value + values

        end

        cookies[name] = Cookie.new(name, *values)

      content_type = options

      buf = _header_for_string(content_type)

    elsif options.is_a?(Hash)

        content_type = options['type']

        buf = _header_for_string(content_type)

      else

    # Returns true if a given query string parameter exists.

    def has_key?(*args)

    end

    alias key? has_key?

    alias include? has_key?

                     { "METHOD" => method, "ACTION" => action,

                       "ENCTYPE" => enctype }

                   else

                       method["METHOD"] = "post"

                     end

                       method["ENCTYPE"] = enctype

                     end

                     method

      pretty = "  " if true == pretty

      buf = ""

        if attributes["DOCTYPE"]

          buf << attributes.delete("DOCTYPE")

        else

                     { "METHOD" => "post", "ACTION" => action,

                       "ENCTYPE" => enctype }

                   else

                       action["METHOD"] = "post"

                     end

                       action["ENCTYPE"] = enctype

                     end

                     action

                                  0,

                                  Socket::AI_PASSIVE)

      families = Hash[*infos.collect { |af, *_| af }.uniq.zip([]).flatten]

      return TCPServer.open(port)

      # :stopdoc:

    end

        ['HDRDIR',        '$(rubyhdrdir)/ruby$(target_prefix)'],

        ['ARCHHDRDIR',    '$(rubyhdrdir)/$(arch)/ruby$(target_prefix)'],

      ]

      dirs = [

        ['BINDIR',        '$(bindir)'],

        ['RUBYCOMMONDIR', '$(vendordir)$(target_prefix)'],

      next unless /dir$/ =~ key

      mk << "#{key} = #{with_destdir(var)}\n"

    end

        sep = config_string('BUILD_FILE_SEPARATOR')

      sep = ":/=#{sep}"

    else

    # A Net::IMAP::NoResponseError is raised if authentication fails.

    def authenticate(auth_type, *args)

      auth_type = auth_type.upcase

        raise ArgumentError,

          format('unknown auth type - "%s"', auth_type)

      end

    end

    def record_response(name, data)

        @responses[name] = []

      end

      @responses[name].push(data)

      STAGE_TWO = :stage_two

      def nc(nonce)

          @nc[nonce] = @nc[nonce] + 1

        else

          @nc[nonce] = 1

    #

    def initialize(options) # :yield: mesg

      @options = options

        @options["Binmode"]    = false

      else

        unless (true == @options["Binmode"] or false == @options["Binmode"])

        end

      end

        @options["Telnetmode"] = true

      else

        unless (true == @options["Telnetmode"] or false == @options["Telnetmode"])

      @telnet_option = { "SGA" => false, "BINARY" => false }

        @log = File.open(@options["Output_log"], 'a+')

        @log.sync = true

        @log.binmode

      end

        @dumplog = File.open(@options["Dump_log"], 'a+')

        @dumplog.sync = true

        @dumplog.binmode

        end

      end

        if @options["Proxy"].kind_of?(Net::Telnet)

          @sock = @options["Proxy"].sock

        elsif @options["Proxy"].kind_of?(IO)

      else

        message = "Trying " + @options["Host"] + "...\n"

        yield(message) if block_given?

        begin

          if @options["Timeout"] == false

        rescue Net::OpenTimeout

          raise Net::OpenTimeout, "timed out while opening a connection to the host"

        rescue

          raise

        end

        @sock.sync = true

        message = "Connected to " + @options["Host"] + ".\n"

        yield(message) if block_given?

      end

    end # initialize

      fail_eof = @options["FailEOF"]

      if options.kind_of?(Hash)

                     options["Match"]

                     options["Prompt"]

                     Regexp.new( Regexp.quote(options["String"]) )

                   end

      else

        prompt = options

      end

        end

        begin

          c = @sock.readpartial(1024 * 1024)

          if @options["Telnetmode"]

            c = rest + c

            if Integer(c.rindex(/#{IAC}#{SE}/no) || 0) <

             buf.gsub!(/#{EOL}/no, "\n")

           end

          end

          line += buf

          yield buf if block_given?

        rescue EOFError # End of file reached

      length = string.length

      while 0 < length

        IO::select(nil, [@sock])

        length -= @sock.syswrite(string[-length..-1])

      end

    end

      if options.kind_of?(Hash)

        string   = options["String"]

      else

        string = options

      end

    # Returns true if +key+ is one of the arguments

    def has_key?(key)

    end

    protected

    def lookup(name) # :nodoc:

        @hash[name]

      elsif @parent

        @parent.lookup(name)

      map = {}

      0.upto(from.length - 1) { |pos|

        from_char = from[pos]

          map[from_char] =

          if pos < to.length

            to[pos]

      if ''.respond_to? :chars

        string(string).chars.collect { |c|

        }.compact.join

      else

        string(string).unpack('U*').collect { |c|

        }.compact.pack('U*')

      end

    end

                    prefixes << prefix unless prefix == "xml"

                  end

                    msg = "Duplicate attribute #{attr_name.inspect}"

                    raise REXML::ParseException.new(msg, @source, self)

                  end

            copy = event[1].clone

            esub = proc { |match|

                @entities[$1].gsub(Text::REFERENCE, &esub)

              else

                match

          rel = link.rel || "alternate"

          next unless rel == "alternate"

          key = [link.hreflang, link.type]

            raise TooMuchTagError.new("link", tag_name)

          end

          link_infos[key] = true

      # test if this uri is registered against this name

      def uri_registered?(uri, name)

      end

      # record class_name for the supplied uri and tag_name

    def instruction(name, content)

      if name == "xml-stylesheet"

        params = parse_pi_content(content)

          @xml_stylesheets << XMLStyleSheet.new(params)

        end

      end

      end

      def install_ns(prefix, uri)

          raise OverlappedPrefixError.new(prefix)

        end

        self::NSPOOL[prefix] = uri

      prefix = ""

      prefix << "#{klass.required_prefix}_" if klass.required_prefix

      key = "#{prefix}#{tag_name.gsub(/-/, '_')}"

        ary = __send__("#{self.class.plural_forms[key]}")

        ary << next_element

      else

        value = __send__(alias_name || name)

        return nil if required and value.nil?

        next if value.nil?

        attrs[name] = value

      end

      attrs

    def tag_filter(tags)

      rv = {}

      tags.each do |tag|

        rv[tag[0]].push(tag[1])

      end

      rv

    # Always include this, even if it's nil

    args << @host

      args << gem_data.spec.metadata['allowed_push_host']

    end

    def initialize(*args)

      if defined?(MOD_RUBY)

          Apache.request.setup_cgi_env

        end

      end

          req_params = MustParams

        end

        req_params.each{|key|

            error('%s: parameter missing. "%s"', auth_req['username'], key)

            raise HTTPStatus::BadRequest

          end

          return false

        end

           (@qop && (! @qop.member?(auth_req['qop'])))

          error('%s: the qop is not allowed. "%s"',

                auth_req['username'], auth_req['qop'])

            res.status = $1.to_i

            header.delete('status')

          end

            # RFC 3875 6.2.3, 6.2.4

            res.status = 302 unless (300...400) === res.status

          end

            header['set-cookie'].each{|k|

              res.cookies << Cookie.parse_set_cookie(k)

            }

        when /^([A-Za-z0-9!\#$%&'*+\-.^_`|~]+):\s*(.*?)\s*\z/om

          field, value = $1, $2

          field.downcase!

          header[field] << value

        when /^\s+(.*?)\s*\z/om

          value = $1

          val = unescape_form(val.to_s)

          val = FormData.new(val)

          val.name = key

            query[key].append_data(val)

            next

          end

          if data

            data.chop!

            key = data.name

              form_data[key].append_data(data)

            else

              form_data[key] = data

    # * <code>'faultString'</code> key is a String

    def self.fault(hash)

      if hash.kind_of? Hash and hash.size == 2 and

        hash["faultCode"].kind_of? Integer and hash["faultString"].kind_of? String

        XMLRPC::FaultException.new(hash["faultCode"], hash["faultString"])