chronicle-core 0.2.2 → 0.3.1

data/lib/chronicle/schema/schema_type.rb

@@ -0,0 +1,110 @@
+module Chronicle
+  module Schema
+    # Represents a type in the RDF graph
+    #
+    # TODO: rename `class` to `type` to match new class name
+    class SchemaType
+      attr_reader :id
+      attr_accessor :properties,
+        :subtype_ids,
+        :comment,
+        :namespace,
+        :subtypes,
+        :supertypes,
+        :see_also
+
+      def initialize(id)
+        @id = id
+        @subtype_ids = []
+        @properties = []
+
+        yield self if block_given?
+      end
+
+      def inspect
+        "#<SchemaType:#{id}>"
+      end
+
+      def pretty_print(pp)
+        pp.text("SchemaType: #{id}")
+        pp.nest(2) do
+          pp.breakable
+          pp.text("subtypeIds: #{subtype_ids.map(&:id)}")
+          pp.breakable
+          pp.text("Comment: #{comment}")
+          pp.breakable
+          pp.text("Properties: #{properties.map(&:id)}")
+        end
+      end
+
+      def short_id
+        id.gsub(@namespace, '')
+      end
+
+      # FIXME
+      def identifier
+        short_id.to_sym
+      end
+
+      def to_h
+        output = {
+          id:,
+          subtype_ids:
+        }
+        output[:see_also] = @see_also if @see_also
+        output[:comment] = @comment if @comment
+        output
+      end
+
+      def ==(other)
+        id == other.id
+      end
+
+      def add_subtype_id(subtype_id)
+        @subtype_ids << subtype_id unless @subtype_ids.include?(subtype_id)
+      end
+
+      def ancestors
+        @ancestors ||= begin
+          ancestors = []
+
+          queue = supertypes.dup
+          until queue.empty?
+            current = queue.shift
+            ancestors << current
+            queue.concat(current.supertypes)
+          end
+          ancestors
+        end
+      end
+
+      def descendants
+        @descendants ||= begin
+          descendants = []
+
+          queue = subtypes.dup
+          until queue.empty?
+            current = queue.shift
+            descendants << current
+            queue.concat(current.subtypes)
+          end
+          descendants
+        end
+      end
+
+      def all_properties
+        @all_properties ||= begin
+          properties = @properties.dup
+          ancestors.each do |ancestor|
+            properties.concat(ancestor.properties)
+          end
+          properties
+        end
+      end
+
+      def add_property(property)
+        @properties << property unless @properties.include?(property)
+      end
+    end
+  end
+end

data/lib/chronicle/schema/types.rb

@@ -0,0 +1,9 @@
+require 'dry-types'
+
+module Chronicle
+  module Schema
+    module Types
+      include Dry.Types()
+    end
+  end
+end

data/lib/chronicle/schema/validation/base_contract.rb

@@ -0,0 +1,22 @@
+require 'dry/validation'
+
+module Chronicle
+  module Schema
+    module Validation
+      class BaseContract < Dry::Validation::Contract
+        option :edge_validator, default: -> { Chronicle::Schema::Validation::EdgeValidator.new }
+
+        # I think this doesn't work for nested objects because
+        # we don't enumerate all the properties and rely on the edgevalidator
+        # to do the validation. Commenting out for now.
+        # config.validate_keys = true
+
+        attr_accessor :type_name
+
+        def self.type(type_name)
+          @type_name = type_name
+        end
+      end
+    end
+  end
+end

data/lib/chronicle/schema/validation/contract_factory.rb

@@ -0,0 +1,133 @@
+module Chronicle
+  module Schema
+    module Validation
+      class ContractFactory
+        def self.process_errors(errors)
+          messages = []
+          errors.each do |key, value|
+            base_path = key == :base ? [] : [key]
+            if value.is_a?(Hash)
+              value.each do |k, v|
+                messages << [base_path + [k], v.first.to_s]
+              end
+            elsif value.is_a?(Array)
+              messages << [base_path, value.first.to_s]
+            else
+              messages << [base_path, value.to_s]
+            end
+          end
+          messages
+        end
+
+        def self.create(type_id:, properties: [])
+          Class.new(Chronicle::Schema::Validation::BaseContract) do
+            type type_id
+
+            params(Chronicle::Schema::Validation::ContractFactory.create_schema(type_id:, properties:))
+
+            properties.each do |property|
+              edge_name = property.id_snakecase
+
+              if property.many?
+                rule(edge_name).each do |index:|
+                  errors = edge_validator.validate(type_id, edge_name, value)
+
+                  error_path = [edge_name, index]
+                  messages = Chronicle::Schema::Validation::ContractFactory.process_errors(errors)
+                  messages.each do |path, message|
+                    key(error_path + path).failure(message)
+                  end
+                end
+              else
+                rule(edge_name) do
+                  # handle nils. FIXME: this is a hack
+                  next unless value
+
+                  errors = edge_validator.validate(type_id, edge_name, value)
+                  error_path = [edge_name]
+                  messages = Chronicle::Schema::Validation::ContractFactory.process_errors(errors)
+                  messages.each do |path, message|
+                    key(error_path + path).failure(message)
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        def self.create_schema(type_id:, properties: [])
+          Dry::Schema.JSON do
+            required(:@type).value(:str?).filled(eql?: type_id.to_s)
+
+            before(:key_coercer) do |result|
+              result.to_h.transform_keys!(&:to_sym)
+
+              valid_property_ids = properties.map(&:id_snakecase)
+              valid_property_ids << :@type
+              invalid_properties = result.to_h.keys - valid_property_ids
+
+              invalid_properties.each do |invalid_property|
+                result.add_error([:unexpected_key, [invalid_property.to_sym, []]])
+              end
+            end
+
+            # Attempt to coerce chronicle edges recursively
+            # I tried to use a custom type in the schema and use the constructor
+            # method to do the coercion but it didn't work consistently
+            before(:value_coercer) do |obj|
+              obj.to_h.transform_values do |value|
+                case value
+                when ::Array
+                  value.map do |v|
+                    Chronicle::Schema::Validation::ContractFactory.coerce_chronicle_edge(v)
+                  end
+                when ::Hash
+                  Chronicle::Schema::Validation::ContractFactory.coerce_chronicle_edge(value)
+                else
+                  value
+                end
+              end
+            end
+
+            properties.each do |property|
+              property_name = property.id_snakecase
+              type = Chronicle::Schema::Validation::ContractFactory.build_type(property.range_identifiers)
+
+              outer_macro = property.required? ? :required : :optional
+
+              if property.many?
+                send(outer_macro, property_name).value(:array).each(type)
+              else
+                send(outer_macro, property_name).value(type)
+              end
+            end
+          end
+        end
+
+        def self.coerce_chronicle_edge(value)
+          return value unless value.is_a?(Hash)
+
+          type = (value[:@type] || value['@type']).to_sym
+          contract_klass = Chronicle::Schema::Validation.get_contract(type)
+          return value unless contract_klass
+
+          result = contract_klass.schema.call(value)
+          result.success? ? result.to_h : value
+        end
+
+        def self.build_type(range)
+          literals = []
+          literals << :integer if range.include?(:Integer)
+          literals << :float if range.include?(:Float)
+          literals << :string if range.include?(:Text)
+          literals << :string if range.include?(:URL)
+          literals << :time if range.include?(:DateTime)
+
+          literals << :hash
+          # puts "building type for #{range}. literals: #{literals}"
+          literals.uniq
+        end
+      end
+    end
+  end
+end

data/lib/chronicle/schema/validation/edge_validator.rb

@@ -0,0 +1,53 @@
+module Chronicle
+  module Schema
+    module Validation
+      class EdgeValidator
+        def validate(type, edge, value)
+          errors = {}
+          return errors unless value.is_a?(Hash)
+
+          value_type = (value[:@type] || value['@type']).to_sym
+
+          property = fetch_property(type, edge)
+          unless property
+            errors[:base] = 'not a valid edge'
+            return errors
+          end
+
+          complete_range = fetch_complete_range(property)
+
+          unless complete_range.include?(value_type)
+            errors[:base] =
+              "#{value_type} is not a valid type for #{edge}. Valid types are #{complete_range.join(', ')}"
+            return errors
+          end
+
+          contract_klass = Chronicle::Schema::Validation.get_contract(value_type)
+          unless contract_klass
+            errors[:base] = "no contract found for #{value_type}"
+            return errors
+          end
+
+          result = contract_klass.new.call(value)
+
+          result.errors.to_h
+        end
+
+        private
+
+        def fetch_property(type, edge)
+          klass = Chronicle::Schema::Validation::Generation.graph.find_type(type)
+          klass&.all_properties&.find { |p| edge == p.id_snakecase }
+        end
+
+        def fetch_complete_range(property)
+          property.range.each_with_object([]) do |range, memo|
+            range_klass = Chronicle::Schema::Validation::Generation.graph.find_type_by_id(range)
+            memo << range_klass.short_id
+            memo.concat(range_klass.descendants.map(&:short_id))
+          end.uniq.map(&:to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/chronicle/schema/validation/generation.rb

@@ -0,0 +1,29 @@
+module Chronicle
+  module Schema
+    module Validation
+      module Generation
+        @contracts_generated = false
+
+        def self.generate_contracts(graph)
+          return if @contracts_generated
+
+          @graph = graph
+
+          graph.types.each do |klass|
+            type_id = klass.short_id.to_sym
+            type_contract_class = Chronicle::Schema::Validation::ContractFactory.create(type_id:,
+              properties: klass.all_properties)
+
+            Chronicle::Schema::Validation.set_contract(type_id, type_contract_class)
+          end
+
+          @contracts_generated = true
+        end
+
+        def self.graph
+          @graph
+        end
+      end
+    end
+  end
+end

data/lib/chronicle/schema/validation/validator.rb

@@ -0,0 +1,23 @@
+module Chronicle
+  module Schema
+    module Validation
+      class Validator
+        def validate(data)
+          type = data[:@type] || data['@type']
+          raise Chronicle::Schema::ValidationError, 'Data does not contain a typed object' unless type
+
+          contract = Chronicle::Schema::Validation.get_contract(type.to_sym)
+
+          # binding.pry unless contract
+          raise Chronicle::Schema::ValidationError, "#{type} is not a valid type" unless contract
+
+          contract.new.call(data)
+        end
+
+        def self.call(data)
+          new.validate(data)
+        end
+      end
+    end
+  end
+end

data/lib/chronicle/schema/validation.rb

@@ -0,0 +1,41 @@
+module Chronicle
+  module Schema
+    module Validation
+      # FIXME:
+      # - refactor all of this
+      # - handle different serialization flavours
+      # - move to model of memoizing individual contracts and generating them on demand
+      @contracts = {}
+      @graph = nil
+
+      class << self
+        attr_accessor :graph, :contracts
+      end
+
+      def self.unload_contracts
+        @contracts = {}
+      end
+
+      def self.set_contract(name, contract)
+        @contracts[name] = contract
+      end
+
+      def self.get_contract(name)
+        # FIXME:
+        # Chronicle::Schema::Validation::Generation.generate_contracts
+
+        @contracts[name]
+      end
+
+      def self.contracts_generated?
+        !@contracts_generated.nil?
+      end
+    end
+  end
+end
+
+require_relative 'validation/generation'
+require_relative 'validation/validator'
+require_relative 'validation/edge_validator'
+require_relative 'validation/base_contract'
+require_relative 'validation/contract_factory'

data/lib/chronicle/schema.rb

@@ -1,7 +1,14 @@
 module Chronicle
   module Schema
+    class Error < StandardError; end
+    class ValidationError < Error; end
   end
 end
 
-require_relative "schema/base"
-require_relative "schema/validator"
+# require_relative "schema/validator"
+
+require_relative 'schema/types'
+require_relative 'schema/validation'
+require_relative 'schema/schema_property'
+require_relative 'schema/schema_type'
+require_relative 'schema/schema_graph'

data/lib/chronicle/serialization/hash_serializer.rb

@@ -1,14 +1,8 @@
-module Chronicle::Serialization
-  class HashSerializer < Chronicle::Serialization::Serializer
-    def serializable_hash
-      @record.properties.transform_values do |v|
-        if v.is_a?(Array)
-          v.map{|record| HashSerializer.new(record).serializable_hash}
-        elsif v.is_a?(Chronicle::Schema::Base)
-          HashSerializer.new(v).serializable_hash
-        else
-          v
-        end
+module Chronicle
+  module Serialization
+    class HashSerializer < Chronicle::Serialization::Serializer
+      def serializable_hash
+        @record.to_h
       end
     end
   end

data/lib/chronicle/serialization/jsonapi_serializer.rb

@@ -1,34 +1,49 @@
-module Chronicle::Serialization
-  class JSONAPISerializer < Chronicle::Serialization::Serializer
-    def serializable_hash
-      identifier_hash.merge({
-        attributes: attribute_hash,
-        relationships: associations_hash,
-        meta: @record.meta
-      })
-    end
+module Chronicle
+  module Serialization
+    class JSONAPISerializer < Chronicle::Serialization::Serializer
+      def serializable_hash
+        { data: serialize_record(@record) }
+      end
 
-    private
+      private
 
-    def identifier_hash
-      {
-        type: @record.class::TYPE,
-        id: @record.id
-      }.compact
-    end
+      def serialize_record(record)
+        identifier_hash(record).merge({
+          attributes: attribute_hash(record),
+          relationships: associations_hash(record),
+          meta: record.meta
+        })
+      end
 
-    def attribute_hash
-      @record.attributes.compact
-    end
+      def identifier_hash(record)
+        {
+          type: record.type.to_s,
+          id: record.id
+        }.compact
+      end
+
+      def attribute_hash(record)
+        record.attribute_properties.compact.transform_values do |v|
+          if v.is_a?(Chronicle::Serialization::Record)
+            serialize_record(v)
+          else
+            v
+          end
+        end
+      end
 
-    def associations_hash
-      @record.associations.map do |k, v|
-        if v.is_a?(Array)
-          [k, { data: v.map{|record| JSONAPISerializer.new(record).serializable_hash} }]
-        else
-          [k, { data: JSONAPISerializer.new(v).serializable_hash }]
+      def associations_hash(record)
+        record.association_properties.compact.to_h do |k, v|
+          if v.is_a?(Array)
+            [k, { data: v.map { |record| serialize_record(record) } }]
+          elsif v.is_a?(Chronicle::Serialization::Record)
+            [k, { data: serialize_record(v) }]
+          else
+            # [k, { data: v }]
+            [k, v]
+          end
         end
-      end.to_h
+      end
     end
   end
 end

data/lib/chronicle/serialization/jsonld_serializer.rb

@@ -0,0 +1,38 @@
+module Chronicle
+  module Serialization
+    class JSONLDSerializer < Chronicle::Serialization::Serializer
+      DEFAULT_CONTEXT = 'https://schema.chronicle.app/'.freeze
+
+      def serializable_hash
+        {
+          '@context': DEFAULT_CONTEXT
+        }.merge(serialize_record(@record))
+      end
+
+      private
+
+      def serialize_record(record)
+        properties = record.properties.to_h.compact.transform_values do |value|
+          if value.is_a?(Array)
+            value.map { |v| serialize_value(v) }
+          else
+            serialize_value(value)
+          end
+        end
+
+        {
+          '@type': record.type.to_s,
+          '@id': record.id
+        }.merge(properties).compact
+      end
+
+      def serialize_value(value)
+        if value.is_a?(Chronicle::Serialization::Record)
+          serialize_record(value)
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/chronicle/serialization/record.rb

@@ -0,0 +1,90 @@
+module Chronicle
+  module Serialization
+    class Record
+      attr_reader :properties,
+        :type,
+        :id,
+        :meta,
+        :schema
+
+      def initialize(properties: {}, type: nil, id: nil, meta: {}, schema: nil)
+        @properties = properties
+        @type = type
+        @id = id
+        @meta = meta
+        @schema = schema
+      end
+
+      def self.build_from_model(model)
+        raise ArgumentError, 'model must be a Chronicle::Models::Base' unless model.is_a?(Chronicle::Models::Base)
+
+        properties = model.properties.transform_values do |v|
+          if v.is_a?(Array)
+            v.map do |record|
+              if record.is_a?(Chronicle::Models::Base)
+                Record.build_from_model(record)
+              else
+                record
+              end
+            end
+          elsif v.is_a?(Chronicle::Models::Base)
+            Record.build_from_model(v)
+          else
+            v
+          end
+        end.compact
+
+        new(
+          properties:,
+          type: model.type_id,
+          id: model.id,
+          meta: model.meta,
+          schema: :chronicle
+        )
+      end
+
+      def association_properties
+        # select properties whose values are a record, or are an array that contain a record
+        properties.select do |_k, v|
+          if v.is_a?(Array)
+            v.any? { |record| record.is_a?(Chronicle::Serialization::Record) }
+          else
+            v.is_a?(Chronicle::Serialization::Record)
+          end
+        end
+      end
+
+      def attribute_properties
+        properties.except(*association_properties.keys)
+      end
+
+      def to_h
+        properties.transform_values do |v|
+          if v.is_a?(Array)
+            v.map do |item|
+              value_to_h(item)
+            end
+          else
+            value_to_h(v)
+          end
+        end.merge({ type:, id: }).compact
+      end
+
+      def value_to_h(v)
+        if v.is_a?(Array)
+          v.map do |item|
+            if item.is_a?(Chronicle::Serialization::Record)
+              item.to_h
+            else
+              item
+            end
+          end
+        elsif v.is_a?(Chronicle::Serialization::Record)
+          v.to_h
+        else
+          v
+        end
+      end
+    end
+  end
+end