roadforest 0.1 → 0.5

data/lib/roadforest/content-handling/type-handlers/rdfa.rb

@@ -1,175 +0,0 @@
-require 'rdf/rdfa' #XXX Otherwise json-ld grabs RDFa documents. Awaiting fix upstream
-require 'roadforest/content-handling/type-handlers/rdf-handler'
-module RoadForest
-  module MediaType
-    module Handlers
-      class RESTfulRDFaWriter < ::RDF::RDFa::Writer
-        HAML = ::RDF::RDFa::Writer::BASE_HAML.merge(:property_values => %q{
-          - objects.each do |object|
-            /
-              = object.inspect
-          %div.property
-            %span.label
-              = get_predicate_name(predicate)
-            %ul
-              - objects.each do |object|
-                - if res = yield(object, :inlist => inlist, :element => :li)
-                  != res
-                - elsif object.node?
-                  %li{:property => get_curie(predicate), :resource => get_curie(object), :inlist => inlist}= get_curie(object)
-                - elsif object.uri?
-                  %li
-                    %a{:property => get_curie(predicate), :href => object.to_s, :inlist => inlist}= object.to_s
-                - elsif object.datatype == RDF.XMLLiteral
-                  %li{:property => get_curie(predicate), :lang => get_lang(object), :datatype => get_curie(object.datatype), :inlist => inlist}<!= get_value(object)
-                - else
-                  %li{:property => get_curie(predicate), :content => get_content(object), :lang => get_lang(object), :datatype => get_dt_curie(object), :inlist => inlist}= escape_entities(get_value(object))
-        })
-
-        def initialize(output = $stdout, options = nil, &block)
-          options ||= {}
-          options = {:haml => HAML}
-          super(output, options, &block)
-        end
-
-
-        # Write a predicate with one or more values.
-        #
-        # Values may be a combination of Literal and Resource (Node or URI).
-        # @param [RDF::Resource] predicate
-        #   Predicate to serialize
-        # @param [Array<RDF::Resource>] objects
-        #   Objects to serialize
-        # @return [String]
-        def predicate(predicate, objects, options = nil)
-          add_debug {"predicate: #{predicate.inspect}, objects: #{objects}"}
-
-          return if objects.to_a.empty?
-
-          add_debug {"predicate: #{get_curie(predicate)}"}
-          render_property(predicate, objects, options || {}) do |o, opts|
-            # Yields each object, for potential recursive definition.
-            # If nil is returned, a leaf is produced
-            opts = {:rel => get_curie(predicate), :element => (:li if objects.length > 1)}.merge(opts||{})
-
-            if !is_done?(o) && @subjects.include?(o)
-              depth {subject(o, opts)}
-            end
-          end
-        end
-
-
-        # Render a single- or multi-valued predicate using
-        # `haml_template[:property_value]` or
-        # `haml_template[:property_values]`. Yields each object for optional
-        # rendering. The block should only render for recursive subject
-        # definitions (i.e., where the object is also a subject and is rendered
-        # underneath the first referencing subject).
-        #
-        # If a multi-valued property definition is not found within the template, the writer will use the single-valued property definition multiple times.
-        #
-        # @param [Array<RDF::Resource>] predicate
-        #   Predicate to render.
-        # @param [Array<RDF::Resource>] objects
-        #   List of objects to render. If the list contains only a single element, the :property_value template will be used. Otherwise, the :property_values template is used.
-        # @param [Hash{Symbol => Object}] options Rendering options passed to Haml render.
-        # @option options [String] haml (haml_template[:property_value], haml_template[:property_values])
-        #   Haml template to render. Otherwise, uses `haml_template[:property_value] or haml_template[:property_values]`
-        #   depending on the cardinality of objects.
-        # @yield [object]
-        #   Yields object.
-        # @yieldparam [RDF::Resource] object
-        # @yieldreturn [String, nil]
-        #   The block should only return a string for recursive object definitions.
-        # @return String
-        #   The rendered document is returned as a string
-        def render_property(predicate, objects, options = {}, &block)
-          add_debug {"render_property(#{predicate}): #{objects.inspect}"}
-          # If there are multiple objects, and no :property_values is defined, call recursively with
-          # each object
-
-          template = options[:haml]
-          template ||= objects.length > 1 ? haml_template[:property_values] : haml_template[:property_value]
-
-          # Separate out the objects which are lists and render separately
-          list_objects = objects.select {|o| o != ::RDF.nil && ::RDF::List.new(o, @graph).valid?}
-          unless list_objects.empty?
-            # Render non-list objects
-            add_debug {"properties with lists: non-lists: #{objects - list_objects} lists: #{list_objects}"}
-            nl = render_property(predicate, objects - list_objects, options, &block) unless objects == list_objects
-            return nl.to_s + list_objects.map do |object|
-              # Render each list as multiple properties and set :inlist to true
-              list = ::RDF::List.new(object, @graph)
-              list.each_statement {|st| subject_done(st.subject)}
-
-              add_debug {"list: #{list.inspect} #{list.to_a}"}
-              render_property(predicate, list.to_a, options.merge(:inlist => "true"), &block)
-            end.join(" ")
-          end
-
-          if objects.length > 1 && template.nil?
-            # Uf there is no property_values template, render each property using property_value template
-            objects.map do |object|
-              render_property(predicate, [object], options, &block)
-            end.join(" ")
-          else
-            raise ::RDF::WriterError, "Missing property template" if template.nil?
-
-            template = options[:haml] || (
-              objects.to_a.length > 1 &&
-              haml_template.has_key?(:property_values) ?
-              :property_values :
-              :property_value)
-              options = {
-                :objects    => objects,
-                :object     => objects.first,
-                :predicate  => predicate,
-                :property   => get_curie(predicate),
-                :rel        => get_curie(predicate),
-                :inlist     => nil,
-              }.merge(options)
-              hamlify(template, options) do |object, options|
-                yield(object, options) if block_given?
-              end
-          end
-        end
-
-      end
-
-      #text/html;q=1;rdfa
-      #image/svg+xml;q=1;rdfa
-      #application/xhtml+xml;q=1;rdfa
-      #text/html
-      #image/svg+xml
-      #application/xhtml+xml
-      class RDFa < RDFHandler
-        include RDF::Normalization
-
-        def local_to_network(base_uri, rdf)
-          raise "Invalid base uri: #{base_uri}" if base_uri.nil?
-          prefixes = relevant_prefixes_for_graph(rdf)
-          prefixes.keys.each do |prefix|
-            prefixes[prefix.to_sym] = prefixes[prefix]
-          end
-          #::RDF::RDFa.debug = true
-          RESTfulRDFaWriter.buffer(:base_uri => base_uri.to_s,
-                                   :prefixes => prefixes) do |writer|
-            rdf.each_statement do |statement|
-              writer << statement
-            end
-                                   end
-        end
-
-        def network_to_local(base_uri, source)
-          raise "Invalid base uri: #{base_uri.inspect}" if base_uri.nil?
-          graph = ::RDF::Graph.new
-          reader = ::RDF::RDFa::Reader.new(source.to_s, :base_uri => base_uri.to_s)
-          reader.each_statement do |statement|
-            graph.insert(statement)
-          end
-          graph
-        end
-      end
-    end
-  end
-end

data/lib/roadforest/content-handling/type-handlers/rdfpost.rb

@@ -1,297 +0,0 @@
-require 'roadforest/content-handling/type-handlers/rdf-handler'
-
-module RoadForest
-  module MediaType
-    module Handlers
-      #application/x-www-form-urlencoded
-      class RDFPost < RDFHandler
-
-        #c.f. http://www.lsrn.org/semweb/rdfpost.html
-        class Reader < ::RDF::Reader
-          module St
-            class State
-              def initialize(reader)
-                @reader = reader
-                @accept_hash = cleanup(accept_list)
-              end
-
-              def cleanup(accept_list)
-                hash = Hash.new{ accept_list[nil] }
-                accept_list.each_key do |key|
-                  next if key.nil?
-                  hash[key.to_s] = accept_list[key]
-                end
-                hash
-              end
-
-              def blank_node(name)
-                ::RDF::Node.new(name)
-              end
-
-              def base_uri
-                ::RDF::URI.intern(@reader.options[:base_uri])
-              end
-
-              def uri(string)
-                base_uri.join(string)
-              end
-
-              def prefix_uri(name)
-                ::RDF::URI.intern(@reader.options[:prefixes][name])
-              end
-
-              def clear_subject
-                @reader.subject = nil
-                @reader.subject_prefix = nil
-              end
-
-              def clear_predicate
-                @reader.predicate = nil
-                @reader.predicate_prefix = nil
-              end
-
-              def clear_object
-                @reader.object = nil
-                @reader.object_prefix = nil
-              end
-
-              def consume_next(name)
-                consume
-                next_state(name)
-              end
-
-              def consume
-                @reader.consume_pair
-              end
-
-              def triple_complete
-                @reader.new_triple = true
-              end
-
-              def next_state(name)
-                @reader.current_state = @reader.states.fetch(name)
-              end
-
-              def accept(key, value)
-                #puts "#{[self.class.to_s.sub(/.*:/,''), key,
-                #value.sub(/\s*\Z/,'')].inspect}"
-                @accept_hash[key][value.sub(/\s*\Z/,'')]
-              end
-            end
-
-            class RDF < State
-              def accept_list
-                { rdf: proc{|v| consume_next(:def_ns_decl) },
-                  nil => proc{ consume } }
-              end
-            end
-
-            class DefNsDecl < State
-              def accept_list
-                { v: proc {|v| consume_next(:ns_decl); @reader.options[:prefixes][nil] = v},
-                  nil => proc{|v| next_state(:ns_decl)}}
-              end
-            end
-
-            class NsDecl < State
-              def accept_list
-                { n: proc{|v| consume_next(:ns_decl_suffix); @reader.namespace_prefix = v},
-                  nil => proc{|v| next_state(:subject)}}
-              end
-            end
-
-            class NsDeclSuffix < State
-              def accept_list
-                { v: proc{|v| consume_next(:ns_decl); @reader.options[:prefixes][@reader.namespace_prefix] = v},
-                  nil => proc{ next_state(:ns_decl)}}
-              end
-            end
-
-            class SkipToSubject < State
-              def accept_list
-                next_is_subject = proc{ next_state(:subject); clear_subject; clear_predicate; clear_object }
-                {
-                  sb: next_is_subject,
-                  su: next_is_subject,
-                  sv: next_is_subject,
-                  sn: next_is_subject,
-                  nil => proc{ consume }
-                }
-              end
-            end
-
-            class SkipToSubjectOrPred < SkipToSubject
-              def accept_list
-                next_is_pred = proc{ next_state(:predicate); clear_predicate; clear_object }
-                super.merge( pu: next_is_pred, pv: next_is_pred, pn: next_is_pred )
-              end
-            end
-
-            class Subject < State
-              def accept_list
-                {
-                  sb: proc{|v| consume_next(:predicate); @reader.subject = blank_node(v)},
-                  su: proc{|v| consume_next(:predicate); @reader.subject = uri(v)},
-                  sv: proc{|v| consume_next(:predicate); @reader.subject = prefix_url(nil) / v},
-                  sn: proc{|v| consume_next(:subject_suffix); @reader.subject_prefix = prefix_uri(v)},
-                  nil => proc{ consume }
-                }
-              end
-            end
-
-            class SubjectSuffix < State
-              def accept_list
-                {
-                  sv: proc{|v| consume_next(:predicate); @reader.subject = @reader.subject_prefix/v},
-                  nil => proc{ next_state(:skip_to_subject)}
-                }
-              end
-            end
-
-            class Predicate < State
-              def accept_list
-                {
-                  pu: proc {|v| @reader.predicate = uri(v); consume_next(:object)},
-                  pv: proc {|v| @reader.predicate = prefix_uri(nil) / v; consume_next(:object)},
-                  pn: proc {|v| @reader.predicate_prefix = prefix_uri(v); consume_next(:predicate_suffix)},
-                  nil => proc { next_state(:skip_to_subject)}
-                }
-              end
-            end
-
-            class PredicateSuffix < State
-              def accept_list
-                {
-                  pv: proc{|v| consume_next(:object); @reader.predicate = @reader.predicate_prefix/v},
-                  nil => proc{ next_state(:skip_to_subject)}
-                }
-              end
-            end
-
-            class Object < State
-              def accept_list
-                {
-                  ob: proc{|v| consume; triple_complete; @reader.object = blank_node(v)},
-                  ou: proc{|v| consume; triple_complete; @reader.object = uri(v)},
-                  ov: proc{|v| consume; triple_complete; @reader.object = prefix_uri(nil) / v},
-                  on: proc{|v| consume_next(:object_suffix); @reader.object_prefix = prefix_uri(v)},
-                  ol: proc{|v| consume_next(:type_or_lang); @reader.object = v},
-                  ll: proc{|v| consume_next(:object_literal); @reader.object_lang = v},
-                  lt: proc{|v| consume_next(:object_literal); @reader.object_type = v},
-                  nil => proc{ next_state(:skip_to_subj_or_pred) }
-                }
-              end
-            end
-
-            class ObjectSuffix < State
-              def accept_list
-                {
-                  ov: proc{|v| consume_next(:object); triple_complete; @reader.object = @reader.object_prefix/v},
-                  nil => proc{ next_state(:skip_to_subj_or_pred)}
-                }
-              end
-            end
-
-            class ObjectLiteral < State
-              def accept_list
-                {
-                  ol: proc{|v| consume_next(:type_or_lang); @reader.object = v},
-                  ll: proc{|v| consume; @reader.object_lang = v},
-                  lt: proc{|v| consume; @reader.object_type = v},
-                  nil => proc{ next_state(:skip_to_subj_or_pred)}
-                }
-              end
-            end
-
-            class TypeOrLang < State
-              def accept_list
-                {
-                  ll: proc{|v| consume; @reader.object_lang = v},
-                  lt: proc{|v| consume; @reader.object_type = v},
-                  nil => proc{ next_state(:object); triple_complete }
-                }
-              end
-            end
-          end
-
-          def initialize(input, options=nil, &block)
-            super(input, options||{}, &block)
-
-            @lineno = 0
-            @new_triple = false
-
-            @states = {
-              :rdf => St::RDF.new(self),
-              :def_ns_decl => St::DefNsDecl.new(self),
-              :ns_decl => St::NsDecl.new(self),
-              :ns_decl_suffix => St::NsDeclSuffix.new(self),
-              :skip_to_subject => St::SkipToSubject.new(self),
-              :skip_to_subj_or_pred => St::SkipToSubjectOrPred.new(self),
-              :subject => St::Subject.new(self),
-              :subject_suffix => St::SubjectSuffix.new(self),
-              :predicate => St::Predicate.new(self),
-              :predicate_suffix => St::PredicateSuffix.new(self),
-              :object => St::Object.new(self),
-              :object_suffix => St::ObjectSuffix.new(self),
-              :object_literal => St::ObjectLiteral.new(self),
-              :type_or_lang => St::TypeOrLang.new(self)
-            }
-
-            @current_state = @states.fetch(:rdf)
-          end
-          attr_reader :lineno, :states
-          attr_accessor :current_state
-          attr_accessor :new_triple, :subject, :predicate, :object
-          attr_accessor :object_type, :object_lang
-          attr_accessor :namespace_prefix, :subject_prefix, :predicate_prefix, :object_prefix
-
-          def read_triple
-            if @lineno >= @input.length
-              raise EOFError
-            end
-            while @lineno < @input.length
-              @current_state.accept(*@input[@lineno])
-              if @new_triple
-                @new_triple = false
-                return build_triple
-              end
-            end
-            return build_triple
-          end
-
-          def build_triple
-            object = @object
-            if object.is_a? String
-              object = ::RDF::Literal.new(object, :datatype => object_type, :language => object_lang)
-            end
-            @object_type = nil
-            @object_lang = nil
-
-            [@subject, @predicate, object]
-          end
-
-          def rewind
-            @lineno = 0
-          end
-
-          def consume_pair
-            @lineno += 1
-          end
-        end
-
-        def local_to_network(base_uri, graph)
-        end
-
-        def network_to_local(base_uri, list)
-          raise "Invalid base uri: #{base_uri.inspect}" if base_uri.nil?
-          graph = ::RDF::Graph.new
-          reader = Reader.new(list, :base_uri => base_uri.to_s)
-          reader.each_statement do |statement|
-            graph.insert(statement)
-          end
-          graph
-        end
-      end
-    end
-  end
-end