emp_json 1.2.0 → 1.2.1.pre.g7126641c2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1be366fe90935e2183bfcebab791742f36bda1eb0d2b4b957d3f8712c8e5021a
-  data.tar.gz: 1e5def92984e8327e5a46712e9c3c615093535eed826f5cd7e406122036274b1
+  metadata.gz: be2d689af57e828d02b12d7926f046e3e16cc710f5943f97fd7d8912604f2daa
+  data.tar.gz: 6567675816c370264323610c46024eb4c1915d05d78a05c92ef23ab43aa8c919
 SHA512:
-  metadata.gz: 53fdb4ad35c3cb6229bc91f0c78db2ebbf29bcfb7286c905b136f4d0f68282fd32701e7df7159dc9517bbeda1b27659b54e9ce9be4763d8d6f188bc14f34029f
-  data.tar.gz: d3b8fd2957612cb2fe6a7c508dceb09b9583d1fc9eae67fc065c357b6278de13e0cc6e6a94ca2e9ee9aab757b743a0f354134bde14a0000795a34c619166a887
+  metadata.gz: 2bbc9e8faacfc512ea65058bcd37c1572a2a1fb8526e8c7bbee560aab37c34b7088456f0f202bb53224722392ace0d1c0fac9dc4ff96cc007f34014741fa8567
+  data.tar.gz: fd3994099ab325ad30b3906db67ef1ffb4ab45e3891f34f0d11bc64272d2e7faa5fb9fca23a096b59d6d919da87120c66b729f7b155ee67f6349b6d865df60d6

data/Gemfile

@@ -16,3 +16,5 @@ gem "activemodel", "~> 7"
 gem "activesupport", "~> 7"
 
 gem "rdf"
+
+gem "rbs"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    emp_json (1.2.0)
+    emp_json (1.2.1.pre.g7126641c2)
 
 GEM
   remote: https://rubygems.org/
@@ -24,6 +24,7 @@ GEM
       ast (~> 2.4.1)
     rainbow (3.1.1)
     rake (13.0.6)
+    rbs (2.6.0)
     rdf (3.2.7)
       link_header (~> 0.0, >= 0.0.8)
     regexp_parser (2.3.1)
@@ -55,6 +56,7 @@ DEPENDENCIES
   emp_json!
   minitest (~> 5.0)
   rake (~> 13.0)
+  rbs
   rdf
   rubocop (~> 1.21)
 

data/emp-json-rb.gemspec

@@ -3,8 +3,11 @@
 require_relative "lib/empathy/emp_json/version"
 
 Gem::Specification.new do |spec|
+  prerelease = ENV.fetch("PUBLISH_PRERELEASE", false)
+  env_version = ENV.fetch("GITHUB_SHA", "")[0..8]
+
   spec.name = "emp_json"
-  spec.version = Empathy::EmpJson::VERSION
+  spec.version = prerelease ? "#{Empathy::EmpJson::VERSION}-g#{env_version}" : Empathy::EmpJson::VERSION
   spec.authors = ["Thom van Kalkeren"]
   spec.email = ["thom@ontola.io"]
 

data/lib/empathy/emp_json/helpers/hash.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Adds to_emp_json to Hash
+class Hash
+  # Converts hash to emp_json
+  class EmpConverter
+    extend Empathy::EmpJson::Helpers::Primitives
+
+    class << self
+      def convert(hash)
+        hash.each_with_object({}) do |(key, value), slice|
+          slice[key.to_s] = value.transform_keys(&:to_s).transform_values do |v|
+            case v
+            when Hash
+              v
+            when Array
+              v.map(&method(:object_to_value))
+            else
+              object_to_value(v)
+            end
+          end
+          slice[key.to_s]["_id"] = object_to_value(key)
+          slice
+        end
+      end
+    end
+  end
+
+  def to_emp_json
+    EmpConverter.convert(self)
+  end
+end

data/lib/empathy/emp_json/helpers/parsing.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Empathy
+  module EmpJson
+    module Helpers
+      # Functions relating to parsing emp_json.
+      module Parsing
+        include Primitives
+
+        def emp_to_primitive(emp_value) # rubocop:disable Metrics/MethodLength
+          type = emp_value.with_indifferent_access[:type]
+          value = emp_value.with_indifferent_access[:v]
+
+          case type
+          when EMP_TYPE_GLOBAL_ID
+            RDF::URI(value)
+          when EMP_TYPE_LOCAL_ID
+            RDF::Node(value.split(":").last)
+          when EMP_TYPE_DATE
+            Date.iso8601(value)
+          when EMP_TYPE_DATETIME
+            Time.iso8601(value)
+          when EMP_TYPE_BOOL
+            value == "true"
+          when EMP_TYPE_INTEGER, EMP_TYPE_LONG
+            value.to_i
+          when EMP_TYPE_PRIMITIVE
+            use_rdf_rb_for_parsing(value, emp_value[:dt])
+          when EMP_TYPE_STRING, EMP_TYPE_LANGSTRING
+            value
+          else
+            throw_unknown_emp_type(type, value)
+          end
+        end
+
+        def use_rdf_rb_for_parsing(value, datatype)
+          RDF::Literal(value, datatype: datatype).object
+        end
+
+        def throw_unknown_emp_type(type, value)
+          throw "unknown emp type: #{type} (#{value})"
+        end
+      end
+    end
+  end
+end

data/lib/empathy/emp_json/helpers/primitives.rb

@@ -6,9 +6,10 @@ module Empathy
   module EmpJson
     module Helpers
       # Functions relating to serializing primitives.
-      module Primitives
+      module Primitives # rubocop:disable Metrics/ModuleLength
         EMP_TYPE_GLOBAL_ID = "id"
         EMP_TYPE_LOCAL_ID = "lid"
+        EMP_TYPE_DATE = "date"
         EMP_TYPE_DATETIME = "dt"
         EMP_TYPE_STRING = "s"
         EMP_TYPE_BOOL = "b"
@@ -21,7 +22,9 @@ module Empathy
         RDF_RDFV_LANGSTRING = "#{RDF_RDFV}langString"
         RDF_RDFS = "http://www.w3.org/2000/01/rdf-schema#"
         RDF_XSD = "http://www.w3.org/2001/XMLSchema#"
+        RDF_XSD_TOKEN = "#{RDF_XSD}token"
         RDF_XSD_STRING = "#{RDF_XSD}string"
+        RDF_XSD_DATE = "#{RDF_XSD}date"
         RDF_XSD_DATETIME = "#{RDF_XSD}dateTime"
         RDF_XSD_BOOLEAN = "#{RDF_XSD}boolean"
         RDF_XSD_INTEGER = "#{RDF_XSD}integer"
@@ -38,7 +41,7 @@ module Empathy
           shorthand(EMP_TYPE_LOCAL_ID, "_:#{value.id}")
         end
 
-        def primitive_to_value(value) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def primitive_to_value(value) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
           throw_unknown_ruby_object(value) if value.nil?
 
           case value
@@ -48,6 +51,8 @@ module Empathy
             shorthand(EMP_TYPE_GLOBAL_ID, value.to_s)
           when DateTime, ActiveSupport::TimeWithZone
             shorthand(EMP_TYPE_DATETIME, value.iso8601)
+          when Date
+            shorthand(EMP_TYPE_DATE, value.iso8601)
           when String, Symbol
             shorthand(EMP_TYPE_STRING, value.to_s)
           when true, false
@@ -74,7 +79,7 @@ module Empathy
           end
         end
 
-        def rdf_literal_to_value(value)
+        def rdf_literal_to_value(value) # rubocop:disable Metrics/AbcSize
           case value.datatype.to_s
           when RDF_RDFV_LANGSTRING
             {
@@ -82,8 +87,10 @@ module Empathy
               l: value.language.to_s,
               v: value.value
             }
-          when RDF_XSD_STRING
+          when RDF_XSD_STRING, RDF_XSD_TOKEN
             shorthand(EMP_TYPE_STRING, value.value)
+          when RDF_XSD_DATE
+            shorthand(EMP_TYPE_DATE, value.value)
           when RDF_XSD_DATETIME
             shorthand(EMP_TYPE_DATETIME, value.value)
           when RDF_XSD_BOOLEAN
@@ -91,7 +98,7 @@ module Empathy
           when RDF_XSD_INTEGER
             integer_to_value(value.to_i)
           else
-            throw "unknown RDF::Literal: #{value.datatype}"
+            throw "unknown RDF::Literal"
           end
         end
 

data/lib/empathy/emp_json/helpers/rdf_list.rb

@@ -10,18 +10,18 @@ module Empathy
           loop do
             list_item_to_record(slice, elem, symbolize)
 
-            break if elem.rest_subject == NS.rdfv.nil
+            break if elem.rest_subject == RDF::RDFV.nil
 
             elem = elem.rest
           end
         end
 
-        def list_item_to_record(slice, elem, symbolize) # rubocop:disable Metrics/AbcSize
+        def list_item_to_record(slice, elem, symbolize)
           rid = add_record_to_slice(slice, elem)
-          add_attribute_to_record(slice, rid, NS.rdfv.type, NS.rdfv.List, symbolize)
+          add_attribute_to_record(slice, rid, RDF::RDFV.type, RDF::RDFV.List, symbolize)
           first = elem.first.is_a?(RDF::Term) ? elem.first : retrieve_id(elem.first)
-          add_attribute_to_record(slice, rid, NS.rdfv.first, first, symbolize)
-          add_attribute_to_record(slice, rid, NS.rdfv.rest, elem.rest_subject, symbolize)
+          add_attribute_to_record(slice, rid, RDF::RDFV.first, first, symbolize)
+          add_attribute_to_record(slice, rid, RDF::RDFV.rest, elem.rest_subject, symbolize)
         end
       end
     end

data/lib/empathy/emp_json/helpers/slices.rb

@@ -56,7 +56,7 @@ module Empathy
         end
 
         def retrieve_id(resource)
-          return resource.to_s if resource.is_a?(URI) || resource.is_a?(RDF::URI)
+          return resource.to_s if resource.is_a?(URI) || resource.is_a?(RDF::URI) || resource.is_a?(RDF::Node)
 
           resource.try(:iri) || resource.try(:subject) || resource.try(:id) || resource
         end
@@ -71,12 +71,6 @@ module Empathy
           values.is_a?(Array) ? values.map(&:with_indifferent_access) : values&.with_indifferent_access
         end
 
-        def expand(slice, website_iri = current_tenant)
-          return slice unless website_iri.present?
-
-          slice.transform_keys { |k| k.start_with?("/") ? website_iri + k : k }
-        end
-
         def field_to_symbol(uri)
           (uri.fragment || uri.path.split("/").last).camelize(:lower)
         end

data/lib/empathy/emp_json/serializer/inclusion.rb

@@ -11,7 +11,7 @@ module Empathy
           when LinkedRails::Sequence
             collect_sequence_and_members(nested_resources, slice, resource, value, serialization_params)
           when RDF::List
-            nested_resources.push value unless value.subject == NS.rdfv.nil
+            nested_resources.push value unless value.subject == RDF::RDFV.nil
           when Array
             collect_array_members(nested_resources, slice, resource, value, serialization_params)
           else

data/lib/empathy/emp_json/version.rb

@@ -2,6 +2,6 @@
 
 module Empathy
   module EmpJson
-    VERSION = "1.2.0"
+    VERSION = "1.2.1"
   end
 end

data/lib/empathy/emp_json.rb

@@ -4,6 +4,8 @@ require "empathy/emp_json/helpers/primitives"
 require "empathy/emp_json/helpers/rdf_list"
 require "empathy/emp_json/helpers/slices"
 require "empathy/emp_json/helpers/values"
+require "empathy/emp_json/helpers/parsing"
+require "empathy/emp_json/helpers/hash"
 require "empathy/emp_json/serializer"
 
 module Empathy

data/rbs_collection.lock.yaml

@@ -0,0 +1,88 @@
+---
+sources:
+- name: ruby/gem_rbs_collection
+  remote: https://github.com/ruby/gem_rbs_collection.git
+  revision: main
+  repo_dir: gems
+path: ".gem_rbs_collection"
+gems:
+- name: activemodel
+  version: '6.0'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: e59b7d94d326a1ac66c6bce8cb82cbabf1734726
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: activesupport
+  version: '6.0'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: e59b7d94d326a1ac66c6bce8cb82cbabf1734726
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: ast
+  version: '2.4'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: e59b7d94d326a1ac66c6bce8cb82cbabf1734726
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: i18n
+  version: '1.10'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: e59b7d94d326a1ac66c6bce8cb82cbabf1734726
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: minitest
+  version: '0'
+  source:
+    type: stdlib
+- name: parallel
+  version: '1.20'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: e59b7d94d326a1ac66c6bce8cb82cbabf1734726
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: rainbow
+  version: '3.0'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: e59b7d94d326a1ac66c6bce8cb82cbabf1734726
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: monitor
+  version: '0'
+  source:
+    type: stdlib
+- name: date
+  version: '0'
+  source:
+    type: stdlib
+- name: singleton
+  version: '0'
+  source:
+    type: stdlib
+- name: logger
+  version: '0'
+  source:
+    type: stdlib
+- name: mutex_m
+  version: '0'
+  source:
+    type: stdlib
+- name: time
+  version: '0'
+  source:
+    type: stdlib
+- name: pathname
+  version: '0'
+  source:
+    type: stdlib

data/rbs_collection.yaml

@@ -0,0 +1,17 @@
+# Download sources
+sources:
+  - name: ruby/gem_rbs_collection
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    revision: main
+    repo_dir: gems
+
+# A directory to install the downloaded RBSs
+path: .gem_rbs_collection
+
+gems:
+  # Skip loading rbs gem's RBS.
+  # It's unnecessary if you don't use rbs as a library.
+  - name: rbs
+    ignore: true
+  - name: emp_json
+    ignore: true

data/sig/lib/empathy/emp_json/helpers/parsing.rbs

@@ -0,0 +1,11 @@
+module Empathy
+  module EmpJson
+    module Helpers
+      module Parsing
+        def emp_to_primitive: (Primitives::shorthand | Primitives::primitive emp_value) -> (RDF::URI | RDF::Node | RDF::Literal | Date | Time | bool | Numeric | String)
+
+        def use_rdf_rb_for_parsing: (string value, string datatype) -> untyped
+      end
+    end
+  end
+end

data/sig/lib/empathy/emp_json/helpers/primitives.rbs

@@ -0,0 +1,70 @@
+module Empathy
+  module EmpJson
+    module Helpers
+      module Primitives
+        EMP_TYPE_GLOBAL_ID: "id"
+
+        EMP_TYPE_LOCAL_ID: "lid"
+
+        EMP_TYPE_DATE: "date"
+
+        EMP_TYPE_DATETIME: "dt"
+
+        EMP_TYPE_STRING: "s"
+
+        EMP_TYPE_BOOL: "b"
+
+        EMP_TYPE_INTEGER: "i"
+
+        EMP_TYPE_LONG: "l"
+
+        EMP_TYPE_PRIMITIVE: "p"
+
+        EMP_TYPE_LANGSTRING: "ls"
+
+        RDF_RDFV: "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+
+        RDF_RDFV_LANGSTRING: "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString"
+
+        RDF_RDFS: "http://www.w3.org/2000/01/rdf-schema#"
+
+        RDF_XSD: "http://www.w3.org/2001/XMLSchema#"
+
+        RDF_XSD_TOKEN: "http://www.w3.org/2001/XMLSchema#token"
+
+        RDF_XSD_STRING: "http://www.w3.org/2001/XMLSchema#string"
+
+        RDF_XSD_DATE: "http://www.w3.org/2001/XMLSchema#date"
+
+        RDF_XSD_DATETIME: "http://www.w3.org/2001/XMLSchema#datetime"
+
+        RDF_XSD_BOOLEAN: "http://www.w3.org/2001/XMLSchema#boolean"
+
+        RDF_XSD_INTEGER: "http://www.w3.org/2001/XMLSchema#integer"
+
+        type shorthand = { type: string, v: string }
+        type primitive = { type: string, dt: string, v: string }
+
+        def serialize_emp: (Hash[untyped, untyped] hash) -> Slices::slice
+
+        def object_to_value: (untyped value) -> shorthand
+
+        def node_to_local_id: (untyped value) -> shorthand
+
+        def primitive_to_value: (untyped value) -> shorthand
+
+        def integer_to_value: (Integer value) -> shorthand
+
+        def rdf_literal_to_value: (untyped value) -> shorthand
+
+        def use_rdf_rb_for_primitive: (untyped value) -> primitive
+
+        def shorthand: (string `type`, string value) -> shorthand
+
+        def primitive: (untyped datatype, untyped value) -> primitive
+
+        def throw_unknown_ruby_object: (untyped value) -> untyped
+      end
+    end
+  end
+end

data/sig/lib/empathy/emp_json/helpers/rdf_list.rbs

@@ -0,0 +1,11 @@
+module Empathy
+  module EmpJson
+    module Helpers
+      module RDFList
+        def add_rdf_list_to_slice: (Slices::slice slice, Serializer::symbolize symbolize, **Serializer::Serializing::emp_options options) -> void
+
+        def list_item_to_record: (Slices::slice slice, untyped elem, Serializer::symbolize symbolize) -> void
+      end
+    end
+  end
+end

data/sig/lib/empathy/emp_json/helpers/slices.rbs

@@ -0,0 +1,33 @@
+module Empathy
+  module EmpJson
+    module Helpers
+      module Slices
+        type record = Hash[string | Symbol, Primitives::shorthand | Primitives::primitive]
+        type slice = Hash[string | Symbol, record]
+        type id = String | RDF::URI
+
+        def all_values_from_slice: (slice slice, id field, ?untyped? _website_iri) -> untyped
+
+        def add_record_to_slice: (slice slice, untyped resource) -> untyped
+
+        def values_from_slice: (slice slice, untyped id, id field, ?untyped? website_iri) -> untyped
+
+        def field_from_slice: (slice slice, untyped id, id field, ?untyped? website_iri) -> (nil | untyped)
+
+        def record_from_slice: (slice slice, untyped id, ?untyped? website_iri) -> untyped
+
+        def field_from_record: (untyped record, id field) -> untyped
+
+        def retrieve_id: (untyped resource) -> untyped
+
+        def absolutized_id: (untyped id, ?untyped? website_iri) -> untyped
+
+        def normalise_slice_values: (untyped values) -> untyped
+
+        def field_to_symbol: (untyped uri) -> untyped
+
+        def slice_includes_record?: (slice slice, untyped resource) -> untyped
+      end
+    end
+  end
+end

data/sig/lib/empathy/emp_json/helpers/values.rbs

@@ -0,0 +1,15 @@
+module Empathy
+  module EmpJson
+    module Helpers
+      module Values
+        def add_attribute_to_record: (Slices::slice slice, untyped rid, untyped key, untyped value, Serializer::symbolize symbolize) -> (nil | untyped)
+
+        def wrap_relation_in_sequence: (untyped value, untyped resource) -> untyped
+
+        def uri_to_symbol: (untyped uri, Serializer::symbolize symbolize) -> untyped
+
+        def value_to_emp_value: (untyped value) -> untyped
+      end
+    end
+  end
+end

data/sig/lib/empathy/emp_json/serializer/fields.rbs

@@ -0,0 +1,23 @@
+module Empathy
+  module EmpJson
+    module Serializer
+      module Fields
+        def serialize_attributes_to_record: (untyped serializer, Helpers::Slices::slice slice, untyped resource, untyped rid, Serializing::serialization_params serialization_params) -> (::Array[untyped] | untyped)
+
+        def serialize_statements: (untyped serializer, Helpers::Slices::slice slice, untyped resource, Serializing::serialization_params serialization_params) -> untyped
+
+        def serialize_relations_to_record: (untyped serializer, Helpers::Slices::slice slice, untyped resource, untyped rid, Serializing::serialization_params serialization_params) -> (::Array[untyped] | untyped)
+
+        def value_for_attribute: (untyped attr, untyped resource, Serializing::serialization_params serialization_params) -> untyped
+
+        def value_for_relation: (untyped relation, untyped resource, Serializing::serialization_params serialization_params) -> (nil | untyped)
+
+        def unpack_relation_value: (untyped relation, untyped resource, Serializing::serialization_params serialization_params) -> untyped
+
+        def unpack_statement: (untyped statement) -> ::Array[untyped]
+
+        def predicate_to_symbol: (untyped attr) -> untyped
+      end
+    end
+  end
+end

data/sig/lib/empathy/emp_json/serializer/inclusion.rbs

@@ -0,0 +1,19 @@
+module Empathy
+  module EmpJson
+    module Serializer
+      module Inclusion
+        def collect_nested_resources: (untyped nested_resources, Helpers::Slices::slice slice, untyped resource, untyped value, Serializing::serialization_params serialization_params) -> untyped
+
+        def collect_sequence_and_members: (untyped nested_resources, Helpers::Slices::slice slice, untyped resource, untyped value, Serializing::serialization_params serialization_params) -> untyped
+
+        def collect_array_members: (untyped nested_resources, Helpers::Slices::slice slice, untyped resource, untyped value, Serializing::serialization_params serialization_params) -> untyped
+
+        def blank_value?: (untyped value) -> untyped
+
+        def nested_resource?: (untyped resource, untyped value) -> untyped
+
+        def process_includes: (Helpers::Slices::slice slice, Serializing::serialization_params serialization_params, **Serializer::Serializing::emp_options options) -> untyped
+      end
+    end
+  end
+end

data/sig/lib/empathy/emp_json/serializer/records.rbs

@@ -0,0 +1,11 @@
+module Empathy
+  module EmpJson
+    module Serializer
+      module Records
+        def serialize_record: (Helpers::Slices::slice slice, Serializing::serialization_params serialization_params, **Serializer::Serializing::emp_options options) -> untyped
+
+        def serialize_record_fields: (untyped serializer, Helpers::Slices::slice slice, untyped resource, untyped rid, Serializing::serialization_params serialization_params) -> untyped
+      end
+    end
+  end
+end

data/sig/lib/empathy/emp_json/serializer/sequence.rbs

@@ -0,0 +1,15 @@
+module Empathy
+  module EmpJson
+    module Serializer
+      module Sequence
+        attr_accessor symbolize: Serializer::symbolize
+
+        def add_sequence_to_slice: (Helpers::Slices::slice slice, Serializing::serialization_params serialization_params, **Serializing::emp_options options) -> untyped
+
+        def process_sequence_members: (untyped serializer, Helpers::Slices::slice slice, untyped resource, untyped rid, Serializing::serialization_params serialization_params, **Serializing::emp_options options) -> untyped
+
+        def process_sequence_member: (untyped member, untyped index, untyped nested, untyped serializer, Helpers::Slices::slice slice, untyped resource, untyped rid, Serializing::serialization_params serialization_params) -> untyped
+      end
+    end
+  end
+end

data/sig/lib/empathy/emp_json/serializer/serializing.rbs

@@ -0,0 +1,18 @@
+module Empathy
+  module EmpJson
+    module Serializer
+      module Serializing
+        type serialization_params = Hash[string, untyped]
+        type emp_options = {includes: untyped?, resource: untyped?, serializer_class: untyped?}
+
+        def render_emp_json: (?untyped resource) -> string
+
+        def emp_json_hash: (?untyped _resource) -> Helpers::Slices::slice
+
+        def create_slice: (untyped resources) -> Helpers::Slices::slice
+
+        def resource_to_emp_json: (Helpers::Slices::slice slice, serialization_params serialization_params, **emp_options options) -> void
+      end
+    end
+  end
+end

data/sig/lib/empathy/emp_json/serializer.rbs

@@ -0,0 +1,33 @@
+module Empathy
+  module EmpJson
+    module Serializer
+      # extend ActiveSupport::Concern
+
+      include Helpers::Primitives
+
+      include Helpers::RDFList
+
+      include Helpers::Slices
+
+      include Helpers::Values
+
+      include Fields
+
+      include Inclusion
+
+      include Records
+
+      include Sequence
+
+      include Serializing
+
+      type symbolize = :class | bool
+
+      attr_accessor symbolize: symbolize
+
+      # def initialize: (untyped resource, ?::Hash[untyped, untyped] opts) -> void
+
+      def dump: (*untyped args, **untyped options) -> untyped
+    end
+  end
+end

data/sig/lib/empathy/emp_json.rbs

@@ -0,0 +1,12 @@
+module Empathy
+  module EmpJson
+    SUPPORTS_RDF_RB: bool
+
+    SUPPORTS_SEQUENCE: bool
+
+    SUPPORTS_AR: bool
+
+    class Error < StandardError
+    end
+  end
+end

data/sig/lib/rdf.rbs

@@ -0,0 +1,261 @@
+module RDF
+  module Value
+    def graph?: (*untyped args) -> false
+    def statement?: (*untyped args) -> false
+    def list?: -> false
+    def term?: (*untyped args) -> false
+    def resource?: -> false
+    def literal?: -> false
+    def node?: -> false
+    def iri?: -> false
+    def uri?: -> false
+    def variable?: (*untyped args) -> false
+    def constant?: -> true
+    def anonymous?: -> false
+    def valid?: -> true
+    def invalid?: -> bool
+    def validate!: -> Value
+    def start_with?: (String? string) -> bool
+    def canonicalize: -> untyped
+    def canonicalize!: -> Value
+    def to_rdf: -> Value
+    def to_term: -> Term
+    def inspect: -> untyped
+    def inspect!: -> untyped
+    def type_error: (untyped message) -> false
+  end
+
+  module Term
+    include Comparable
+    include Value
+
+    def <=>: (untyped other) -> untyped
+    def ==: (untyped other) -> bool
+    def eql?: (untyped other) -> untyped
+    def term?: (*untyped args) -> bool
+    def to_term: -> Term
+    def terms: -> [Term]
+    def to_base: -> untyped
+    def compatible?: (untyped other) -> false
+    def escape: (string string) -> untyped
+  end
+
+  module Resource
+    include Term
+
+    def self.new: (*untyped args) -> URI
+    def resource?: -> true
+  end
+
+  class Literal
+    TRUE: Literal
+    FALSE: Literal
+    ZERO: Literal
+
+    include RDF::Term
+
+    def self.inherited: (untyped child) -> untyped
+    def self.datatype_map: () -> untyped
+    def self.datatyped_class: (untyped uri) -> untyped
+    def self.new: (untyped value, ?language: untyped?, ?datatype: untyped?, ?lexical: untyped?, ?validate: bool, ?canonicalize: bool, **untyped options) -> untyped
+
+
+    attr_accessor language: untyped
+    attr_accessor datatype: untyped
+
+    def initialize: (untyped value, ?language: untyped?, ?datatype: untyped?, ?lexical: untyped?, ?validate: bool, ?canonicalize: bool, **untyped options) -> void
+    def value: () -> String?
+    def object: () -> untyped
+    def literal?: () -> true
+    def compatible?: (Literal other) -> bool
+    def hash: () -> Integer
+    def value_hash: () -> untyped
+    def freeze: () -> untyped
+    def eql?: (Literal other) -> bool
+    def ==: (Literal other) -> untyped
+    alias === ==
+    def <=>: (Literal other) -> untyped
+    def plain?: () -> bool
+    def simple?: () -> bool
+    def language?: () -> bool
+    alias has_language? language?
+    def datatype?: () -> bool
+    alias has_datatype? datatype?
+    alias typed? datatype?
+    alias datatyped? datatype?
+    def valid?: () -> bool
+    def validate!: () -> self
+    def comperable_datatype?: (Literal other) -> bool
+    def comperable_datatype2?: (Literal other) -> bool
+    def canonicalize!: () -> self
+    def squish: (*untyped other_string) -> untyped
+    def squish!: () -> self
+    def escape: (string string) -> untyped
+    def to_s: () -> String
+    def humanize: (?::Symbol lang) -> untyped
+    def inspect: () -> untyped
+    def method_missing: (untyped name, *untyped args) -> untyped
+    def respond_to_missing?: (untyped name, ?bool include_private) -> (true | untyped)
+  end
+
+  class URI
+    UCSCHAR: Regexp
+    IPRIVATE: Regexp
+    SCHEME: Regexp
+    PORT: Regexp
+    IP_literal: Regexp
+    PCT_ENCODED: Regexp
+    GEN_DELIMS: Regexp
+    SUB_DELIMS: Regexp
+    RESERVED: Regexp
+    UNRESERVED: Regexp
+    IUNRESERVED: Regexp
+    IPCHAR: Regexp
+    IQUERY: Regexp
+    IFRAGMENT: Regexp
+    ISEGMENT: Regexp
+    ISEGMENT_NZ: Regexp
+    ISEGMENT_NZ_NC: Regexp
+    IPATH_ABEMPTY: Regexp
+    IPATH_ABSOLUTE: Regexp
+    IPATH_NOSCHEME: Regexp
+    IPATH_ROOTLESS: Regexp
+    IPATH_EMPTY: Regexp
+    IREG_NAME: Regexp
+    IHOST: Regexp
+    IUSERINFO: Regexp
+    IAUTHORITY: Regexp
+    IRELATIVE_PART: Regexp
+    IRELATIVE_REF: Regexp
+    IHIER_PART: Regexp
+    IRI: Regexp
+    IRI_PARTS: Regexp
+    RDS_2A: Regexp
+    RDS_2B1: Regexp
+    RDS_2B2: Regexp
+    RDS_2C1: Regexp
+    RDS_2C2: Regexp
+    RDS_2D: Regexp
+    RDS_2E: Regexp
+    PORT_MAPPING: Hash[String, Integer]
+    NON_HIER_SCHEMES: [String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String]
+    PN_ESCAPE_CHARS: Regexp
+    PN_ESCAPES: Regexp
+    HOST_FROM_AUTHORITY_RE: Regexp
+    PORT_FROM_AUTHORITY_RE: Regexp
+    include Resource
+    @hash: Integer?
+    @object: {scheme: nil, authority: String?, userinfo: nil, user: String?, password: String?, host: nil, port: nil, path: String?, query: nil, fragment: nil}?
+    @value: String?
+    @mutex: Thread::Mutex
+    self.@cache: untyped
+
+    def self.cache: -> untyped
+    def self.intern: (String str, *untyped args, **untyped) -> URI
+    def self.parse: (untyped str) -> URI
+    def self.normalize_path: (String? path) -> String
+    def initialize: (*String? args, ?validate: (String | false)?, ?canonicalize: (String | false)?, **String?) -> void
+    def uri?: -> true
+    def urn?: -> bool
+    def hier?: -> bool
+    def url?: -> bool
+    def absolute?: -> bool
+    def relative?: -> bool
+    def relativize: (untyped base_uri) -> (String | URI)
+    def length: -> Integer
+    def valid?: -> false
+    def validate!: -> URI
+    def canonicalize: -> URI
+    def canonicalize!: -> URI
+    def join: (*untyped uris) -> URI
+    def /: (untyped fragment) -> URI
+    def +: (untyped other) -> URI
+    def root?: -> bool
+    def root: -> URI
+    def parent?: -> bool
+    def parent: -> URI?
+    def qname: (?prefixes: nil) -> [:rdf, Symbol?]?
+    def pname: (?prefixes: nil) -> String
+    def dup: -> URI
+    def freeze: -> URI
+    def end_with?: (string string) -> bool
+    def eql?: (untyped other) -> bool
+    def ==: (untyped other) -> bool
+    def ===: (untyped other) -> bool
+    def =~: (untyped pattern) -> ((Integer | bool)?)
+    def to_uri: -> URI
+    def to_str: -> String?
+    def inspect: -> String
+    def value: -> String?
+    def hash: -> Integer
+    def object: -> {scheme: nil, authority: String?, userinfo: nil, user: String?, password: String?, host: nil, port: nil, path: String?, query: nil, fragment: nil}
+    def parse: (String? value) -> {scheme: nil, authority: nil, userinfo: nil, user: String?, password: String?, host: nil, port: nil, path: String?, query: nil, fragment: nil}
+    def scheme: -> String?
+    def scheme=: (untyped value) -> URI
+    def normalized_scheme: -> nil
+    def user: -> String?
+    def user=: (untyped value) -> URI
+    def normalized_user: -> nil
+    def password: -> String?
+    def password=: (untyped value) -> URI
+    def normalized_password: -> nil
+    def host: -> String?
+    def host=: (untyped value) -> URI
+    def normalized_host: -> nil
+    def port: -> String?
+    def port=: (untyped value) -> URI
+    def normalized_port: -> Integer?
+    def path: -> String?
+    def path=: (String value) -> URI
+    def normalized_path: -> nil
+    def query: -> String?
+    def query=: (nil value) -> URI
+    def normalized_query: -> nil
+    def fragment: -> String?
+    def fragment=: (untyped value) -> URI
+    def normalized_fragment: -> nil
+    def authority: -> String?
+    def authority=: (untyped value) -> URI
+    def normalized_authority: -> String?
+    def userinfo: -> String?
+    def userinfo=: (untyped value) -> URI
+    def normalized_userinfo: -> nil
+    def query_values: (?singleton(Hash) return_type) -> ((Array[Array[nil]?] | Hash[untyped, Array[nil]?])?)
+    def query_values=: (untyped value) -> nil
+    def request_uri: -> String?
+    def _dump: (untyped level) -> String?
+    def self._load: (untyped data) -> URI
+
+    private
+    def normalize_segment: (String? value, untyped expr, ?bool downcase) -> nil
+    def format_userinfo: (?String append) -> String
+    def format_authority: -> String
+    def self.encode: (untyped str, Regexp expr) -> untyped
+    def self.decode: (untyped str) -> untyped
+  end
+
+  class Node
+    include RDF::Resource
+    attr_accessor original: untyped
+    attr_accessor id: untyped
+
+    def self.cache: () -> untyped
+    def self.uuid: (?format: ::Symbol) -> untyped
+    def self.intern: (untyped id) -> untyped
+
+    def dup: () -> Node
+    def initialize: (?untyped? id) -> void
+    def node?: () -> true
+    def anonymous?: () -> true
+    alias unlabeled? anonymous?
+    def labeled?: () -> bool
+    def hash: () -> Integer
+    def eql?: (Node other) -> bool
+    def ==: (Node other) -> untyped
+    alias === ==
+    def to_unique_base: () -> (untyped | ::String)
+    def make_unique!: () -> self
+    def to_s: () -> String
+    def to_sym: () -> untyped
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: emp_json
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1.pre.g7126641c2
 platform: ruby
 authors:
 - Thom van Kalkeren
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-06-21 00:00:00.000000000 Z
+date: 2022-08-01 00:00:00.000000000 Z
 dependencies: []
 description: Serializer for the EmpJson specification.
 email:
@@ -27,6 +27,8 @@ files:
 - Rakefile
 - emp-json-rb.gemspec
 - lib/empathy/emp_json.rb
+- lib/empathy/emp_json/helpers/hash.rb
+- lib/empathy/emp_json/helpers/parsing.rb
 - lib/empathy/emp_json/helpers/primitives.rb
 - lib/empathy/emp_json/helpers/rdf_list.rb
 - lib/empathy/emp_json/helpers/slices.rb
@@ -38,7 +40,21 @@ files:
 - lib/empathy/emp_json/serializer/sequence.rb
 - lib/empathy/emp_json/serializer/serializing.rb
 - lib/empathy/emp_json/version.rb
-- sig/emp/json/rb.rbs
+- rbs_collection.lock.yaml
+- rbs_collection.yaml
+- sig/lib/empathy/emp_json.rbs
+- sig/lib/empathy/emp_json/helpers/parsing.rbs
+- sig/lib/empathy/emp_json/helpers/primitives.rbs
+- sig/lib/empathy/emp_json/helpers/rdf_list.rbs
+- sig/lib/empathy/emp_json/helpers/slices.rbs
+- sig/lib/empathy/emp_json/helpers/values.rbs
+- sig/lib/empathy/emp_json/serializer.rbs
+- sig/lib/empathy/emp_json/serializer/fields.rbs
+- sig/lib/empathy/emp_json/serializer/inclusion.rbs
+- sig/lib/empathy/emp_json/serializer/records.rbs
+- sig/lib/empathy/emp_json/serializer/sequence.rbs
+- sig/lib/empathy/emp_json/serializer/serializing.rbs
+- sig/lib/rdf.rbs
 homepage: https://empathy.tools/tools/emp-json
 licenses:
 - MIT
@@ -59,9 +75,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.7.0.preview1
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.3.7
 signing_key: 

data/sig/emp/json/rb.rbs

@@ -1,8 +0,0 @@
-module Emp
-  module Json
-    module Rb
-      VERSION: String
-      # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-    end
-  end
-end