case_model 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7975b117f28b3b97b7280d00cfa2ed0ed2ed5f88
+  data.tar.gz: e6afbc109997f137b98fa31d54041a1f51bd0b97
+SHA512:
+  metadata.gz: db40192af1d3e44978dce73891cca821f5a00cff05b1d6b42a029afb2e3c4d7728f14920ca68f767e1111742faa99826ff7100a6b7fbbc171f4c785a636bde61
+  data.tar.gz: 04bbf2ca4ba64e812318d6b1b20a79210baf416ce8d3872d27eb8107af0f6e72498274dc40af6d46e6cace603901ad22a792eb38ea85bdc5802383579e82bc71

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - "2.1.1"
+  - rbx

data/Gemfile

@@ -0,0 +1,11 @@
+source "https://rubygems.org"
+
+# gem "rubidium", path: "~/Dropbox/PhD/project/code/rubidium"
+# gem "rubidium-dir", path: "~/Dropbox/PhD/project/code/rubidium-dir"
+
+gem 'rdf-n3', '1.99.0'
+gem 'rdf-vocab', '0.8.7.1'
+gem 'webmock', '1.22.3'
+gem 'rest-client', '1.8.0'
+gem 'rake', '10.5.0'
+gem 'rspec', '3.4.0'

data/Gemfile.lock

@@ -0,0 +1,61 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.4.0)
+    crack (0.4.3)
+      safe_yaml (~> 1.0.0)
+    diff-lcs (1.2.5)
+    domain_name (0.5.25)
+      unf (>= 0.0.5, < 1.0.0)
+    hashdiff (0.2.3)
+    http-cookie (1.0.2)
+      domain_name (~> 0.5)
+    link_header (0.0.8)
+    mime-types (2.99)
+    netrc (0.11.0)
+    rake (10.5.0)
+    rdf (1.99.1)
+      link_header (~> 0.0, >= 0.0.8)
+    rdf-n3 (1.99.0)
+      rdf (~> 1.99)
+    rdf-vocab (0.8.7.1)
+      rdf (~> 1.1, >= 1.1.10)
+    rest-client (1.8.0)
+      http-cookie (>= 1.0.2, < 2.0)
+      mime-types (>= 1.16, < 3.0)
+      netrc (~> 0.7)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.1)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    safe_yaml (1.0.4)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.7.1)
+    webmock (1.22.3)
+      addressable (>= 2.3.6)
+      crack (>= 0.3.2)
+      hashdiff
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake (= 10.5.0)
+  rdf-n3 (= 1.99.0)
+  rdf-vocab (= 0.8.7.1)
+  rest-client (= 1.8.0)
+  rspec (= 3.4.0)
+  webmock (= 1.22.3)
+
+BUNDLED WITH
+   1.11.2

data/README.md

@@ -0,0 +1,27 @@
+CASE (Context-aware Software Ecosystem)
+=======================================
+
+Evaluation of application models
+--------------------------------
+
+Supplementary evaluation for the paper **Semantic Model of Variability and Capabilities of IoT Applications for Embedded Software Ecosystems**.
+
+# Browsing the sample scenarios
+
+To investigate the tested application models and scenarios, see the folder
+[spec/use_cases](spec/use_cases).
+
+# Installation
+
+1. Install the Eye reasoner
+    - ([Windows](http://eulersharp.sourceforge.net/README.Windows), [OS X](http://eulersharp.sourceforge.net/README.MacOSX), [Linux](http://eulersharp.sourceforge.net/README.Linux))
+    - requires the SWI Prolog
+        - `brew tap homebrew/x11`
+        - `brew install swi-prolog`
+2. Install [Ruby](https://www.ruby-lang.org/en/) version 2.x.x
+3. Run in inside a folder for this repository: `gem install bundler`
+4. Run in inside a folder for this repository: `bundle install`
+
+# Running the specs
+
+To run the tests, simply execute `rspec` in the folder of this repository.

data/Rakefile

@@ -0,0 +1,9 @@
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec)
+
+  task :default => :spec
+rescue LoadError
+  # no rspec available
+end

data/case_model.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name        = 'case_model'
+  s.version     = '0.0.1'
+  s.date        = '2016-01-28'
+  s.summary     = 'Resolver for the CASE ecosystem application models'
+  s.description = 'Built for the Context-Aware Software Ecosystem. Resolves application model requirements using semantic reasoning.'
+  s.authors     = ['Matus Tomlein']
+  s.email       = 'matus@cs.au.dk'
+
+  s.files         = `git ls-files -z`.split("\x0")
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+
+  s.homepage    = 'https://github.com/case-iot/app_model'
+  s.license     = 'MIT'
+end

data/lib/case_model.rb

@@ -0,0 +1,3 @@
+Dir[File.join(File.dirname(__FILE__), "**/*.rb")].each do |f|
+  require f
+end

data/lib/descriptions/states.n3

@@ -0,0 +1,47 @@
+@prefix e: <http://eulersharp.sourceforge.net/2003/03swap/log-rules#>.
+@prefix st: <http://purl.org/restdesc/states#>.
+@prefix log: <http://www.w3.org/2000/10/swap/log#>.
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>.
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>.
+@prefix owl: <http://www.w3.org/2002/07/owl#>.
+
+st:State a rdfs:Class;
+         rdfs:label "A consistent state of (parts of) the world at a certain point in time."@en.
+
+st:StateChange a rdfs:Class;
+               rdfs:label "A transition from one state to another."@en.
+
+st:added a rdf:Property, owl:FunctionalProperty;
+         rdfs:label "added triples"@en;
+         rdfs:domain st:StateChange;
+         rdfs:range log:Formula.
+
+st:removed a rdf:Property, owl:FunctionalProperty;
+           rdfs:label "removed triples"@en;
+           rdfs:domain st:StateChange;
+           rdfs:range log:Formula.
+
+st:parent a rdf:Property, owl:FunctionalProperty;
+          rdfs:label "is based upon"@en;
+          rdfs:domain st:StateChange;
+          rdfs:range st:State.
+
+st:derivedFrom a rdf:Property, owl:FunctionalProperty;
+               rdfs:label "is derived from"@en;
+               rdfs:domain st:State;
+               rdfs:range st:StateChange.
+
+# Derive the complete state from a state change
+{
+  ?change st:added ?added;
+          st:removed ?removed;
+          st:parent ?parent.
+
+  (?parent ?removed) e:graphDifference ?inherited.
+  (?inherited ?added) log:conjunction ?newState.
+}
+=>
+{
+  ?newState a st:State;
+            st:derivedFrom ?change.
+}.

data/lib/models/action.rb

@@ -0,0 +1,48 @@
+require_relative '../services/question_references'
+
+class Action
+  attr_reader :query
+
+  include QuestionReferences
+
+  def initialize(node, repository)
+    @query = NodeQuery.new(node, repository)
+  end
+
+  def description
+    query.value(LV.description)
+  end
+
+  def requirements
+    list = RDF::List.new(query.value(LV.requirement), query.repository)
+    list.map { |node| Requirement.new(node, query.repository) }
+  end
+
+  def failed_requirements
+    requirements.select {|r| not r.satisfied? }
+  end
+
+  def compatible?
+    not failed_requirements.any?
+  end
+
+  def questions
+    q = []
+    q << question if has_question?
+
+    with_question = requirements.select { |r| r.has_question? }
+    q + with_question.map { |r| r.question }
+  end
+
+  def open_questions
+    questions.select { |q| not q.has_answer? }
+  end
+
+  def execution
+    ActionExecution.new(query.value(LV.executes), query.repository)
+  end
+
+  def effect
+    StateChange.new(query.value(LV.effect), query.repository)
+  end
+end

data/lib/models/answer.rb

@@ -0,0 +1,25 @@
+module Answer
+  def self.create(reply_type, node, repository)
+    case reply_type
+    when :location
+      Location.new(node, repository)
+    when :temperature
+      Temperature.new(node, repository)
+    when :select
+      Selection.new(node, repository)
+    else
+      nil
+    end
+  end
+
+  def reply_type
+    question.reply_type
+  end
+
+  def question
+    node = query.value(QV.answers)
+    return nil if node.nil?
+
+    Question.new(node, query.repository)
+  end
+end

data/lib/models/application.rb

@@ -0,0 +1,57 @@
+class Application
+  attr_reader :query
+
+  def initialize(node, repository)
+    @query = NodeQuery.new(node, repository)
+  end
+
+  def name
+    if query.value_exists?(RDF::Vocab::FOAF.name)
+      query.value(RDF::Vocab::FOAF.name)
+    else
+      query.value(LV.name)
+    end
+  end
+
+  def description
+    query.value(LV.description)
+  end
+
+  def questions
+    list = repo.query([nil, RDF.type, QV.Question]).map { |s| s.subject }
+    list.map { |node| Question.new(node, repo) }
+  end
+
+  def open_questions
+    questions.select { |q| not q.has_answer? }
+  end
+
+  def question_with_text(text)
+    questions.find { |q| q.text == text }
+  end
+
+  def requirements
+    list = repo.query([nil, RDF.type, QV.Requirement]).map { |s| s.subject }
+    list.map { |node| Requirement.new(node, repo) }
+  end
+
+  def requirement_with_description(description)
+    requirements.find { |r| r.description == description }
+  end
+
+  def deployment_plans
+    query.values(LV.hasDeploymentPlan).map do |node|
+      DeploymentPlan.new(node, repo)
+    end
+  end
+
+  def deployment_plan_with_description(description)
+    deployment_plans.find { |a| a.description == description }
+  end
+
+  private
+
+  def repo
+    query.repository
+  end
+end

data/lib/models/capability.rb

@@ -0,0 +1,23 @@
+class Capability
+  attr_reader :query
+
+  def initialize(node, repository)
+    @query = NodeQuery.new(node, repository)
+  end
+
+  def description
+    query.value(LV.description)
+  end
+
+  def actuators
+    query.values(LV.actuator).map do |node|
+      Device.new node, query.repository
+    end
+  end
+
+  def sensors
+    query.values(LV.sensor).map do |node|
+      Device.new node, query.repository
+    end
+  end
+end

data/lib/models/deployment_plan.rb

@@ -0,0 +1,44 @@
+require_relative '../services/question_references'
+
+class DeploymentPlan
+  attr_reader :query
+
+  include QuestionReferences
+
+  def initialize(node, repository)
+    @query = NodeQuery.new(node, repository)
+  end
+
+  def description
+    query.value(LV.description)
+  end
+
+  def host
+    nil unless query.value_exists?(LV.host)
+    EcosystemHost.new(query.value(LV.host), query.repository)
+  end
+
+  def arguments
+    node = query.value(LV.arguments)
+    arg_query = NodeQuery.new(node, query.repository)
+
+    if arg_query.value_exists?(RDFV.first)
+      RDF::List.new(node, query.repository)
+    else
+      arg_query.predicates_and_objects
+    end
+  end
+
+  def deployment_plans
+    query.values(LV.hasDeploymentPlan).map do |node|
+      DeploymentPlan.new(node, query.repository)
+    end
+  end
+
+  def capabilities
+    list = RDF::List.new(query.value(LV.capabilities), query.repository)
+    list.map do |node|
+      Capability.new(node, query.repository)
+    end
+  end
+end

data/lib/models/device.rb

@@ -0,0 +1,26 @@
+class Device
+  attr_reader :query
+
+  def initialize(node, repository)
+    @query = NodeQuery.new(node, repository)
+  end
+
+  def manufacturer_name
+    query.value(LV.manufacturerName)
+  end
+
+  def description
+    query.value(LV.description)
+  end
+
+  def location
+    node = query.value(LV.locatedAt)
+    return nil if node.nil?
+
+    Location.new(node, query.repository)
+  end
+
+  def node
+    query.node
+  end
+end

data/lib/models/ecosystem_host.rb

@@ -0,0 +1,5 @@
+class EcosystemHost < Device
+  def initialize(node, repository)
+    super(node, repository)
+  end
+end

data/lib/models/http_request.rb

@@ -0,0 +1,27 @@
+require 'rest-client'
+
+class HttpRequest
+  attr_reader :query
+
+  def initialize(node, repository)
+    @query = NodeQuery.new(node, repository)
+  end
+
+  def uri
+    query.value(HttpVocabulary.request_uri)
+  end
+
+  def body
+    query.value(HttpVocabulary.body)
+  end
+
+  def method_name
+    query.value(HttpVocabulary.method_name)
+  end
+
+  def execute
+    raise "Unsupported method #{method_name}" unless method_name == 'POST'
+    RestClient.post(uri.to_s, body.to_s)
+    true
+  end
+end

data/lib/models/location.rb

@@ -0,0 +1,17 @@
+class Location
+  attr_reader :query
+
+  include Answer
+
+  def initialize(node, repository)
+    @query = NodeQuery.new(node, repository)
+  end
+
+  def name
+    query.value(LV.locationName)
+  end
+
+  def name=(value)
+    query.set_value(LV.locationName, value)
+  end
+end

data/lib/models/ontology.rb

@@ -0,0 +1,52 @@
+require 'rdf'
+require 'rdf/vocab'
+
+require_relative '../services/repository_proxy'
+
+class Ontology
+  attr_reader :repository
+
+  include RepositoryProxy
+
+  def self.from_n3(n3_input)
+    Ontology.new(RDF::Repository.new, n3_input)
+  end
+
+  def initialize(repository, n3_input = nil)
+    @repository = repository
+    load_and_process_n3 n3_input if n3_input
+    # initialize_state
+  end
+
+  def load_and_process_n3(n3_input)
+    (@n3_inputs ||= []) << n3_input
+    refresh
+  end
+
+  def applications
+    query([nil, RDF.type, LV.Application]).map do |statement|
+      Application.new(statement.subject, self)
+    end
+  end
+
+  def devices
+    query([nil, RDF.type, LV.Device]).map do |statement|
+      Device.new(statement.subject, self)
+    end
+  end
+
+  def device_with_description(description)
+    devices.find { |d| d.description == description }
+  end
+
+  def refresh
+    @n3_inputs.each { |input| Reasoner.new(self).load_and_process_n3(input) }
+  end
+
+  private
+
+  ## load an empty State formula in case there are some StateChange statements
+  def initialize_state
+    load_and_process_n3 '{ <http://example.com/x> <http://example.com/y> <http://example.com/z>.} a <http://purl.org/restdesc/states#State>.'
+  end
+end

data/lib/models/question.rb

@@ -0,0 +1,51 @@
+class Question
+  attr_reader :query
+
+  def initialize(node, repository)
+    @query = NodeQuery.new(node, repository)
+  end
+
+  def text
+    query.value(QV.text).to_s
+  end
+
+  def reply_type
+    QuestionReplyType.to_sym(query)
+  end
+
+  def has_answer?
+    query.value_exists?(QV.has_answer)
+  end
+
+  # returns an existing one or nil if there is no
+  def answer
+    node = query.value(QV.has_answer)
+    return nil if node.nil?
+
+    Answer.create(reply_type, node, query.repository)
+  end
+
+  # creates a new answer or returns an existing one
+  def answer!
+    answer || create_answer
+  end
+
+  private
+
+  def repository; query.repository; end
+
+  def create_answer
+    node = generate_answer_node
+    repository << [ node, RDF.type, QV.answer_type ]
+    answer_query = NodeQuery.new(node, repository)
+    answer_query.set_value(QV.answers, query.node)
+    query.set_value(QV.has_answer, node)
+
+    answer
+  end
+
+  def generate_answer_node
+    question_uri_hash = query.node.to_s.hash.to_s
+    ('answer' + question_uri_hash).to_sym
+  end
+end

data/lib/models/question_reply_type.rb

@@ -0,0 +1,14 @@
+class QuestionReplyType
+  def self.to_sym(query)
+    case query.value(QV.replyType)
+    when QV.Location
+      :location
+    when QV.Temperature
+      :temperature
+    when QV.Select
+      :select
+    else
+      nil
+    end
+  end
+end

data/lib/models/requirement.rb

@@ -0,0 +1,17 @@
+require_relative '../services/question_references'
+
+class Requirement
+  attr_reader :query
+
+  def initialize(node, repository)
+    @query = NodeQuery.new(node, repository)
+  end
+
+  def description
+    query.value(LV.description)
+  end
+
+  def satisfied?
+    query.value(LV.satisfied) == true
+  end
+end

data/lib/models/selection.rb

@@ -0,0 +1,32 @@
+class Selection
+  attr_reader :query
+
+  include Answer
+
+  def initialize(node, repository)
+    @query = NodeQuery.new(node, repository)
+  end
+
+  def options
+    if question.query.value_exists?(QV.options)
+      RDF::List.new(question.query.value(QV.options), query.repository)
+    elsif question.query.value_exists?(QV.option)
+      question.query.values(QV.option)
+    else
+      nil
+    end
+  end
+
+  def selected
+    query.value(LV.selected)
+  end
+
+  def selected=(value)
+    # in case it is an array, store all the answers
+    if value.is_a? Array
+      value.each { |v| query.set_value(LV.selected, v, false) }
+    else
+      query.set_value(LV.selected, value)
+    end
+  end
+end

data/lib/models/state_change.rb

@@ -0,0 +1,19 @@
+class StateChange
+  attr_reader :query
+
+  def initialize(node, repository)
+    @query = NodeQuery.new(node, repository)
+  end
+
+  def apply
+    new_repo = query.repository.clone
+    new_repo.load_and_process_n3(state_rules)
+    new_repo
+  end
+
+  private
+
+  def state_rules
+    File.read(File.dirname(__FILE__) + '/../descriptions/states.n3')
+  end
+end

data/lib/models/temperature.rb

@@ -0,0 +1,17 @@
+class Temperature
+  attr_reader :query
+
+  include Answer
+
+  def initialize(node, repository)
+    @query = NodeQuery.new(node, repository)
+  end
+
+  def in_celsius
+    query.value(LV.in_celsius)
+  end
+
+  def in_celsius=(value)
+    query.set_value(LV.in_celsius, value)
+  end
+end