case_model 0.0.1

data/spec/unit/models/selection_spec.rb

@@ -0,0 +1,48 @@
+require_relative '../spec_helper'
+
+describe Question do
+  let(:repo) do
+    RDF::Repository.new do |r|
+      r << [:a, RDF.type, QV.Application]
+      r << [:question, RDF.type, QV.question_type]
+      r << [:question, QV.text, 'Are you OK?']
+      r << [:question, QV.replyType, QV.Select]
+    end
+  end
+
+  let(:ontology) { Ontology.new(repo) }
+  let(:question) { Question.new(:question, repo) }
+  let(:answer) { question.answer! }
+
+  context '#options' do
+    subject { answer.options }
+
+    describe 'options as a list of strings' do
+      before do
+        options = RDF::List[ 'opt1', 'opt2' ]
+        repo << options
+        repo << [:question, LV.options, options]
+      end
+
+      it { is_expected.to eq [ 'opt1', 'opt2' ] }
+    end
+
+    describe 'options as a set of strings' do
+      before do
+        repo << [:question, LV.option, 'opt1']
+        repo << [:question, LV.option, 'opt2']
+      end
+
+      it { is_expected.to eq [ 'opt1', 'opt2' ] }
+    end
+
+    describe 'options as a set of nodes' do
+      before do
+        repo << [:question, LV.option, LV.opt1]
+        repo << [:question, LV.option, LV.opt2]
+      end
+
+      it { is_expected.to eq [ LV.opt1, LV.opt2 ] }
+    end
+  end
+end

data/spec/unit/models/state_change_spec.rb

@@ -0,0 +1,33 @@
+require_relative '../spec_helper'
+
+describe StateChange do
+  let(:repo) { RDF::Repository.new }
+  let(:ontology) { Ontology.new(repo) }
+  let(:state_change) { StateChange.new(:state_change, ontology) }
+
+  before do
+    repo << [ :state, RDF.type, StateVocabulary.State ]
+    repo << [ :state_change, RDF.type, StateVocabulary.StateChange ]
+    repo << [ :state_change, StateVocabulary.added, :added ]
+    repo << [ :state_change, StateVocabulary.removed, :removed ]
+    repo << [ :state_change, StateVocabulary.parent, :state ]
+
+    repo << [ :app, RDF.type, LV.Application, :added ]
+    repo << [ :app, LV.description, 'A new app', :added ]
+  end
+
+  describe 'before applying the state change' do
+    let(:app) { ontology.applications.first }
+
+    subject { app.nil? }
+    pending { is_expected.to eq true }
+  end
+
+  context '#apply' do
+    let(:new_ontology) { state_change.apply }
+    let(:app) { new_ontology.applications.first }
+
+    subject { app.description }
+    it { is_expected.to eq 'A new app' }
+  end
+end

data/spec/unit/ontology/local_vocabulary_spec.rb

@@ -0,0 +1,9 @@
+require_relative '../spec_helper'
+
+describe LocalVocabulary do
+  it 'returns a URI with the called method name' do
+    uri = LocalVocabulary.Application.to_s
+    expect(uri).to include('Application')
+    expect(uri).to include('http')
+  end
+end

data/spec/unit/ontology/ontology_spec.rb

@@ -0,0 +1,62 @@
+require_relative '../spec_helper'
+
+describe Ontology do
+  let(:repo) { RDF::Repository.new }
+  let(:ontology) { Ontology.new(repo) }
+
+  before do
+    # APPS
+    repo << [:app1, RDF.type, LV.Application]
+    repo << [:app1, RDF::Vocab::FOAF.name, 'App 1']
+    repo << [:app2, RDF.type, LV.Application]
+    repo << [:app2, RDF::Vocab::FOAF.name, 'App 2']
+
+    # DEVICES
+    repo << [:dev1, RDF.type, LV.Device]
+    repo << [:dev1, LV.manufacturerName, 'Grundfos']
+    repo << [:dev2, RDF.type, LV.Device]
+    repo << [:dev2, LV.manufacturerName, 'Danfoss']
+  end
+
+  context '#applications' do
+    let(:apps) { ontology.applications }
+
+    it 'finds 2 applications' do
+      expect(apps.size).to eq(2)
+    end
+
+    it 'gives the right names' do
+      expect(apps.first.name).to eq('App 1')
+      expect(apps.last.name).to eq('App 2')
+    end
+  end
+
+  context '#devices' do
+    let(:devices) { ontology.devices }
+
+    it 'finds 2 devices' do
+      expect(devices.size).to eq(2)
+    end
+
+    it 'gives the right names' do
+      expect(devices.first.manufacturer_name).to eq('Grundfos')
+      expect(devices.last.manufacturer_name).to eq('Danfoss')
+    end
+  end
+
+  context '#refresh' do
+    let(:n3_input) { '@prefix c: <http://matus.tomlein.org/case/>.
+                     { ?a c:knows ?b. } => { ?b c:knows ?a. }.' }
+    before { ontology.load_and_process_n3(n3_input) }
+
+    it 'executes the rule after refresh' do
+      any = lambda { ontology.query([ LV.marry, LV.knows, LV.john ]).any? }
+
+      ontology << [ LV.john, LV.knows, LV.marry ]
+      expect(any.call).to eq false
+
+      ontology.refresh
+      expect(any.call).to eq true
+    end
+  end
+end

data/spec/unit/services/application_by_capability_finder_spec.rb

@@ -0,0 +1,81 @@
+require_relative '../spec_helper'
+
+describe ApplicationByCapabilityFinder do
+  let(:repo) { RDF::Repository.new }
+  let(:ontology) { Ontology.new repo }
+  let(:finder) { ApplicationByCapabilityFinder.new ontology }
+
+  before do
+    repo << [ :app1, RDF.type, LV.Application ]
+    repo << [ :app1, LV.description, 'Some app' ]
+    repo << [ :app1, LV.hasDeploymentPlan, :dp1 ]
+    repo << [ :dp1, LV.capability, :capability1 ]
+    repo << [ :capability1, RDF.type, LV.Irrigation ]
+    repo << [ :capability1, LV.actuator, :irrigator1 ]
+    repo << [ :irrigator1, LV.description, 'The irrigator' ]
+
+    repo << [ :app2, RDF.type, LV.Application ]
+    repo << [ :app2, LV.description, 'Some other app' ]
+    repo << [ :app2, LV.hasDeploymentPlan, :dp2 ]
+    repo << [ :dp2, LV.capability, :capability2 ]
+    repo << [ :capability2, RDF.type, LV.SmartHome ]
+    repo << [ :capability2, LV.actuator, LV.light ]
+    repo << [ LV.light, LV.description, 'Light' ]
+  end
+
+  context '#find' do
+    describe 'by the capability type' do
+      let(:applications) do
+        finder.find({
+          RDF.type => LV.Irrigation
+        })
+      end
+
+      context '#size' do
+        subject { applications.size }
+        it { is_expected.to eq 1 }
+      end
+
+      context '#description' do
+        subject { applications.first.description }
+        it { is_expected.to eq 'Some app' }
+      end
+    end
+  end
+
+  context '#find_by_actuator' do
+    describe 'by actuator node' do
+      let(:applications) do
+        finder.find_by_actuator(LV.light)
+      end
+
+      context '#size' do
+        subject { applications.size }
+        it { is_expected.to eq 1 }
+      end
+
+      context '#description' do
+        subject { applications.first.description }
+        it { is_expected.to eq 'Some other app' }
+      end
+    end
+
+    describe 'by the actuator type' do
+      let(:applications) do
+        finder.find_by_actuator({
+          LV.description => 'Light'
+        })
+      end
+
+      context '#size' do
+        subject { applications.size }
+        it { is_expected.to eq 1 }
+      end
+
+      context '#description' do
+        subject { applications.first.description }
+        it { is_expected.to eq 'Some other app' }
+      end
+    end
+  end
+end

data/spec/unit/services/eye_serializer_spec.rb

@@ -0,0 +1,34 @@
+require_relative '../spec_helper'
+
+describe EyeSerializer do
+  let(:p1) { RDF::Query::Variable.new(:p1) }
+  let(:p2) { RDF::Query::Variable.new(:p2) }
+  let(:facts) do
+    RDF::Graph.new do |g|
+      g << [LV.john, LV.knows, LV.jane]
+    end
+  end
+  let(:precondition) do
+    RDF::Graph.new do |g|
+      g << [p1, LV.knows, p2]
+    end
+  end
+  let(:postcondition) do
+    RDF::Graph.new do |g|
+      g << [p2, LV.knows, p1]
+    end
+  end
+
+  context '.serialize_implication' do
+
+    subject { EyeSerializer.serialize_implication(facts, precondition, postcondition) }
+
+    it do
+      is_expected.to eq('<http://matus.tomlein.org/case/john> <http://matus.tomlein.org/case/knows> <http://matus.tomlein.org/case/jane> .
+{?p1 <http://matus.tomlein.org/case/knows> ?p2 .
+} => {?p2 <http://matus.tomlein.org/case/knows> ?p1 .
+}.
+')
+    end
+  end
+end

data/spec/unit/services/node_builder_spec.rb

@@ -0,0 +1,56 @@
+require_relative '../spec_helper'
+
+describe NodeBuilder do
+  let(:repo) do
+    RDF::Repository.new do |repo|
+      repo << [LV.john, LV.knows, LV.jane]
+    end
+  end
+
+  context '.create' do
+    describe 'generate a device node' do
+      let(:node) do
+        NodeBuilder.create({
+          RDF.type => [
+            LV.Device,
+            LV.Irrigator,
+            LV.EcosystemHost
+          ],
+          LV.manufacturerName => 'Apple',
+          LV.description => 'Insanely great',
+          LV.locatedAt => {
+            LV.locationName => 'Cupertino'
+          }
+        },
+        repo)
+      end
+      let(:device) { Device.new(node, repo) }
+
+      context '#manufacturer_name' do
+        subject { device.manufacturer_name }
+        it { is_expected.to eq 'Apple' }
+      end
+
+      context '#description' do
+        subject { device.description }
+        it { is_expected.to eq 'Insanely great' }
+      end
+
+      context '#location' do
+        let(:location) { device.location }
+
+        context '#name' do
+          subject { location.name }
+          it { is_expected.to eq 'Cupertino' }
+        end
+      end
+
+      context '#types' do
+        subject do
+          NodeQuery.new(node, repo).values(RDF.type).size
+        end
+        it { is_expected.to eq 3 }
+      end
+    end
+  end
+end

data/spec/unit/services/node_query_spec.rb

@@ -0,0 +1,74 @@
+require_relative '../spec_helper'
+
+describe NodeQuery do
+  let(:repo) do
+    RDF::Repository.new do |repo|
+      repo << [LV.john, LV.knows, LV.jane]
+    end
+  end
+  let(:query) { NodeQuery.new(LV.john, repo) }
+
+  context '#value' do
+    subject { query.value(LV.knows) }
+    it { is_expected.to eq(LV.jane) }
+
+    describe 'unset value' do
+      subject { query.value(LV.hates) }
+      it { is_expected.to eq(nil) }
+    end
+  end
+
+  context '#values' do
+    before :each do
+      repo << [ LV.john, LV.knows, LV.emily ]
+    end
+    let(:values) { query.values(LV.knows) }
+
+    context '#size' do
+      subject { values.size }
+      it { is_expected.to eq(2) }
+    end
+
+    context '#first' do
+      subject { values.first }
+      it { is_expected.to eq(LV.jane) }
+    end
+
+    context '#last' do
+      subject { values.last }
+      it { is_expected.to eq(LV.emily) }
+    end
+
+    describe 'size when unset value' do
+      subject { query.values(LV.hates).size }
+      it { is_expected.to eq(0) }
+    end
+  end
+
+  context '#set_value' do
+    before :each do
+      query.set_value LV.loves, LV.jane
+    end
+
+    context '#value' do
+      subject { query.value(LV.loves) }
+      it { is_expected.to eq(LV.jane) }
+    end
+
+    describe 'overwrites previous value' do
+      before :each do
+        query.set_value LV.loves, LV.emily
+      end
+
+      context '#value' do
+        subject { query.value(LV.loves) }
+        it { is_expected.to eq(LV.emily) }
+      end
+
+      context '#values.size' do
+        subject { query.values(LV.loves).size }
+        it { is_expected.to eq(1) }
+      end
+    end
+  end
+end

data/spec/unit/services/reasoner_spec.rb

@@ -0,0 +1,76 @@
+require_relative '../spec_helper'
+
+describe Reasoner do
+  let(:repo) { RDF::Repository.new }
+  let(:reasoner) { Reasoner.new(Ontology.new(repo)) }
+  let(:person1) { RDF::Query::Variable.new(:p1) }
+  let(:person2) { RDF::Query::Variable.new(:p2) }
+
+  before do
+    repo << [LV.john, LV.knows, LV.jane]
+    repo << [person1, LV.knows, person2, :precondition]
+    repo << [person1, LV.doesnt_know, person2, :wrong_precondition]
+  end
+
+  context '#check_condition' do
+    describe 'correct condition' do
+      subject { reasoner.check_condition(:precondition) }
+      it { is_expected.to eq true }
+    end
+
+    describe 'wrong condition' do
+      subject { reasoner.check_condition(:wrong_precondition) }
+      it { is_expected.to eq false }
+    end
+  end
+
+  context '#imply' do
+    before :each do
+      repo << [person2, LV.knows, person1, :postcondition]
+    end
+
+    describe 'correct precondition' do
+      let!(:result) { reasoner.imply(:precondition, :postcondition) }
+
+      it 'should find that Jane knows John' do
+        expect(result.query([LV.jane, LV.knows, LV.john]).size).
+          to eq(1)
+      end
+
+      it 'should not modify the source repository' do
+        expect(repo.query([LV.jane, LV.knows, LV.john]).size).
+          to eq(0)
+        expect(repo.query([LV.john, LV.knows, LV.jane]).size).
+          to eq(1)
+      end
+    end
+
+    describe 'wrong precondition' do
+      let!(:result) { reasoner.imply(:wrong_precondition, :postcondition) }
+
+      it 'should not find that Jane knows John' do
+        expect(result.query([LV.jane, LV.knows, LV.john]).size).
+          to eq(0)
+      end
+    end
+  end
+
+  context '#load_and_process_n3' do
+    let(:n3_input) { '@prefix c: <http://matus.tomlein.org/case/>.
+                     c:dog c:likes c:cat.
+                     { ?dog c:likes ?cat } => { ?cat c:likes ?dog }.' }
+    let(:repo) { RDF::Repository.new }
+
+    before { reasoner.load_and_process_n3(n3_input) }
+
+    describe 'the known fact' do
+      subject { repo.query([LV.dog, LV.likes, LV.cat]).any? }
+      it { is_expected.to eq true }
+    end
+
+    describe 'the implied fact' do
+      subject { repo.query([LV.cat, LV.likes, LV.dog]).any? }
+      it { is_expected.to eq true }
+    end
+  end
+end

data/spec/unit/spec_helper.rb

@@ -0,0 +1 @@
+require_relative '../spec_helper'

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: case_model
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Matus Tomlein
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-28 00:00:00.000000000 Z
+dependencies: []
+description: Built for the Context-Aware Software Ecosystem. Resolves application
+  model requirements using semantic reasoning.
+email: matus@cs.au.dk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- case_model.gemspec
+- lib/case_model.rb
+- lib/descriptions/states.n3
+- lib/models/action.rb
+- lib/models/answer.rb
+- lib/models/application.rb
+- lib/models/capability.rb
+- lib/models/deployment_plan.rb
+- lib/models/device.rb
+- lib/models/ecosystem_host.rb
+- lib/models/http_request.rb
+- lib/models/location.rb
+- lib/models/ontology.rb
+- lib/models/question.rb
+- lib/models/question_reply_type.rb
+- lib/models/requirement.rb
+- lib/models/selection.rb
+- lib/models/state_change.rb
+- lib/models/temperature.rb
+- lib/ontology/http_vocabulary.rb
+- lib/ontology/local_vocabulary.rb
+- lib/ontology/math_vocabulary.rb
+- lib/ontology/rdf_vocabulary.rb
+- lib/ontology/state_vocabulary.rb
+- lib/services/application_by_capability_finder.rb
+- lib/services/eye_serializer.rb
+- lib/services/node_builder.rb
+- lib/services/node_query.rb
+- lib/services/question_references.rb
+- lib/services/reasoner.rb
+- lib/services/repository_proxy.rb
+- spec/spec_helper.rb
+- spec/unit/models/answer_spec.rb
+- spec/unit/models/application_spec.rb
+- spec/unit/models/deployment_plan_spec.rb
+- spec/unit/models/http_request_spec.rb
+- spec/unit/models/location_spec.rb
+- spec/unit/models/question_spec.rb
+- spec/unit/models/requirement_spec.rb
+- spec/unit/models/selection_spec.rb
+- spec/unit/models/state_change_spec.rb
+- spec/unit/ontology/local_vocabulary_spec.rb
+- spec/unit/ontology/ontology_spec.rb
+- spec/unit/services/application_by_capability_finder_spec.rb
+- spec/unit/services/eye_serializer_spec.rb
+- spec/unit/services/node_builder_spec.rb
+- spec/unit/services/node_query_spec.rb
+- spec/unit/services/reasoner_spec.rb
+- spec/unit/spec_helper.rb
+homepage: https://github.com/case-iot/app_model
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Resolver for the CASE ecosystem application models
+test_files:
+- spec/spec_helper.rb
+- spec/unit/models/answer_spec.rb
+- spec/unit/models/application_spec.rb
+- spec/unit/models/deployment_plan_spec.rb
+- spec/unit/models/http_request_spec.rb
+- spec/unit/models/location_spec.rb
+- spec/unit/models/question_spec.rb
+- spec/unit/models/requirement_spec.rb
+- spec/unit/models/selection_spec.rb
+- spec/unit/models/state_change_spec.rb
+- spec/unit/ontology/local_vocabulary_spec.rb
+- spec/unit/ontology/ontology_spec.rb
+- spec/unit/services/application_by_capability_finder_spec.rb
+- spec/unit/services/eye_serializer_spec.rb
+- spec/unit/services/node_builder_spec.rb
+- spec/unit/services/node_query_spec.rb
+- spec/unit/services/reasoner_spec.rb
+- spec/unit/spec_helper.rb
+has_rdoc: