Class: RDF::Format Abstract

Inherits:
Object
  • Object
show all
Extended by:
Enumerable
Defined in:
lib/rdf/format.rb

Overview

This class is abstract.

The base class for RDF serialization formats.

Examples:

Loading an RDF serialization format implementation

require 'rdf/ntriples'

Iterating over known RDF serialization formats

RDF::Format.each { |klass| puts klass.name }

Getting a serialization format class

RDF::Format.for(:ntriples)     #=> RDF::NTriples::Format
RDF::Format.for("etc/doap.nt")
RDF::Format.for(:file_name => "etc/doap.nt")
RDF::Format.for(:file_extension => "nt")
RDF::Format.for(:content_type => "text/plain")

Obtaining serialization format MIME types

RDF::Format.content_types      #=> {"text/plain" => [RDF::NTriples::Format]}

Obtaining serialization format file extension mappings

RDF::Format.file_extensions    #=> {:nt => "text/plain"}

Defining a new RDF serialization format class

class RDF::NTriples::Format < RDF::Format
  content_type     'text/plain', :extension => :nt
  content_encoding 'ascii'

  reader RDF::NTriples::Reader
  writer RDF::NTriples::Writer
end

Instantiating an RDF reader or writer class (1)

RDF::Format.for(:ntriples).reader.new($stdin)  { |reader| ... }
RDF::Format.for(:ntriples).writer.new($stdout) { |writer| ... }

Instantiating an RDF reader or writer class (2)

RDF::Reader.for(:ntriples).new($stdin)  { |reader| ... }
RDF::Writer.for(:ntriples).new($stdout) { |writer| ... }

See Also:

Direct Known Subclasses

NTriples::Format

Class Method Summary (collapse)

Class Method Details

+ content_encoding(encoding) (protected)

This method returns an undefined value.

Defines the content encoding for this RDF serialization format.

Parameters:

  • (#to_sym) encoding


298
299
300
# File 'lib/rdf/format.rb', line 298

def self.content_encoding(encoding)
  @@content_encoding[self] = encoding.to_sym
end

+ content_type(type, options) + (Array<String>) content_type

Retrieves or defines MIME content types for this RDF serialization format.

Overloads:

  • + content_type(type, options)

    This method returns an undefined value.

    Retrieves or defines the MIME content type for this RDF serialization format.

    Optionally also defines alias MIME content types for this RDF serialization format.

    Optionally also defines a file extension, or a list of file extensions, that should be mapped to the given MIME type and handled by this class.

    Parameters:

    • (String) type
    • (Hash{Symbol => Object}) options

    Options Hash (options):

    • (String) :alias — default: nil
    • (Array<String>) :aliases — default: nil
    • (Symbol) :extension — default: nil
    • (Array<Symbol>) :extensions — default: nil
  • + (Array<String>) content_type

    Retrieves the MIME content types for this RDF serialization format.

    The return is an array where the first element is the cannonical MIME type for the format and following elements are alias MIME types.

    Returns:

    • (Array<String>)


260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
# File 'lib/rdf/format.rb', line 260

def self.content_type(type = nil, options = {})
  if type.nil?
    [@@content_type[self], @@content_types.map {
      |ct, cl| (cl.include?(self) && ct != @@content_type[self]) ?  ct : nil }].flatten.compact
  else
    @@content_type[self] = type
    (@@content_types[type] ||= []) << self

    if extensions = (options[:extension] || options[:extensions])
      extensions = [extensions].flatten.map(&:to_sym)
      extensions.each { |ext| @@file_extensions[ext] = type }
    end
    if aliases = (options[:alias] || options[:aliases])
      aliases = [aliases].flatten.each { |a| (@@content_types[a] ||= []) << self }
    end
  end
end

+ (Hash{String => Array<Class>}) content_types

Returns MIME content types for known RDF serialization formats.

Returns:

  • (Hash{String => Array<Class>})


130
131
132
# File 'lib/rdf/format.rb', line 130

def self.content_types
  @@content_types
end

+ (Enumerator) each {|klass| ... }

Enumerates known RDF serialization format classes.

Yields:

  • (klass)

Yield Parameters:

  • (Class)

Returns:



54
55
56
# File 'lib/rdf/format.rb', line 54

def self.each(&block)
  @@subclasses.each(&block)
end

+ (Hash{Symbol => String}) file_extensions

Returns file extensions for known RDF serialization formats.

Returns:

  • (Hash{Symbol => String})


138
139
140
# File 'lib/rdf/format.rb', line 138

def self.file_extensions
  @@file_extensions
end

+ (Class) for(format) + (Class) for(filename) + (Class) for(options = {})

Finds an RDF serialization format class based on the given criteria.

Overloads:

  • + (Class) for(format)

    Finds an RDF serialization format class based on a symbolic name.

    Parameters:

    • (Symbol) format

    Returns:

    • (Class)
  • + (Class) for(filename)

    Finds an RDF serialization format class based on a file name.

    Parameters:

    • (String) filename

    Returns:

    • (Class)
  • + (Class) for(options = {})

    Finds an RDF serialization format class based on various options.

    Parameters:

    • (Hash{Symbol => Object}) options

    Options Hash (options):

    • (String, #to_s) :file_name — default: nil
    • (Symbol, #to_sym) :file_extension — default: nil
    • (String, #to_s) :content_type — default: nil

    Returns:

    • (Class)

Returns:

  • (Class)


83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
# File 'lib/rdf/format.rb', line 83

def self.for(options = {})
  case options
    when String
      # Find a format based on the file name
      self.for(:file_name => options)

    when Hash
      case
        # Find a format based on the MIME content type:
        when mime_type = options[:content_type]
          # @see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.17
          # @see http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7
          mime_type = mime_type.to_s
          mime_type = mime_type.split(';').first if mime_type.include?(?;) # remove any media type parameters
          content_types.has_key?(mime_type) ? content_types[mime_type].first : nil
        # Find a format based on the file name:
        when file_name = options[:file_name]
          self.for(:file_extension => File.extname(file_name.to_s)[1..-1])
        # Find a format based on the file extension:
        when file_ext  = options[:file_extension]
          if file_extensions.has_key?(file_ext = file_ext.to_sym)
            self.for(:content_type => file_extensions[file_ext])
          end
      end

    when Symbol
      case format = options
        # Special case, since we want this to work despite autoloading
        when :ntriples
          RDF::NTriples::Format
        # For anything else, find a match based on the full class name
        else
          format = format.to_s.downcase
          @@subclasses.each do |klass|
            if klass.name.to_s.split('::').map(&:downcase).include?(format)
              return klass
            end
          end
          nil # not found
      end
  end
end

+ reader(klass) + reader { ... } + (Class) reader Also known as: reader_class

This method returns an undefined value.

Retrieves or defines the reader class for this RDF serialization format.

Overloads:

  • + reader(klass)

    This method returns an undefined value.

    Defines the reader class for this RDF serialization format.

    The class should be a subclass of Reader, or implement the same interface.

    Parameters:

    • (Class) klass
  • + reader { ... }

    This method returns an undefined value.

    Defines the reader class for this RDF serialization format.

    The block should return a subclass of Reader, or a class that implements the same interface. The block won't be invoked until the reader class is first needed.

    Yields:

    Yield Returns:

    • (Class)

      klass

  • + (Class) reader

    Retrieves the reader class for this RDF serialization format.

    Returns:

    • (Class)


172
173
174
175
176
177
178
179
180
181
182
183
# File 'lib/rdf/format.rb', line 172

def self.reader(klass = nil, &block)
  case
    when klass
      @@readers[self] = klass
    when block_given?
      @@readers[self] = block
    else
      klass = @@readers[self]
      klass = @@readers[self] = klass.call if klass.is_a?(Proc)
      klass
  end
end

+ require(library) (protected)

This method returns an undefined value.

Defines a required Ruby library for this RDF serialization format.

The given library will be required lazily, i.e. only when it is actually first needed, such as when instantiating a reader or parser instance for this format.

Parameters:

  • (String, #to_s) library


289
290
291
# File 'lib/rdf/format.rb', line 289

def self.require(library)
  (@@requires[self] ||= []) << library.to_s
end

+ writer(klass) + writer { ... } + (Class) writer Also known as: writer_class

This method returns an undefined value.

Retrieves or defines the writer class for this RDF serialization format.

Overloads:

  • + writer(klass)

    This method returns an undefined value.

    Defines the writer class for this RDF serialization format.

    The class should be a subclass of Writer, or implement the same interface.

    Parameters:

    • (Class) klass
  • + writer { ... }

    This method returns an undefined value.

    Defines the writer class for this RDF serialization format.

    The block should return a subclass of Writer, or a class that implements the same interface. The block won't be invoked until the writer class is first needed.

    Yields:

    Yield Returns:

    • (Class)

      klass

  • + (Class) writer

    Retrieves the writer class for this RDF serialization format.

    Returns:

    • (Class)


215
216
217
218
219
220
221
222
223
224
225
226
# File 'lib/rdf/format.rb', line 215

def self.writer(klass = nil, &block)
  case
    when klass
      @@writers[self] = klass
    when block_given?
      @@writers[self] = block
    else
      klass = @@writers[self]
      klass = @@writers[self] = klass.call if klass.is_a?(Proc)
      klass
  end
end