odrl-ruby 0.1.4 → 0.2.0

data/lib/odrl/party.rb

@@ -1,100 +1,91 @@
 # frozen_string_literal: true
 
 module ODRL
-
-    class Party < Base
-        attr_accessor :uid, :refinements, :partOf, :predicate, :type
-        def initialize(
-            uid: nil,
-            refinements: nil,
-            partOf: nil,
-            predicate: nil,
-            type: CPARTY,
-            **args
-            )
-
-            @uid = uid
-            unless @uid
-                @uid = Base.baseURI + "#party_" + Base.getuuid
-            end
-            super(uid: @uid, type: type, **args)
-
-
-            @refinements = Hash.new
-            @partOf = partOf
-            @predicate = predicate
-
-            unless @predicate
-                raise "If you don't indicate a predicate (assigner/assignee) we will default to assigner.  This may not be what you want!"
-                @predicate = "http://www.w3.org/ns/odrl/2/assigner"
-            else
-                unless [PASSIGNER, PASSIGNEE].include? @predicate 
-                    raise "You didn't indicate a valid predicate (assigner/assignee) so we will default to assigner.  This may not be what you want!"
-                    @predicate = PASSIGNER
-                end
-            end
-
-
-
-            refinements = [refinements] unless refinements.is_a? Array
-            if !(refinements.first.nil?)
-                refinements.each do |c|
-                    self.addRefinement(refinement:  c)
-                end
-            end
-
-            if @partOf and !(@partOf.is_a? PartyCollection) # if it exists and is the wrong type
-                raise "The parent collection of a Party must be of type ODRL::PaertyCollection.  The provided value will be discarded" 
-                @partOf = nil
-            end
-
+  class Party < Base
+    attr_accessor :uid, :refinements, :partOf, :predicate, :type
+
+    def initialize(
+      uid: nil,
+      refinements: nil,
+      partOf: nil,
+      predicate: nil,
+      type: CPARTY,
+      **args
+    )
+
+      @uid = uid
+      @uid ||= Base.baseURI + "#party_" + Base.getuuid
+      super(uid: @uid, type: type, **args)
+
+      @refinements = {}
+      @partOf = partOf
+      @predicate = predicate
+
+      if @predicate&.match(/https?:/)
+        # do nothing! It's their choice to send a full predicate!
+      elsif @predicate  # we're guessing it will be a string from the valid list?
+        unless PARTYFUNCTIONS.include? @predicate
+          raise "You didn't indicate a valid predicate"
+          # @predicate = ODRLV.assigner
+        else
+          @predicate = "#{ODRLV.to_s}#{predicate}" # make the URI form of the valid predicate
         end
-
-        def addRefinement(refinement: args)
-            unless refinement.is_a?(Constraint)
-                raise "Refinement is not an ODRL Constraint" 
-            else
-                self.refinements[refinement.uid] = [PREFINEMENT, refinement] 
-            end
+      elsif @predicate.nil?
+        raise "If you don't indicate a predicate at all"
+        # @predicate = ODRLV.assigner
+      end
+
+      refinements = [refinements] unless refinements.is_a? Array
+      unless refinements.first.nil?
+        refinements.each do |c|
+          addRefinement(refinement: c)
         end
+      end
 
-        def addPart(part: args)
-            unless self.is_a?(PartyCollection)
-                raise "Party cannot be added as part of something that is not an PartyCollection" 
-            end
-            unless part.is_a?(Asset)
-                raise "Only Parties can be added as part of PartyCollections" 
-            end
-            part.partOf[self.uid] = [PPARTOF, self] 
-        end
+      return unless @partOf and !(@partOf.is_a? PartyCollection) # if it exists and is the wrong type
 
-        def load_graph
-            super
-            # TODO  This is bad DRY!!  Put the bulk of this method into the base object
-            [:refinements, :partOf].each do |connected_object_type|
-                next unless self.send(connected_object_type)
-                self.send(connected_object_type).each do |uid, typedconnection|
-                    predicate, odrlobject = typedconnection  # e.g. "refinement", RefinementObject
-                    object = odrlobject.uid
-                    subject = self.uid
-                    repo = self.repository
-                    triplify(subject, predicate, object, repo)
-                    odrlobject.load_graph  # start the cascade
-                end
-            end
-        end
+      raise "The parent collection of a Party must be of type ODRL::PaertyCollection."
+      # @partOf = nil
+    end
 
-        def serialize(format:)
-            super
-        end
+    def addRefinement(refinement: args)
+      raise "Refinement is not an ODRL Constraint" unless refinement.is_a?(Constraint)
+
+      refinements[refinement.uid] = [PREFINEMENT, refinement]
+    end
 
+    def addPart(part: args)
+      raise "Party cannot be added as part of something that is not an PartyCollection" unless is_a?(PartyCollection)
+      raise "Only Parties can be added as part of PartyCollections" unless part.is_a?(Asset)
+
+      part.partOf[uid] = [PPARTOF, self]
     end
-    class PartyCollection < Party
 
-        def initialize(type: CPARTYCOLLECTION, **args)
-            super(type: type, **args)
+    def load_graph
+      super
+      # TODO: This is bad DRY!!  Put the bulk of this method into the base object
+      %i[refinements partOf].each do |connected_object_type|
+        next unless send(connected_object_type)
+
+        send(connected_object_type).each do |_uid, typedconnection|
+          predicate, odrlobject = typedconnection # e.g. "refinement", RefinementObject
+          object = odrlobject.uid
+          subject = uid
+          repo = repository
+          triplify(subject, predicate, object, repo)
+          odrlobject.load_graph # start the cascade
         end
+      end
     end
 
+    def serialize(format:)
+      super
+    end
+  end
 
+  class PartyCollection < Party
+    def initialize(type: CPARTYCOLLECTION, **args)
+      super(type: type, **args)
+    end
+  end
 end

data/lib/odrl/policy.rb

@@ -3,83 +3,95 @@
 require_relative "odrl/version"
 
 module ODRL
-    class Error < StandardError; end
-
-
-    class Policy  < Base
-        attr_accessor :rules
-
-        def initialize(uid: nil, type: CPOLICY, **args)
-            @uid = uid
-            unless @uid
-                self.uid = Base.baseURI + "#policy_" + Base.getuuid
-            end
-            super(uid: @uid, type: type, **args)
-            
-            @rules = Hash.new
-        end
-
-        def addDuty(rule:)
-            uid = rule.uid
-            self.rules[uid] = [POBLIGATION, rule] 
-        end
-
-        def addPermission(rule:)
-            uid = rule.uid
-            self.rules[uid] = [PPERMISSION, rule] 
-
-        end
-
-        def addProhibition(rule:)
-            uid = rule.uid
-            self.rules[uid] = [PPROHIBITION, rule] 
-        end
-
-        def load_graph
-            super
-            self.rules.each do |uid, rulepair|
-                predicate, ruleobject = rulepair  # e.g. "permission", RuleObject
-                object = ruleobject.uid
-                subject = self.uid
-                repo = self.repository
-                triplify(subject, predicate, object, repo)
-                ruleobject.load_graph  # start the cascade
-            end
-        end
-
-        def serialize(format:)
-            super
-        end
+  class Error < StandardError; end
+
+  class Policy < Base
+    attr_accessor :rules, :profiles
+
+    def initialize(uid: nil, type: CPOLICY, **args)
+      @uid = uid
+      self.uid = Base.baseURI + "#policy_" + Base.getuuid unless @uid
+      super(uid: @uid, type: type, **args)
+
+      @rules = {}
+      @profiles = {}
+    end
+
+    def addDuty(rule:)
+      uid = rule.uid
+      rules[uid] = [POBLIGATION, rule]
+    end
+
+    def addPermission(rule:)
+      uid = rule.uid
+      rules[uid] = [PPERMISSION, rule]
+    end
+
+    def addProhibition(rule:)
+      uid = rule.uid
+      rules[uid] = [PPROHIBITION, rule]
+    end
+
+    def addProfile(profile:)
+      uid = profile.uid
+      profiles[uid] = [PPROFILE, uid]
     end
 
-    class Set  < Policy
-        def initialize(type: CSET, **args)
-            super(type: type, **args)
-        end
+    def load_graph
+      super
+      rules.each do |_uid, rulepair|
+        predicate, ruleobject = rulepair # e.g. "permission", RuleObject
+        object = ruleobject.uid
+        subject = uid
+        repo = repository
+        triplify(subject, predicate, object, repo)
+        ruleobject.load_graph # start the cascade
+      end
+
+      # TODO make test for profiles
+      profiles.each do |_uid, profile_pair|
+        predicate, profileuri = profile_pair # e.g. "permission", RuleObject
+        object = profileuri
+        subject = uid
+        repo = repository
+        triplify(subject, predicate, object, repo)
+      end
+
     end
 
-    class Offer  < Set
-        def initialize(type: COFFER, **args)
-            super(type: type, **args)
-        end
+    def serialize(format:)
+      super
     end
-    class Agreement  < Set
-        def initialize(type: CAGREEMENT, **args)
-            super(type: type, **args)
-        end
+  end
+
+  class Set < Policy
+    def initialize(type: CSET, **args)
+      super(type: type, **args)
     end
-    class Request  < Set
-        def initialize(type: CREQUEST, **args)
-            super(type: type, **args)
-        end
+  end
+
+  class Offer < Set
+    def initialize(type: COFFER, **args)
+      super(type: type, **args)
     end
+  end
 
-    class Privacy  < Set
-        def initialize(type: CPRIVACY, **args)
-            super(type: type, **args)
-        end
+  class Agreement < Set
+    def initialize(type: CAGREEMENT, **args)
+      super(type: type, **args)
     end
-# ====================================================
+  end
 
+  class Request < Set
+    def initialize(type: CREQUEST, **args)
+      super(type: type, **args)
+    end
+  end
 
+  class Privacy < Set
+    def initialize(type: CPRIVACY, **args)
+      super(type: type, **args)
+    end
+  end
+  # ====================================================
 end

data/lib/odrl/profile/builder.rb

@@ -0,0 +1,185 @@
+require "linkeddata"
+
+RDFS = RDF::Vocabulary.new("http://www.w3.org/2000/01/rdf-schema#")
+DCAT = RDF::Vocabulary.new("http://www.w3.org/ns/dcat#")
+DC = RDF::Vocabulary.new("http://purl.org/dc/elements/1.1/")
+DCT = RDF::Vocabulary.new("http://purl.org/dc/terms/")
+FUND = RDF::Vocabulary.new("http://vocab.ox.ac.uk/projectfunding#")
+SKOS = RDF::Vocabulary.new("http://www.w3.org/2004/02/skos/core#")
+ODRLV = RDF::Vocabulary.new("http://www.w3.org/ns/odrl/2/")
+OBO = RDF::Vocabulary.new("http://purl.obolibrary.org/obo/")
+XSD = RDF::Vocabulary.new("http://www.w3.org/2001/XMLSchema#")
+SCHEMA = RDF::Vocabulary.new("https://schema.org/")
+OWL = RDF::Vocabulary.new("http://www.w3.org/2002/07/owl#")
+
+module ODRL
+  module Profile
+    class Builder
+      attr_accessor :uri, :profile_class, :repository, :title, :description, :author 
+      attr_accessor :asset_relations, :party_functional_roles, :actions, :leftOperands, :rightOperands
+
+      # attr_accessor :logicalConstraints, :conflict_strategies, :rules
+      def initialize(uri:, profile_class:, title:, description:, author:)
+        @uri = uri
+        @profile_class = profile_class
+        @title = title
+        @description = description
+        @author = author
+        @repository = RDF::Repository.new
+        @asset_relations = []
+        @party_functional_roles = []
+        @actions = []
+        @leftOperands = []
+        @rightOperands = []
+        @asset_relations = []
+
+        # Required declarations of disjointedness
+        ODRL::Profile::Builder.triplify(@profile_class, RDFS.subClassOf, ODRLV.Policy, @repository)
+        ODRL::Profile::Builder.triplify(@profile_class, OWL.disjointWith, ODRLV.Agreement, @repository)
+        ODRL::Profile::Builder.triplify(@profile_class, OWL.disjointWith, ODRLV.Offer, @repository)
+        ODRL::Profile::Builder.triplify(@profile_class, OWL.disjointWith, ODRLV.Privacy, @repository)
+        ODRL::Profile::Builder.triplify(@profile_class, OWL.disjointWith, ODRLV.Request, @repository)
+        ODRL::Profile::Builder.triplify(@profile_class, OWL.disjointWith, ODRLV.Ticket, @repository)
+        ODRL::Profile::Builder.triplify(@profile_class, OWL.disjointWith, ODRLV.Assertion, @repository)
+      end
+
+      def build
+        repo = repository # just shorter :-)
+        title and ODRL::Profile::Builder.triplify(uri, DCT.title, title, repo)
+        description and ODRL::Profile::Builder.triplify(uri, DCT.title, description, repo)
+        author and ODRL::Profile::Builder.triplify(uri, DC.creator, author, repo)
+
+        [asset_relations, party_functional_roles, actions, leftOperands, rightOperands, asset_relations].flatten.each do |elem|
+          elem.build(repo: repo)
+        end
+      end
+
+      def serialize(format: :turtle)
+        format = format.to_sym
+        w = get_writer(type: format)
+        w.dump(repository)
+      end
+
+      def get_writer(type: :turtle)
+        RDF::Writer.for(type)
+      end
+
+      def self.triplify(s, p, o, repo)
+        s = s.strip if s.instance_of?(String)
+        p = p.strip if p.instance_of?(String)
+        o = o.strip if o.instance_of?(String)
+
+        unless s.respond_to?("uri")
+
+          raise "Subject #{s} must be a URI-compatible thingy #{s}, #{p}, #{o}" unless s.to_s =~ %r{^\w+:/?/?[^\s]+}
+
+          s = RDF::URI.new(s.to_s)
+
+        end
+
+        unless p.respond_to?("uri")
+
+          raise "Predicate #{p} must be a URI-compatible thingy #{s}, #{p}, #{o}" unless p.to_s =~ %r{^\w+:/?/?[^\s]+}
+
+          p = RDF::URI.new(p.to_s)
+
+        end
+        unless o.respond_to?("uri")
+          o = if o.to_s =~ %r{^\w+:/?/?[^\s]+}
+                RDF::URI.new(o.to_s)
+              elsif o.to_s =~ /^\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d/
+                RDF::Literal.new(o.to_s, datatype: RDF::XSD.date)
+              elsif o.to_s =~ /^\d\.\d/
+                RDF::Literal.new(o.to_s, datatype: RDF::XSD.float)
+              elsif o.to_s =~ /^[0-9]+$/
+                RDF::Literal.new(o.to_s, datatype: RDF::XSD.int)
+              else
+                RDF::Literal.new(o.to_s, language: :en)
+              end
+        end
+
+        triple = RDF::Statement(s, p, o)
+        repo.insert(triple)
+
+        true
+      end
+    end # end of Class Builder
+
+    class ProfileElement
+      attr_accessor :uri, :label, :definition
+
+      def initialize(uri:, label:, definition:, **_args)
+        @uri = uri
+        @label = label
+        @definition = definition
+      end
+    end
+
+    class AssetRelation < ProfileElement
+      # ex:myRelation rdfs:subPropertyOf odrl:relation .
+      def build(repo:)
+        ODRL::Profile::Builder.triplify(uri, RDFS.subPropertyOf, ODRLV.relation, repo)
+        ODRL::Profile::Builder.triplify(uri, RDFS.label, label, repo)
+        ODRL::Profile::Builder.triplify(uri, SKOS.defintion, definition, repo)
+      end
+    end
+
+    class PartyFunction < ProfileElement
+      # ex:myFunctionRole rdfs:subPropertyOf odrl:function
+      def build(repo:)
+        ODRL::Profile::Builder.triplify(uri, RDFS.subPropertyOf, ODRLV.function, repo)
+        ODRL::Profile::Builder.triplify(uri, RDFS.label, label, repo)
+        ODRL::Profile::Builder.triplify(uri, SKOS.defintion, definition, repo)
+      end
+    end
+
+    class Rule < ProfileElement
+      # ex:myAction a odrl:Action .
+      # ex:myAction odrl:includedIn odrl:use .
+      # ex:myAction odrl:implies odrl:distribute .
+      attr_accessor :implies, :included_in
+
+      def initialize(implies: nil, included_in: ODRLV.use, **args)
+        @implies = implies
+        @included_in = included_in
+        super(**args)
+      end
+
+      def build(repo:)
+        ODRL::Profile::Builder.triplify(uri, RDF.type, ODRLV.Action, repo)
+        ODRL::Profile::Builder.triplify(uri, RDFS.label, label, repo)
+        ODRL::Profile::Builder.triplify(uri, SKOS.defintion, definition, repo)
+        ODRL::Profile::Builder.triplify(uri, ODRLV.includedIn, included_in, repo)
+        return unless implies
+        ODRL::Profile::Builder.triplify(uri, ODRLV.implies, implies, repo)
+      end
+    end
+
+    class LeftOperand < ProfileElement
+      # ex:myLeftOperand a odrl:LeftOperand .
+      def build(repo:)
+        ODRL::Profile::Builder.triplify(uri, RDF.type, ODRLV.LeftOperand, repo)
+        ODRL::Profile::Builder.triplify(uri, RDFS.label, label, repo)
+        ODRL::Profile::Builder.triplify(uri, SKOS.defintion, definition, repo)
+      end
+    end
+
+    class RightOperand < ProfileElement
+      # ex:myRightOperand a odrl:RightOperand .
+      def build(repo:)
+        ODRL::Profile::Builder.triplify(uri, RDF.type, ODRLV.RightOperand, repo)
+        ODRL::Profile::Builder.triplify(uri, RDFS.label, label, repo)
+        ODRL::Profile::Builder.triplify(uri, SKOS.defintion, definition, repo)
+      end
+    end
+
+    class Relation < ProfileElement
+      # ex:myOperator a odrl:Operator .
+      def build(repo:)
+        ODRL::Profile::Builder.triplify(uri, RDF.type, ODRLV.Operator, repo)
+        ODRL::Profile::Builder.triplify(uri, RDFS.label, label, repo)
+        ODRL::Profile::Builder.triplify(uri, SKOS.defintion, definition, repo)
+      end
+    end
+  end
+end

data/lib/odrl/ruby.rb

@@ -1,27 +1,26 @@
-require 'linkeddata'
-require 'rdf/raptor'
-
-#RDF =  RDF::Vocabulary.new("http://www.w3.org/1999/02/22-rdf-syntax-ns#")
+require "linkeddata"
+require "rdf/raptor"
 
+# RDF =  RDF::Vocabulary.new("http://www.w3.org/1999/02/22-rdf-syntax-ns#")
 
 RDFS = RDF::Vocabulary.new("http://www.w3.org/2000/01/rdf-schema#")
 DCAT = RDF::Vocabulary.new("http://www.w3.org/ns/dcat#")
 DC = RDF::Vocabulary.new("http://purl.org/dc/elements/1.1/")
 DCT = RDF::Vocabulary.new("http://purl.org/dc/terms/")
 FUND = RDF::Vocabulary.new("http://vocab.ox.ac.uk/projectfunding#")
-SKOS =  RDF::Vocabulary.new("http://www.w3.org/2004/02/skos/core#")
-ODRLV =  RDF::Vocabulary.new("http://www.w3.org/ns/odrl/2/")
+SKOS = RDF::Vocabulary.new("http://www.w3.org/2004/02/skos/core#")
+ODRLV = RDF::Vocabulary.new("http://www.w3.org/ns/odrl/2/")
 OBO = RDF::Vocabulary.new("http://purl.obolibrary.org/obo/")
 XSD = RDF::Vocabulary.new("http://www.w3.org/2001/XMLSchema#")
 SCHEMA = RDF::Vocabulary.new("https://schema.org/")
 
-require_relative "./base"
-require_relative "./action"
-require_relative "./asset"
-require_relative "./constraint"
-require_relative "./party"
-require_relative "./policy"
-require_relative "./rule"
+require_relative "base"
+require_relative "action"
+require_relative "asset"
+require_relative "constraint"
+require_relative "party"
+require_relative "policy"
+require_relative "rule"
 
 module ODRL
 end