odrl-ruby 0.1.4 → 0.2.0

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,16 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: odrl-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Mark Wilkinson
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-06-28 00:00:00.000000000 Z
+date: 2023-06-30 00:00:00.000000000 Z
 dependencies: []
-description: builds ODRL files nicely.
+description: A builder for ODRL files. Does basic validation against core ODRL vocabularies.
+  Has a Builder that allows you to create ODRL Profiles to extend the core vocabulary.  DOES
+  NOT validate against a profile.  DOES NOT cover the full ODRL specificaiton, only
+  the bits that I needed!
 email:
 - markw@illuminae.com
 executables: []
@@ -26,9 +29,11 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
-- examples/builder-translator-output.ttl
+- examples/biohackathon-output.ttl
+- examples/build_profile.rb
 - 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
@@ -37,6 +42,7 @@ files:
 - lib/odrl/odrl/version.rb
 - lib/odrl/party.rb
 - lib/odrl/policy.rb
+- lib/odrl/profile/builder.rb
 - lib/odrl/ruby.rb
 - lib/odrl/rule.rb
 homepage: https://example.org