case_model 0.0.1

data/lib/ontology/http_vocabulary.rb

@@ -0,0 +1,17 @@
+class HttpVocabulary
+  def self.method_missing(name, *arguments, &block)
+    uri_for(name)
+  end
+
+  def self.method_name
+    uri_for('methodName')
+  end
+
+  def self.request_uri
+    uri_for('requestURI')
+  end
+
+  def self.uri_for(name)
+    RDF::URI("http://www.w3.org/2011/http##{name}")
+  end
+end

data/lib/ontology/local_vocabulary.rb

@@ -0,0 +1,26 @@
+require 'rdf'
+
+class LocalVocabulary
+  def self.method_missing(name, *arguments, &block)
+    uri_for(name)
+  end
+
+  def self.name
+    uri_for('name')
+  end
+
+  def self.question_type
+    uri_for('question')
+  end
+
+  def self.answer_type
+    uri_for('answer')
+  end
+
+  def self.uri_for(name)
+    RDF::URI("http://matus.tomlein.org/case/#{name}")
+  end
+end
+
+LV = LocalVocabulary
+QV = LocalVocabulary

data/lib/ontology/math_vocabulary.rb

@@ -0,0 +1,15 @@
+class MathVocabulary
+  def self.method_missing(name, *arguments, &block)
+    uri_for(name)
+  end
+
+  def self.less_than
+    uri_for('lessThan')
+  end
+
+  def self.uri_for(name)
+    RDF::URI("http://www.w3.org/2000/10/swap/math##{name}")
+  end
+end
+
+MV = MathVocabulary

data/lib/ontology/rdf_vocabulary.rb

@@ -0,0 +1,11 @@
+class RDFVocabulary
+  def self.method_missing(name, *arguments, &block)
+    uri_for(name)
+  end
+
+  def self.uri_for(name)
+    RDF::URI("http://www.w3.org/1999/02/22-rdf-syntax-ns##{name}")
+  end
+end
+
+RDFV = RDFVocabulary

data/lib/ontology/state_vocabulary.rb

@@ -0,0 +1,9 @@
+class StateVocabulary
+  def self.method_missing(name, *arguments, &block)
+    uri_for(name)
+  end
+
+  def self.uri_for(name)
+    RDF::URI("http://matus.tomlein.org/case/#{name}")
+  end
+end

data/lib/services/application_by_capability_finder.rb

@@ -0,0 +1,37 @@
+class ApplicationByCapabilityFinder
+  def initialize(ontology)
+    @ontology = ontology
+  end
+
+  def find(options)
+    solutions = RDF::Query.execute(@ontology, {
+      application: {
+        LV.hasDeploymentPlan => {
+          LV.capability => options
+        }
+      }
+    })
+
+    solutions.map do |solution|
+      solution[:application]
+    end.uniq.map do |node|
+      Application.new(node, @ontology)
+    end
+  end
+
+  def find_by_type(type)
+    find({ RDF.type => type })
+  end
+
+  def find_by_description(description)
+    find({ LV.description => description })
+  end
+
+  def find_by_actuator(actuator)
+    find({ LV.actuator => actuator })
+  end
+
+  def find_by_sensor(sensor)
+    find({ LV.sensor => sensor })
+  end
+end

data/lib/services/eye_serializer.rb

@@ -0,0 +1,19 @@
+class EyeSerializer
+  def self.serialize_implication(facts, precondition, postcondition)
+    pre = serialize_graph(precondition)
+    post = serialize_graph(postcondition)
+    "#{facts.dump(:ntriples)}{#{pre}} => {#{post}}.\n"
+  end
+
+  def self.serialize_graph(graph)
+    statements = []
+    graph.each_statement do |statement|
+      statements << RDF::Statement.new({
+        subject: statement.subject,
+        predicate: statement.predicate,
+        object: statement.object
+      }).to_s + "\n"
+    end
+    statements.join
+  end
+end

data/lib/services/node_builder.rb

@@ -0,0 +1,34 @@
+require 'securerandom'
+
+class NodeBuilder
+  def self.create(properties, repository)
+    node = generate_node
+    query = NodeQuery.new node, repository
+
+    properties.each do |key, v|
+      values = if v.is_a?(Array)
+                 v
+               else
+                 [ v ]
+               end
+
+      values.each do |value|
+        query.set_value(key,
+          if value.is_a?(Hash)
+            create(value, repository)
+          else
+            value
+          end, false)
+      end
+    end
+
+    node
+  end
+
+  private
+
+  def self.generate_node
+    id = SecureRandom.hex
+    RDF::URI("http://example.org/#{id}")
+  end
+end

data/lib/services/node_query.rb

@@ -0,0 +1,55 @@
+class NodeQuery
+  attr_reader :node, :repository
+
+  def initialize(node, repository)
+    @node = node
+    @repository = repository
+  end
+
+  def value(predicate)
+    values(predicate).first
+  end
+
+  def values(predicate)
+    results = repository.query([ node, predicate, nil ])
+    results.map {|s| s.object }
+  end
+
+  def value_exists?(predicate)
+    values(predicate).any?
+  end
+
+  def set_value(predicate, object, replace = true)
+    delete_value(predicate) if replace
+    @repository << [ node, predicate, object ]
+  end
+
+  def predicates_and_objects
+    values = {}
+    repository.query([ node, nil, nil ]).each do |s|
+      if values.has_key? s.predicate
+        if values[s.predicate].is_a? Array
+          values[s.predicate] << s.object
+        else
+          values[s.predicate] = [
+            values[s.predicate], s.object
+          ]
+        end
+      else
+        values[s.predicate] = s.object
+      end
+    end
+    values
+  end
+
+  private
+
+  def delete_value(predicate)
+    # makes sure not to delete any values in subgraphs
+    repository.query([ node, predicate, nil ]).select do |s|
+      s.graph_name.nil?
+    end.each do |s|
+      repository.delete(s)
+    end
+  end
+end

data/lib/services/question_references.rb

@@ -0,0 +1,19 @@
+module QuestionReferences
+  def has_question?
+    query.value_exists?(LV.requires_answering)
+  end
+
+  def has_condition?
+    query.value_exists?(LV.condition)
+  end
+
+  def question
+    node = query.value(LV.requires_answering)
+    return nil if node.nil?
+    Question.new(node, query.repository)
+  end
+
+  def question_answered?
+    question.has_answer?
+  end
+end

data/lib/services/reasoner.rb

@@ -0,0 +1,77 @@
+require 'rdf/n3'
+require 'tempfile'
+
+class Reasoner
+  attr_reader :repository
+
+  def initialize(repository)
+    @repository = repository
+  end
+
+  # implication doesn't work well when a blank node is used in the
+  # condition, e.g.:
+  # {?device1 <http://...#type> _:vehicle .} => {...}
+  # will always result in the postcondition, because of _:vehicle
+  def imply(precondition, postcondition)
+    eye_input = EyeSerializer.serialize_implication(
+      repository.facts_only,
+      repository.graph(precondition),
+      repository.graph(postcondition)
+    )
+
+    eye_output = run_eye eye_input
+    parse_eye_output eye_output
+  end
+
+  # makes sure that the graph with name condition is valid
+  # to do that, it creates a temporary graph (:helper_graph) and tries to imply
+  # condition => helper_graph
+  # it creates a new temp_reasoner object so as not to modify the current repository
+  # with the helper_graph
+  def check_condition(condition)
+    temp_repository = @repository.clone
+    temp_repository << [ LV.condition, LV.was, LV.true, :helper_graph ]
+
+    temp_reasoner = Reasoner.new temp_repository
+    result = temp_reasoner.imply(condition, :helper_graph)
+
+    result.query([ LV.condition, LV.was, LV.true ]).any?
+  end
+
+  def load_and_process_n3(n3_input)
+    input = [
+      n3_input,
+      EyeSerializer.serialize_graph(repository.facts_only)
+    ].join
+
+    eye_output = run_eye input
+    parse_eye_output eye_output, @repository
+    @repository
+  end
+
+  private
+
+  def run_eye(input)
+    data = Tempfile.new('data')
+    data.write(input)
+    data.close
+    output = `eye --nope --pass #{data.path} 2> /dev/null`
+    data.unlink
+
+    output
+  end
+
+  def parse_eye_output(output, repo = nil)
+    output = remove_incompatible_prefix_from_eye_output output
+    repo = RDF::Repository.new if repo.nil?
+    reader = RDF::Reader.for(:n3).new(output)
+    reader.each_statement { |statement| repo << statement }
+    repo
+  end
+
+  def remove_incompatible_prefix_from_eye_output(output)
+    output.gsub(/PREFIX .+\n/) do |match|
+      match.sub('PREFIX ', '@prefix ') + '.'
+    end
+  end
+end

data/lib/services/repository_proxy.rb

@@ -0,0 +1,26 @@
+module RepositoryProxy
+  def graph(name)
+    graph_name = if name.is_a? Symbol; "_:#{name.to_s}"; else; name.to_s; end
+    g = RDF::Graph.new
+    repository.statements.each do |statement|
+      next if statement.graph_name.nil?
+      next unless statement.graph_name.to_s.include? graph_name
+
+      g << [ statement.subject, statement.predicate, statement.object ]
+    end
+    g
+  end
+
+  def facts_only
+    RDF::Graph.new do |g|
+      repository.statements.each do |statement|
+        g << statement if statement.graph_name.nil?
+      end
+    end
+  end
+
+  # proxy everything to the repository
+  def method_missing(method, *args, &block)
+    repository.send(method, *args, &block)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require_relative '../lib/case_model'
+require 'webmock/rspec'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/unit/models/answer_spec.rb

@@ -0,0 +1,43 @@
+require_relative '../spec_helper'
+
+describe Answer do
+  let(:repo) do
+    RDF::Repository.new do |r|
+      # DEVICE
+      r << [:dev, RDF.type, LV.Device]
+      r << [:dev, LV.manufacturerName, 'Grundfos']
+      r << [:dev, LV.locatedAt, :device_location]
+      # QUESTION
+      r << [:device_location, RDF.type, QV.question_type]
+      r << [:device_location, QV.replyType, QV.Location]
+      r << [:device_location, QV.location_of, :dev]
+      r << [:device_location, QV.text, 'Where is the thing?']
+      # ANSWER
+      r << [:device_location, QV.has_answer, :answer]
+      r << [:answer, RDF.type, QV.answer_type]
+      r << [:answer, QV.answers, :device_location]
+      r << [:answer, RDF.type, QV.Location]
+      r << [:answer, LV.locationName, 'Living Room']
+    end
+  end
+
+  let(:ontology) { Ontology.new(repo) }
+  let(:question) { Question.new(:device_location, ontology) }
+  let(:answer) { question.answer }
+
+  context '#question.text' do
+    subject { answer.question.text }
+    it { is_expected.not_to eq(nil) }
+    it { is_expected.to eq('Where is the thing?') }
+  end
+
+  context '#reply_type' do
+    subject { answer.reply_type }
+    it { is_expected.to eq(:location) }
+  end
+
+  describe 'should have type Location' do
+    subject { answer }
+    it { is_expected.to be_kind_of Location }
+  end
+end

data/spec/unit/models/application_spec.rb

@@ -0,0 +1,43 @@
+require_relative '../spec_helper'
+
+def create_repo
+  RDF::Repository.new do |r|
+    r << [:a, RDF.type, LV.Application]
+    r << [:a, RDF::Vocab::FOAF.name, 'Some App']
+    r << [:a, LV.description, 'Description of the app.']
+
+    r << [:a, LV.hasDeploymentPlan, :deployment_plan1]
+    r << [:a, LV.hasDeploymentPlan, :deployment_plan2]
+    r << [:deployment_plan1, LV.description, 'This needs to be so and so.']
+    r << [:deployment_plan2, LV.description, 'This needs to be so and so.']
+  end
+end
+
+describe Application do
+  let(:repo) { create_repo }
+  let(:ontology) { Ontology.new(repo) }
+  let(:app) { Application.new(:a, repo) }
+
+  context '#name' do
+    subject { app.name }
+    it { is_expected.to eq('Some App') }
+  end
+
+  context '#description' do
+    subject { app.description }
+    it { is_expected.to eq('Description of the app.') }
+  end
+
+  context '#deployment_plans' do
+    subject { app.deployment_plans.size }
+    it { is_expected.to eq 2 }
+
+    describe 'should not have doubles' do
+      before do
+        repo << [ :a, LV.hasDeploymentPlan, :deployment_plan2 ]
+      end
+
+      it { is_expected.to eq 2 }
+    end
+  end
+end

data/spec/unit/models/deployment_plan_spec.rb

@@ -0,0 +1,28 @@
+require_relative '../spec_helper'
+
+describe DeploymentPlan do
+  let(:repo) { RDF::Repository.new }
+  let(:ontology) { Ontology.new(repo) }
+  let(:deployment_plan) { DeploymentPlan.new(:a, repo) }
+
+  before do
+    repo << [:deployment_plan, LV.description, 'Install the app']
+  end
+
+  context '#description' do
+    subject { deployment_plan.description }
+    it { is_expected.to eq('Install the app') }
+  end
+
+  context '#arguments' do
+    before do
+      arguments = RDF::List[ 'arg1', 'arg2' ]
+      repo << arguments
+      repo << [ :deployment_plan, LV.arguments, arguments ]
+    end
+    let(:arguments) { deployment_plan.arguments }
+
+    subject { arguments.to_a }
+    it { is_expected.to eq [ 'arg1', 'arg2' ] }
+  end
+end

data/spec/unit/models/http_request_spec.rb

@@ -0,0 +1,42 @@
+require_relative '../spec_helper'
+
+describe HttpRequest do
+  let(:repo) { RDF::Repository.new }
+  let(:ontology) { Ontology.new(repo) }
+  let(:request) { HttpRequest.new(:r, repo) }
+
+  before do
+    repo << [ :r, HttpVocabulary.method_name, 'POST' ]
+    repo << [ :r, HttpVocabulary.body, 'the body' ]
+  end
+
+  context '#uri' do
+    subject { request.uri }
+
+    describe 'as literal' do
+      before { repo << [ :r, HttpVocabulary.request_uri, 'http://example.com' ] }
+
+      it { is_expected.to eq 'http://example.com' }
+    end
+
+    describe 'as URI' do
+      before { repo << [ :r, HttpVocabulary.request_uri, RDF::URI('http://example.eu') ] }
+
+      it { is_expected.to eq 'http://example.eu' }
+    end
+  end
+
+  context '#execute' do
+    before do
+      repo << [ :r, HttpVocabulary.request_uri, 'http://example.com' ]
+      stub_request(:post, 'example.com')
+    end
+
+    it 'makes the request' do
+      expect(request.execute).to eq true
+
+      expect(WebMock).to have_requested(:post, 'example.com').
+          with(:body => 'the body')
+    end
+  end
+end

data/spec/unit/models/location_spec.rb

@@ -0,0 +1,36 @@
+require_relative '../spec_helper'
+
+describe Location do
+  let(:repo) do
+    RDF::Repository.new do |r|
+      # ANSWER
+      r << [:location, RDF.type, QV.answer_type]
+      r << [:location, RDF.type, QV.location]
+      r << [:location, LV.locationName, 'Living Room']
+    end
+  end
+
+  let(:ontology) { Ontology.new(repo) }
+  let(:location) { Location.new(:location, repo) }
+
+  context '#name' do
+    subject { location.name }
+    it { is_expected.to eq('Living Room') }
+  end
+
+  context '#name=' do
+    before :each do
+      location.name = 'Kitchen'
+    end
+
+    subject { location.name }
+    it { is_expected.to eq('Kitchen') }
+
+    describe 'new instances should have the changed value' do
+      let(:new_answer) { Location.new(:location, repo) }
+
+      subject { new_answer.name }
+      it { is_expected.to eq('Kitchen') }
+    end
+  end
+end

data/spec/unit/models/question_spec.rb

@@ -0,0 +1,89 @@
+require_relative '../spec_helper'
+
+describe Question do
+  let(:repo) do
+    RDF::Repository.new do |r|
+      r << [:a, RDF.type, LV.Application]
+      r << [:device_location, RDF.type, QV.question_type]
+      r << [:device_location, QV.text, 'Where is the thing?']
+      r << [:device_location, QV.replyType, QV.Location]
+      r << [:device_location, QV.location_of, :device]
+      r << [:dev, RDF.type, LV.Device]
+      r << [:dev, LV.manufacturerName, 'Apple']
+    end
+  end
+
+  let(:ontology) { Ontology.new(repo) }
+  let(:question) { Question.new(:device_location, repo) }
+
+  context '#text' do
+    subject { question.text }
+    it { is_expected.to eq('Where is the thing?') }
+  end
+
+  context '#reply_type' do
+    subject { question.reply_type }
+    it { is_expected.to eq(:location) }
+  end
+
+  describe 'without answer' do
+    context '#has_answer?' do
+      subject { question.has_answer? }
+      it { is_expected.to eq(false) }
+    end
+
+    context '#answer' do
+      subject { question.answer }
+      it { is_expected.to eq(nil) }
+    end
+
+    context '#answer!' do
+      let(:answer) { question.answer! }
+
+      subject { answer }
+      it { is_expected.not_to eq(nil) }
+
+      describe 'location answer properties' do
+        before :each do
+          answer.name = 'Balcony'
+        end
+
+        subject { answer.name }
+        it { is_expected.to eq('Balcony') }
+      end
+    end
+  end
+
+  describe 'with answer' do
+    before :each do
+      repo << [:answer, RDF.type, QV.answer_type]
+      repo << [:answer, QV.answers, :device_location]
+      repo << [:device_location, QV.has_answer, :answer]
+    end
+
+    context '#has_answer?' do
+      subject { question.has_answer? }
+      it { is_expected.to eq(true) }
+    end
+
+    context '#answer' do
+      let(:answer) { question.answer }
+      subject { answer }
+
+      it { is_expected.not_to eq(nil) }
+
+      context '#question.text' do
+        subject { answer.question.text }
+        it { is_expected.to eq(question.text) }
+      end
+    end
+
+    context '#answer!' do
+      it 'should have the same value as calling answer' do
+        with_bang = question.answer!.name
+        without_bang = question.answer.name
+        expect(with_bang).to eq(without_bang)
+      end
+    end
+  end
+end

data/spec/unit/models/requirement_spec.rb

@@ -0,0 +1,29 @@
+require_relative '../spec_helper'
+
+describe Ontology do
+  let(:repo) { RDF::Repository.new }
+  let(:ontology) { Ontology.new(repo) }
+  let(:requirement) { Requirement.new(:req, repo) }
+
+  before do
+    repo << [ :req, LV.description, 'This needs to be so and so.' ]
+  end
+
+  context '#description' do
+    subject { requirement.description }
+    it { is_expected.to eq('This needs to be so and so.') }
+  end
+
+  context '#satisfied?' do
+    describe 'satisfied requirement' do
+      before { repo << [ :req, LV.satisfied, true ] }
+      subject { requirement.satisfied? }
+      it { is_expected.to eq true }
+    end
+
+    describe 'not satisfied requirement' do
+      subject { requirement.satisfied? }
+      it { is_expected.to eq false }
+    end
+  end
+end