roadforest 0.0.3 → 0.1

data/lib/roadforest/content-handling/media-type.rb

@@ -8,28 +8,32 @@ module RoadForest
       MEDIA_TYPE_REGEX = /^\s*([^;\s]+)\s*((?:;\s*\S+\s*)*)\s*$/
 
       # Matches sub-type parameters
-      PARAMS_REGEX = /;\s*([^=]+)=([^;=\s]+)/
+      PARAMS_REGEX = /;\s*([^;=]+)(?:=([^;=\s]+))?/
 
       # Creates a new MediaType by parsing an alternate representation.
       # @param [MediaType, String, Array<String,Hash>] obj the raw type
       #   to be parsed
       # @return [MediaType] the parsed media type
       # @raise [ArgumentError] when the type could not be parsed
-      def self.parse(obj)
-        case obj
-        when MediaType
+      def self.parse(*args)
+        if args.length == 1
+          obj = args.first
+        else
+          obj = args
+        end
+
+        if obj.is_a? MediaType
           obj
-        when MEDIA_TYPE_REGEX
-          type, raw_params = $1, $2
+        elsif obj.is_a? String and !(match = MEDIA_TYPE_REGEX.match(obj)).nil?
+          type, raw_params = *match[1,2]
           params = Hash[raw_params.scan(PARAMS_REGEX)]
           new(type, params)
-        else
-          unless Array === obj && String === obj[0] && Hash === obj[1]
-            raise ArgumentError, "Invalid media type #{obj.inspect}"
-          end
+        elsif Array === obj && String === obj[0] && Hash === obj[1]
           type = parse(obj[0])
           type.params.merge!(obj[1])
           type
+        else
+          raise ArgumentError, "Invalid media type #{obj.inspect}"
         end
       end
 
@@ -95,12 +99,16 @@ module RoadForest
         end
       end
 
+      def params_for_header
+        params.map {|k,v| ";#{k}#{v ? "=":""}#{v}" }.join("")
+      end
+
       def accept_header
-        [type, "q=#{quality}", *params.map {|k,v| "#{k}=#{v}" }].join(";")
+        "#{type};q=#{quality}#{params_for_header}"
       end
 
       def content_type_header
-        [type, *params.map {|k,v| "#{k}=#{v}" }].join(";")
+        "#{type}#{params_for_header}"
       end
       alias to_s content_type_header
 

data/lib/roadforest/content-handling/type-handler.rb

@@ -0,0 +1,76 @@
+module RoadForest
+  module MediaType
+    module Handlers
+      class Handler
+        def network_to_local(base_uri, network)
+          return network
+        end
+
+        def local_to_network(base_uri, local)
+          return local
+        end
+
+        def parse_for(resource)
+          source = resource.request_body
+          model = resource.model
+          input_data = network_to_local(model.my_url, source)
+
+          update_model(model, input_data)
+
+          renderer = model.type_handling.choose_renderer(resource.request_accept_header)
+          body = renderer.local_to_network(model.my_url, model.response_data)
+
+          build_response(resource)
+        end
+
+        def render_for(resource)
+          model = resource.model
+          output_data = get_output(model)
+          local_to_network(model.my_url,  output_data)
+        end
+
+        def add_child_to(resource)
+          model = resource.model
+          source = resource.request_body
+          input_data = network_to_local(model.my_url, source)
+
+          child_for_model(resource.model, input_data)
+
+          build_response(resource)
+        end
+
+        def build_response(resource)
+          model = resource.model
+
+          renderer = model.type_handling.choose_renderer(resource.request_accept_header)
+          body = renderer.local_to_network(model.my_url, model.response_data)
+
+          resource.response_content_type = renderer.content_type_header
+          resource.response_body = body
+          if model.response_location
+            resource.redirect_to(model.response_location)
+          end
+        end
+
+        def child_for_model(model, data)
+          model.add_child(data)
+          model.processed
+        end
+
+        def update_model(model, input_data)
+          result = model.update(input_data)
+          model.response_data = result
+          model.processed
+          result
+        end
+
+        def get_output(model)
+          result = model.retrieve
+          model.response_data = result
+          model.processed
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -1,152 +1,8 @@
-#@require 'rdf/rdfa' #XXX Otherwise json-ld grabs RDFa documents. Awaiting fix
-#upstream
 require 'json/ld'
-require 'roadforest/rdf/normalization'
-
+require 'roadforest/content-handling/type-handlers/rdf-handler'
 module RoadForest
   module MediaType
     module Handlers
-      module Wrap
-        class Wrapper
-          def initialize(type, handler)
-            @type = type
-            @handler = handler
-          end
-          attr_reader :type, :handler
-
-          def local_to_network(base_uri, network)
-            @handler.local_to_network(base_uri, network)
-          end
-          alias from_graph local_to_network
-
-          def network_to_local(base_uri, source)
-            @handler.network_to_local(base_uri, source)
-          end
-          alias to_graph network_to_local
-        end
-
-        class Render < Wrapper
-          def call(resource)
-            @handler.render_for(resource)
-          end
-
-          def content_type_header
-            @type.content_type_header
-          end
-        end
-
-        class Parse < Wrapper
-          def call(resource)
-            @handler.parse_for(resource)
-          end
-
-          def add_child(resource)
-            @handler.add_child_to(resource)
-          end
-        end
-      end
-
-      class Handler
-        def network_to_local(base_uri, network)
-          return network
-        end
-
-        def local_to_network(base_uri, local)
-          return local
-        end
-
-        def parse_for(resource)
-          source = resource.request_body
-          model = resource.model
-          input_data = network_to_local(model.my_url, source)
-
-          update_model(model, input_data)
-
-          renderer = model.type_handling.choose_renderer(resource.request_accept_header)
-          body = renderer.local_to_network(model.my_url, model.response_data)
-
-          build_response(resource)
-        end
-
-        def render_for(resource)
-          model = resource.model
-          output_data = get_output(model)
-          local_to_network(model.my_url,  output_data)
-        end
-
-        def add_child_to(resource)
-          model = resource.model
-          source = resource.request_body
-          input_data = network_to_local(model.my_url, source)
-
-          child_for_model(resource.model, input_data)
-
-          build_response(resource)
-        end
-
-        def build_response(resource)
-          model = resource.model
-
-          renderer = model.type_handling.choose_renderer(resource.request_accept_header)
-          body = renderer.local_to_network(model.my_url, model.response_data)
-
-          resource.response_content_type = renderer.content_type_header
-          resource.response_body = body
-          if model.response_location
-            resource.redirect_to(model.response_location)
-          end
-        end
-
-        def child_for_model(model, data)
-          model.add_child(data)
-          model.processed
-        end
-
-        def update_model(model, input_data)
-          result = model.update(input_data)
-          model.response_data = result
-          model.processed
-          result
-        end
-
-        def get_output(model)
-          result = model.retrieve
-          model.response_data = result
-          model.processed
-          result
-        end
-      end
-      class RDFHandler < Handler
-        include RDF::Normalization
-
-        def get_output(model)
-          graph = super
-          root_uri = model.canonical_uri
-
-          graph.each_statement do |statement|
-            original = statement.dup
-            if ::RDF::URI === statement.subject and statement.subject.relative?
-              statement.subject = normalize_resource(root_uri.join(statement.subject))
-            end
-
-            if ::RDF::URI === statement.object and statement.object.relative?
-              statement.object = normalize_resource(root_uri.join(statement.object))
-            end
-
-            if statement != original
-              graph.delete(original)
-              graph.insert(statement)
-            end
-          end
-          graph
-        end
-
-        def child_for_model(model, data)
-          model.add_graph_child(data)
-          model.processed
-        end
-      end
-
       #application/ld+json
       class JSONLD < RDFHandler
         include RDF::Normalization
@@ -162,7 +18,7 @@ module RoadForest
             rdf.each_statement do |statement|
               writer << statement
             end
-          end
+                                  end
         end
 
         def network_to_local(base_uri, source)

data/lib/roadforest/content-handling/type-handlers/rdf-handler.rb

@@ -0,0 +1,38 @@
+require 'roadforest/content-handling/type-handler'
+require 'roadforest/rdf/normalization'
+module RoadForest
+  module MediaType
+    module Handlers
+      class RDFHandler < Handler
+        include RDF::Normalization
+
+        def get_output(model)
+          graph = super
+          root_uri = model.canonical_uri
+
+          graph.each_statement do |statement|
+            original = statement.dup
+            if ::RDF::URI === statement.subject and statement.subject.relative?
+              statement.subject = normalize_resource(root_uri.join(statement.subject))
+            end
+
+            if ::RDF::URI === statement.object and statement.object.relative?
+              statement.object = normalize_resource(root_uri.join(statement.object))
+            end
+
+            if statement != original
+              graph.delete(original)
+              graph.insert(statement)
+            end
+          end
+          graph
+        end
+
+        def child_for_model(model, data)
+          model.add_graph_child(data)
+          model.processed
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'roadforest/content-handling/type-handlers/rdfa-writer/render-environment'
+module RoadForest::MediaType
+  class RDFaWriter
+    class DocumentEnvironment < RenderEnvironment
+      attr_accessor :subject_terms, :title, :prefixes, :lang, :base
+      def yielded(item)
+        @_engine.render(item)
+      end
+
+      def subjects
+        enum_for(:each_subject_environment)
+      end
+
+      def each_subject_environment
+        subject_terms.each do |term|
+          yield @_engine.subject_env(term)
+        end
+      end
+
+      def template_kinds
+        %w{doc}
+      end
+
+      def prefix
+        @prefix ||=
+          if prefixes.empty?
+            nil
+          else
+            prefixes.keys.map {|pk| "#{pk}: #{prefixes[pk]}"}.sort.join(" ")
+          end.tap{|prefix| add_debug {"\nserialize: prefixes: #{prefixes.inspect} prefix src: #{prefix.inspect}"}}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+require 'roadforest/content-handling/type-handlers/rdfa-writer/render-environment'
+module RoadForest::MediaType
+  class RDFaWriter
+    class ObjectEnvironment < RenderEnvironment
+      attr_accessor :predicate, :object, :inlist, :element
+
+      def simple_attrs
+        {:property => get_curie(predicate), :content => get_content(object), :lang => get_lang(object), :datatype => get_dt_curie(object), :inlist => inlist}
+      end
+
+      alias attrs simple_attrs
+
+      def template_kinds
+        %w{object}
+      end
+
+      def literal?
+        object.literal?
+      end
+    end
+
+    class NilObjectEnvironment < ObjectEnvironment
+      def attrs
+        {:rel => get_curie(predicate), :inlist => ''}
+      end
+
+      def template_kinds
+        %w{nil-object object}
+      end
+    end
+
+    class NodeObjectEnvironment < ObjectEnvironment
+      def attrs
+        {:property => get_curie(predicate), :resource => get_curie(object), :inlist => inlist}
+      end
+
+      def template_kinds
+        %w{node-object object}
+      end
+    end
+
+    class UriObjectEnvironment < ObjectEnvironment
+      def attrs
+        {}
+      end
+
+      def template_kinds
+        %w{uri-object object}
+      end
+    end
+
+    class XMLLiteralObjectEnvironment < ObjectEnvironment
+      def attrs
+        {:property => get_curie(predicate), :lang => get_lang(object), :datatype => get_curie(object.datatype), :inlist => inlist}
+      end
+
+      def template_kinds
+        %w{xml-literal-object object}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require 'roadforest/content-handling/type-handlers/rdfa-writer/render-environment'
+module RoadForest::MediaType
+  class RDFaWriter
+    class PropertyEnvironment < RenderEnvironment
+      attr_accessor :object_terms, :predicate, :inlist
+
+      def yielded(item)
+        @_engine.render(item)
+      end
+
+      def objects
+        enum_for(:each_object)
+      end
+
+      def each_object
+        object_terms.each do |term|
+          env = @_engine.object_env(predicate, term)
+          env.inlist = inlist
+          #XXX Remove element=
+          env.element = :li if object_terms.length > 1 || inlist
+          yield(env)
+        end
+      end
+
+      def object
+        objects.first
+      end
+
+      def property
+        get_curie(predicate)
+      end
+
+      def rel
+        get_curie(predicate)
+      end
+
+      def template_kinds
+        if objects.to_a.length > 1
+          %w{property_values}
+        else
+          %w{property_value property_values}
+        end
+      end
+    end
+  end
+end