kalimba 0.0.1

data/lib/kalimba/validations.rb

@@ -0,0 +1,69 @@
+require "active_support/concern"
+
+module Kalimba
+  # Raised by <tt>save!</tt> and <tt>create!</tt> when the record is invalid. Use the
+  # +record+ method to retrieve the record which did not validate.
+  #
+  # @example
+  #   begin
+  #     complex_operation_that_calls_save!_internally
+  #   rescue Kalimba::RecordInvalid => invalid
+  #     puts invalid.record.errors
+  #   end
+  class RecordInvalid < KalimbaError
+    attr_reader :record
+    def initialize(record)
+      @record = record
+      errors = @record.errors.full_messages.join(", ")
+      # TODO: use I18n later
+      # super I18n.t("activerecord.errors.messages.record_invalid", :errors => errors)
+      super "invalid record"
+    end
+  end
+
+  module Validations
+    extend ActiveSupport::Concern
+    include ActiveModel::Validations
+
+    module ClassMethods
+      # Creates an object just like Persistence.create but calls <tt>save!</tt> instead of +save+
+      # so an exception is raised if the record is invalid.
+      def create!(attributes = {}, &block)
+        if attributes.is_a?(Array)
+          attributes.each { |attr| create!(attr, &block) }
+        else
+          create(attributes, &block) || (raise RecordInvalid, self)
+        end
+      end
+    end
+
+    def save(options = {})
+      perform_validations(options) ? super : false
+    end
+
+    def save!(options = {})
+      save || (raise RecordInvalid, self)
+    end
+
+    # Runs all the validations within the specified context. Returns true if no errors are found,
+    # false otherwise.
+    #
+    # If the argument is false (default is +nil+), the context is set to <tt>:create</tt> if
+    # <tt>new_record?</tt> is true, and to <tt>:update</tt> if it is not.
+    #
+    # Validations with no <tt>:on</tt> option will run no matter the context. Validations with
+    # some <tt>:on</tt> option will only run in the specified context.
+    def valid?(context = nil)
+      context ||= (new_record? ? :create : :update)
+      output = super(context)
+      errors.empty? && output
+    end
+
+    protected
+
+    def perform_validations(options={})
+      perform_validation = options[:validate] != false
+      perform_validation ? valid?(options[:context]) : true
+    end
+  end
+end

data/lib/kalimba/version.rb

@@ -0,0 +1,3 @@
+module Kalimba
+  VERSION = "0.0.1"
+end

data/spec/lib/kalimba/attributes_spec.rb

@@ -0,0 +1,145 @@
+require "spec_helper"
+
+describe "attribute handling" do
+  before :all do
+    class AttributeTestOilRig < Kalimba::Resource
+      type "http://schema.org/OilRig"
+      base_uri "http://example.org/oil_rigs"
+
+      property :safe, :predicate => "http://example.org/safe", :datatype => NS::XMLSchema["boolean"]
+      property :name, :predicate => "http://example.org/name", :datatype => NS::XMLSchema["string"]
+      property :local_time, :predicate => "http://example.org/time", :datatype => NS::XMLSchema["time"]
+      property :created_at, :predicate => "http://example.org/date", :datatype => NS::XMLSchema["date"]
+    end
+  end
+
+  let(:rig) { AttributeTestOilRig.for("bp1") }
+
+  describe "boolean value" do
+    subject { rig.safe }
+
+    context "when not set" do
+      it { should be_a NilClass }
+    end
+
+    context "when set to 'false'" do
+      before { rig.safe = false }
+
+      it { should be_a FalseClass }
+    end
+  end
+
+  describe "localized string" do
+    before do
+      # populate the storage with literals in different locales
+      { en: "Quarter Pounder with Cheese",
+        fr: "Le Big Mac" }.each do |lang, text|
+        Kalimba.repository.statements.create(subject: rig.subject,
+                                             predicate: rig.class.properties["name"][:predicate],
+                                             object: text.with_lang(lang))
+      end
+    end
+
+    subject { rig.name }
+
+    context "when retrieved" do
+      describe "string language" do
+        subject { rig.name.lang }
+
+        context "in :fr locale" do
+          around do |example|
+            I18n.with_locale(:fr) { example.call }
+          end
+
+          it { should eql :fr }
+        end
+
+        context "in :en locale" do
+          around do |example|
+            I18n.with_locale(:en) { example.call }
+          end
+
+          it { should eql :en }
+        end
+      end
+    end
+
+    context "when stored" do
+      it "should not be overwritten by a localized string in another language" do
+        rig.update_attributes(name: "Burger")
+
+        s1 = Redlander::Statement.new(subject: rig.subject,
+                                      predicate: rig.class.properties["name"][:predicate],
+                                      object: "Quarter Pounder with Cheese".with_lang(:en))
+        s2 = Redlander::Statement.new(subject: rig.subject,
+                                      predicate: rig.class.properties["name"][:predicate],
+                                      object: "Le Big Mac".with_lang(:fr))
+        s3 = Redlander::Statement.new(subject: rig.subject,
+                                      predicate: rig.class.properties["name"][:predicate],
+                                      object: "Burger")
+
+        Kalimba.repository.statements.to_a.should include s1
+        Kalimba.repository.statements.to_a.should include s2
+        Kalimba.repository.statements.to_a.should include s3
+      end
+    end
+  end
+
+  describe "multiparameter attribute" do
+    describe "localized string" do
+      subject { rig.name }
+
+      context "when assigned" do
+        before { rig.assign_attributes("name(1)" => "Oil Rig", "name(2)" => "en") }
+
+        it { should be_a LocalizedString }
+        it { should eql "Oil Rig" }
+        it "should have language set to 'en'" do
+          expect(rig.name.lang).to eql "en"
+        end
+      end
+    end
+
+    describe "time" do
+      subject { rig.local_time }
+
+      context "when assigned from two parameters" do
+        before do
+          rig.assign_attributes("local_time(1)" => "2013-03-08",
+                                "local_time(2)" => "18:14")
+        end
+
+        it { should be_a Time }
+        it { should eql Time.new(2013, 3, 8, 18, 14) }
+      end
+
+      context "when assigned from many parameters" do
+        before do
+          rig.assign_attributes("local_time(1i)" => "2013",
+                                "local_time(2i)" => "03",
+                                "local_time(3i)" => "08",
+                                "local_time(4i)" => "18",
+                                "local_time(5i)" => "14")
+        end
+
+        it { should be_a Time }
+        it { should eql Time.new(2013, 3, 8, 18, 14) }
+      end
+    end
+
+    describe "date" do
+      subject { rig.created_at }
+
+      context "when assigned" do
+        before do
+          rig.assign_attributes("created_at(1i)" => "2013",
+                                "created_at(2i)" => "03",
+                                "created_at(3i)" => "08")
+        end
+
+        it { should be_a Date }
+        it { should eql Date.new(2013, 3, 8) }
+      end
+    end
+  end
+end

data/spec/lib/kalimba/callbacks_spec.rb

@@ -0,0 +1,90 @@
+require "spec_helper"
+
+describe "callbacks" do
+  before :all do
+    class CallbacksTestPerson < Human
+      attr_accessor :triggers
+
+      type "http://schema.org/CallbacksTestPerson"
+      base_uri "http://example.com/people/"
+
+      before_create  :trigger_1
+      before_update  :trigger_2
+      before_save    :trigger_3
+      before_destroy :trigger_4
+
+      def initialize(*args)
+        @triggers = []
+        super
+      end
+
+      private
+
+      def trigger_1
+        @triggers << 1
+      end
+
+      def trigger_2
+        @triggers << 2
+      end
+
+      def trigger_3
+        @triggers << 3
+      end
+
+      def trigger_4
+        @triggers << 4
+      end
+    end
+  end
+
+  let(:person) { CallbacksTestPerson.create }
+
+  context "when creating a resource" do
+    it "should trigger 2 callbacks" do
+      expect(person.triggers.size).to eql 2
+    end
+
+    it "before_create callback should be triggered" do
+      expect(person.triggers).to include 1
+    end
+
+    it "before_save callback should be triggered" do
+      expect(person.triggers).to include 3
+    end
+  end
+
+  context "when destroying a resource" do
+    before do
+      person.triggers = []
+      person.destroy
+    end
+
+    it "should trigger 1 callback" do
+      expect(person.triggers.size).to eql 1
+    end
+
+    it "before_destroy callback should be triggered" do
+      expect(person.triggers).to include 4
+    end
+  end
+
+  context "when updating a resource" do
+    before do
+      person.triggers = []
+      person.update_attributes(name: "Vasya")
+    end
+
+    it "should trigger 2 callbacks" do
+      expect(person.triggers.size).to eql 2
+    end
+
+    it "before_update callback should be triggered" do
+      expect(person.triggers).to include 2
+    end
+
+    it "before_save callback should be triggered" do
+      expect(person.triggers).to include 3
+    end
+  end
+end

data/spec/lib/kalimba/persistence_spec.rb

@@ -0,0 +1,344 @@
+require "spec_helper"
+
+describe Kalimba::Persistence do
+  before :all do
+    class PersistenceTestPerson < Engineer
+      type "http://schema.org/PersistenceTestPerson"
+      base_uri "http://example.org/people"
+    end
+
+    class PersistenceTestOilRig < Kalimba::Resource
+      type "http://schema.org/OilRig"
+      base_uri "http://example.org/oil_rigs"
+
+      property :safe, :predicate => "http://example.org/safe", :datatype => NS::XMLSchema["boolean"]
+      property :operator, :predicate => "http://example.org/operator", :datatype => :PersistenceTestPerson
+      has_many :saboteurs, :predicate => "http://example.org/saboteur", :datatype => "http://schema.org/Saboteur"
+    end
+  end
+
+  describe "associations" do
+    before { PersistenceTestOilRig.create }
+    let(:rig) { PersistenceTestOilRig.first }
+
+    describe "instantiation" do
+      context "of existing Kalimba resources" do
+        before do
+          Kalimba.repository.statements.create(:subject => rig.subject,
+                                               :predicate => PersistenceTestOilRig.properties["operator"][:predicate],
+                                               :object => PersistenceTestPerson.create.subject)
+        end
+
+        subject { rig.operator }
+
+        it { should be_an_instance_of(PersistenceTestPerson) }
+      end
+
+      context "of unknown Kalimba resources" do
+        before do
+          Kalimba.repository.statements.create(:subject => rig.subject,
+                                               :predicate => PersistenceTestOilRig.properties["saboteurs"][:predicate],
+                                               :object => URI("http://schema.org/Saboteur#Karen_Knight"))
+          Kalimba.repository.statements.create(:subject => rig.subject,
+                                               :predicate => PersistenceTestOilRig.properties["saboteurs"][:predicate],
+                                               :object => URI("http://schema.org/Saboteur#Lee_Knight"))
+        end
+
+        subject { rig.saboteurs }
+
+        it { should be_a(Enumerable) }
+
+        it "should yield anonymous class instances" do
+          expect(subject.first.class).to be_anonymous
+        end
+
+        it "should add the anonymous class to RDFSClass repository" do
+          subject
+          expect(Kalimba::Resource.descendants).to include(subject.first.class)
+        end
+
+        it "should not create more than one anonymous class for homogenious objects" do
+          expect(subject.first.class).to eql subject.last.class
+        end
+
+        it "should set class type to the declared datatype" do
+          expect(subject.first.class.type).to eql PersistenceTestOilRig.properties["saboteurs"][:datatype]
+        end
+
+        it "should set class base_uri to the URI of the instance (without the fragment)" do
+          expect(subject.first.class.base_uri).to eql URI("http://schema.org/Saboteur/")
+        end
+      end
+    end
+  end
+
+  describe "count" do
+    subject { PersistenceTestPerson.count }
+
+    before do
+      3.times { PersistenceTestPerson.create }
+    end
+
+    it { should eql 3 }
+  end
+
+  describe "find" do
+    let(:options) { {:conditions => {:rank => 4}} }
+
+    context "when records are found" do
+      before do
+        PersistenceTestPerson.create(:rank => 4, :duties => %w(sex sleep eat drink dream))
+      end
+
+      describe ":first" do
+        subject { PersistenceTestPerson.find(:first, options) }
+
+        it { should be_a PersistenceTestPerson }
+      end
+
+      describe ":all" do
+        subject { PersistenceTestPerson.find(:all, options) }
+
+        it { should be_a Enumerable }
+        it "should return an array of found entries" do
+          subject.size.should eql 1
+          subject.first.should be_a PersistenceTestPerson
+        end
+      end
+    end
+
+    context "when records are not found" do
+      before do
+        PersistenceTestPerson.create(:rank => 0, :duties => %w(sex sleep eat drink dream))
+      end
+
+      describe ":first" do
+        subject { PersistenceTestPerson.find(:first, options) }
+
+        it { should be_nil }
+      end
+
+      describe ":all" do
+        subject { PersistenceTestPerson.find(:all, options) }
+
+        it { should be_empty }
+      end
+    end
+  end
+
+  describe "create" do
+    let(:person) { PersistenceTestPerson.create }
+    subject { person }
+
+    it { should be_a Kalimba::Resource }
+
+    it "should persist the instance" do
+      subject.should be_persisted
+      subject.should_not be_new_record
+    end
+  end
+
+  describe "destroy_all" do
+    before do
+      2.times { PersistenceTestPerson.create }
+    end
+
+    it "should destroy all instances of the given RDFS class" do
+      expect { PersistenceTestPerson.destroy_all }.to change(Kalimba.repository, :size).by(-2)
+    end
+
+    it "should not destroy instances of other RDFS classes" do
+      rig = PersistenceTestOilRig.create
+      PersistenceTestPerson.destroy_all
+      expect(PersistenceTestOilRig.exist?).to be_true
+    end
+  end
+
+  describe "exist?" do
+    subject { PersistenceTestPerson.exist? }
+
+    context "when there are no RDFS class instances in the repository" do
+      before { PersistenceTestPerson.new }
+
+      it { should be_false }
+    end
+
+    context "when there are RDFS class instances in the repository" do
+      before { PersistenceTestPerson.create }
+
+      it { should be_true }
+    end
+  end
+
+  describe "new record" do
+    let(:person) { PersistenceTestPerson.new }
+    subject { person }
+
+    it { should be_new_record }
+    it { should_not be_persisted }
+
+    describe "subject" do
+      subject { person.subject }
+
+      it { should be_nil }
+
+      context "after save" do
+        before { person.save }
+
+        it { should be_a URI }
+      end
+    end
+
+    describe "save" do
+      it "should return true" do
+        expect(person.save).to be_true
+      end
+
+      it "should persist the record" do
+        person.save
+        person.should_not be_new_record
+        person.should_not be_changed
+        person.should be_persisted
+      end
+
+      context "when failed halfway" do
+        # TODO: need a more "natural" method of causing an error on save
+        before { person.stub(store_type: false) }
+
+        it "should not leave remains in the repository" do
+          person.save
+          Kalimba.repository.statements.exist?(subject: person.subject).should be_false
+        end
+      end
+    end
+
+    context "with changes" do
+      context "when saved" do
+        it "should have values type cast" do
+          person.rank = "2"
+          expect {
+            person.save && person.reload
+          }.to change(person, :rank).from("2").to(2)
+        end
+
+        it "should not persist non-castable values" do
+          person.retired = true
+          expect(person.save).to be_true
+
+          person.reload
+          expect(person.retired).to be_nil
+        end
+      end
+
+      context "to a single value" do
+        before { person.rank = 1 }
+
+        context "when saved" do
+          before { subject.save }
+
+          it "should be added statements with changed attributes (type + rank)" do
+            expect(Kalimba.repository.size).to eql 2
+          end
+        end
+      end
+
+      context "to an association" do
+        let(:charlie) { PersistenceTestPerson.for("charlie") }
+        before do
+          charlie.rank = 99
+          person.boss = charlie
+        end
+
+        context "when saved" do
+          before { subject.save }
+
+          it "should persist the association" do
+            charlie.should_not be_new_record
+            charlie.should be_persisted
+            charlie.should_not be_changed
+          end
+        end
+      end
+
+      context "to collections" do
+        before { person.duties = %w(building designing) }
+
+        context "when saved" do
+          before { person.save }
+
+          it "should be added statements with changed attributes (type + duties*2)" do
+            expect(Kalimba.repository.size).to eql 3
+          end
+        end
+      end
+    end
+
+    describe "reload" do
+      subject { PersistenceTestPerson.for(person.id) }
+
+      context "with related data in the storage" do
+        before { person.update_attributes(:rank => 7, :duties => %w(idling procrastinating)) }
+
+        it "should assign attributes the values from the storage" do
+          expect { subject.reload }.to change { subject.attributes["rank"] }.from(nil).to(7)
+        end
+
+        it "should assign attributes the collections from the storage" do
+          expect { subject.reload }.to change { subject.attributes["duties"] }.from([]).to(%w(idling procrastinating))
+        end
+
+        context "when accessing an attribute" do
+          it "should retrieve it from the storage" do
+            expect { subject.rank }.to change { subject.attributes["rank"] }.from(nil).to(7)
+          end
+        end
+      end
+    end
+  end
+
+  describe "already persisted record" do
+    let(:person) { PersistenceTestPerson.create }
+    subject { person }
+
+    it { should_not be_new_record }
+    it { should be_persisted }
+
+    describe "subject" do
+      subject { person.subject }
+
+      it { should be_a URI }
+    end
+
+    describe "destroy" do
+      before { @another = PersistenceTestPerson.create }
+
+      it "should remove the record from the storage" do
+        subject # create subject
+        expect { subject.destroy }.to change(Kalimba.repository, :size).by(-1)
+        subject.should_not be_new_record
+        subject.should_not be_persisted
+        subject.should be_destroyed
+        subject.should be_frozen
+      end
+
+      it "should not remove other records from the storage" do
+        subject.destroy
+        expect(Kalimba.repository.statements.exist?(:subject => @another.subject)).to be_true
+      end
+    end
+
+    describe "update_attributes" do
+      subject { person.update_attributes(:rank => 9) }
+
+      it { should be_true }
+
+      it "should assign the given attributes" do
+        expect { person.update_attributes(:rank => 0) }.to change(person, :rank).to(0)
+      end
+
+      it "should have no changes" do
+        expect(person.changes).to be_empty
+      end
+    end
+  end
+end