roadforest 0.1 → 0.5

data/lib/roadforest/{content-handling/type-handlers → type-handlers}/rdfa-writer/render-environment.rb

@@ -1,13 +1,18 @@
-require 'roadforest/content-handling/type-handlers/rdfa-writer'
-module RoadForest::MediaType
+require 'roadforest/type-handlers/rdfa-writer'
+module RoadForest::TypeHandlers
   class RDFaWriter
     class RenderEnvironment
-      attr_accessor :heading_predicates, :lang
+      attr_accessor :heading_predicates, :lang, :parent
+      attr_reader :_engine
 
       def initialize(engine)
         @_engine = engine
       end
 
+      def _base_env_
+        self
+      end
+
       def add_debug(msg = nil, &block)
         @_engine.add_debug(msg, &block)
       end
@@ -18,27 +23,9 @@ module RoadForest::MediaType
           "#{name}=#{instance_variable_get(name).inspect}"
         end.compact.join(" ")}>"
       end
-      # Display a subject.
-      #
-      # If the Haml template contains an entry matching the subject's rdf:type URI, that entry will be used as the template for this subject and it's properties.
-      #
-      # @example Displays a subject as a Resource Definition:
-      #     <div typeof="rdfs:Resource" about="http://example.com/resource">
-      #       <h1 property="dc:title">label</h1>
-      #       <ul>
-      #         <li content="2009-04-30T06:15:51Z" property="dc:created">2009-04-30T06:15:51+00:00</li>
-      #       </ul>
-      #     </div>
-      #
-      # @param [RDF::Resource] subject
-      # @param [Hash{Symbol => Object}] options
-      # @option options [:li, nil] :element(:div)
-      #   Serialize using &lt;li&gt; rather than template default element
-      # @option options [RDF::Resource] :rel (nil)
-      #   Optional @rel property
-      # @return [String]
-      def subject(subject, &block)
-        @_engine.render_subject(subject, &block)
+
+      def like_a?(klass)
+        is_a?(klass)
       end
 
       def is_subject?
@@ -53,6 +40,26 @@ module RoadForest::MediaType
         false
       end
 
+      def yielded(item)
+        _engine.render(item)
+      end
+
+      def subject_env(term)
+        _engine.subject_env(term)
+      end
+
+      def simple_property_env(predicate, nonlists)
+        _engine.simple_property_env(predicate, nonlists)
+      end
+
+      def list_property_envs(predicate, lists)
+        _engine.list_property_envs(predicate, lists)
+      end
+
+      def object_env(predicate, term)
+        _engine.object_env(predicate, term)
+      end
+
       # Haml rendering helper. Return CURIE for the literal datatype, if the
       # literal is a typed literal.
       #
@@ -71,7 +78,7 @@ module RoadForest::MediaType
       # @raise [RDF::WriterError]
       def get_lang(literal)
         raise RDF::WriterError, "Getting datatype CURIE for #{literal.inspect}, which must be a literal" unless literal.is_a?(RDF::Literal)
-        literal.language if literal.literal? && literal.language && literal.language.to_s != @_engine.lang.to_s
+        literal.language if literal.literal? && literal.language && literal.language.to_s != _engine.lang.to_s
       end
 
       # Haml rendering helper. Data to be added to a @content value
@@ -125,7 +132,7 @@ module RoadForest::MediaType
       # @return [String] value to use to identify URI
       # @raise [RDF::WriterError]
       def get_curie(resource)
-        @_engine.get_curie(resource)
+        _engine.get_curie(resource)
       end
 
       ##

data/lib/roadforest/{content-handling/type-handlers → type-handlers}/rdfa-writer/subject-environment.rb

@@ -1,20 +1,8 @@
-require 'roadforest/content-handling/type-handlers/rdfa-writer/render-environment'
-module RoadForest::MediaType
+require 'roadforest/type-handlers/rdfa-writer/render-environment'
+module RoadForest::TypeHandlers
   class RDFaWriter
     class SubjectEnvironment < RenderEnvironment
-      attr_accessor :base, :element, :predicate_terms, :property_objects, :rel, :inlist, :subject, :typeof
-
-      # 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)
-        @_engine.render_predicate(subject, predicate)
-      end
+      attr_accessor :base, :predicate_terms, :property_objects, :rel, :inlist, :subject, :typeof
 
       def attrs
         {:rel => rel, :resource => (about || resource), :typeof => typeof, :inlist => inlist}
@@ -35,12 +23,12 @@ module RoadForest::MediaType
           next if objects.nil? or objects.empty?
 
           nonlists, lists = objects.partition do |object|
-            !@_engine.is_list?(object)
+            !_engine.is_list?(object)
           end
 
           add_debug {"properties with lists: #{lists} non-lists: #{nonlists}"}
 
-          ([@_engine.simple_property_env(predicate, nonlists)] + @_engine.list_property_envs(predicate, lists)).compact.each do |env|
+          ([simple_property_env(predicate, nonlists)] + list_property_envs(predicate, lists)).compact.each do |env|
             yield(env)
           end
         end
@@ -51,8 +39,8 @@ module RoadForest::MediaType
       end
 
       def render_checked
-        return true if @_engine.is_done?(subject)
-        @_engine.subject_done(subject)
+        return true if _engine.is_done?(subject)
+        _engine.subject_done(subject)
         return false
       end
 
@@ -71,10 +59,6 @@ module RoadForest::MediaType
           get_curie(subject)
         end
       end
-
-      def yielded(pred)
-        @_engine.render(pred)
-      end
     end
   end
 end

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

@@ -0,0 +1,73 @@
+require 'rdf/rdfa' #XXX Otherwise json-ld grabs RDFa documents. Awaiting fix upstream
+require 'rdf'
+require 'roadforest/type-handlers/rdf-handler'
+require 'roadforest/type-handlers/rdfa-writer/render-engine'
+module RoadForest
+  module TypeHandlers
+    #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 Graph::Normalization
+
+      attr_writer :valise, :tilt_cache
+
+      def valise
+        @valise ||= Valise.define do
+          ro up_to("lib") + "roadforest"
+        end
+      end
+
+      def tilt_cache
+        @tilt_cache ||= ::Tilt::Cache.new
+      end
+
+      def local_to_network(base_uri, rdf)
+        raise "Invalid base uri: #{base_uri}" if base_uri.nil?
+
+        debug = []
+
+        templates = RDFaWriter::TemplateHandler.new
+        templates.valise = valise
+        templates.template_cache = tilt_cache
+
+        engine = RDFaWriter::RenderEngine.new(rdf, debug) do |engine|
+          engine.graph_name = rdf.context
+          engine.base_uri = base_uri
+          engine.standard_prefixes = true
+          engine.template_handler = templates
+
+          #engine.style_name = options[:haml]
+          #engine.lang = options[:lang]
+
+          engine.top_classes = [::RDF::RDFS.Class]
+          engine.predicate_order = [::RDF.type, ::RDF::RDFS.label, ::RDF::DC.title]
+          engine.heading_predicates = [::RDF::RDFS.label, ::RDF::DC.title]
+        end
+
+        prefixes = relevant_prefixes_for_graph(rdf)
+        prefixes.keys.each do |prefix|
+          prefixes[prefix.to_sym] = prefixes[prefix]
+        end
+        engine.prefixes.merge! prefixes
+
+        #$stderr.puts debug
+
+        result = engine.render_document
+      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

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

@@ -0,0 +1,301 @@
+require 'roadforest/type-handlers/rdf-handler'
+
+module RoadForest
+  module TypeHandlers
+    #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
+          if @object.nil? or @predicate.nil? or @subject.nil?
+            raise EOFError
+          end
+
+          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