virtual_assembly-semantizer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cbd44cbccb6f557aebdb7ef2cb5ed9119ae53839dba26f0a9540794a4fa447a5
+  data.tar.gz: 973105f42f81b44ae526b34c822c05898bcd29d8b5a94edbf99b189c4381970e
+SHA512:
+  metadata.gz: d032ce8d8eee24379cb6babc939ffdb6243187f7347f7f2d151c742acb5f62cdeb8e0d5d07216131aaced9d518edc26b854e83bc36da11283de011f6c57e349d
+  data.tar.gz: 1c55b2707feb65c622a080c27ec6af6d26cf9abc9c9fe556dfd1a4b4c32ebaf2b6197c730cfadfcafaa5b04958919e0deae40c96b53d17222b6aa97af1f5d6f4

data/lib/virtual_assembly/semantizer/hash_serializer.rb

@@ -0,0 +1,99 @@
+# Copyright © 2023 Maxime Lecoq, <maxime@lecoqlibre.fr>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+# and associated documentation files (the “Software”), to deal in the Software without
+# restriction, including without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or
+# substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+# BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# The HashSerializer turns all the semantic properties of a SemanticObject into a Hash.
+#
+# Lets consider the following SemanticObject with a single semantic property like:
+# - name: "http://xmlns.com/foaf/0.1/name"
+# - value: "John"
+#
+# The HashSerializer will return the following Hash:
+# {"http://xmlns.com/foaf/0.1/name" => "John"}.
+class Semantizer::HashSerializer
+
+    # This is the main method to begin the serialization.
+    #
+    # The subject should be a SemanticObject.
+    def process(subject)
+        result = {}
+
+        # We iterate over all the semantic properties of the subject.
+        subject.semanticProperties.each do |property|
+            name = property.name
+            value = property.value
+
+            if (value == nil)
+                next
+            end
+
+            # In case the property is a primitive, we simply get its value.
+            if ([ String, Integer, Float, TrueClass, FalseClass ].include?(value.class))
+                result[name] = value
+
+            # In case the property is a SemanticObject, we get its semanticId 
+            # or we process it if it is a blank node.
+            elsif (value.is_a? SemanticObject)
+                if (value.isBlankNode?)
+                    result[name] = process(value)
+                else
+                    result[name] = value.semanticId
+                end
+
+            # In case the property is an Array, we export each item.
+            elsif (value.class == Array)
+                result[name] = exportCollection(value)
+
+            else 
+                raise "The type of the property '" + name + "' is '" + value.class.to_s + "' but a primitive, a SemanticObject or an Array is required."
+            end
+        end
+     
+        return result;
+    end
+
+    private 
+    
+        # Serialize a collection of values.
+        def exportCollection(values)
+            collection = []
+
+            if (!values.empty?)
+                type = values.at(0).class
+
+                # If the collection contains only primitives, we simply return it.
+                if ([ String, Integer, Float, TrueClass, FalseClass ].include?(type))
+                    collection = values
+
+                # In case the collection contains SemanticObject we have to process 
+                # the blank nodes or return the semantic id.
+                elsif type == SemanticObject
+                    values.each do |item|
+                        if (item.isBlankNode?)
+                            collection.push(process(item))
+                        else
+                            collection.push(item.semanticId)
+                        end
+                    end
+                else
+                    raise "Elements of the collection are not primitive nor SemanticObject."
+                end
+            end
+
+            return collection;
+        end
+
+end

data/lib/virtual_assembly/semantizer/semantic_object.rb

@@ -0,0 +1,173 @@
+# Copyright © 2023 Maxime Lecoq, <maxime@lecoqlibre.fr>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+# and associated documentation files (the “Software”), to deal in the Software without
+# restriction, including without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or
+# substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+# BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'virtual_assembly/semantizer/semantic_property'
+
+# The SemanticObject module is designed to add linked data
+# to classical objects.
+#
+# A semanticObject holds semantic properties (SemanticProperty)
+# that refers to linked data concepts.
+#
+# For example, a Person object including this module could register 
+# in its initializer method a semantic property for its name like:
+# Person.registerSemanticProperty("http://xmlns.com/foaf/0.1/name") {self.name}
+module Semantizer::SemanticObject
+
+    # The semantic ID implements the concept of linked data ID.
+    #
+    # This ID is an uri pointing to the location of the object
+    # on the web like "https://mywebsite/myobject" for instance.
+    #
+    # If a SemanticObject doesn't define its ID, it
+    # will be considered as a blank node.
+    #
+    # This should be a String or nil.
+    attr_accessor :semanticId
+
+    # The semantic type implements the concept of linked data type 
+    # (also called class).
+    #
+    # This type is an uri pointing to the location of the linked 
+    # data concept on the web like "http://xmlns.com/foaf/0.1/Person"
+    # for instance.
+    #
+    # This should be a String or nil.
+    attr_accessor :semanticType
+
+    # This Array stores the semantic properties of the object.
+    # To append a SemanticProperty, use the dedicated
+    # registerSemanticProperty method. You should pass the value 
+    # of the property as a block (callback) like so:
+    # registerSemanticProperty("http://xmlns.com/foaf/0.1/name") {self.name}.
+    attr_reader :semanticProperties
+
+    # If the semanticId is nil, the object will be treated as a blank node.
+    def initialize(semanticId = nil, semanticType = nil)
+        @semanticId = semanticId
+        @semanticType = semanticType
+        @semanticProperties = Array.new
+
+        # This Hash allows us to find a property using its name.
+        #
+        # Hash<String, Integer>
+        #
+        # The key store the name of a property (String).
+        # The value store the index of the property in the 
+        # semanticProperties array (Integer).
+        @semanticPropertiesNameIndex = Hash.new
+    end
+
+    def hasSemanticProperty?(name)
+        return @semanticPropertiesNameIndex.include?(name)
+    end
+
+    def isBlankNode?
+        return @semanticId == nil || @semanticId == ""
+    end
+
+    # Given the name of the property, it returns the value
+    # associated to a property of this object.
+    def semanticPropertyValue(name)
+        index = @semanticPropertiesNameIndex.fetch(name, nil)
+        return index != nil ? @semanticProperties[index].value : nil;
+    end
+
+    # Use this method to append a semantic property to this object.
+    # The value of the property should be passed as a block so its
+    # value would be up to date when we will access it.
+    def registerSemanticProperty(name, &valueGetter)
+        createOrUpdateSemanticProperty(name, valueGetter)
+    end
+
+    # Sets the semantic id of the object and registers the 
+    # corresponding semantic property.
+    #
+    # The semantic ID implements the concept of linked data ID.
+    #
+    # This ID is an uri pointing to the location of the object
+    # on the web like "https://mywebsite/myobject" for instance.
+    #
+    # If a SemanticObject doesn't define its ID, it
+    # will be considered as a blank node.
+    #
+    # This should be a String or nil.
+    def semanticId=(uri)
+        @semanticId = uri
+        registerSemanticProperty("@id") {self.semanticId}
+    end
+
+    # Sets the semantic type of the object and registers the 
+    # corresponding semantic property.
+    #
+    # The semantic type implements the concept of linked data type
+    # (also called class).
+    #
+    # This type is an uri pointing to the location of the linked 
+    # data concept on the web like "http://xmlns.com/foaf/0.1/Person"
+    # for instance.
+    #
+    # This should be a String or nil.
+    def semanticType=(type)
+        @semanticType = type
+        registerSemanticProperty("@type") {self.semanticType}
+    end
+
+    # Serialize all the semantic properties of this object
+    # to an output format.
+    #
+    # You could use the HashSerializer to export as a Hash.
+    # This Hash should be then exported to JSON for instance.
+    def serialize(serializer)
+        return serializer.process(self)
+    end
+
+    protected
+
+        # If the semantic property already exist in this object, this
+        # method will simply update the valueGetter of the property.
+        #
+        # If this object does not holds the property, the new property
+        # will be added into the semanticProperties Array of this object.
+        def createOrUpdateSemanticProperty(name, valueGetter)
+            # Update
+            if (hasSemanticProperty?(name))
+                semanticProperty = findSemanticProperty(name)
+                if (semanticProperty != nil)
+                    semanticProperty.valueGetter = valueGetter
+                end
+
+            # Create
+            else
+                @semanticProperties.push(Semantizer::SemanticProperty.new(name, &valueGetter))
+                index = @semanticProperties.count - 1
+                @semanticPropertiesNameIndex.store(name, index);
+            end
+        end
+
+        # Given its name, returns the corresponding SemanticProperty
+        # stored by this object or nil if the property does not exist.
+        def findSemanticProperty(name)
+            begin
+                index = @semanticPropertiesNameIndex.fetch(name)
+                return @semanticProperties.at(index)
+            rescue
+                return nil
+            end
+        end
+
+end

data/lib/virtual_assembly/semantizer/semantic_property.rb

@@ -0,0 +1,63 @@
+# Copyright © 2023 Maxime Lecoq, <maxime@lecoqlibre.fr>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+# and associated documentation files (the “Software”), to deal in the Software without
+# restriction, including without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or
+# substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+# BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# The SemanticPropety class is designed to turn properties of 
+# objects into linked data.
+#
+# A SemanticProperty has a name and a corresponding value that
+# can be fetched later (so its value would be up to date).
+#
+# This class is intented to be used through the SemanticObject 
+# class.
+# 
+# For instance, we can tell that the name of a Person object refers
+# to the linked data concept "name" from the FOAF project. The name
+# of the property would be the uri of the FOAF:name property while the
+# value would be the attribute reader of the name of the Person object.
+#
+# You should use a block to pass the value like so:
+# SemanticProperty.new("http://xmlns.com/foaf/0.1/name") {self.name}
+class Semantizer::SemanticProperty
+
+    # The name of the property. It generally points to an uri
+    # like "http://xmlns.com/foaf/0.1/name" or it is used to 
+    # define a reserved linked data property like "@id".
+    #
+    # This should be a String.
+    attr_accessor :name
+
+    # The function to call when the value is requested.
+    #
+    # This should be a Proc passed as a Block.
+    attr_accessor :valueGetter
+
+    # @param name The name of the property, like 
+    # "http://xmlns.com/foaf/0.1/name" or "@id" for instance.
+    #
+    # @param valueGetter A Proc used to retrieve the value of the 
+    # property when requested. 
+    def initialize(name, &valueGetter)
+        @name = name
+        @valueGetter = valueGetter
+    end
+
+    # Fetch and returns the value associated to this property.
+    def value
+        return @valueGetter.call
+    end
+
+end

data/lib/virtual_assembly/semantizer.rb

@@ -0,0 +1,5 @@
+class Semantizer
+    require 'virtual_assembly/semantizer/semantic_object'
+    require 'virtual_assembly/semantizer/semantic_property'
+    require 'virtual_assembly/semantizer/hash_serializer'
+end

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: virtual_assembly-semantizer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Maxime Lecoq
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-01-05 00:00:00.000000000 Z
+dependencies: []
+description: A library to add linked data to your models
+email: maxime@lecoqlibre.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/virtual_assembly/semantizer.rb
+- lib/virtual_assembly/semantizer/hash_serializer.rb
+- lib/virtual_assembly/semantizer/semantic_object.rb
+- lib/virtual_assembly/semantizer/semantic_property.rb
+homepage: https://github.com/assemblee-virtuelle/semantizer-ruby/
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.25
+signing_key:
+specification_version: 4
+summary: Semantizer
+test_files: []