odrl-ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cb0c189a2525a3571135dcf826b1564c4fe2b7cba12cb1da11070b14b02b8d7f
+  data.tar.gz: 8fd96e53f85538edaf482bb8a3a70fc2f41963e1e33815ce86dc07385d8c6ad8
+SHA512:
+  metadata.gz: 73442b39ecdfa15aa2a1e5901916bc6302bc3af4b29b445f452982fa395cc10b272ed360b50262e350eaf3f5f748e7492b3a8293841baf82035ededb1abb986f
+  data.tar.gz: 2dd24c86e07382a59f47cfc50a1c047a948328c47e19ca499c68afc988ce74d3141d8d8522ce368adc5af3439cbe3bb871dbed3d0e357d1cff9117b387adf551

data/.rubocop.yml

@@ -0,0 +1,13 @@
+AllCops:
+  TargetRubyVersion: 2.6
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2022-03-15
+
+- Initial release

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in odrl-ruby.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+gem "linkeddata", "~> 3.2.0"
+gem "rubocop", "~> 1.21"
+gem "rspec", "~> 3.11.0"
+gem "rdf-raptor", "~> 3.2.0"
+# gem "ruby-debug-ide"

data/Gemfile.lock

@@ -0,0 +1,235 @@
+PATH
+  remote: .
+  specs:
+    odrl-ruby (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.0)
+      public_suffix (>= 2.0.2, < 5.0)
+    amazing_print (1.4.0)
+    ast (2.4.2)
+    bcp47 (0.3.3)
+      i18n
+    builder (3.2.4)
+    concurrent-ruby (1.1.9)
+    connection_pool (2.2.5)
+    diff-lcs (1.5.0)
+    ebnf (2.3.1)
+      amazing_print (~> 1.4)
+      htmlentities (~> 4.3)
+      rdf (~> 3.2)
+      scanf (~> 1.0)
+      sxp (~> 1.2)
+      unicode-types (~> 1.7)
+    ffi (1.15.5)
+    haml (5.2.2)
+      temple (>= 0.8.0)
+      tilt
+    hamster (3.0.0)
+      concurrent-ruby (~> 1.0)
+    htmlentities (4.3.4)
+    i18n (1.10.0)
+      concurrent-ruby (~> 1.0)
+    json-canonicalization (0.3.0)
+    json-ld (3.2.0)
+      htmlentities (~> 4.3)
+      json-canonicalization (~> 0.3)
+      link_header (~> 0.0, >= 0.0.8)
+      multi_json (~> 1.15)
+      rack (~> 2.2)
+      rdf (~> 3.2)
+    json-ld-preloaded (3.2.0)
+      json-ld (~> 3.2)
+      rdf (~> 3.2)
+    ld-patch (3.2.0)
+      ebnf (~> 2.2)
+      rdf (~> 3.2)
+      rdf-xsd (~> 3.2)
+      sparql (~> 3.2)
+      sxp (~> 1.2)
+    link_header (0.0.8)
+    linkeddata (3.2.0)
+      json-ld (~> 3.2)
+      json-ld-preloaded (~> 3.2)
+      ld-patch (~> 3.2)
+      nokogiri (~> 1.12, >= 1.12.5)
+      rdf (~> 3.2)
+      rdf-aggregate-repo (~> 3.2)
+      rdf-hamster-repo (~> 3.2)
+      rdf-isomorphic (~> 3.2)
+      rdf-json (~> 3.2)
+      rdf-microdata (~> 3.2)
+      rdf-n3 (~> 3.2)
+      rdf-normalize (~> 0.5)
+      rdf-ordered-repo (~> 3.2)
+      rdf-rdfa (~> 3.2)
+      rdf-rdfxml (~> 3.2)
+      rdf-reasoner (~> 0.8)
+      rdf-tabular (~> 3.2)
+      rdf-trig (~> 3.2)
+      rdf-trix (~> 3.2)
+      rdf-turtle (~> 3.2)
+      rdf-vocab (~> 3.2)
+      rdf-xsd (~> 3.2)
+      shacl (~> 0.2)
+      shex (~> 0.7)
+      sparql (~> 3.2)
+      sparql-client (~> 3.2)
+    logger (1.5.0)
+    matrix (0.4.2)
+    multi_json (1.15.0)
+    net-http-persistent (4.0.1)
+      connection_pool (~> 2.2)
+    nokogiri (1.13.3-x86_64-linux)
+      racc (~> 1.4)
+    parallel (1.21.0)
+    parser (3.1.1.0)
+      ast (~> 2.4.1)
+    public_suffix (4.0.6)
+    racc (1.6.0)
+    rack (2.2.3)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    rdf (3.2.6)
+      link_header (~> 0.0, >= 0.0.8)
+    rdf-aggregate-repo (3.2.0)
+      rdf (~> 3.2)
+    rdf-hamster-repo (3.2.1)
+      hamster (~> 3.0)
+      rdf (~> 3.2, >= 3.2.1)
+    rdf-isomorphic (3.2.1)
+      rdf (~> 3.2)
+    rdf-json (3.2.0)
+      rdf (~> 3.2)
+    rdf-microdata (3.2.1)
+      htmlentities (~> 4.3)
+      nokogiri (~> 1.13)
+      rdf (~> 3.2)
+      rdf-rdfa (~> 3.2)
+      rdf-xsd (~> 3.2)
+    rdf-n3 (3.2.1)
+      ebnf (~> 2.2)
+      rdf (~> 3.2)
+      sparql (~> 3.2)
+      sxp (~> 1.2)
+    rdf-normalize (0.5.0)
+      rdf (~> 3.2)
+    rdf-ordered-repo (3.2.1)
+      rdf (~> 3.2, >= 3.2.1)
+    rdf-raptor (3.2.0)
+      ffi (~> 1.15)
+      rdf (~> 3.2)
+    rdf-rdfa (3.2.0)
+      haml (~> 5.2)
+      htmlentities (~> 4.3)
+      rdf (~> 3.2)
+      rdf-aggregate-repo (~> 3.2)
+      rdf-vocab (~> 3.2)
+      rdf-xsd (~> 3.2)
+    rdf-rdfxml (3.2.0)
+      htmlentities (~> 4.3)
+      rdf (~> 3.2)
+      rdf-rdfa (~> 3.2)
+      rdf-xsd (~> 3.2)
+    rdf-reasoner (0.8.0)
+      rdf (~> 3.2)
+      rdf-xsd (~> 3.2)
+    rdf-tabular (3.2.0)
+      addressable (~> 2.8)
+      bcp47 (~> 0.3, >= 0.3.3)
+      json-ld (~> 3.2)
+      rdf (~> 3.2)
+      rdf-vocab (~> 3.2)
+      rdf-xsd (~> 3.2)
+    rdf-trig (3.2.0)
+      ebnf (~> 2.2)
+      rdf (~> 3.2)
+      rdf-turtle (~> 3.2)
+    rdf-trix (3.2.0)
+      rdf (~> 3.2)
+      rdf-xsd (~> 3.2)
+    rdf-turtle (3.2.0)
+      ebnf (~> 2.3)
+      rdf (~> 3.2)
+    rdf-vocab (3.2.1)
+      rdf (~> 3.2, >= 3.2.4)
+    rdf-xsd (3.2.1)
+      rdf (~> 3.2)
+      rexml (~> 3.2)
+    regexp_parser (2.2.1)
+    rexml (3.2.5)
+    rspec (3.11.0)
+      rspec-core (~> 3.11.0)
+      rspec-expectations (~> 3.11.0)
+      rspec-mocks (~> 3.11.0)
+    rspec-core (3.11.0)
+      rspec-support (~> 3.11.0)
+    rspec-expectations (3.11.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-mocks (3.11.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-support (3.11.0)
+    rubocop (1.26.0)
+      parallel (~> 1.10)
+      parser (>= 3.1.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml
+      rubocop-ast (>= 1.16.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.16.0)
+      parser (>= 3.1.1.0)
+    ruby-progressbar (1.11.0)
+    scanf (1.0.0)
+    shacl (0.2.1)
+      json-ld (~> 3.2)
+      rdf (~> 3.2)
+      sparql (~> 3.2)
+      sxp (~> 1.2)
+    shex (0.7.1)
+      ebnf (~> 2.2)
+      htmlentities (~> 4.3)
+      json-ld (~> 3.2)
+      json-ld-preloaded (~> 3.2)
+      rdf (~> 3.2)
+      rdf-xsd (~> 3.2)
+      sparql (~> 3.2)
+      sxp (~> 1.2)
+    sparql (3.2.1)
+      builder (~> 3.2)
+      ebnf (~> 2.2)
+      logger (~> 1.4)
+      rdf (~> 3.2, >= 3.2.3)
+      rdf-aggregate-repo (~> 3.2)
+      rdf-xsd (~> 3.2)
+      sparql-client (~> 3.2)
+      sxp (~> 1.2, >= 1.2.1)
+    sparql-client (3.2.0)
+      net-http-persistent (~> 4.0, >= 4.0.1)
+      rdf (~> 3.2)
+    sxp (1.2.2)
+      matrix
+      rdf (~> 3.2)
+    temple (0.8.2)
+    tilt (2.0.10)
+    unicode-display_width (2.1.0)
+    unicode-types (1.7.0)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  linkeddata (~> 3.2.0)
+  odrl-ruby!
+  rake (~> 13.0)
+  rdf-raptor (~> 3.2.0)
+  rspec (~> 3.11.0)
+  rubocop (~> 1.21)
+
+BUNDLED WITH
+   2.2.31

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Mark Wilkinson
+
+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.

data/README.md

@@ -0,0 +1,41 @@
+# THIS IS NOT READY FOR USE!  ...SO DON'T!  :-)
+
+# ODRL::Ruby
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/odrl/ruby`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'odrl-ruby'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install odrl-ruby
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/odrl-ruby.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: :rubocop

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "odrl/ruby"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/create-biohackathon-offer.rb

@@ -0,0 +1,44 @@
+require 'odrl/ruby'
+
+
+# an offer to toshiaki from mark to use the polyA resource during the biohackathon
+
+# core annotatons are:  :title, :creator, :description, :subject :baseURI, :uid, :type
+policy = ODRL::Offer.new(
+    title: "Offer to Toshiaki-san", 
+    creator: "https://orcid.org/0000-0001-6960-357X", 
+    description: "An offer for Toshiaki-san to use the polyA data during the hackathon",
+    subject: "collaboration", # this is the CCE category
+)
+
+asset = ODRL::Asset.new(uid: "http://mark.wilkinson.org/data/polyA", title: "Mark's PolyA Database")
+
+# you indicate the type of party by assigning the predicate (either assigner or assignee)
+# ODRLV is the RDF::Vocabulary for ODRL, exported to this namespace
+mark = ODRL::Party.new(uid: "https://orcid.org/0000-0001-6960-357X", predicate: ODRLV.assigner, title: "Mark D Wilkinson" )
+toshiaki = ODRL::Party.new(uid: "https://orcid.org/0000-0003-2391-0384", predicate: ODRLV.assignee, title: "Toshiaki Katayama")
+
+# Rules
+permission = ODRL::Permission.new(title: "Permission to use")
+
+use = ODRL::Use.new(value: "use") # subclass of action
+
+# Constraints: :uid, :rightOperand, :leftOperand, :operator, :rightOperandReference, :dataType, :unit, :status
+constraint = ODRL::Constraint.new(
+    title: "Only during the hackathon",
+    leftOperand: "event",
+    operator: "eq",
+    rightOperand: "https://2023.biohackathon.org"
+)
+permission.addConstraint(constraint: constraint)
+permission.addAsset(asset: asset)
+permission.addAssigner(party: toshiaki)
+permission.addAssignee(party: mark)
+permission.addAction(action: use)
+
+policy.addPermission(rule: permission)
+
+policy.load_graph
+result = policy.serialize(format: 'turtle')
+puts result
+

data/launch.json

@@ -0,0 +1,11 @@
+{
+    "name": "RSpec - all",
+    "type": "Ruby",
+    "request": "launch",
+    "cwd": "${workspaceRoot}",
+    "program": "/home/osboxes/.rvm/rubies/ruby-3.0.0/bin/rspec",
+    "args": [
+      "-I",
+      "${workspaceRoot}"
+    ]
+  }

data/lib/odrl/action.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module ODRL
+
+    class Action < Base
+        attr_accessor :uid, :refinements, :predicate, :type, :value, :vallabel
+        def initialize(args)
+            @value = args[:value]
+            @vallabel = args[:value]
+            raise "Actions must haves a value such as 'use' - I'm dead!" unless @value
+            @value = "http://www.w3.org/ns/odrl/2/#{@value}" unless @value =~ /http:\/\//  # if it is already a URI, then let it go
+
+            @uid = @value
+            # unless @uid
+            #     self.uid = Base.baseURI + "#action_" + Base.getuuid
+            # end
+            super(args.merge({uid: @uid}))
+
+            self.type="http://www.w3.org/ns/odrl/2/Action"
+
+            @refinements = Hash.new
+
+            args[:refinements] = [args[:refinements]] unless args[:refinements].is_a? Array
+            if !(args[:refinements].first.nil?)
+                args[:refinements].each do |c|
+                    self.addRefinement(refinement:  c)
+                end
+            end
+
+            self.predicate = PACTION unless self.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
+        end
+
+
+        def load_graph
+            super
+            # TODO  This is bad DRY!!  Put the bulk of this method into the base object
+            [:refinements].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
+            subject = self.uid
+            object = self.vallabel
+            predicate = SCHEMA.name
+            repo = self.repository
+            triplify(subject, predicate, object, repo)
+            object = self.vallabel
+            predicate = RDFS.label
+            repo = self.repository
+            triplify(subject, predicate, object, repo)
+        end
+
+        def serialize
+            super
+        end
+
+    end
+
+
+
+    class Use < Action 
+        def initialize(args)
+            super(args)
+            self.type = "http://www.w3.org/ns/odrl/2/Action" unless self.type
+        end
+    end
+    class Transfer < Action
+        def initialize(args)
+            super(args)
+            self.type = "http://www.w3.org/ns/odrl/2/Action" unless self.type
+        end
+    end
+
+end

data/lib/odrl/asset.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module ODRL
+
+    class Asset < Base
+        attr_accessor :uid, :hasPolicy, :refinements, :partOf
+
+        def initialize(args)
+            @uid = args[:uid]
+            unless @uid
+                self.uid = Base.baseURI + "#asset_" + Base.getuuid
+            end
+            super(args.merge({uid: @uid}))
+            self.type="http://www.w3.org/ns/odrl/2/Asset"
+
+            @refinements = Hash.new
+            @partOf = args[:partOf]
+            @hasPolicy = args[:hasPolicy]
+
+            if @hasPolicy and !(@hasPolicy.is_a? Policy) # if it exists and is the wrong type
+                raise "The policy of an Asset must be of type ODRL::Policy.  The provided value will be discarded" 
+                @hasPolicy = nil
+            end
+            if @partOf and !(@partOf.is_a? AssetCollection) # if it exists and is the wrong type
+                raise "The parent collection of an Asset must be of type ODRL::AssetCollection.  The provided value will be discarded" 
+                @partOf = nil
+            end
+
+            args[:refinements] = [args[:refinements]] unless args[:refinements].is_a? Array
+            if !(args[:refinements].first.nil?)
+                args[:refinements].each do |c|
+                    self.addRefinement(refinement:  c)
+                end
+            end
+        end
+
+
+        def addPart(part: args)
+            unless self.is_a?(AssetCollection)
+                raise "Asset cannot be added as part of something that is not an asset collection" 
+            end
+            unless part.is_a?(Asset)
+                raise "Only Assets can be added as part of asset collections" 
+            end
+            part.partOf[self.uid] = [PPARTOF, self] 
+        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
+        end
+
+        def load_graph
+            super
+            # TODO  This is bad DRY!!  Put the bulk of this method into the base object
+            [:refinements, :partOf, :hasPolicy].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
+
+        def serialize(format:)
+            super
+        end
+
+    end
+
+    class AssetCollection < Asset
+
+        def initialize(args)
+            super(args)
+            self.type="http://www.w3.org/ns/odrl/2/AssetCollection"
+        end
+    end
+
+
+end

data/lib/odrl/base.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require_relative "odrl/version"
+
+# one day move these all to ODRLV.xxxx
+CPOLICY= "http://www.w3.org/ns/odrl/2/Policy"
+
+CSET= "http://www.w3.org/ns/odrl/2/Set"
+COFFER= "http://www.w3.org/ns/odrl/2/Offer"
+CREQUEST= "http://www.w3.org/ns/odrl/2/Request"
+CAGREEMENT= "http://www.w3.org/ns/odrl/2/Agreement"
+
+PASSET = "http://www.w3.org/ns/odrl/2/target"
+CASSET= "http://www.w3.org/ns/odrl/2/Asset"
+
+CPERMISSION= "http://www.w3.org/ns/odrl/2/Permission"
+PPERMISSION = "http://www.w3.org/ns/odrl/2/permission"
+CPROHIBITION= "http://www.w3.org/ns/odrl/2/Prohibition"
+PPROHIBITION = "http://www.w3.org/ns/odrl/2/prohibition"
+PDUTY= "http://www.w3.org/ns/odrl/2/obligation"
+CDUTY = "http://www.w3.org/ns/odrl/2/Duty"
+
+PRULE = "http://www.w3.org/ns/odrl/2/Rule"
+
+
+PACTION = "http://www.w3.org/ns/odrl/2/action"
+CACTION= "http://www.w3.org/ns/odrl/2/Action"
+
+PREFINEMENT = "http://www.w3.org/ns/odrl/2/refinement"
+
+PASSIGNER = "http://www.w3.org/ns/odrl/2/assigner"
+PASSIGNEE =  "http://www.w3.org/ns/odrl/2/assignee"
+CPARTY= "http://www.w3.org/ns/odrl/2/Party"
+
+PCONSTRAINT = "http://www.w3.org/ns/odrl/2/constraint"
+CCONSTRAINT = "http://www.w3.org/ns/odrl/2/Constraint"
+PLEFT = "http://www.w3.org/ns/odrl/2/leftOperand"
+PRIGHT = "http://www.w3.org/ns/odrl/2/rightOperand"
+POPERATOR = "http://www.w3.org/ns/odrl/2/operator"
+POPERANDREFERENCE = "http://www.w3.org/ns/odrl/2/rightOperandReference"
+PDATATYPE = "http://www.w3.org/ns/odrl/2/dataType"
+PUNIT = "http://www.w3.org/ns/odrl/2/unit"
+PSTATUS = "http://www.w3.org/ns/odrl/2/status"
+
+PPARTOF = "http://www.w3.org/ns/odrl/2/partOf"
+
+
+PROPERTIES = {
+        title: DCT.title,
+        creator: DCT.creator,
+        description: DCT.description,
+        uid: DCT.identifier,
+        type: RDF.type,
+        subject: DCT.subject
+
+}
+
+module ODRL
+        class Base
+
+        @@repository = RDF::Repository.new()
+                
+        attr_accessor :title, :creator, :description, :subject, :baseURI, :uid, :type
+
+        def self.baseURI
+                return ENV['ODRL_BASEURI'] || "http://example.org"
+        end
+
+        def self.repository
+                return @@repository
+        end
+        def repository
+                return @@repository
+        end
+
+        def self.clear_repository
+                @@repository.clear!
+                return true
+        end
+
+        def initialize(args)
+                #args = defaults.merge(args)
+
+                @title = args[:title]
+                @creator = args[:creator]
+                @description = args[:description]
+                @subject = args[:subject]
+                @baseURI = args[:baseURI] || self.baseURI
+                @uid = args[:uid]
+                @type = args[:type]
+                #@repository = RDF::Repository.new() unless self.repository
+
+                raise "Every object must have a uid - attempt to create #{@type}" unless @uid
+
+                $g = RDF::Graph.new()
+                if ENV["TRIPLES_FORMAT"]
+                        $format = ENV["TRIPLES_FORMAT"].to_sym
+                else
+                        $format = :jsonld
+                end
+                $writer = get_writer(type: $format)  # set it by default
+
+        end
+
+        def get_writer(type:)
+                $writer = RDF::Writer.for(type).buffer do |w|
+                w.prefix(:foaf, RDF::URI.new("http://xmlns.com/foaf/0.1/"))
+                w.prefix(:dc, RDF::URI.new("http://purl.org/dc/terms/"))
+                w.prefix(:rdf, RDF::URI.new("http://www.w3.org/1999/02/22-rdf-syntax-ns#"))
+                w.prefix(:rdfs, RDF::URI.new("http://www.w3.org/2000/01/rdf-schema#"))
+                w.prefix(:vcard, RDF::URI.new("http://www.w3.org/2006/vcard/ns#"))
+                w.prefix(:odrl, RDF::URI.new("http://www.w3.org/ns/odrl/2/"))
+                w.prefix(:this, RDF::URI.new("http://w3id.org/FAIR_Training_LDP/DAV/home/LDP/DUC-CCE/IPGB#"))
+                w.prefix(:obo, RDF::URI.new("http://purl.obolibrary.org/obo/"))
+                w.prefix(:xsd, RDF::URI.new("http://www.w3.org/2001/XMLSchema#"))
+                end
+                return $writer
+        end
+
+        def triplify(s, p, o, repo)
+        
+                if s.class == String
+                        s = s.strip
+                end
+                if p.class == String
+                        p = p.strip
+                end
+                if o.class == String
+                        o = o.strip
+                end
+                
+                unless s.respond_to?('uri')
+                
+                        if s.to_s =~ /^\w+:\/?\/?[^\s]+/
+                                s = RDF::URI.new(s.to_s)
+                        else
+                                raise "Subject #{s.to_s} must be a URI-compatible thingy #{s}, #{p}, #{o}"
+                        end
+                end
+                
+                unless p.respond_to?('uri')
+        
+                        if p.to_s =~ /^\w+:\/?\/?[^\s]+/
+                                p = RDF::URI.new(p.to_s)
+                        else
+                                raise "Predicate #{p.to_s} must be a URI-compatible thingy #{s}, #{p}, #{o}"
+                        end
+                end        
+                unless o.respond_to?('uri')
+                if o.to_s =~ /^\w+:\/?\/?[^\s]+/
+                        o = RDF::URI.new(o.to_s)
+                elsif o.to_s =~ /^\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d/
+                        o = RDF::Literal.new(o.to_s, :datatype => RDF::XSD.date)
+                elsif o.to_s =~ /^\d\.\d/
+                        o = RDF::Literal.new(o.to_s, :datatype => RDF::XSD.float)
+                elsif o.to_s =~ /^[0-9]+$/
+                        o = RDF::Literal.new(o.to_s, :datatype => RDF::XSD.int)
+                else
+                        o = RDF::Literal.new(o.to_s, :language => :en)
+                end
+                end
+        
+                triple = RDF::Statement(s, p, o) 
+                repo.insert(triple)
+        
+                return true
+        end
+
+        def self.getuuid
+                return  Time.now.to_f.to_s.gsub("\.", "")[1..14]               
+        end
+
+        def load_graph
+                [:title, :creator, :description, :subject, :uid, :type].each do |method|
+                        next unless self.send(method)
+                        next if self.send(method).empty?
+                        subject = self.uid
+                        predicate = PROPERTIES[method]
+                        #warn "prediate #{predicate} for method #{method}"
+                        object = self.send(method)
+                        repo = self.repository
+                        triplify(subject, predicate, object, repo)
+                end
+        end
+
+        def serialize(format: $format)
+                format = format.to_sym
+                return self.repository.dump(format)
+        end
+        
+        private  
+        
+        
+        end
+end

data/lib/odrl/constraint.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module ODRL
+
+    class Constraint < Base
+        
+        attr_accessor :uid, :rightOperand, :leftOperand, :operator, :rightOperandReference, :dataType, :unit, :status
+        def initialize(args)
+            @uid = args[:uid]
+            unless @uid
+                @uid = Base.baseURI + "#constraint_" + Base.getuuid
+            end
+            super(args.merge({uid: @uid}))
+
+            self.type = "http://www.w3.org/ns/odrl/2/Constraint"
+
+            @rightOperand = args[:rightOperand]
+            raise "Constraints must haves a Right operand such as 'event' - I'm dead!" unless @rightOperand
+            @rightOperand = "http://www.w3.org/ns/odrl/2/#{@rightOperand}" unless @rightOperand =~ /https?:\/\//  # if it is already a URI, then let it go
+
+            @leftOperand = args[:leftOperand]
+            raise "Constraints must haves a Left Operand such as 'http://some.event.org/on-now' - I'm dead!" unless @leftOperand
+            @leftOperand = "http://www.w3.org/ns/odrl/2/#{@leftOperand}" unless @leftOperand =~ /https?:\/\//  # if it is already a URI, then let it go
+
+            @operator = args[:operator]
+            raise "Constraints must haves an operator such as 'eq' - I'm dead!" unless @operator
+            @operator = "http://www.w3.org/ns/odrl/2/#{@operator}" unless @operator =~ /https?:\/\//  # if it is already a URI, then let it go
+
+            @rightOperandReference = args[:rightOperandReference]
+            @dataType = args[:dataType]
+            @unit = args[:unit]
+            @status = args[:status]
+        end
+
+        def load_graph
+            super
+            # TODO  This is bad DRY!!  Put the bulk of this method into the base object
+            if self.rightOperand
+                predicate = PRIGHT
+                object = self.rightOperand
+                subject = self.uid
+                repo = self.repository
+                triplify(subject, predicate, object, repo)
+            end
+            if self.leftOperand
+                predicate = PLEFT
+                object = self.leftOperand
+                subject = self.uid
+                repo = self.repository
+                triplify(subject, predicate, object, repo)
+            end
+            if self.operator
+                predicate = POPERATOR
+                object = self.operator
+                subject = self.uid
+                repo = self.repository
+                triplify(subject, predicate, object, repo)
+            end
+            if self.rightOperandReference
+                predicate = POPERANDREFERENCE
+                object = self.rightOperandReference
+                subject = self.uid
+                repo = self.repository
+                triplify(subject, predicate, object, repo)
+            end
+            if self.dataType
+                predicate = PDATATYPE
+                object = self.dataType
+                subject = self.uid
+                repo = self.repository
+                triplify(subject, predicate, object, repo)
+            end
+            if self.unit
+                predicate = PUNIT
+                object = self.unit
+                subject = self.uid
+                repo = self.repository
+                triplify(subject, predicate, object, repo)
+            end
+            if self.status
+                predicate = PSTATUS
+                object = self.status
+                subject = self.uid
+                repo = self.repository
+                triplify(subject, predicate, object, repo)
+            end
+        end
+
+        def serialize(format:)
+            super
+        end
+
+    end
+
+end

data/lib/odrl/odrl/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ODRL
+  module ODRL
+    VERSION = "0.1.0"
+  end
+end

data/lib/odrl/party.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module ODRL
+
+    class Party < Base
+        attr_accessor :uid, :refinements, :partOf, :predicate, :type
+        def initialize(args)
+            @uid = args[:uid]
+            unless @uid
+                @uid = Base.baseURI + "#party_" + Base.getuuid
+            end
+            super(args.merge({uid: @uid}))
+            self.type="http://www.w3.org/ns/odrl/2/Party"
+
+
+            @refinements = Hash.new
+            @partOf = args[:partOf]
+            @predicate = args[:predicate]
+            @type = CPARTY
+
+            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
+
+
+
+            args[:refinements] = [args[:refinements]] unless args[:refinements].is_a? Array
+            if !(args[:refinements].first.nil?)
+                args[: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
+
+        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
+        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
+
+        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
+
+        def serialize(format:)
+            super
+        end
+
+    end
+    class PartyCollection < Party
+
+        def initialize(args)
+            super(args)
+            self.type = "http://www.w3.org/ns/odrl/2/PartyCollection"
+        end
+    end
+
+
+end

data/lib/odrl/policy.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "odrl/version"
+
+module ODRL
+    class Error < StandardError; end
+
+
+    class Policy  < Base
+        attr_accessor :rules
+
+        def initialize(args)
+            @uid = args[:uid]
+            unless @uid
+                self.uid = Base.baseURI + "#policy_" + Base.getuuid
+            end
+            super(args.merge({uid: @uid}))
+            
+            @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
+    end
+
+    class Set  < Policy
+        def initialize(args)
+            super({type: CSET}.merge(args))
+        end
+    end
+
+    class Offer  < Set
+        def initialize(args)
+            super({type: COFFER}.merge(args))
+        end
+    end
+    class Agreement  < Set
+        def initialize(args)
+            super({type: CAGREEMENT}.merge(args))
+        end
+    end
+    class Request  < Set
+        def initialize(args)
+            super({type: CREQUEST}.merge(args))
+        end
+    end
+# ====================================================
+
+
+end

data/lib/odrl/ruby.rb

@@ -0,0 +1,27 @@
+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/")
+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"
+
+module ODRL
+end

data/lib/odrl/rule.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require_relative "odrl/version"
+# require "ODRL::Asset"
+# require "ODRL::Constraint"
+
+module ODRL
+    class Rule < Base
+        attr_accessor :uid, :constraints, :assets, :predicate, :type, :action, :assigner, :assignee
+        def initialize(args)
+            @uid = args[:uid]
+
+            unless @uid
+                @uid = Base.baseURI + "#rule_" + Base.getuuid
+            end
+            super(args.merge({uid: @uid}))
+            
+            @constraints = Hash.new
+            @assets = Hash.new
+            @assigner = Hash.new
+            @assignee = Hash.new
+            @action = Hash.new
+
+            args[:assets] = [args[:assets]] unless args[:assets].is_a? Array
+            if !(args[:assets].first.nil?)
+                args[:assets].each do |c|
+                    self.addAsset(asset: c)
+                end
+            end
+            args[:constraints] = [args[:constraints]] unless args[:constraints].is_a? Array
+            if !(args[:constraints].first.nil?)
+                args[:constraints].each do |c|
+                    self.addConstraint(constraint:  c)
+                end
+            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 addConstraint(constraint:)
+            unless constraint.is_a?(Constraint)
+                raise "Constraint is not an ODRL Constraint" 
+            else
+                self.constraints[constraint.uid] = [PCONSTRAINT, constraint] 
+            end
+        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 addAssigner(party:)
+            unless party.is_a?(Party)
+                raise "Assigner is not an ODRL Party" 
+            else
+                self.assigner[party.uid] = [PASSIGNER, party] 
+            end
+        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 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
+
+        def serialize(format:)
+            super
+        end
+    end
+
+
+    class Permission  < Rule
+        def initialize(args)
+            super(args)
+            self.predicate = PPERMISSION
+            self.type = CPERMISSION
+
+
+        end
+    end
+
+    class Duty  < Rule
+        def initialize(args)
+            super(args)
+            self.predicate = PDUTY
+            self.type = CDUTY
+
+
+        end
+    end
+
+    class Prohibition < Rule
+        def initialize(args)
+            super(args)
+            self.predicate = PPROHIBITION
+            self.type = CPROHIBITION
+
+
+        end
+    end
+
+end

data/testme.rb

@@ -0,0 +1,28 @@
+require_relative "./lib/odrl/policy.rb"
+require_relative "./lib/odrl/rule.rb"
+require_relative "./lib/odrl/base.rb"
+require_relative "./lib/odrl/asset.rb"
+require_relative "./lib/odrl/constraint.rb"
+
+
+t = ODRL::Policy.new(
+    title: "this",
+    author: "mark",
+    baseURI: "http://adsjfhalsdjfasdh",
+
+)
+
+pro = ODRL::Prohibition.new({})
+# puts t.methods
+# abort
+# t.addProhibition(rule: pro)
+# puts t.rules.length
+# puts t.rules[t.rules.keys.first][1].inspect
+# puts t.rules[t.rules.keys.first][1].class.to_s == "ODRL::Prohibition"
+
+#p t.inspect
+c1 = ODRL::Constraint.new({})
+#p c1.inspect
+c2 = ODRL::Constraint.new({})
+d = ODRL::Duty.new({constraints: c1})
+puts d.inspect

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: odrl-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mark Wilkinson
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2023-06-27 00:00:00.000000000 Z
+dependencies: []
+description: builds ODRL files nicely.
+email:
+- markw@illuminae.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/create-biohackathon-offer.rb
+- launch.json
+- lib/odrl/action.rb
+- lib/odrl/asset.rb
+- lib/odrl/base.rb
+- lib/odrl/constraint.rb
+- lib/odrl/odrl/version.rb
+- lib/odrl/party.rb
+- lib/odrl/policy.rb
+- lib/odrl/ruby.rb
+- lib/odrl/rule.rb
+- testme.rb
+homepage: https://example.org
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  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
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.23
+signing_key: 
+specification_version: 4
+summary: builds ODRL files.
+test_files: []