rdf-serializers 0.0.4 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: baf9653c33444a315a892a3720aa0be0503540db
-  data.tar.gz: ca4fbe6d2ad6b87d3fabd8f1b68167fd0470475b
+SHA256:
+  metadata.gz: 3782c211f6d60abc17cf58d6c0566c94913f5429d19f8c7ba633687dabf95ea8
+  data.tar.gz: c2cd93434a13082bd8d8da0b15b0d4554d7215b77e4e89ae2cf2fbeacb566957
 SHA512:
-  metadata.gz: 06fda50c2eaec5b6bb346e31f40d78d24645211c3d87eef0c6206492d47f481cbde8a0a540ae447a0fdc75a6e31be45e9686bdfd252121f7bb998aa89c7db9ac
-  data.tar.gz: 94a3b7701bd3291a3cff825782ff06945d1382336574de174030991f2c3f20558537c2ce6423fc8d8fd90c460094f3579c6f2d889abdf2af90c2215691ac8a2a
+  metadata.gz: c4938923d6d9bcb9b41e4c774025786dddf554dd8089691604e24235fff5311b8cb9cc39382a3e808d3aedd7909ee7e38fd1c273526aa469699413807cc6311f
+  data.tar.gz: 0a4131a7e8e1054620945780c4a430e33c846f78f2eedf450a881cfb2452ffbbd852f58c765540bbf329791b6614f40afe2c797d6f942f4021eca882284425aa

data/lib/rdf/serializers/config.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RDF
+  module Serializers
+    def self.configure
+      yield @config ||= RDF::Serializers::Configuration.new
+    end
+
+    def self.config
+      @config
+    end
+
+    class Configuration
+      include ActiveSupport::Configurable
+      config_accessor :always_include_named_graphs
+      config_accessor :default_graph
+      config_accessor :serializer_lookup_chain
+      config_accessor :serializer_lookup_enabled
+    end
+
+    configure do |config|
+      config.always_include_named_graphs = true
+
+      config.serializer_lookup_enabled = true
+
+      # For configuring how serializers are found.
+      # This should be an array of procs.
+      #
+      # The priority of the output is that the first item
+      # in the evaluated result array will take precedence
+      # over other possible serializer paths.
+      #
+      # i.e.: First match wins.
+      #
+      # @example output
+      # => [
+      #   "CustomNamespace::ResourceSerializer",
+      #   "ParentSerializer::ResourceSerializer",
+      #   "ResourceNamespace::ResourceSerializer" ,
+      #   "ResourceSerializer"]
+      #
+      # If CustomNamespace::ResourceSerializer exists, it will be used
+      # for serialization
+      config.serializer_lookup_chain = RDF::Serializers::LookupChain::DEFAULT.dup
+    end
+  end
+end

data/lib/rdf/serializers/data_type_helper.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RDF
+  module Serializers
+    module DataTypeHelper
+      def xsd_to_rdf(xsd, value, opts = {}) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+        klass =
+          case xsd
+          when RDF::XSD[:anyURI]
+            RDF::URI
+          when RDF::XSD[:integer]
+            RDF::Literal::Integer
+          when RDF::XSD[:dateTime]
+            RDF::Literal::DateTime
+          when RDF::XSD[:date]
+            RDF::Literal::Date
+          when RDF::XSD[:boolean]
+            RDF::Literal::Boolean
+          when RDF::XSD[:time]
+            RDF::Literal::Time
+          when RDF::XSD[:long], RDF::XSD[:double]
+            RDF::Literal::Double
+          when RDF::XSD[:decimal]
+            RDF::Literal::Decimal
+          when RDF::XSD[:token]
+            RDF::Literal::Token
+          else
+            RDF::Literal
+          end
+
+        klass.new(value, opts)
+      end
+    end
+  end
+end

data/lib/rdf/serializers/hdnjson_parser.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RDF
+  module Serializers
+    class HndJSONParser
+      include DataTypeHelper
+
+      HEX_SUBJECT = 0
+      HEX_PREDICATE = 1
+      HEX_OBJECT = 2
+      HEX_DATATYPE = 3
+      HEX_LANGUAGE = 4
+      HEX_GRAPH = 5
+
+      def parse_body(body)
+        body.split("\n").map { |line| parse_hex(JSON.parse(line)) }
+      end
+
+      def parse_hex(hex)
+        subject = parse_subject(hex[HEX_SUBJECT])
+        predicate = RDF::URI(hex[HEX_PREDICATE])
+        object = parse_object(hex[HEX_OBJECT], hex[HEX_DATATYPE], hex[HEX_LANGUAGE])
+        graph = hex[HEX_GRAPH].present? ? RDF::URI(hex[HEX_GRAPH]) : RDF::Serializers.config.default_graph
+
+        RDF::Statement.new(
+          subject,
+          predicate,
+          object,
+          graph_name: graph
+        )
+      end
+
+      private
+
+      def blank_node(id)
+        @blank_nodes ||= {}
+        @blank_nodes[id] ||= RDF::Node(id)
+      end
+
+      def parse_object(value, datatype, language)
+        case datatype
+        when 'http://www.w3.org/1999/02/22-rdf-syntax-ns#namedNode'
+          RDF::URI(value)
+        when 'http://www.w3.org/1999/02/22-rdf-syntax-ns#blankNode'
+          blank_node(value.sub('_:', ''))
+        when language
+          RDF::Literal(value, datatype: RDF.langString, language: language)
+        else
+          xsd_to_rdf(datatype, value, language: language.presence)
+        end
+      end
+
+      def parse_subject(subject)
+        if subject.is_a?(RDF::Resource)
+          subject
+        elsif subject.start_with?('_')
+          blank_node(subject.sub('_:', ''))
+        else
+          RDF::URI(subject)
+        end
+      end
+
+      class << self
+        def parse(body)
+          new.parse_body(body)
+        end
+      end
+    end
+  end
+end

data/lib/rdf/serializers/hextuple_serializer.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RDF
+  module Serializers
+    module HextupleSerializer
+      def iri_from_record(record)
+        return record if record.try(:uri?)
+
+        raise FastJsonapi::MandatoryField, 'record has no iri' unless record.respond_to?(:iri)
+
+        record.iri
+      end
+
+      def normalized_object(object)
+        case object
+        when ::RDF::Term
+          object
+        when ActiveSupport::TimeWithZone
+          ::RDF::Literal(object.to_datetime)
+        else
+          ::RDF::Literal(object)
+        end
+      end
+
+      def object_value(obj)
+        if obj.is_a?(::RDF::URI)
+          obj.value
+        elsif obj.is_a?(::RDF::Node)
+          obj.to_s
+        else
+          obj.value.to_s
+        end
+      end
+
+      def object_datatype(obj)
+        if obj.is_a?(::RDF::URI)
+          'http://www.w3.org/1999/02/22-rdf-syntax-ns#namedNode'
+        elsif obj.is_a?(::RDF::Node)
+          'http://www.w3.org/1999/02/22-rdf-syntax-ns#blankNode'
+        elsif obj.try(:datatype?)
+          obj.datatype
+        else
+          lit = RDF::Literal(obj)
+          lit.datatype.to_s
+        end
+      end
+
+      def value_to_hex(iri, predicate, object, graph = nil, serialization_params = {})
+        return if object.nil?
+
+        obj = normalized_object(object)
+
+        [
+          iri.to_s,
+          predicate.to_s,
+          object_value(obj),
+          object_datatype(obj),
+          obj.try(:language) || '',
+          operation((graph || ::RDF::Serializers.config.default_graph)&.value, serialization_params[:context])
+        ]
+      end
+
+      def operation(operation, graph_name)
+        return nil if operation.blank?
+        return operation if graph_name.blank?
+
+        "#{operation}?graph=#{WEBrick::HTTPUtils.escape_form(graph_name.to_s)}"
+      end
+    end
+  end
+end

data/lib/rdf/serializers/list_serializer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RDF
+  module Serializers
+    class ListSerializer
+      include RDF::Serializers::ObjectSerializer
+
+      def hextuples_for_collection
+        @resource.map do |resource|
+          RDF::Serializers.serializer_for(resource).record_hextuples(resource, nil, @includes, @params)
+        end.flatten(1)
+      end
+
+      class << self
+        def validate_includes!(_includes); end
+      end
+    end
+  end
+end

data/lib/rdf/serializers/lookup_chain.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RDF
+  module Serializers
+    # Extracted from active_model_serializers
+    module LookupChain
+      # Standard appending of Serializer to the resource name.
+      #
+      # Example:
+      #   Author => AuthorSerializer
+      BY_RESOURCE = lambda do |resource_class, _namespace|
+        serializer_from(resource_class)
+      end
+
+      # Uses the namespace of the resource to find the serializer
+      #
+      # Example:
+      #  British::Author => British::AuthorSerializer
+      BY_RESOURCE_NAMESPACE = lambda do |resource_class, _namespace|
+        resource_namespace = namespace_for(resource_class)
+        serializer_name = serializer_from(resource_class)
+
+        "#{resource_namespace}::#{serializer_name}"
+      end
+
+      # Uses the controller namespace of the resource to find the serializer
+      #
+      # Example:
+      #  Api::V3::AuthorsController => Api::V3::AuthorSerializer
+      BY_NAMESPACE = lambda do |resource_class, namespace|
+        resource_name = resource_class_name(resource_class)
+        namespace ? "#{namespace}::#{resource_name}Serializer" : nil
+      end
+
+      DEFAULT = [
+        BY_NAMESPACE,
+        BY_RESOURCE_NAMESPACE,
+        BY_RESOURCE
+      ].freeze
+
+      module_function
+
+      def namespace_for(klass)
+        klass.name.deconstantize
+      end
+
+      def resource_class_name(klass)
+        klass.name.demodulize
+      end
+
+      def serializer_from_resource_name(name)
+        "#{name}Serializer"
+      end
+
+      def serializer_from(klass)
+        name = resource_class_name(klass)
+        serializer_from_resource_name(name)
+      end
+    end
+  end
+end

data/lib/rdf/serializers/nil_serializer.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RDF
+  module Serializers
+    class NilSerializer
+      include RDF::Serializers::ObjectSerializer
+
+      class << self
+        def validate_includes!(_includes); end
+      end
+    end
+  end
+end

data/lib/rdf/serializers/object_serializer.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module RDF
+  module Serializers
+    module ObjectSerializer
+      extend ActiveSupport::Concern
+      include FastJsonapi::ObjectSerializer
+      include SerializationCore
+
+      def dump(*args, **options)
+        case args.first
+        when :hndjson
+          render_hndjson
+        else
+          render_repository(*args, options)
+        end
+      end
+
+      def triples(*args, **options)
+        if include_named_graphs?(*args)
+          repository.triples(*args, options)
+        else
+          repository.project_graph(nil).triples(*args, options)
+        end
+      end
+
+      private
+
+      def blank_node(id)
+        @blank_nodes ||= {}
+        @blank_nodes[id] ||= RDF::Node(id)
+      end
+
+      def hextuples_for_collection
+        data = []
+        fieldset = @fieldsets[self.class.record_type.to_sym]
+        @resource.each do |record|
+          data.concat self.class.record_hextuples(record, fieldset, @includes, @params)
+          next unless @includes.present?
+
+          data.concat(
+            self.class.get_included_records_hex(record, @includes, @known_included_objects, @fieldsets, @params)
+          )
+        end
+
+        data
+      end
+
+      def hextuples_for_one_record
+        serializable_hextuples = []
+
+        serializable_hextuples.concat self.class.record_hextuples(
+          @resource,
+          @fieldsets[self.class.record_type.to_sym],
+          @includes,
+          @params
+        )
+
+        if @includes.present?
+          serializable_hextuples.concat self.class.get_included_records_hex(
+            @resource,
+            @includes,
+            @known_included_objects,
+            @fieldsets,
+            @params
+          )
+        end
+
+        serializable_hextuples
+      end
+
+      def include_named_graphs?(*args)
+        ::RDF::Serializers.config.always_include_named_graphs ||
+          ::RDF::Writer.for(*args.presence || :nquads).instance_methods.include?(:write_quad)
+      end
+
+      def meta_hextuples
+        return [] unless @meta.is_a?(Array)
+
+        @meta.map do |statement|
+          if statement.is_a?(Array)
+            value_to_hex(statement[0], statement[1], statement[2], statement[3], @params)
+          else
+            value_to_hex(statement.subject.to_s, statement.predicate, statement.object, statement.graph_name, @params)
+          end
+        end.compact
+      end
+
+      def repository
+        return @repository if @repository.present?
+
+        @repository = ::RDF::Repository.new
+        parser = HndJSONParser.new
+
+        serializable_hextuples.compact.each do |hextuple|
+          @repository << parser.parse_hex(hextuple)
+        end
+
+        @repository
+      end
+
+      def render_hndjson
+        serializable_hextuples
+          .map { |s| Oj.fast_generate(s) }
+          .join("\n")
+      end
+
+      def render_repository(*args, options)
+        if include_named_graphs?(*args)
+          repository.dump(*args, options)
+        else
+          repository.project_graph(nil).dump(*args, options)
+        end
+      end
+
+      def serializable_hextuples
+        if is_collection?(@resource, @is_collection)
+          hextuples_for_collection + meta_hextuples
+        elsif !@resource
+          []
+        else
+          hextuples_for_one_record + meta_hextuples
+        end
+      end
+
+      class_methods do
+        def create_relationship(base_key, relationship_type, options, block)
+          association = options.delete(:association)
+          image = options.delete(:image)
+          predicate = options.delete(:predicate)
+          sequence = options.delete(:sequence)
+          relation = super
+          relation.association = association
+          relation.image = image
+          relation.predicate = predicate
+          relation.sequence = sequence
+
+          relation
+        end
+
+        # Checks for the `class_name` property on the Model's association to
+        # determine a serializer.
+        def association_serializer_for(name)
+          model_class_name = self.name.to_s.demodulize.classify.gsub(/Serializer$/, '')
+          model_class = model_class_name.safe_constantize
+
+          association_class_name = model_class.try(:reflect_on_association, name)&.class_name
+
+          return nil unless association_class_name
+
+          serializer_for(association_class_name)
+        end
+
+        def serializer_for(name)
+          associatopm_serializer = association_serializer_for(name)
+          return associatopm_serializer if associatopm_serializer
+
+          begin
+            RDF::Serializers.serializer_for(const_get(name.to_s.classify))
+          rescue NameError
+            raise NameError, "#{self.name} cannot resolve a serializer class for '#{name}'.  " \
+                             'Consider specifying the serializer directly through options[:serializer].'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdf/serializers/relationship.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RDF
+  module Serializers
+    module Relationship
+      include HextupleSerializer
+
+      attr_accessor :predicate, :image, :association, :sequence
+
+      def serialize_hex(record, included, serialization_params)
+        return [] unless include_relationship?(record, serialization_params, included) && predicate.present?
+
+        iris = iris_from_record_and_relationship(record, serialization_params)
+
+        sequence ? relationship_sequence(record, iris, serialization_params) : relationship_statements(record, iris, serialization_params)
+      end
+
+      def relationship_sequence(record, iris, serialization_params)
+        sequence = RDF::Node.new
+
+        [
+          value_to_hex(iri_from_record(record).to_s, predicate, sequence, nil, serialization_params),
+          value_to_hex(sequence, RDF.type, RDF.Seq, nil, serialization_params)
+        ] + iris.map.with_index do |iri, index|
+          value_to_hex(sequence, RDF["_#{index}"], iri, nil, serialization_params)
+        end
+      end
+
+      def relationship_statements(record, iris, serialization_params)
+        iris.map do |related_iri|
+          value_to_hex(
+            iri_from_record(record).to_s,
+            predicate,
+            related_iri,
+            nil,
+            serialization_params
+          )
+        end
+      end
+
+      def include_relationship?(record, serialization_params, included = false)
+        return false if lazy_load_data && !included
+
+        super(record, serialization_params)
+      end
+
+      def iris_from_record_and_relationship(record, params = {})
+        initialize_static_serializer unless @initialized_static_serializer
+
+        associated_object = fetch_associated_object(record, params)
+        return [] unless associated_object
+
+        if associated_object.respond_to? :map
+          return associated_object.compact.map do |object|
+            iri_from_record(object)
+          end
+        end
+
+        [iri_from_record(associated_object)]
+      end
+    end
+  end
+end
+
+FastJsonapi::Relationship.prepend(RDF::Serializers::Relationship)

data/lib/rdf/serializers/renderers.rb

@@ -16,18 +16,45 @@ module RDF
         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?
+          raise "#{symbol} is not a known rdf format" if format.nil?
+
           Mime::Type.register format.content_type.first, format.file_extension.first
-          add_renderer(format, opts)
+          add_renderer(format.file_extension.first, format.content_type.first, format.symbols.first, 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)
+      def self.add_renderer(ext, content_type, symbol, opts = {})
+        ActionController::Renderers.add ext do |resource, options|
+          self.content_type = content_type
+          serializer_opts = RDF::Serializers::Renderers.transform_opts(
+            options,
+            respond_to?(:serializer_params, true) ? serializer_params : {}
+          )
+          RDF::Serializers.serializer_for(resource)&.new(resource, serializer_opts)&.dump(symbol, opts)
         end
       end
+
+      def self.transform_include(include, root = nil)
+        return root if include.blank?
+        return [root, include].compact.join('.') if include.is_a?(Symbol) || include.is_a?(String)
+
+        if include.is_a?(Hash)
+          include.flat_map do |k, v|
+            transform_include(v, [root, k].compact.join('.'))
+          end
+        elsif include.is_a?(Array)
+          include.flat_map do |v|
+            transform_include(v, root)
+          end
+        end.compact
+      end
+
+      def self.transform_opts(options, params)
+        (options || {}).merge(
+          include: transform_include(options[:include]),
+          params: params
+        )
+      end
     end
   end
 end

data/lib/rdf/serializers/scalar.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RDF
+  module Serializers
+    module Scalar
+      include HextupleSerializer
+
+      attr_accessor :predicate, :image, :datatype
+
+      def initialize(key:, method:, options: {})
+        super
+        @predicate = options[:predicate]
+        @image = options[:image]
+        @datatype = options[:datatype]
+      end
+
+      def serialize_hex(record, serialization_params)
+        return [] unless conditionally_allowed?(record, serialization_params) && predicate.present?
+
+        value = value_from_record(record, method, serialization_params)
+
+        return [] if value.nil?
+
+        if value.is_a?(Array)
+          value.map { |arr_item| value_to_hex(iri_from_record(record).to_s, predicate, arr_item, nil, serialization_params) }
+        elsif value.is_a?(::RDF::List)
+          first = value.statements.first&.subject || RDF.nil
+          value.statements.map do |statement|
+            value_to_hex(statement.subject.to_s, statement.predicate, statement.object, statement.graph_name, serialization_params)
+          end + [
+            value_to_hex(iri_from_record(record).to_s, predicate, first, nil, serialization_params)
+          ]
+        else
+          [value_to_hex(iri_from_record(record).to_s, predicate, value, nil, serialization_params)]
+        end
+      end
+
+      def value_from_record(record, method, serialization_params)
+        if method.is_a?(Proc)
+          FastJsonapi.call_proc(method, record, serialization_params)
+        else
+          v = record.public_send(method)
+          v.is_a?('ActiveRecord'.safe_constantize&.const_get('Relation') || NilClass) ? v.to_a : v
+        end
+      end
+    end
+  end
+end
+
+FastJsonapi::Scalar.prepend(RDF::Serializers::Scalar)

data/lib/rdf/serializers/serialization_core.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RDF
+  module Serializers
+    module SerializationCore
+      extend ActiveSupport::Concern
+
+      included do
+        include HextupleSerializer
+        extend HextupleSerializer
+      end
+
+      class_methods do
+        def relationships_hextuples(record, relationships = nil, fieldset = nil, includes_list = [], params = {})
+          relationships = relationships_to_serialize if relationships.nil?
+          relationships = relationships.slice(*fieldset) if fieldset.present?
+          relationships = [] if fieldset == []
+
+          statements = []
+          relationships.each do |key, relationship|
+            included = includes_list.present? && includes_list.include?(key)
+            statements.concat relationship.serialize_hex(record, included, params)
+          end
+
+          statements
+        end
+
+        def attributes_hextuples(record, fieldset = nil, params = {})
+          attributes = attributes_to_serialize
+          attributes = attributes.slice(*fieldset) if fieldset.present?
+          attributes = {} if fieldset == []
+
+          statements = attributes.flat_map do |_k, attr|
+            attr.serialize_hex(record, params)
+          end
+
+          statements.compact
+        end
+
+        def statements_hextuples(record, params = {})
+          statements = []
+
+          _statements&.map do |key|
+            send(key, record, params).each do |statement|
+              statements << if statement.is_a?(Array)
+                value_to_hex(statement[0], statement[1], statement[2], statement[3], params)
+              else
+                value_to_hex(statement.subject.to_s, statement.predicate, statement.object, statement.graph_name, params)
+              end
+            end
+          end
+
+          statements.compact
+        end
+
+        def record_hextuples(record, fieldset, includes_list, params = {})
+          if cache_store_instance
+            record_hex = Rails.cache.fetch(record.cache_key, expires_in: cache_length, race_condition_ttl: race_condition_ttl) do
+              temp_hex = []
+              temp_hex.concat attributes_hextuples(record, fieldset, params) if attributes_to_serialize.present?
+              temp_hex.concat statements_hextuples(record, params)
+              if cachable_relationships_to_serialize.present?
+                temp_hex.concat relationships_hextuples(record, cachable_relationships_to_serialize, fieldset, includes_list, params)
+              end
+              temp_hex
+            end
+            if uncachable_relationships_to_serialize.present?
+              record_hex.concat relationships_hextuples(record, uncachable_relationships_to_serialize, fieldset, includes_list, params)
+            end
+          else
+            record_hex = []
+            record_hex.concat attributes_hextuples(record, fieldset, params) if attributes_to_serialize.present?
+            record_hex.concat statements_hextuples(record, params)
+            if relationships_to_serialize.present?
+              record_hex.concat relationships_hextuples(record, nil, fieldset, includes_list, params)
+            end
+          end
+          record_hex
+        end
+
+        def get_included_records_hex(record, includes_list, known_included_objects, fieldsets, params = {})
+          return unless includes_list.present?
+
+          includes_list.sort.each_with_object([]) do |include_item, included_records|
+            items = parse_include_item(include_item)
+            remaining_items = remaining_items(items)
+
+            items.each do |item|
+              next unless relationships_to_serialize && relationships_to_serialize[item]
+
+              relationship_item = relationships_to_serialize[item]
+              next unless relationship_item.include_relationship?(record, params)
+
+              relationship_type = relationship_item.relationship_type
+
+              included_objects = relationship_item.fetch_associated_object(record, params)
+              next if included_objects.blank?
+
+              included_objects = [included_objects] unless relationship_type == :has_many
+
+              static_serializer = relationship_item.static_serializer
+              static_record_type = relationship_item.static_record_type
+
+              included_objects.each do |inc_obj|
+                serializer = static_serializer || relationship_item.serializer_for(inc_obj, params)
+                record_type = static_record_type || serializer.record_type
+
+                if remaining_items.present?
+                  serializer_records =
+                    serializer
+                    .get_included_records_hex(inc_obj, remaining_items, known_included_objects, fieldsets, params)
+                  included_records.concat(serializer_records) unless serializer_records.empty?
+                end
+
+                code = "#{record_type}_#{serializer.iri_from_record(inc_obj)}"
+                next if known_included_objects.key?(code)
+
+                known_included_objects[code] = inc_obj
+
+                included_records.concat(
+                  serializer.record_hextuples(inc_obj, fieldsets[record_type], includes_list, params)
+                )
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdf/serializers/statements.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RDF
+  module Serializers
+    module Statements
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_statements
+        self._statements ||= []
+      end
+
+      module ClassMethods
+        def inherited(base)
+          super
+          base._statements = _statements.dup
+        end
+
+        def statements(attribute)
+          self._statements << attribute
+        end
+      end
+    end
+  end
+end
+
+FastJsonapi::ObjectSerializer.include(RDF::Serializers::Statements)

data/lib/rdf/serializers/version.rb

@@ -2,6 +2,6 @@
 
 module RDFSerializers
   module Version
-    VERSION = '0.0.4'
+    VERSION = '0.0.8'
   end
 end

data/lib/rdf/serializers.rb

@@ -1,4 +1,88 @@
 # frozen_string_literal: true
 
-require 'active_model_serializers/adapter/rdf'
-require 'active_model_serializers/serializer'
+require 'fast_jsonapi'
+
+require 'rdf/serializers/lookup_chain'
+require 'rdf/serializers/config'
+require 'rdf/serializers/statements'
+require 'rdf/serializers/hextuple_serializer'
+require 'rdf/serializers/data_type_helper'
+require 'rdf/serializers/hdnjson_parser'
+require 'rdf/serializers/serialization_core'
+require 'rdf/serializers/object_serializer'
+require 'rdf/serializers/scalar'
+require 'rdf/serializers/relationship'
+require 'rdf/serializers/nil_serializer'
+require 'rdf/serializers/list_serializer'
+
+module RDF
+  module Serializers
+    class << self
+      # Extracted from active_model_serializers
+      # @param resource [ActiveRecord::Base, ActiveModelSerializers::Model]
+      # @return [ActiveModel::Serializer]
+      #   Preferentially returns
+      #   1. resource.serializer_class
+      #   2. ArraySerializer when resource is a collection
+      #   3. options[:serializer]
+      #   4. lookup serializer when resource is a Class
+      def serializer_for(resource_or_class, options = {})
+        if resource_or_class.respond_to?(:serializer_class)
+          resource_or_class.serializer_class
+        elsif resource_or_class.respond_to?(:to_ary)
+          unless resource_or_class.all? { |resource| resource.is_a?(resource_or_class.first.class) }
+            return ListSerializer
+          end
+
+          serializer_for(resource_or_class.first)
+        else
+          resource_class = resource_or_class.class == Class ? resource_or_class : resource_or_class.class
+          options.fetch(:serializer) { get_serializer_for(resource_class, options[:namespace]) }
+        end
+      end
+
+      private
+
+      # Extracted from active_model_serializers
+      # Find a serializer from a class and caches the lookup.
+      # Preferentially returns:
+      #   1. class name appended with "Serializer"
+      #   2. try again with superclass, if present
+      #   3. nil
+      def get_serializer_for(klass, namespace = nil)
+        return nil unless config.serializer_lookup_enabled
+
+        return NilSerializer if klass == NilClass
+
+        cache_key = ActiveSupport::Cache.expand_cache_key(klass, namespace)
+        serializers_cache.fetch_or_store(cache_key) do
+          # NOTE(beauby): When we drop 1.9.3 support we can lazify the map for perfs.
+          lookup_chain = serializer_lookup_chain_for(klass, namespace)
+          serializer_class = lookup_chain.map(&:safe_constantize).find do |x|
+            x&.include?(FastJsonapi::SerializationCore)
+          end
+
+          if serializer_class
+            serializer_class
+          elsif klass.superclass
+            get_serializer_for(klass.superclass, namespace)
+          end
+        end
+      end
+
+      # Extracted from active_model_serializers
+      # Used to cache serializer name => serializer class
+      # when looked up by Serializer.get_serializer_for.
+      def serializers_cache
+        @serializers_cache ||= Concurrent::Map.new
+      end
+
+      def serializer_lookup_chain_for(klass, namespace = nil)
+        lookups = config.serializer_lookup_chain
+        Array[*lookups].flat_map do |lookup|
+          lookup.call(klass, namespace)
+        end.compact
+      end
+    end
+  end
+end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: rdf-serializers
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.8
 platform: ruby
 authors:
 - Arthur Dingemans
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-12-11 00:00:00.000000000 Z
+date: 2021-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: active_model_serializers
+  name: fast_jsonapi
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
@@ -33,7 +33,7 @@ dependencies:
         version: 4.2.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -43,37 +43,47 @@ dependencies:
         version: 4.2.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '7'
 - !ruby/object:Gem::Dependency
   name: rdf
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
-description: 
+        version: '3.0'
+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/active_model_serializers/serializer.rb
 - lib/rdf/serializers.rb
+- lib/rdf/serializers/config.rb
+- lib/rdf/serializers/data_type_helper.rb
+- lib/rdf/serializers/hdnjson_parser.rb
+- lib/rdf/serializers/hextuple_serializer.rb
+- lib/rdf/serializers/list_serializer.rb
+- lib/rdf/serializers/lookup_chain.rb
+- lib/rdf/serializers/nil_serializer.rb
+- lib/rdf/serializers/object_serializer.rb
+- lib/rdf/serializers/relationship.rb
 - lib/rdf/serializers/renderers.rb
+- lib/rdf/serializers/scalar.rb
+- lib/rdf/serializers/serialization_core.rb
+- lib/rdf/serializers/statements.rb
 - lib/rdf/serializers/version.rb
-homepage: https://github.com/argu-co/rdf-serializers
-licenses: []
+homepage: https://github.com/ontola/rdf-serializers
+licenses:
+- MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -88,9 +98,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Adds RDF serialization, like n-triples or turtle, to active model serializers
 test_files: []

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

@@ -1,60 +0,0 @@
-# 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 |object|
-            raise "#{object} is not a RDF::Resource but a #{object.class}" unless object.is_a?(::RDF::Resource)
-            ::RDF::Statement.new(subject, predicate, object)
-          end
-        end
-
-        private
-
-        def data
-          @data ||=
-            if association.collection?
-              objects_for_many(association).compact
-            else
-              [object_for_one(association)].compact
-            end
-        end
-
-        def objects_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(:rdf_subject)
-            end
-          else
-            []
-          end
-        end
-
-        def object_for_one(association)
-          if belongs_to_id_on_self?(association)
-            parent_serializer.read_attribute_for_serialization(:rdf_subject)
-          else
-            serializer = association.lazy_association.serializer
-            if (virtual_value = association.virtual_value)
-              virtual_value[:id]
-            elsif serializer && association.object
-              serializer.read_attribute_for_serialization(:rdf_subject)
-            end
-          end
-        end
-
-        def predicate
-          @predicate ||= association.reflection.options[:predicate]
-        end
-
-        def subject
-          @subject ||= parent_serializer.read_attribute_for_serialization(:rdf_subject)
-        end
-      end
-    end
-  end
-end

data/lib/active_model_serializers/adapter/rdf.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModelSerializers
-  module Adapter
-    class RDF < Base
-      extend ActiveSupport::Autoload
-      autoload :Relationship
-
-      delegate :object, to: :serializer
-      delegate :dump, :triples, 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, subject, value)
-        predicate = data.options[:predicate]
-        return unless predicate
-        value = value.respond_to?(:each) ? value : [value]
-        value.compact.map { |v| add_triple(subject, predicate, v) }
-      end
-
-      def add_triple(subject, predicate, object)
-        obj =
-          case object
-          when ::RDF::Term
-            object
-          when ActiveSupport::TimeWithZone
-            ::RDF::Literal(object.to_datetime)
-          else
-            ::RDF::Literal(object)
-          end
-        @graph << ::RDF::Statement.new(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(:rdf_subject), serializer.attributes[key])
-        end
-      end
-
-      def custom_triples_for(serializer)
-        serializer.class.try(:_triples)&.map do |key|
-          serializer.read_attribute_for_serialization(key).each do |triple|
-            @graph << triple
-          end
-        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)
-        return serializer.each { |s| process_relationship(s, include_slice) } if serializer.respond_to?(:each)
-        return unless serializer&.object && process_resource(serializer, include_slice)
-        process_relationships(serializer, include_slice)
-      end
-
-      def process_relationships(serializer, include_slice)
-        return unless serializer.respond_to?(:associations)
-        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 = {})
-        if serializer.is_a?(ActiveModel::Serializer::CollectionSerializer)
-          return serializer.map { |child| process_resource(child, include_slice) }
-        end
-        return unless serializer.respond_to?(:rdf_subject) || serializer.object.respond_to?(:rdf_subject)
-        return false unless @resource_identifiers.add?(serializer.read_attribute_for_serialization(:rdf_subject))
-        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(:rdf_subject).nil?
-          requested_fields = fieldset&.fields_for(type)
-          attributes_for(serializer, requested_fields)
-          custom_triples_for(serializer)
-        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/active_model_serializers/serializer.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModel
-  class Serializer
-    class_attribute :_triples
-
-    def self.triples(attribute)
-      self._triples ||= []
-      self._triples << attribute
-    end
-  end
-end