rdf-serializers 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6db3307aae5e975df5c2a5d3dde85f6354d0b788
+  data.tar.gz: b1ed8984ee9a8c054140d311e46e730d26f7bd10
+SHA512:
+  metadata.gz: 5e1af6b5e5c7e641516b61cabbf8ced44fa2f85ee4e3954bf9e6d8819621c6716cbdba4efd8cdd86c77c0f4882be3c7dad149f713c49cfe193afdd689a17ee57
+  data.tar.gz: 52ef788b59d23e5fef8bab0cce2a4874d956f89b77115d3e8bf67d6885884cfe14a5ab21b6a158d19b7b6c09a8da1adfdc6f465f3ee8eab422901987da8427ba

data/lib/active_model_serializers/adapter/rdf/relationship.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ActiveModelSerializers
+  module Adapter
+    class RDF
+      class Relationship < JsonApi::Relationship
+        def triples
+          return [] if subject.blank? || predicate.blank? || data.empty?
+          data.map do |iri|
+            raise "#{iri} is not a RDF::URI but a #{iri.class}" unless iri.is_a?(::RDF::URI)
+            [subject, predicate, iri]
+          end
+        end
+
+        private
+
+        def data
+          @data ||=
+            if association.collection?
+              iri_for_many(association).compact
+            else
+              [iri_for_one(association)].compact
+            end
+        end
+
+        def iri_for_many(association)
+          collection_serializer = association.lazy_association.serializer
+          if collection_serializer.respond_to?(:each)
+            collection_serializer.map do |serializer|
+              serializer.read_attribute_for_serialization(:iri)
+            end
+          else
+            []
+          end
+        end
+
+        def iri_for_one(association)
+          if belongs_to_id_on_self?(association)
+            parent_serializer.read_attribute_for_serialization(:iri)
+          else
+            serializer = association.lazy_association.serializer
+            serializer.read_attribute_for_serialization(:iri) if serializer && association.object
+          end
+        end
+
+        def predicate
+          @predicate ||= association.reflection.options[:predicate]
+        end
+
+        def subject
+          @subject ||= parent_serializer.read_attribute_for_serialization(:iri)
+        end
+      end
+    end
+  end
+end

data/lib/active_model_serializers/adapter/rdf.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module ActiveModelSerializers
+  module Adapter
+    class RDF < Base
+      extend ActiveSupport::Autoload
+      autoload :Relationship
+
+      delegate :object, to: :serializer
+      delegate :dump, to: :graph
+
+      def initialize(serializer, options = {})
+        super
+        @include_directive = JSONAPI::IncludeDirective.new(options[:include], allow_wildcard: true)
+        @fieldset = options[:fieldset] || ActiveModel::Serializer::Fieldset.new(options.delete(:fields))
+        @resource_identifiers = Set.new
+      end
+
+      protected
+
+      attr_reader :fieldset
+
+      private
+
+      def add_attribute(data, iri, value)
+        predicate = data.options[:predicate]
+        return unless predicate
+        value = value.respond_to?(:each) ? value : [value]
+        value.compact.map { |v| add_triple(iri, predicate, v) }
+      end
+
+      def add_triple(subject, predicate, object)
+        obj =
+          case object
+          when ::RDF::Resource, ::RDF::Literal
+            object
+          when ActiveSupport::TimeWithZone
+            ::RDF::Literal(object.to_datetime)
+          else
+            ::RDF::Literal(object)
+          end
+        @graph << [::RDF::URI(subject), ::RDF::URI(predicate), obj]
+      end
+
+      def attributes_for(serializer, fields)
+        serializer.class._attributes_data.map do |key, data|
+          next if data.excluded?(serializer)
+          next unless fields.nil? || fields.include?(key)
+          add_attribute(data, serializer.read_attribute_for_serialization(:iri), serializer.attributes[key])
+        end
+      end
+
+      def graph
+        return @graph if @graph.present?
+        @graph = ::RDF::Graph.new
+
+        serializers.each { |serializer| process_resource(serializer, @include_directive) }
+        serializers.each { |serializer| process_relationships(serializer, @include_directive) }
+        instance_options[:meta]&.each { |meta| add_triple(*meta) }
+
+        @graph
+      end
+
+      def process_relationship(serializer, include_slice)
+        if serializer.respond_to?(:each)
+          serializer.each { |s| process_relationship(s, include_slice) }
+          return
+        end
+        return unless serializer&.object
+        return unless process_resource(serializer, include_slice)
+        process_relationships(serializer, include_slice)
+      end
+
+      def process_relationships(serializer, include_slice)
+        serializer.associations(include_slice).each do |association|
+          process_relationship(association.lazy_association.serializer, include_slice[association.key])
+        end
+      end
+
+      def process_resource(serializer, include_slice = {})
+        return unless serializer.respond_to?(:iri) || serializer.object.respond_to?(:iri)
+        return false unless @resource_identifiers.add?(serializer.read_attribute_for_serialization(:iri))
+        resource_object_for(serializer, include_slice)
+        true
+      end
+
+      def relationships_for(serializer, requested_associations, include_slice)
+        include_directive = JSONAPI::IncludeDirective.new(
+          requested_associations,
+          allow_wildcard: true
+        )
+        serializer.associations(include_directive, include_slice).each do |association|
+          Relationship.new(serializer, instance_options, association).triples.each do |triple|
+            @graph << triple
+          end
+        end
+      end
+
+      def resource_object_for(serializer, include_slice = {})
+        type = type_for(serializer, instance_options).to_s
+        serializer.fetch(self) do
+          break nil if serializer.read_attribute_for_serialization(:iri).nil?
+          requested_fields = fieldset&.fields_for(type)
+          attributes_for(serializer, requested_fields)
+        end
+        requested_associations = fieldset.fields_for(type) || '*'
+        relationships_for(serializer, requested_associations, include_slice)
+      end
+
+      def serializers
+        serializer.respond_to?(:each) ? serializer : [serializer]
+      end
+
+      def type_for(serializer, instance_options)
+        JsonApi::ResourceIdentifier.new(serializer, instance_options).as_json[:type]
+      end
+    end
+  end
+end

data/lib/rdf_serializers/renderers.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Registers the N-Triples renderer
+#
+# And then in controllers, use `render nt: model`.
+#
+# For example, in a controller action, we can:
+# respond_to do |format|
+#   format.nt { render nt: model }
+# end
+
+require 'active_model_serializers/adapter/rdf.rb'
+
+module RDFSerializers
+  module Renderers
+    def self.register(symbols, opts = {})
+      symbols = [symbols] unless symbols.respond_to?(:each)
+      symbols.each do |symbol|
+        format = RDF::Format.for(symbol)
+        raise "#{symbol} if not a known rdf format" if format.nil?
+        Mime::Type.register format.content_type.first, format.file_extension.first
+        add_renderer(format, opts)
+      end
+    end
+
+    def self.add_renderer(format, opts = {})
+      ActionController::Renderers.add format.file_extension.first do |resource, options|
+        self.content_type = format.content_type.first
+        get_serializer(resource, options.merge(adapter: :rdf)).adapter.dump(format.symbols.first, opts)
+      end
+    end
+  end
+end

data/lib/rdf_serializers/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RDFSerializers
+  module Version
+    VERSION = '0.0.1'
+  end
+end

data/lib/rdf_serializers.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'active_model_serializers/adapter/rdf'

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: rdf-serializers
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Arthur Dingemans
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-12-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: active_model_serializers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: rdf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+description: 
+email: arthur@argu.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/active_model_serializers/adapter/rdf.rb
+- lib/active_model_serializers/adapter/rdf/relationship.rb
+- lib/rdf_serializers.rb
+- lib/rdf_serializers/renderers.rb
+- lib/rdf_serializers/version.rb
+homepage: http://rubygems.org/gems/rdf_serializers
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Adds RDF serialization, like n-triples or turtle, to active model serializers
+test_files: []