Web portal for RDF.rb.

Alphabetic Index

File Listing

Namespace Listing A-Z

Top Level Namespace

ABNF (EBNF)
ABNFCore
ABNFMeta
ACos (RDF::N3::Algebra::Math)
ACosH (RDF::N3::Algebra::Math)
API (YAML_LD)
API (JSON::LD)
ASin (RDF::N3::Algebra::Math)
ASinH (RDF::N3::Algebra::Math)
ATan (RDF::N3::Algebra::Math)
ATanH (RDF::N3::Algebra::Math)
Abs (SPARQL::Algebra::Operator)
AbsoluteValue (RDF::N3::Algebra::Math)
Abstract (Rack::Events)
AbstractHandler (Rack::Auth)
AbstractRequest (Rack::Auth)
Adapters (RDF::DataObjects)
Add (LD::Patch::Algebra)
Add (SPARQL::Client::Update)
Add (SPARQL::Algebra::Operator)
Adjust (SPARQL::Algebra::Operator)
Aggregate (SPARQL::Algebra)
AggregateRepo (RDF)
Algebra (SPARQL)
Algebra (RDF::N3)
Algebra (LD::Patch)
Algebra (SHACL)
Algebra (ShEx)
Aliasing (RDF::Util)
Alt (SPARQL::Algebra::Operator)
AmazingPrint
And (SPARQL::Algebra::Operator)
And (ShEx::Algebra)
AndConstraintComponent (SHACL::Algebra)
Annotation (ShEx::Algebra)
AnyURI (RDF::Literal)
Append (RDF::N3::Algebra::List)
Application (RDF::Distiller)
Array
Asc (SPARQL::Algebra::Operator)
Ask (SPARQL::Algebra::Operator)
Auth (Rack)
Avg (SPARQL::Algebra::Operator)

BGP (SPARQL::Algebra::Operator)
BNF (EBNF)
BNode (SPARQL::Algebra::Operator)
BadRequest (Rack)
Base (RDF::Normalize)
Base (EBNF)
Base (SPARQL::Algebra::Operator)
Base64Binary (RDF::Literal)
BaseIterator (Rack::Files)
Basic (Rack::Auth)
Basic (SXP::Reader)
BigDecimal
Binary (SPARQL::Algebra::Operator)
Binary (ShEx::Algebra::Operator)
Bind (LD::Patch::Algebra)
BlankNodeMapper (JSON::LD)
BlankNodeNamer (JSON::LD)
BlankNodeUniqer (JSON::LD)
Block (SXP::Generator)
BodyProxy (Rack)
Boolean (RDF::Literal)
Bound (SPARQL::Algebra::Operator)
BoundaryTooLongError (Rack::Multipart)
BoundedIO (Rack::Multipart::Parser)
BufferPart (Rack::Multipart::Parser::Collector)
BufferedResponse (Rack::Events)
Builder (Rack)
Builder
Builtin (RDF::N3::Algebra)
Byte (RDF::Literal)

CLI (RDF)
CSVW (RDF::Tabular)
Cache (RDF::Util)
Canonicalize (RDF)
Carroll2001 (RDF::Normalize)
Cascade (Rack)
Ceil (SPARQL::Algebra::Operator)
Ceiling (RDF::N3::Algebra::Math)
Cell (RDF::Tabular::Row)
Changeset (RDF)
ClassMethods (EBNF::LL1::Parser)
ClassMethods (EBNF::PEG::Parser)
Clear (SPARQL::Algebra::Operator)
Clear (SPARQL::Client::Update)
Client (SPARQL)
ClientError (SPARQL::Client)
Coalesce (SPARQL::Algebra::Operator)
Coercions (RDF::Util)
Collector (Rack::Multipart::Parser)
CollidingKeywords (JSON::LD::JsonLdError)
Column (RDF::Tabular)
CommonLisp (SXP::Reader)
CommonLogger (Rack)
Compact (JSON::LD)
Compare (SPARQL::Algebra::Operator)
Concat (SPARQL::Algebra::Operator)
Concatenation (RDF::N3::Algebra::Str)
Conclusion (RDF::N3::Algebra::Log)
ConditionalGet (Rack)
Config (Rack)
ConflictingIndexes (JSON::LD::JsonLdError)
Conjunction (RDF::N3::Algebra::Log)
Constraint (LD::Patch::Algebra)
ConstraintComponent (SHACL::Algebra)
Construct (SPARQL::Algebra::Operator)
Contains (RDF::N3::Algebra::Str)
Contains (SPARQL::Algebra::Operator)
ContainsIgnoringCase (RDF::N3::Algebra::Str)
Content (RDF::N3::Algebra::Log)
ContentLength (Rack)
ContentNegotiation (Rack::LinkedData)
ContentNegotiation (Rack::SPARQL)
ContentNegotiation (Rack::RDF)
ContentNegotiation (JSON::LD)
ContentType (Rack)
Context (JSON::LD)
Context (RDF::RDFa)
Context (Rack::Utils)
ContextError (RDF::RDFa)
ContextOverflow (JSON::LD::JsonLdError)
Cookie (Rack::MockResponse)
Copy (SPARQL::Algebra::Operator)
Copy (SPARQL::Client::Update)
Cos (RDF::N3::Algebra::Math)
CosH (RDF::N3::Algebra::Math)
Count (SPARQL::Algebra::Operator)
Countable (RDF)
Counter (RDF::Query::HashPatternNormalizer)
Create (SPARQL::Client::Update)
Create (SPARQL::Algebra::Operator)
Crypto (RDF::N3)
Cut (LD::Patch::Algebra)
CyclicIRIMapping (JSON::LD::JsonLdError)

DataObjects (RDF)
Dataset (SPARQL::Algebra::Operator)
Dataset (RDF)
Datatype (RDF::Tabular)
Datatype (SPARQL::Algebra::Operator)
Date (RDF::Literal)
DateTime (RDF::Literal)
DateTimeStamp (RDF::Literal)
Day (SPARQL::Algebra::Operator)
Day (RDF::Literal)
Day (RDF::N3::Algebra::Time)
DayOfWeek (RDF::N3::Algebra::Time)
DayTimeDuration (RDF::Literal)
DebugContext (RDF::Tabular::Metadata)
Decimal (RDF::Literal)
Defaults (RDF::DataObjects::Adapters)
Deflater (Rack)
Delete (LD::Patch::Algebra)
Delete (SPARQL::Algebra::Operator)
DeleteData (SPARQL::Algebra::Operator)
DeleteData (SPARQL::Client::Update)
DeleteInsert (SPARQL::Client::Update)
DeleteWhere (SPARQL::Algebra::Operator)
Desc (SPARQL::Algebra::Operator)
Describe (SPARQL::Algebra::Operator)
Dialect (RDF::Tabular)
Difference (RDF::N3::Algebra::Math)
Directory (Rack)
DirectoryBody (Rack::Directory)
Distiller (RDF)
Distinct (SPARQL::Algebra::Operator)
Divide (SPARQL::Algebra::Operator)
Document (Nokogiri::XML)
Double (RDF::Literal)
Drop (SPARQL::Algebra::Operator)
Drop (SPARQL::Client::Update)
DtLit (RDF::N3::Algebra::Log)
Durable (RDF)
Duration (RDF::Literal)

EBNF
EBNFMeta
EOF (SXP::Reader)
ETag (Rack)
EachOf (ShEx::Algebra)
Element (REXML)
Element (Nokogiri::XML)
EmptyContentError (Rack::Multipart)
EncodeForURI (SPARQL::Algebra::Operator)
EndsWith (RDF::N3::Algebra::Str)
Enumerable (RDF)
Enumerable (RDF::JSON::Extensions)
Enumerator (RDF::Enumerable)
Enumerator (RDF::Countable)
Enumerator (RDF::Queryable)
Env (Rack::Request)
Equal (SPARQL::Algebra::Operator)
EqualIgnoringCase (RDF::N3::Algebra::Str)
EqualTo (RDF::N3::Algebra::Math)
EqualTo (RDF::N3::Algebra::Log)
Error (EBNF::LL1::Parser)
Error (EBNF::LL1::Lexer)
Error (SHACL)
Error (LD::Patch)
Error (YAML_LD)
Error (RDF::Reasoner)
Error (RDF::Tabular)
Error (EBNF::PEG::Parser)
Error (SXP::Reader)
Error (ShEx)
ErrorWrapper (Rack::Lint::Wrapper)
Evaluatable (SPARQL::Algebra)
EventedBodyProxy (Rack::Events)
Events (Rack)
Exists (SPARQL::Algebra::Operator)
Expand (JSON::LD)
Expansion (RDF::RDFa)
Expansion (RDF::Microdata)
Exponentiation (RDF::N3::Algebra::Math)
Expression (SPARQL::Algebra)
Exprlist (SPARQL::Algebra::Operator)
Extend (SPARQL::Algebra::Operator)
Extended (SXP::Reader)
Extension (ShEx)
Extensions (RDF::JSON)
External (ShEx::Algebra)

FalseClass
FaradayAdapter (RDF::Util::File)
FatalWarner (Rack::MockRequest)
FatalWarning (Rack::MockRequest)
File (RDF::Util)
Files (Rack)
Filter (SPARQL::Algebra::Operator)
Filter (SPARQL::Client::Query)
First (RDF::N3::Algebra::List)
Flatten (JSON::LD)
Float
Float (RDF::Literal)
Floor (SPARQL::Algebra::Operator)
Floor (RDF::N3::Algebra::Math)
Format (RDF::Canonicalize)
Format (RDF::RDFa)
Format (RDF::Vocabulary)
Format (RDF::RDFXML)
Format (RDF::N3)
Format (RDF::Reasoner)
Format (RDF::Tabular)
Format (LD::Patch)
Format (RDF::TriG)
Format (RDF::N3::Algebra::Str)
Format (RDF::Turtle)
Format (RDF::JSON)
Format (ShEx)
Format (JSON::LD)
Format (SHACL)
Format (RDF::NQuads)
Format (RDF::Normalize)
Format (RDF::Microdata)
Format (RDF)
Format (YAML_LD)
Format (RDF::TriX)
Format (RDF::NTriples)
FormatError (RDF)
Formula (RDF::N3::Algebra)
ForwardRequest (Rack)
Frame (JSON::LD)
Frame (Rack::ShowExceptions)
FreebaseReader (RDF::Turtle)
FromRDF (JSON::LD)
FunctionCall (SPARQL::Algebra::Operator)

Generator (SXP)
Generator (Rack::Multipart)
GmTime (RDF::N3::Algebra::Time)
Grammar (SPARQL)
Graph (RDF)
Graph (SPARQL::Algebra::Operator)
Graph (RDF::JSON::Extensions)
GreaterThan (RDF::N3::Algebra::Math)
GreaterThan (RDF::N3::Algebra::Str)
GreaterThan (SPARQL::Algebra::Operator)
GreaterThanOrEqual (SPARQL::Algebra::Operator)
Group (SPARQL::Algebra::Operator)
GroupConcat (SPARQL::Algebra::Operator)
GzipStream (Rack::Deflater)

HCalendar (RDF)
HCard (RDF)
HTML (RDF::Literal)
HamsterRepo (RDF)
Hash
HashPatternNormalizer (RDF::Query)
Head (Rack)
Headers (Rack)
Helpers (Sinatra::RDF)
Helpers (Sinatra::LinkedData)
Helpers (Rack::Request)
Helpers (Sinatra::SPARQL)
Helpers (Rack::Response)
HexBinary (RDF::Literal)
Hour (RDF::N3::Algebra::Time)
Hours (SPARQL::Algebra::Operator)
HttpAdapter (RDF::Util::File)

IRI (SPARQL::Algebra::Operator)
IRIConfusedWithPrefix (JSON::LD::JsonLdError)
IRTree (YAML_LD::Representation)
ISOEBNF (EBNF)
ISOEBNFMeta
IdentifierIssuer (RDF::Normalize::RDFC10)
If (SPARQL::Algebra::Operator)
Implementation (RDF::Repository)
Implies (RDF::N3::Algebra::Log)
Import (ShEx::Algebra)
In (SPARQL::Algebra::Operator)
In (RDF::N3::Algebra::List)
InSeconds (RDF::N3::Algebra::Time)
Includes (RDF::N3::Algebra::Log)
Index (LD::Patch::Algebra)
Indexable (RDF)
Info (RDF::Spec::Matchers)
InputWrapper (Rack::Lint::Wrapper)
Insert (SPARQL::Algebra::Operator)
InsertData (SPARQL::Algebra::Operator)
InsertData (SPARQL::Client::Update)
Int (RDF::Literal)
Integer
Integer (RDF::Literal)
InvalidAnnotation (JSON::LD::JsonLdError)
InvalidBaseDirection (JSON::LD::JsonLdError)
InvalidBaseIRI (JSON::LD::JsonLdError)
InvalidContainerMapping (JSON::LD::JsonLdError)
InvalidContextEntry (JSON::LD::JsonLdError)
InvalidContextNullification (JSON::LD::JsonLdError)
InvalidDefaultLanguage (JSON::LD::JsonLdError)
InvalidEmbedValue (JSON::LD::JsonLdError)
InvalidEmbeddedNode (JSON::LD::JsonLdError)
InvalidEncoding (YAML_LD::Error)
InvalidFrame (JSON::LD::JsonLdError)
InvalidIRIMapping (JSON::LD::JsonLdError)
InvalidIdValue (JSON::LD::JsonLdError)
InvalidImportValue (JSON::LD::JsonLdError)
InvalidIncludedValue (JSON::LD::JsonLdError)
InvalidIndexValue (JSON::LD::JsonLdError)
InvalidJsonLiteral (JSON::LD::JsonLdError)
InvalidKeywordAlias (JSON::LD::JsonLdError)
InvalidLanguageMapValue (JSON::LD::JsonLdError)
InvalidLanguageMapping (JSON::LD::JsonLdError)
InvalidLanguageTaggedString (JSON::LD::JsonLdError)
InvalidLanguageTaggedValue (JSON::LD::JsonLdError)
InvalidLocalContext (JSON::LD::JsonLdError)
InvalidNestValue (JSON::LD::JsonLdError)
InvalidParameterError (Rack::QueryParser)
InvalidPrefixValue (JSON::LD::JsonLdError)
InvalidPropagateValue (JSON::LD::JsonLdError)
InvalidRemoteContext (JSON::LD::JsonLdError)
InvalidReverseProperty (JSON::LD::JsonLdError)
InvalidReversePropertyMap (JSON::LD::JsonLdError)
InvalidReversePropertyValue (JSON::LD::JsonLdError)
InvalidReverseValue (JSON::LD::JsonLdError)
InvalidScopedContext (JSON::LD::JsonLdError)
InvalidScriptElement (JSON::LD::JsonLdError)
InvalidSetOrListObject (JSON::LD::JsonLdError)
InvalidStreamingKeyOrder (JSON::LD::JsonLdError)
InvalidTermDefinition (JSON::LD::JsonLdError)
InvalidTypeMapping (JSON::LD::JsonLdError)
InvalidTypeValue (JSON::LD::JsonLdError)
InvalidTypedValue (JSON::LD::JsonLdError)
InvalidValueObject (JSON::LD::JsonLdError)
InvalidValueObjectValue (JSON::LD::JsonLdError)
InvalidVersionValue (JSON::LD::JsonLdError)
InvalidVocabMapping (JSON::LD::JsonLdError)
IriStem (ShEx::Algebra)
IriStemRange (ShEx::Algebra)
IsBlank (SPARQL::Algebra::Operator)
IsIRI (SPARQL::Algebra::Operator)
IsLiteral (SPARQL::Algebra::Operator)
IsNumeric (SPARQL::Algebra::Operator)
IsTriple (SPARQL::Algebra::Operator)
Isomorphic (RDF)
Iterate (RDF::N3::Algebra::List)
Iterator (Rack::Files)

JSON (RDF)
JSON (RDF::Tabular)
JSON
Join (SPARQL::Algebra::Operator)
JsonLdError (JSON::LD)

KeywordRedefinition (JSON::LD::JsonLdError)

LCase (SPARQL::Algebra::Operator)
LD
LD (JSON)
LL1 (EBNF)
Lang (SPARQL::Algebra::Operator)
LangLit (RDF::N3::Algebra::Log)
LangMatches (SPARQL::Algebra::Operator)
Language (ShEx::Algebra)
LanguageStem (ShEx::Algebra)
LanguageStemRange (ShEx::Algebra)
Last (RDF::N3::Algebra::List)
LateBound (RDF::Util::Aliasing)
LeftJoin (SPARQL::Algebra::Operator)
Length (RDF::N3::Algebra::List)
LessThan (RDF::N3::Algebra::Str)
LessThan (SPARQL::Algebra::Operator)
LessThan (RDF::N3::Algebra::Math)
LessThanOrEqual (SPARQL::Algebra::Operator)
Lexer (EBNF::LL1)
LibXML (RDF::TriX::Reader)
LinkedData
LinkedData (Sinatra)
LinkedData (Rack)
Lint (Rack)
LintError (Rack::Lint)
List (RDF::N3::Algebra)
List (SXP)
List (RDF)
List (RDF::N3)
ListOperator (RDF::N3::Algebra)
Literal (RDF)
Literal (RDF::JSON::Extensions)
LiteralStem (ShEx::Algebra)
LiteralStemRange (ShEx::Algebra)
Load (SPARQL::Client::Update)
Load (SPARQL::Algebra::Operator)
LoadingDocumentFailed (JSON::LD::JsonLdError)
LoadingRemoteContextFailed (JSON::LD::JsonLdError)
LocalTime (RDF::N3::Algebra::Time)
Lock (Rack)
Log (RDF::N3::Algebra)
Log (RDF::N3)
Logger (RDF::Util)
LoggerBehavior (RDF::Util::Logger)
Long (RDF::Literal)

MD (RDF)
MD5 (SPARQL::Algebra::Operator)
MalformedQuery (SPARQL::Client)
MalformedQuery (SPARQL)
MappingKeyError (YAML_LD::Error)
MatchArray (RSpec::Matchers)
Matchers (RSpec)
Matchers (RDF::Spec)
Matches (RDF::N3::Algebra::Str)
Math (RDF::N3)
Math (RDF::N3::Algebra)
Max (SPARQL::Algebra::Operator)
MaxCallsExceeded (RDF::Normalize)
MediaType (Rack)
Member (RDF::N3::Algebra::List)
MergeGraph (RDF)
Meta (SPARQL::Grammar)
Meta (LD::Patch)
Meta (ShEx)
Meta11 (SPARQL::Grammar)
Metadata (RDF::Tabular)
MethodOverride (Rack)
Microdata (RDF)
Middleware (Rack::RewindableInput)
Mime (Rack)
MimePart (Rack::Multipart::Parser::Collector)
Min (SPARQL::Algebra::Operator)
Minus (SPARQL::Algebra::Operator)
Minute (RDF::N3::Algebra::Time)
Minutes (SPARQL::Algebra::Operator)
MissingIncludedReferent (JSON::LD::JsonLdError)
MissingInputError (Rack::Multipart)
MockRequest (Rack)
MockResponse (Rack)
Modify (SPARQL::Algebra::Operator)
Month (RDF::N3::Algebra::Time)
Month (RDF::Literal)
Month (SPARQL::Algebra::Operator)
MonthDay (RDF::Literal)
Move (SPARQL::Algebra::Operator)
Move (SPARQL::Client::Update)
Multipart (Rack)
MultipartInfo (Rack::Multipart::Parser)
MultipartPartLimitError (Rack::Multipart)
MultipartTotalPartLimitError (Rack::Multipart)
MultipleContextLinkHeaders (JSON::LD::JsonLdError)
Multiply (SPARQL::Algebra::Operator)
Mutable (RDF)

N3 (RDF)
N3String (RDF::N3::Algebra::Log)
NQuads (RDF)
NTriples (RDF)
Namespace (RDF::RDFXML::Reader::REXML)
Native (EBNF)
Negate (SPARQL::Algebra::Operator)
Negation (RDF::N3::Algebra::Math)
NegativeInteger (RDF::Literal)
NetHttpAdapter (RDF::Util::File)
NilClass
Node (RDF)
Node (RDF::JSON::Extensions)
Node (Nokogiri::XML)
NodeConstraint (ShEx::Algebra)
NodeProxy (RDF::RDFa::Reader::REXML)
NodeProxy (JSON::LD::API::Nokogiri)
NodeProxy (RDF::Microdata::Reader::Nokogiri)
NodeProxy (RDF::RDFXML::Reader::REXML)
NodeProxy (RDF::RDFXML::Reader::Nokogiri)
NodeProxy (RDF::RDFa::Reader::Nokogiri)
NodeProxy (JSON::LD::API::REXML)
NodeSet (Nokogiri::XML)
NodeSetProxy (RDF::RDFa::Reader::Nokogiri)
NodeSetProxy (JSON::LD::API::REXML)
NodeSetProxy (RDF::Microdata::Reader::Nokogiri)
NodeSetProxy (JSON::LD::API::Nokogiri)
NodeSetProxy (RDF::RDFXML::Reader::Nokogiri)
NodeSetProxy (RDF::RDFXML::Reader::REXML)
NodeSetProxy (RDF::RDFa::Reader::REXML)
NodeShape (SHACL::Algebra)
Nokogiri (RDF::Microdata::Reader)
Nokogiri (RDF::RDFa::Reader)
Nokogiri (RDF::TriX::Writer)
Nokogiri (RDF::TriX::Reader)
Nokogiri (JSON::LD::API)
Nokogiri (RDF::RDFXML::Reader)
NonNegativeInteger (RDF::Literal)
NonPositiveInteger (RDF::Literal)
NormalizationState (RDF::Normalize::URGNA2012)
NormalizationState (RDF::Normalize::RDFC10)
Normalize (RDF)
Not (ShEx::Algebra)
Not (SPARQL::Algebra::Operator)
NotConstraintComponent (SHACL::Algebra)
NotEqual (SPARQL::Algebra::Operator)
NotEqualIgnoringCase (RDF::N3::Algebra::Str)
NotEqualTo (RDF::N3::Algebra::Log)
NotEqualTo (RDF::N3::Algebra::Math)
NotExists (SPARQL::Algebra::Operator)
NotGreaterThan (RDF::N3::Algebra::Str)
NotGreaterThan (RDF::N3::Algebra::Math)
NotImplemented (RDF::N3::Algebra)
NotIn (SPARQL::Algebra::Operator)
NotIncludes (RDF::N3::Algebra::Log)
NotLessThan (RDF::N3::Algebra::Str)
NotLessThan (RDF::N3::Algebra::Math)
NotMatched (ShEx)
NotMatches (RDF::N3::Algebra::Str)
NotOneOf (SPARQL::Algebra::Operator)
NotSatisfied (ShEx)
Now (SPARQL::Algebra::Operator)
NullLogger (Rack)
Nullary (SPARQL::Algebra::Operator)
Numeric (RDF::Literal)

OWL (RDF)
OWL (RDF::Reasoner)
Object (SPARQL::Algebra::Operator)
Object
ObjectSpaceCache (RDF::Util::Cache)
OneOf (ShEx::Algebra)
Operation (SPARQL::Client::Update)
Operator (SPARQL::Algebra)
Operator (ShEx::Algebra)
Operator (SHACL::Algebra)
Option (RDF::CLI)
OptionParser
Or (SPARQL::Algebra::Operator)
Or (ShEx::Algebra)
OrConstraintComponent (SHACL::Algebra)
Order (SPARQL::Algebra::Operator)
OrderedRepo (RDF)
OutputString (RDF::N3::Algebra::Log)

PEG (EBNF)
Pair (SXP)
ParamList (Rack::Multipart)
ParameterTypeError (Rack::QueryParser)
Params (Rack::QueryParser)
ParseError (RDF::Tabular::UAX35)
ParseError (LD::Patch)
ParseError (ShEx)
ParsedAsN3 (RDF::N3::Algebra::Log)
Parser (ShEx)
Parser (Rack::Multipart)
Parser (EBNF::PEG)
Parser (EBNF)
Parser (LD::Patch)
Parser (SPARQL::Grammar)
Parser (EBNF::LL1)
Parser11 (SPARQL::Grammar)
Patch (LD)
Patch (LD::Patch::Algebra)
Path (LD::Patch::Algebra)
Path (SPARQL::Algebra::Operator)
PathOpt (SPARQL::Algebra::Operator)
PathPlus (SPARQL::Algebra::Operator)
PathRange (SPARQL::Algebra::Operator)
PathStar (SPARQL::Algebra::Operator)
PathZero (SPARQL::Algebra::Operator)
Pattern (RDF::Query)
PatternConstraintComponent (SHACL::Algebra)
Plus (SPARQL::Algebra::Operator)
PositiveInteger (RDF::Literal)
Postgres (RDF::DataObjects::Adapters)
Predicate (SPARQL::Algebra::Operator)
Prefix (SPARQL::Algebra::Operator)
Prefix (LD::Patch::Algebra)
Preloaded (JSON::LD)
ProcessingModeConflict (JSON::LD::JsonLdError)
Product (RDF::N3::Algebra::Math)
ProfileError (YAML_LD::Error)
Project (SPARQL::Algebra::Operator)
PropertyShape (SHACL::Algebra)
ProtectedTermRedefinition (JSON::LD::JsonLdError)
Psych (AmazingPrint)

QualifiedValueConstraintComponent (SHACL::Algebra)
Quaternary (SPARQL::Algebra::Operator)
Query (SPARQL::Client)
Query (RDF)
Query (SPARQL::Algebra)
QueryElement (SPARQL::Client)
QueryLimitError (Rack::QueryParser)
QueryParser (Rack)
QueryRequestRefused (SPARQL)
Queryable (RDF)
Quotient (RDF::N3::Algebra::Math)

RDF (Rack)
RDF (Sinatra)
RDF
RDFA (RDF)
RDFC10 (RDF::Normalize)
RDFS (RDF)
RDFS (RDF::Reasoner)
RDFV (RDF)
RDFXML (RDF)
RDFa (RDF)
REXML (RDF::RDFXML::Reader)
REXML (RDF::RDFa::Reader)
REXML (RDF::TriX::Reader)
REXML (RDF::TriX::Writer)
REXML (JSON::LD::API)
RSpec
Rack
Rand (SPARQL::Algebra::Operator)
Raw (Rack::Response)
RdfXml (Builder)
RdfaReader (RDF::Microdata)
Readable (RDF)
Reader (RDF::RDFXML)
Reader (RDF::NTriples)
Reader (RDF::TriG)
Reader (RDF::TriX)
Reader (RDF::Turtle)
Reader (RDF::Tabular)
Reader (RDF)
Reader (YAML_LD)
Reader (RDF::NQuads)
Reader (JSON::LD)
Reader (RDF::JSON)
Reader (SXP)
Reader (RDF::RDFa)
Reader (RDF::N3)
Reader (RDF::Microdata)
ReaderError (RDF)
Reasoner (RDF::N3)
Reasoner (RDF)
Recovery (RDF::N3::Reader)
Recovery (RDF::Turtle::Reader)
Recursive (Rack)
Reduced (SPARQL::Algebra::Operator)
ReferencedStatement (ShEx::Algebra)
Refinements (SHACL)
Refinements (RDF::N3)
Regex (SPARQL::Algebra::Operator)
Regexp
Registry (RDF::Microdata)
Rei (RDF::N3)
Reloader (Rack)
Remainder (RDF::N3::Algebra::Math)
RemoteDocument (JSON::LD::API)
RemoteDocument (RDF::Util::File)
Replace (RDF::N3::Algebra::Str)
Replace (SPARQL::Algebra::Operator)
Repository (RDF::N3)
Repository (RDF::DataObjects)
Repository (RDF)
Repository (SPARQL::Client)
Repository (RDF::JSON::Extensions)
Representation (YAML_LD)
Request (Rack::Auth::Basic)
Request (Rack)
Resource (RDF)
Resource (JSON::LD)
ResourceOperator (RDF::N3::Algebra)
Response (Sinatra)
Response (Rack)
RestClientAdapter (RDF::Util::File)
Results (SPARQL)
Reverse (LD::Patch::Algebra)
Reverse (SPARQL::Algebra::Operator)
RewindableInput (Rack)
Round (SPARQL::Algebra::Operator)
Rounded (RDF::N3::Algebra::Math)
Row (RDF::Tabular)
Rule (RDF::Microdata::Expansion)
Rule (EBNF)
Rule (RDF::RDFa::Expansion)
Rule (EBNF::PEG)
Runtime (Rack)

SHA1 (SPARQL::Algebra::Operator)
SHA256 (SPARQL::Algebra::Operator)
SHA384 (SPARQL::Algebra::Operator)
SHA512 (SPARQL::Algebra::Operator)
SHACL (RDF::Vocab)
SHACL
SPARQL (Sinatra)
SPARQL (SXP::Reader)
SPARQL
SPARQL (Rack)
SPARQLConstraintComponent (SHACL::Algebra)
SXP
SameTerm (SPARQL::Algebra::Operator)
Sample (SPARQL::Algebra::Operator)
Scanner (EBNF::LL1)
Schema (RDF::Reasoner)
Schema (RDF::Tabular)
Schema (ShEx::Algebra)
Scheme (SXP::Reader)
Scrape (RDF::N3::Algebra::Str)
Second (RDF::N3::Algebra::Time)
Seconds (SPARQL::Algebra::Operator)
SemAct (ShEx::Algebra)
Semantics (RDF::N3::Algebra::Log)
Sendfile (Rack)
Seq (SPARQL::Algebra::Operator)
Sequence (SPARQL::Algebra::Operator)
SerializedTransaction (RDF::Transaction)
Server (SPARQL)
ServerError (SPARQL::Client)
Service (SPARQL::Algebra::Operator)
ShEx
Shape (SHACL::Algebra)
Shape (ShEx::Algebra)
ShapeExpression (ShEx::Algebra)
ShapeResult (ShEx::Algebra)
Shapes (SHACL)
Short (RDF::Literal)
ShowExceptions (Rack)
ShowStatus (Rack)
Sin (RDF::N3::Algebra::Math)
SinH (RDF::N3::Algebra::Math)
Sinatra
Slice (SPARQL::Algebra::Operator)
Solution (RDF::Query)
Solutions (RDF::Query)
Spec (RDF)
Sqlite3 (RDF::DataObjects::Adapters)
Start (ShEx::Algebra)
StartsWith (RDF::N3::Algebra::Str)
Stat (Rack::Reloader)
Statement (RDF)
Statement (RDF::JSON::Extensions)
Static (Rack)
Stem (ShEx::Algebra)
StemRange (ShEx::Algebra)
Str (SPARQL::Algebra::Operator)
Str (RDF::N3)
Str (RDF::N3::Algebra)
StrAfter (SPARQL::Algebra::Operator)
StrBefore (SPARQL::Algebra::Operator)
StrDT (SPARQL::Algebra::Operator)
StrEnds (SPARQL::Algebra::Operator)
StrLang (SPARQL::Algebra::Operator)
StrLen (SPARQL::Algebra::Operator)
StrStarts (SPARQL::Algebra::Operator)
StrUUID (SPARQL::Algebra::Operator)
StreamWrapper (Rack::Lint::Wrapper)
StreamingReader (JSON::LD)
StreamingWriter (RDF::Turtle)
StreamingWriter (RDF::TriG)
StreamingWriter (JSON::LD)
StrictVocabulary (RDF)
String
StructureError (SHACL)
StructureError (ShEx)
SubStr (SPARQL::Algebra::Operator)
Subject (SPARQL::Algebra::Operator)
Subtract (SPARQL::Algebra::Operator)
Sum (RDF::N3::Algebra::Math)
Sum (SPARQL::Algebra::Operator)
Symbol
SyntaxError (RDF::Turtle::Reader)
SyntaxError (RDF::N3::Reader)

TZ (SPARQL::Algebra::Operator)
Table (RDF::Tabular)
Table (SPARQL::Algebra::Operator)
TableGroup (RDF::Tabular)
Tabular (RDF)
Tan (RDF::N3::Algebra::Math)
TanH (RDF::N3::Algebra::Math)
TempfilePart (Rack::Multipart::Parser::Collector)
TempfileReaper (Rack)
Temporal (RDF::Literal)
Term (RDF)
Term (RDF::Vocabulary)
TermDefinition (JSON::LD::Context)
Terminal (EBNF::LL1::Lexer)
Terminals (SPARQL::Grammar)
Terminals (LD::Patch)
Terminals (ShEx)
Terminals (RDF::Turtle)
Terminals (EBNF)
Terminals (RDF::N3)
Ternary (SPARQL::Algebra::Operator)
Time (RDF::N3)
Time (RDF::Literal)
Time
Time (RDF::N3::Algebra)
Timezone (SPARQL::Algebra::Operator)
Timezone (RDF::N3::Algebra::Time)
ToRDF (JSON::LD)
Token (RDF::Literal)
Token (EBNF::LL1::Lexer)
Transactable (RDF)
Transaction (RDF::JSON::Extensions)
Transaction (RDF)
TransactionError (RDF::Transaction)
Transformation (RDF::Tabular)
TriG (RDF)
TriX (RDF)
Triple (SPARQL::Algebra::Operator)
TripleConstraint (ShEx::Algebra)
TripleExpression (ShEx::Algebra)
TrueClass
Turtle (RDF)
TypeCheck (RDF)

UAX35 (RDF::Tabular)
UCase (SPARQL::Algebra::Operator)
URGNA2012 (RDF::Normalize)
URI (RDF::JSON::Extensions)
URI (RDF)
URLMap (Rack)
UUID (RDF::Util)
UUID (SPARQL::Algebra::Operator)
Unary (ShEx::Algebra::Operator)
Unary (SPARQL::Algebra::Operator)
Unescape (EBNF)
Union (SPARQL::Algebra::Operator)
UnknownHashAlgorithm (RDF::Normalize)
Unmatched (EBNF::PEG::Parser)
UnsignedByte (RDF::Literal)
UnsignedInt (RDF::Literal)
UnsignedLong (RDF::Literal)
UnsignedShort (RDF::Literal)
Update (SPARQL::Client)
Update (SPARQL::Algebra::Operator)
Update (SPARQL::Algebra)
UpdateList (LD::Patch::Algebra)
UploadedFile (Rack::Multipart)
Using (SPARQL::Algebra::Operator)
Util (RDF)
Utils (JSON::LD)
Utils (Rack)

VERSION (SPARQL::Algebra)
VERSION (RDF::Microdata)
VERSION (RDF::JSON)
VERSION (RDF::N3)
VERSION (RDF::Isomorphic)
VERSION (RDF::HamsterRepo)
VERSION (RDF::Normalize)
VERSION (RDF::OrderedRepo)
VERSION (RDF::DataObjects)
VERSION (RDF::RDFa)
VERSION (EBNF)
VERSION (RDF::RDFXML)
VERSION (RDF::Reasoner)
VERSION (RDF::Spec)
VERSION (RDF::Distiller)
VERSION (RDF::Tabular)
VERSION (RDF::TriG)
VERSION (JSON::LD)
VERSION (RDF::TriX)
VERSION (RDF::Turtle)
VERSION (RDF::Vocab)
VERSION (RDF::XSD)
VERSION (SHACL)
VERSION (ShEx)
VERSION (Sinatra::LinkedData)
VERSION (RDF)
VERSION (RDF::AggregateRepo)
VERSION (SPARQL)
VERSION (Rack::RDF)
VERSION (Rack::LinkedData)
VERSION (JSON::LD::Preloaded)
VERSION (LD::Patch)
VERSION (SPARQL::Client)
VERSION (SXP)
VERSION (YAML_LD)
ValidationReport (SHACL)
ValidationResult (SHACL)
Value (ShEx::Algebra)
Value (RDF)
Variable (RDF::Query)
Vector
Vocab (RDF)
VocabFormatExtensions (RDF::Vocabulary)
Vocabulary (RDF)

WeakRefCache (RDF::Util::Cache)
With (SPARQL::Algebra::Operator)
Wrapper (Rack::Lint)
Writable (RDF)
Writer (RDF::TriX)
Writer (YAML_LD)
Writer (RDF::JSON)
Writer (RDF::RDFa)
Writer (RDF)
Writer (RDF::Turtle)
Writer (EBNF)
Writer (RDF::N3)
Writer (RDF::RDFXML)
Writer (RDF::NQuads)
Writer (RDF::NTriples)
Writer (RDF::Normalize)
Writer (JSON::LD)
Writer (RDF::TriG)
Writer (RDF::Vocabulary)
WriterError (RDF)

XML (Nokogiri)
XML (RDF::Literal)
XSD (RDF)
XoneConstraintComponent (SHACL::Algebra)

YAML_LD
Year (SPARQL::Algebra::Operator)
Year (RDF::Literal)
Year (RDF::N3::Algebra::Time)
YearMonth (RDF::Literal)
YearMonthDuration (RDF::Literal)