W3cubDocs

/Crystal 0.31

struct HTTP::Params

Overview

Represents a collection of http parameters and their respective values.

Included Modules

Defined in:

http/params.cr

Constructors

Class Method Summary

Instance Method Summary

Instance methods inherited from module Enumerable({String, String})

all?(&block)
all?(pattern)
all? all?
, any?(&block)
any?(pattern)
any? any?
, chunks(&block : {String, String} -> U) forall U chunks, compact_map(&block) compact_map, count(item)
count(&block) count
, cycle(&block)
cycle(n, &block) cycle
, each(&block : {String, String} -> UNDERSCORE) each, each_cons(count : Int, reuse = false, &block) each_cons, each_slice(count : Int, reuse = false, &block) each_slice, each_with_index(offset = 0, &block) each_with_index, each_with_object(obj, &block) each_with_object, find(if_none = nil, &block) find, first(count : Int)
first first
, first? first?, flat_map(&block : {String, String} -> Array(U) | Iterator(U) | U) forall U flat_map, grep(pattern) grep, group_by(&block : {String, String} -> U) forall U group_by, in_groups_of(size : Int, filled_up_with : U = nil) forall U
in_groups_of(size : Int, filled_up_with : U = nil, reuse = false, &block) forall U in_groups_of
, includes?(obj) includes?, index(&block)
index(obj) index
, index_by(&block : {String, String} -> U) forall U index_by, join(separator = "", &block)
join(separator, io, &block)
join(separator, io)
join(separator = "") join
, map(&block : {String, String} -> U) forall U map, map_with_index(&block : {String, String}, Int32 -> U) forall U map_with_index, max max, max? max?, max_by(&block : {String, String} -> U) forall U max_by, max_by?(&block : {String, String} -> U) forall U max_by?, max_of(&block : {String, String} -> U) forall U max_of, max_of?(&block : {String, String} -> U) forall U max_of?, min min, min? min?, min_by(&block : {String, String} -> U) forall U min_by, min_by?(&block : {String, String} -> U) forall U min_by?, min_of(&block : {String, String} -> U) forall U min_of, min_of?(&block : {String, String} -> U) forall U min_of?, minmax minmax, minmax? minmax?, minmax_by(&block : {String, String} -> U) forall U minmax_by, minmax_by?(&block : {String, String} -> U) forall U minmax_by?, minmax_of(&block : {String, String} -> U) forall U minmax_of, minmax_of?(&block : {String, String} -> U) forall U minmax_of?, none?
none?(pattern)
none?(&block) none?
, one?(&block)
one?(pattern)
one? one?
, partition(&block) partition, product(&block)
product(initial : Number, &block)
product
product(initial : Number) product
, reduce(memo, &block)
reduce(&block) reduce
, reduce?(&block) reduce?, reject(&block : {String, String} -> )
reject(type : U.class) forall U
reject(pattern) reject
, select(pattern)
select(type : U.class) forall U
select(&block : {String, String} -> ) select
, size size, skip(count : Int) skip, skip_while(&block) skip_while, sum(initial)
sum
sum(initial, &block)
sum(&block) sum
, take_while(&block) take_while, tally : Hash({String, String}, Int32) tally, to_a to_a, to_h
to_h(&block : {String, String} -> Tuple(K, V)) forall K, V to_h
, to_set to_set, zip(*others : Indexable | Iterable | Iterator, &block)
zip(*others : Indexable | Iterable | Iterator) zip
, zip?(*others : Indexable | Iterable | Iterator, &block)
zip?(*others : Indexable | Iterable | Iterator) zip?

Instance methods inherited from struct Struct

==(other) : Bool ==, hash(hasher) hash, inspect(io : IO) : Nil inspect, pretty_print(pp) : Nil pretty_print, to_s(io : IO) : Nil to_s

Instance methods inherited from struct Value

==(other : JSON::Any)
==(other : YAML::Any)
==(other) ==
, dup dup

Instance methods inherited from class Object

!=(other) !=, !~(other) !~, ==(other) ==, ===(other : JSON::Any)
===(other : YAML::Any)
===(other) ===
, =~(other) =~, class class, dup dup, hash(hasher)
hash hash
, inspect(io : IO) : Nil
inspect : String inspect
, itself itself, not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, tap(&block) tap, to_json(io : IO)
to_json to_json
, to_pretty_json(indent : String = " ")
to_pretty_json(io : IO, indent : String = " ") to_pretty_json
, to_s : String
to_s(io : IO) : Nil to_s
, to_yaml(io : IO)
to_yaml to_yaml
, try(&block) try, unsafe_as(type : T.class) forall T unsafe_as

Constructor methods inherited from class Object

from_json(string_or_io, root : String) : self
from_json(string_or_io) : self from_json
, from_yaml(string_or_io : String | IO) : self from_yaml

Constructor Detail

def self.new(raw_params : Hash(String, Array(String)))Source

def self.newSource

Returns an empty HTTP::Params.

def self.parse(query : String) : selfSource

Parses an HTTP query string into a HTTP::Params

require "http/params"

HTTP::Params.parse("foo=bar&foo=baz&qux=zoo")
# => #<HTTP::Params @raw_params = {"foo" => ["bar", "baz"], "qux" => ["zoo"]}>

Class Method Detail

def self.build(&block : Builder -> ) : StringSource

Builds an url-encoded HTTP form/query.

The yielded object has an #add method that accepts two arguments, a key (String) and a value (String or Nil). Keys and values are escaped using URI.encode_www_form.

require "http/params"

params = HTTP::Params.build do |form|
  form.add "color", "black"
  form.add "name", "crystal"
  form.add "year", "2012 - today"
end
params # => "color=black&name=crystal&year=2012+-+today"

def self.encode(hash : Hash(String, String | Array(String)))Source

Returns the given key value pairs as a url-encoded HTTP form/query.

require "http/params"

HTTP::Params.encode({"foo" => "bar", "baz" => ["quux", "quuz"]}) # => "foo=bar&baz=quux&baz=quuz"

def self.encode(named_tuple : NamedTuple)Source

Returns the given key value pairs as a url-encoded HTTP form/query.

require "http/params"

HTTP::Params.encode({foo: "bar", baz: ["quux", "quuz"]}) # => "foo=bar&baz=quux&baz=quuz"

def self.parse(query : String, &block)Source

Parses an HTTP query and yields each key-value pair.

require "http/params"

query = "foo=bar&foo=baz&qux=zoo"
HTTP::Params.parse(query) do |key, value|
  # ...
end

Instance Method Detail

def ==(other : self)Source

def ==(other)Source

Description copied from struct Struct

Returns true if this struct is equal to other.

Both structs's instance vars are compared to each other. Thus, two structs are considered equal if each of their instance variables are equal. Subclasses should override this method to provide specific equality semantics.

struct Point
  def initialize(@x : Int32, @y : Int32)
  end
end

p1 = Point.new 1, 2
p2 = Point.new 1, 2
p3 = Point.new 3, 4

p1 == p2 # => true
p1 == p3 # => false

def [](name)Source

Returns first value for specified param name.

require "http/params"

params = HTTP::Params.parse("[email protected]")
params["email"]              # => "[email protected]"
params["non_existent_param"] # KeyError

def []=(name, value)Source

Sets first value for specified param name.

params["item"] = "pencil"

def []?(name)Source

Returns first value or nil for specified param name.

params["email"]?              # => "[email protected]"
params["non_existent_param"]? # nil

def add(name, value)Source

Appends new value for specified param name. Creates param when there was no such param.

params.add("item", "keychain")
params.fetch_all("item") # => ["pencil", "book", "workbook", "keychain"]

def delete(name)Source

Deletes first value for provided param name. If there are no values left, deletes param itself. Returns deleted value.

params.delete("item")    # => "keychain"
params.fetch_all("item") # => ["keynote"]

params.delete("item") # => "keynote"
params["item"]        # KeyError

params.delete("non_existent_param") # KeyError

def delete_all(name)Source

Deletes all values for provided param name. Returns array of deleted values.

params.set_all("comments", ["hello, world!", ":+1:"])
params.delete_all("comments") # => ["hello, world!", ":+1:"]
params.has_key?("comments")   # => false

def each(&block)Source

Allows to iterate over all name-value pairs.

params.each do |name, value|
  puts "#{name} => #{value}"
end

# Outputs:
# email => [email protected]
# item => keychain
# item => keynote

def empty?(*args, **options)Source

Returns true if params is empty.

HTTP::Params.new.empty?                              # => true
HTTP::Params.parse("foo=bar&foo=baz&qux=zoo").empty? # => false

def empty?(*args, **options, &block)Source

Returns true if params is empty.

HTTP::Params.new.empty?                              # => true
HTTP::Params.parse("foo=bar&foo=baz&qux=zoo").empty? # => false

def fetch(name, default)Source

Returns first value for specified param name. Fallbacks to provided default value when there is no such param.

params.fetch("email", "[email protected]")           # => "[email protected]"
params.fetch("non_existent_param", "default value") # => "default value"

def fetch(name, &block)Source

Returns first value for specified param name. Fallbacks to return value of provided block when there is no such param.

params.fetch("email") { raise "Email is missing" }              # raises "Email is missing"
params.fetch("non_existent_param") { "default computed value" } # => "default computed value"

def fetch_all(name)Source

Returns all values for specified param name.

params.set_all("item", ["pencil", "book", "workbook"])
params.fetch_all("item") # => ["pencil", "book", "workbook"]

def has_key?(*args, **options, &block)Source

Returns true if param with provided name exists.

params.has_key?("email")   # => true
params.has_key?("garbage") # => false

def has_key?(*args, **options)Source

Returns true if param with provided name exists.

params.has_key?("email")   # => true
params.has_key?("garbage") # => false

def set_all(name, values)Source

Sets all values for specified param name at once.

params.set_all("item", ["keychain", "keynote"])
params.fetch_all("item") # => ["keychain", "keynote"]

def to_s(io : IO) : NilSource

Serializes to string representation as http url-encoded form.

require "http/params"

params = HTTP::Params.parse("item=keychain&item=keynote&[email protected]")
params.to_s # => "item=keychain&item=keynote&email=john%40example.org"

© 2012–2019 Manas Technology Solutions.
Licensed under the Apache License, Version 2.0.
https://crystal-lang.org/api/0.31.1/HTTP/Params.html