rdf-serializers 0.0.7 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a641b5b49c74bdc4479196b25f4c70e5718fabb324a703e10e4f60d07fb8574
-  data.tar.gz: 45be5ccf9f007536f261332f396d65a8ecf8b2f63bd5ee9878320e50433a415c
+  metadata.gz: d375c9e57bfcdfcaf9bee6372abbf54ea974e1991a34936917e59c1ed67469a8
+  data.tar.gz: 0efed8bc77b7d97301d08ddaf5e5194c6234fd2c203bc1244d0269f06c81becf
 SHA512:
-  metadata.gz: d908f4bf5f1886890c23e9268779aa4755b3de4f2e5b1e4910f2117c21983a21fef01bc32a8af24b89942b4e1b2fc46d46d0b0481fea52831d86a8b779d42c9a
-  data.tar.gz: f9bdabf7f8455e09dd9ae273d565061c13f127f718cb271f9387cb442a0a5469daa4f0cda5b8058181f74d178c54ab4caae9ca6deb89f65f510a9dafae248d8f
+  metadata.gz: 6edcec3ce7990cb072e6211ce96452d12dd7c245de15177dffafac781b86e48b3f04e60e01af9853e8523a129cc84210c5e9ed3959a1c192c35184f7379a0f5f
+  data.tar.gz: 807766507554892c53f3dd0c9a3199a9d80b59f8b9c4ddb763b609d57727249f050797dfb55591837ce519b4b31fd3635be96fe14aae48e97dca72e01f997604

data/lib/rdf/serializers/config.rb

@@ -14,10 +14,34 @@ module RDF
       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,60 @@
+# 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}" if 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|
+        (namespace && resource_class.name) ? "#{namespace}::#{resource_class_name(resource_class)}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) if 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,184 @@
+# frozen_string_literal: true
+
+require 'oj'
+
+module RDF
+  module Serializers
+    module ObjectSerializer
+      extend ActiveSupport::Concern
+      include FastJsonapi::ObjectSerializer
+      include SerializationCore
+
+      included do
+        class_attribute :_statements
+        self._statements ||= []
+      end
+
+      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 self.class.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 inherited(base)
+          super
+          base._statements = _statements.dup
+        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
+
+        def statements(attribute)
+          self._statements << attribute
+        end
+      end
+    end
+  end
+end

data/lib/rdf/serializers/relationship.rb

@@ -0,0 +1,67 @@
+# 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)
+        return [] if iris.blank?
+
+        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

@@ -19,16 +19,42 @@ module RDF
           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,121 @@
+# 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?
+          return [] unless relationships_to_serialize
+
+          includes_list = parse_includes_list(includes_list)
+
+          includes_list.each_with_object([]) do |include_item, included_records|
+            relationship_item = relationships_to_serialize[include_item.first]
+
+            next unless relationship_item&.include_relationship?(record, params)
+
+            included_objects = Array(relationship_item.fetch_associated_object(record, params))
+            next if included_objects.empty?
+
+            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 include_item.last.any?
+                serializer_records = serializer.get_included_records_hex(inc_obj, include_item.last, 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.include?(code)
+
+              known_included_objects << code
+
+              included_records.concat(
+                serializer.record_hextuples(inc_obj, fieldsets[record_type], includes_list, params)
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rdf/serializers/version.rb

@@ -2,6 +2,6 @@
 
 module RDFSerializers
   module Version
-    VERSION = '0.0.7'
+    VERSION = '0.0.11'
   end
 end

data/lib/rdf/serializers.rb

@@ -1,5 +1,95 @@
 # 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/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 = serializer_class_from_chain(lookup_chain)
+
+          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_class_from_chain(lookup_chain)
+        lookup_chain.map do |klass|
+          klass&.safe_constantize
+        rescue LoadError
+          nil
+        end.find do |klass|
+          klass&.include?(FastJsonapi::SerializationCore)
+        end
+      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,43 @@
 --- !ruby/object:Gem::Specification
 name: rdf-serializers
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.11
 platform: ruby
 authors:
 - Arthur Dingemans
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-10-28 00:00:00.000000000 Z
+date: 2021-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: active_model_serializers
+  name: jsonapi-serializer
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: 2.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        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
@@ -58,24 +72,31 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-description: 
+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/version.rb
 homepage: https://github.com/ontola/rdf-serializers
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -90,8 +111,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
-signing_key: 
+rubygems_version: 3.2.22
+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,70 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveModelSerializers
-  module Adapter
-    class RDF
-      class Relationship < JsonApi::Relationship
-        def triples
-          return [] if no_data?
-
-          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, graph_name: graph_name)
-          end
-        end
-
-        private
-
-        def data
-          @data ||=
-            if association.collection?
-              objects_for_many(association).compact
-            else
-              [object_for_one(association)].compact
-            end
-        end
-
-        def graph_name
-          association.reflection.options[:graph] || ::RDF::Serializers.config.default_graph
-        end
-
-        def no_data?
-          subject.blank? || predicate.blank? || data.empty?
-        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,193 +0,0 @@
-# frozen_string_literal: true
-
-# rubocop:disable Metrics/ClassLength
-module ActiveModelSerializers
-  module Adapter
-    class RDF < Base
-      extend ActiveSupport::Autoload
-      autoload :Relationship
-
-      delegate :object, to: :serializer
-
-      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
-
-      def dump(*args, **options)
-        if include_named_graphs?(*args)
-          repository.dump(*args, options)
-        else
-          repository.project_graph(nil).dump(*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
-
-      protected
-
-      attr_reader :fieldset
-
-      private
-
-      def add_attribute(subject, predicate, value, graph)
-        return unless predicate
-
-        normalized = value.is_a?(Array) ? value : [value]
-        normalized.compact.map { |v| add_triple([subject, predicate, v, graph]) }
-      end
-
-      def add_triple(triple)
-        @repository << (triple.is_a?(Array) ? normalized_triple(*triple) : triple)
-      end
-
-      def attributes_for(serializer, fields)
-        serializer.attributes(fields).each do |key, value|
-          add_attribute(
-            serializer.read_attribute_for_serialization(:rdf_subject),
-            serializer.class._attributes_data[key].try(:options).try(:[], :predicate),
-            value,
-            serializer.class._attributes_data[key].try(:options).try(:[], :graph)
-          )
-        end
-      end
-
-      def custom_triples_for(serializer)
-        serializer.class.try(:_triples)&.map do |key|
-          serializer.read_attribute_for_serialization(key).each do |triple|
-            add_triple(triple)
-          end
-        end
-      end
-
-      def repository
-        return @repository if @repository.present?
-
-        @repository = ::RDF::Repository.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) }
-
-        raise_missing_nodes if raise_on_missing_nodes?
-
-        @repository
-      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 missing_nodes
-        @missing_nodes ||=
-          @repository
-          .objects
-          .select(&:node?)
-          .reject { |n| @repository.has_subject?(n) }
-          .map { |n| @repository.query([nil, nil, n]).first }
-      end
-
-      def normalized_object(object) # rubocop:disable Metrics/MethodLength
-        case object
-        when ::RDF::Term
-          object
-        when ::RDF::List
-          list = object.statements
-          @repository << object.statements
-          list.first.subject
-        when ActiveSupport::TimeWithZone
-          ::RDF::Literal(object.to_datetime)
-        else
-          ::RDF::Literal(object)
-        end
-      end
-
-      def normalized_triple(subject, predicate, object, graph = nil)
-        ::RDF::Statement.new(
-          subject,
-          ::RDF::URI(predicate),
-          normalized_object(object),
-          graph_name: graph || ::RDF::Serializers.config.default_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 raise_on_missing_nodes?
-        Rails.env.development? || Rails.env.test?
-      end
-
-      def raise_missing_nodes
-        return if missing_nodes.empty?
-
-        raise "The following triples point to nodes that are not included in the graph:\n#{missing_nodes.join("\n")}"
-      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|
-            add_triple(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
-# rubocop:enable Metrics/ClassLength

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