odrl-ruby 0.1.3 → 0.1.6

data/lib/odrl/party.rb

@@ -1,100 +1,87 @@
 # 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
+        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
-
-        def addRefinement(refinement: args)
-            unless refinement.is_a?(Constraint)
-                raise "Refinement is not an ODRL Constraint" 
-            else
-                self.refinements[refinement.uid] = [PREFINEMENT, refinement] 
-            end
+      else
+        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"
+      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.  The provided value will be discarded"
+      @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,79 @@
 require_relative "odrl/version"
 
 module ODRL
-    class Error < StandardError; end
+  class Error < StandardError; end
 
+  class Policy < Base
+    attr_accessor :rules
 
-    class Policy  < Base
-        attr_accessor :rules
+    def initialize(uid: nil, type: CPOLICY, **args)
+      @uid = uid
+      self.uid = Base.baseURI + "#policy_" + Base.getuuid unless @uid
+      super(uid: @uid, type: type, **args)
 
-        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
+      @rules = {}
+    end
 
-        def addProhibition(rule:)
-            uid = rule.uid
-            self.rules[uid] = [PPROHIBITION, rule] 
-        end
+    def addDuty(rule:)
+      uid = rule.uid
+      rules[uid] = [POBLIGATION, 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 addPermission(rule:)
+      uid = rule.uid
+      rules[uid] = [PPERMISSION, rule]
+    end
 
-        def serialize(format:)
-            super
-        end
+    def addProhibition(rule:)
+      uid = rule.uid
+      rules[uid] = [PPROHIBITION, rule]
     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
     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/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

data/lib/odrl/rule.rb

@@ -5,124 +5,112 @@ require_relative "odrl/version"
 # require "ODRL::Constraint"
 
 module ODRL
-    class Rule < Base
-        attr_accessor :uid, :constraints, :assets, :predicate, :type, :action, :assigner, :assignee
-        def initialize(
-            uid: nil,
-            constraints: nil, 
-            assets: nil, 
-            predicate: nil,
-            action: nil, 
-            assigner: nil, 
-            assignee: nil,
-            type: CRULE,
-            **args)
-            @uid = uid
-
-            unless @uid
-                @uid = Base.baseURI + "#rule_" + Base.getuuid
-            end
-            super(uid: @uid, type: type, **args)
-            
-            @constraints = Hash.new
-            @assets = Hash.new
-            @assigner = Hash.new
-            @assignee = Hash.new
-            @action = Hash.new
-
-            assets = [assets] unless assets.is_a? Array
-            if !assets.first.nil?
-                assets.each do |c|
-                    self.addAsset(asset: c)
-                end
-            end
-            constraints = [constraints] unless constraints.is_a? Array
-            if !constraints.first.nil?
-                constraints.each do |c|
-                    self.addConstraint(constraint:  c)
-                end
-            end
+  class Rule < Base
+    attr_accessor :uid, :constraints, :assets, :predicate, :type, :action, :assigner, :assignee
+
+    def initialize(
+      uid: nil,
+      constraints: nil,
+      assets: nil,
+      predicate: nil,
+      action: nil,
+      assigner: nil,
+      assignee: nil,
+      type: CRULE,
+      **args
+    )
+      @uid = uid
+
+      @uid ||= Base.baseURI + "#rule_" + Base.getuuid
+      super(uid: @uid, type: type, **args)
+
+      @constraints = {}
+      @assets = {}
+      @assigner = {}
+      @assignee = {}
+      @action = {}
+
+      assets = [assets] unless assets.is_a? Array
+      unless assets.first.nil?
+        assets.each do |c|
+          addAsset(asset: c)
         end
+      end
+      constraints = [constraints] unless constraints.is_a? Array
+      return if constraints.first.nil?
 
+      constraints.each do |c|
+        addConstraint(constraint: c)
+      end
+    end
 
-        def addAsset(asset:)
-            unless asset.is_a?(Asset)
-                raise "Asset is not an ODRL Asset" 
-            else
-                uid = asset.uid
-                self.assets[uid] = [PASSET, asset] 
-            end
-        end
+    def addAsset(asset:)
+      raise "Asset is not an ODRL Asset" unless asset.is_a?(Asset)
 
-        def addConstraint(constraint:)
-            unless constraint.is_a?(Constraint)
-                raise "Constraint is not an ODRL Constraint" 
-            else
-                self.constraints[constraint.uid] = [PCONSTRAINT, constraint] 
-            end
-        end
+      uid = asset.uid
+      assets[uid] = [PASSET, asset]
+    end
 
-        def addAction(action:)
-            unless action.is_a?(Action)
-                raise "Action is not an ODRL Action" 
-            else
-                self.action[action.uid] = [PACTION, action] 
-            end
-        end
+    def addConstraint(constraint:)
+      raise "Constraint is not an ODRL Constraint" unless constraint.is_a?(Constraint)
 
-        def addAssigner(party:)
-            unless party.is_a?(Party)
-                raise "Assigner is not an ODRL Party" 
-            else
-                self.assigner[party.uid] = [PASSIGNER, party] 
-            end
-        end
+      constraints[constraint.uid] = [PCONSTRAINT, constraint]
+    end
 
-        def addAssignee(party:)
-            unless party.is_a?(Party)
-                raise "Asigner is not an ODRL Party" 
-            else
-                self.assignee[party.uid] = [PASSIGNEE, party] 
-            end
-        end
+    def addAction(action:)
+      raise "Action is not an ODRL Action" unless action.is_a?(Action)
 
-        def load_graph
-            super
-            [:constraints, :assets, :action, :assigner, :assignee].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. "action", ActionObject
-                    object = odrlobject.uid
-                    subject = self.uid
-                    repo = self.repository
-                    triplify(subject, predicate, object, repo)
-                    odrlobject.load_graph  # start the cascade
-                end
-            end
-        end
+      self.action[action.uid] = [PACTION, action]
+    end
 
-        def serialize(format:)
-            super
-        end
+    def addAssigner(party:)
+      raise "Assigner is not an ODRL Party" unless party.is_a?(Party)
+
+      assigner[party.uid] = [PASSIGNER, party]
     end
 
+    def addAssignee(party:)
+      raise "Asigner is not an ODRL Party" unless party.is_a?(Party)
 
-    class Permission  < Rule
-        def initialize(predicate: PPERMISSION, type: CPERMISSION, **args)
-            super(predicate: predicate, type: type, **args)
-        end
+      assignee[party.uid] = [PASSIGNEE, party]
     end
 
-    class Duty  < Rule
-        def initialize(predicate: PDUTY, type: CDUTY, **args)
-            super(predicate: predicate, type: type, **args)
+    def load_graph
+      super
+      %i[constraints assets action assigner assignee].each do |connected_object_type|
+        next unless send(connected_object_type)
+
+        send(connected_object_type).each do |_uid, typedconnection|
+          predicate, odrlobject = typedconnection # e.g. "action", ActionObject
+          object = odrlobject.uid
+          subject = uid
+          repo = repository
+          triplify(subject, predicate, object, repo)
+          odrlobject.load_graph  # start the cascade
         end
+      end
     end
 
-    class Prohibition < Rule
-        def initialize(predicate: PPROHIBITION, type: CPROHIBITION, **args)
-            super(predicate: predicate, type: type, **args)
-        end
+    def serialize(format:)
+      super
     end
+  end
 
+  class Permission < Rule
+    def initialize(predicate: PPERMISSION, type: CPERMISSION, **args)
+      super(predicate: predicate, type: type, **args)
+    end
+  end
+
+  class Duty < Rule
+    def initialize(predicate: PDUTY, type: CDUTY, **args)
+      super(predicate: predicate, type: type, **args)
+    end
+  end
+
+  class Prohibition < Rule
+    def initialize(predicate: PPROHIBITION, type: CPROHIBITION, **args)
+      super(predicate: predicate, type: type, **args)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: odrl-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.6
 platform: ruby
 authors:
 - Mark Wilkinson
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-06-28 00:00:00.000000000 Z
+date: 2023-06-29 00:00:00.000000000 Z
 dependencies: []
 description: builds ODRL files nicely.
 email:
@@ -26,9 +26,10 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
-- examples/builder-translator-output.ttl
+- examples/biohackathon-output.ttl
 - examples/create-biohackathon-offer.rb
-- examples/output.ttl
+- examples/create-nagoya-es-offer.rb
+- examples/nagoya-output.ttl
 - launch.json
 - lib/odrl/action.rb
 - lib/odrl/asset.rb
@@ -47,6 +48,7 @@ metadata:
   homepage_uri: https://example.org
   source_code_uri: https://github.com/markwilkinson/ODRL-RUBY
   changelog_uri: https://github.com/markwilkinson/ODRL-RUBY/blob/master/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/odrl-ruby/
 post_install_message: 
 rdoc_options: []
 require_paths: