gearbox 0.1.0 → 0.1.10

data/spec/gearbox/mixins/active_model_implementation_spec.rb

@@ -0,0 +1,18 @@
+require_relative '../../spec_helper'
+
+include Gearbox
+
+describe ActiveModelImplementation do
+  
+  before do
+    @class = Class.new do
+      include Gearbox::ActiveModelImplementation
+    end
+  end
+  
+  let(:model) { @class.new }
+  subject { @class.new }
+  
+  # I need to get the Lint working with the spec format.  I'll need to read how they do that in MiniTest...
+
+end

data/spec/gearbox/mixins/ad_hoc_properties_spec.rb

@@ -4,49 +4,49 @@ include Gearbox
 
 describe AdHocProperties do
   
-  before do
-    @class = Class.new do
-      def self.name; 'demo_class'; end
-      include SemanticAccessors
-      include AdHocProperties
-    end
-  end
-  
-  subject { @class.new }
-
-  it "has an id getter and setter" do
-    id = 1
-    subject.id = id
-    subject.id.must_equal(id)
-  end
-  
-  # Concerned about the id and the model lifecycle.
-  it "offers a bnode, deriving from the id" do
-    subject.id = 3
-    subject.bnode.must_be_kind_of RDF::Node
-    subject.bnode.id.must_equal "demo_class_3"
-  end
-  
-  it "generates a UUID for the bnode if the id is nil" do
-    subject.id.must_be_nil
-    subject.bnode
-    subject.id.wont_be_nil
-    subject.bnode.id.must_equal "demo_class_#{subject.id}"
-  end
-  
-  it "has an attributes_list" do
-    subject.must_respond_to :attributes_list
-    subject.attributes_list.must_be_kind_of RDFCollection
-  end
-  
-  # Excited about models that can take new properties ad hoc, therefore being more 
-  # friendly to the underlying graph and the nature of semantic data generally.
-  it "can add_property with a predicate and an object" do
-    subject.add_property :field_name, :predicate, :object
-    newly_created = subject.attributes_list[:field_name]
-    newly_created.subject.id.must_equal subject.bnode.id
-    newly_created.predicate.id.must_equal 'predicate'
-    newly_created.object.id.must_equal 'object'
-  end
+  # before do
+  #   @class = Class.new do
+  #     def self.name; 'demo_class'; end
+  #     include SemanticAccessors
+  #     include AdHocProperties
+  #   end
+  # end
+  # 
+  # subject { @class.new }
+  # 
+  # it "has an id getter and setter" do
+  #   id = 1
+  #   subject.id = id
+  #   subject.id.must_equal(id)
+  # end
+  # 
+  # # Concerned about the id and the model lifecycle.
+  # it "offers a bnode, deriving from the id" do
+  #   subject.id = 3
+  #   subject.bnode.must_be_kind_of RDF::Node
+  #   subject.bnode.id.must_equal "demo_class_3"
+  # end
+  # 
+  # it "generates a UUID for the bnode if the id is nil" do
+  #   subject.id.must_be_nil
+  #   subject.bnode
+  #   subject.id.wont_be_nil
+  #   subject.bnode.id.must_equal "demo_class_#{subject.id}"
+  # end
+  # 
+  # it "has an attributes_list" do
+  #   subject.must_respond_to :attributes_list
+  #   subject.attributes_list.must_be_kind_of RDFCollection
+  # end
+  # 
+  # # Excited about models that can take new properties ad hoc, therefore being more 
+  # # friendly to the underlying graph and the nature of semantic data generally.
+  # it "can add_property with a predicate and an object" do
+  #   subject.add_property :field_name, :predicate, :object
+  #   newly_created = subject.attributes_list[:field_name]
+  #   newly_created.subject.id.must_equal subject.bnode.id
+  #   newly_created.predicate.id.must_equal 'predicate'
+  #   newly_created.object.id.must_equal 'object'
+  # end
 
 end

data/spec/gearbox/mixins/resource_spec.rb

@@ -6,27 +6,66 @@ describe Resource do
   
   before do
     @class = Class.new do
-      def self.name; 'demo_class'; end
-      include Gearbox
+      include Gearbox::Resource
     end
   end
   
   subject { @class.new }
   
-  it "uses AdHocProperties" do
-    Resource.included_modules.must_include Gearbox::AdHocProperties
-  end
+  # Rethinking this one, they will be much more robust soon.
+  # This is more for knowledge base discovery or throw-away models
+  # So there's a new approach on the horizon of my imagination.
+  # it "uses AdHocProperties" do
+  #   @class.included_modules.must_include Gearbox::AdHocProperties
+  # end
   
   it "uses SemanticAccessors" do
-    Resource.included_modules.must_include Gearbox::SemanticAccessors
+    @class.included_modules.must_include Gearbox::SemanticAccessors
+  end
+  
+  it "uses SubjectMethods" do
+    @class.included_modules.must_include Gearbox::SubjectMethods
+  end
+  
+  it "uses ActiveModelImplementation" do
+    @class.included_modules.must_include Gearbox::ActiveModelImplementation
   end
   
   it "uses RDF::Mutable" do
-    Resource.included_modules.must_include RDF::Mutable
+    @class.included_modules.must_include RDF::Mutable
   end
   
   it "uses RDF::Queryable" do
-    Resource.included_modules.must_include RDF::Queryable
+    @class.included_modules.must_include RDF::Queryable
+  end
+  
+  describe "Enumerable integration" do
+    it "has each defined on the model" do
+      subject.respond_to?(:each).must_equal true
+    end
+    
+    it "produces RDF statements from the enumeration" do
+      @class.attribute :name, :predicate => RDF::FOAF.name
+      subject = @class.new(:name => "George")
+      subject.to_a.must_equal([RDF::Statement.new(subject.subject, RDF::FOAF.name, RDF::Literal.new("George"))])
+    end
+    
+  end
+  
+  describe "Load order" do
+    # Unfortunately, the load order is important here.
+    # There is only one example right now: id.
+    # id is part of the subject system. It's actually quite robust, so that any identification pattern
+    # can be implemented in Gearbox.  That's handled in the SubjectMethods.  The attribute system needs
+    # id for some ActiveModel goodness.  So, I have to load SubjectMethods before SemanticAccessors.
+    # A recent MWRC kept picking on this dependency problem, but none of their suggestions would help
+    # make this code follow the Law of Demeter any better.
+    
+    it "has an id for the attribute system" do
+      @class.attribute :name, :predicate => RDF::FOAF.name
+      subject = @class.new(:name => "George")
+      subject.attributes.must_equal({:id => subject.id, :name => "George"})
+    end
   end
 
 end

data/spec/gearbox/mixins/semantic_accessors_spec.rb

@@ -4,50 +4,79 @@ include Gearbox
 
 describe SemanticAccessors do
   
-  before do
-    @class = Class.new do
-      def self.name; 'demo_class'; end
-      include SemanticAccessors
-    end
-  end
-  
-  subject { @class.new }
-  
-  it "has an rdf_collection" do
-    subject.must_respond_to :rdf_collection
-    subject.rdf_collection.must_be_kind_of RDFCollection
-  end
-  
-  it "has an attribute_collection on the class" do
-    subject.class.must_respond_to :attribute_collection
-    subject.class.attribute_collection.must_be_kind_of AttributeCollection
-  end
-  
-  it "has an attribute macro for setting up new attributes" do
-    @class.attribute :given_name, :predicate => RDF::FOAF.givenname
-    subject.given_name = "Frank"
-    subject.given_name.must_equal("Frank")
-  end
   
-  it "raises an error unless a predicate is defined" do
-    lambda{@class.attribute :given_name}.must_raise(ArgumentError, /predicate/i)
-  end
-  
-  it "takes a hash on initialization" do
-    @class.attribute :given_name, :predicate => RDF::FOAF.givenname
-    subject = @class.new :given_name => "Frank"
-    subject.given_name.must_equal "Frank"
-  end
-  
-  it "takes an RDFCollection on initialization" do
-    @class.attribute :given_name, :predicate => RDF::FOAF.givenname
-    collection = RDFCollection.new
-    collection[:given_name] = RDF::Statement.new(:a, RDF::FOAF.givenname, 'Frank')
-    collection[:family_name] = RDF::Statement.new(:a, RDF::FOAF.familyname, 'Wilde')
-    subject = @class.new(collection)
-    subject.given_name.must_equal "Frank"
-  end
+  describe "Class methods" do
+    before do
+      @class = Class.new do
+        def self.name; 'demo_class'; end
+        include SemanticAccessors
+      end
+    end
+
+    it "uses an attributes hash" do
+      @class.attributes.must_be_kind_of Hash
+    end
+    
+    describe "attribute" do
+      it "has an attribute method" do
+        @class.respond_to?(:attribute).must_equal true
+      end
+      
+      it "defines a setter and getter" do
+        @class.attribute(:name, :predicate => RDF::FOAF.name)
+        subject = @class.new
+        subject.respond_to?(:name).must_equal true
+        subject.respond_to?(:name=).must_equal true
+      end
+      
+      it "stores the options + {:name => name} in the attributes hash" do
+        @class.attribute(:name, :predicate => RDF::FOAF.name)
+        @class.attributes[:name].must_equal({:name => :name, :predicate => RDF::FOAF.name})
+      end
+    end
+  end # "Class methods"
   
-  it "takes an Array of RDF::Statement objects on initialization"
+  describe "Instance methods" do
+    before do
+      @class = Class.new do
+        include SemanticAccessors
+        attribute :name, :predicate => RDF::FOAF.name
+      end
+    end
 
+    subject { @class.new }
+    
+    it "creates a setter and a getter for each attribute" do
+      subject.name = "George"
+      subject.name.must_equal "George"
+    end
+    
+    it "supports the attribute data types" do
+      # In fact, it supports the full attribute system, this is just a quick check.
+      @class.attribute :birthday, :predicate => RDF::FOAF.birthday, :datatype => RDF::XSD.date
+      subject.birthday = Time.now
+      subject.birthday.must_equal Time.now.to_date
+    end
+    
+    it "creates an attributes hash from attribute values" do
+      subject.name = "George"
+      def subject.id; 1; end
+      subject.attributes.must_equal({:id => subject.id, :name => "George"})
+    end
+    
+    it "uses the default attribute parameter to set defaults" do
+      @class.attribute :spanish_name, :predicate => RDF::FOAF.name, :language => :es, :default => "Jorge"
+      subject = @class.new
+      subject.spanish_name.must_equal "Jorge"
+    end
+    
+    it "can take attribute values as an initialization hash" do
+      subject = @class.new(:name => "George")
+      subject.name.must_equal "George"
+    end
+    
+    # TODO: Once I implement some finds via SPARQL, I should standardize the kind of data I'll be feeding
+    # the model initialization.  At that point, either refactor the RDF::Statement feature in Attribute,
+    # or add it in the initialization process.
+  end # "Instance methods"
 end

data/spec/gearbox/mixins/subject_methods_spec.rb

@@ -0,0 +1,126 @@
+require_relative '../../spec_helper'
+
+include Gearbox
+
+describe SubjectMethods do
+  
+  before do
+    @class = Class.new do
+      include SubjectMethods
+    end
+  end
+
+  let(:base_uri) { "http://example.com" }
+  subject { @class.new }
+  
+  # =============
+  # = ID Method =
+  # =============
+  it "can define the id_method on the class level" do
+    @class.id_method :new_id
+    @class.id_method.must_equal :new_id
+  end
+  
+  it "defaults id_method to :object_id" do
+    @class.id_method.must_equal :object_id
+  end
+  
+  it "can set the id_method at initialization" do
+    subject = @class.new(:id_method => :new_id)
+    subject.id_method.must_equal(:new_id)
+  end
+
+  it "defaults the id to object_id" do
+    subject.id.must_equal subject.object_id
+  end
+
+  it "uses id_method to define which method sets the id" do
+    def subject.new_id; :new_id; end
+    subject.id_method = :new_id
+    subject.id.must_equal :new_id
+  end
+  
+  # ======
+  # = Id =
+  # ======
+  it "has an id setter" do
+    subject.id = :whale
+    subject.id.must_equal :whale
+  end
+  
+  it "can set the id at initialization" do
+    subject = @class.new(:id => "george")
+    subject.id.must_equal "george"
+  end
+  
+  # ============
+  # = Base URI =
+  # ============
+  it "can define the base_uri on the class level" do
+    @class.base_uri base_uri
+    @class.base_uri.must_equal base_uri
+  end
+  
+  it "can set the base_uri at initialization" do
+    subject = @class.new(:base_uri => base_uri)
+    subject.base_uri.must_equal base_uri
+  end
+  
+  it "can set the base_uri as a normal accessor" do
+    subject.base_uri = "http://weird.com"
+    subject.base_uri.must_equal "http://weird.com"
+  end
+  
+  it "defaults to the class.base_uri" do
+    @class.base_uri base_uri
+    subject = @class.new
+    subject.base_uri.must_equal base_uri
+  end
+  
+  # =====================
+  # = Subject Decorator =
+  # =====================
+  it "can define the subject_decorator on the class level" do
+    @class.subject_decorator :spoofy
+    @class.subject_decorator :spoofy
+  end
+  
+  it "can set the subject_decorator at initialization" do
+    subject = @class.new(:subject_decorator => :spoofy)
+    subject.subject_decorator.must_equal :spoofy
+  end
+  
+  it "can set the subject_decorator as a normal accessor" do
+    subject.subject_decorator = :spoofy
+    subject.subject_decorator.must_equal :spoofy
+  end
+  
+  it "default to the class.subject_decorator" do
+    @class.subject_decorator :spoofy
+    subject = @class.new
+    subject.subject_decorator.must_equal :spoofy
+  end
+  
+  # ===========
+  # = Subject =
+  # ===========
+  it "has a default subject method that combines the base_uri with the id" do
+    subject.base_uri = base_uri
+    subject.id = "george"
+    subject.subject.must_equal "#{base_uri}/george"
+  end
+  
+  it "uses the subject_decorator if it is set" do
+    def subject.special_case; "#{base_uri}/special/#{id}"; end
+    subject.subject_decorator = :special_case
+    subject.base_uri = "http://example.com"
+    subject.subject.must_equal subject.special_case
+  end
+  
+  it "can use a lambda for a subject_decorator" do
+    subject.subject_decorator = lambda{|model| "#{model.base_uri}/special/#{model.id}"}
+    subject.base_uri = "http://example.com"
+    subject.subject.must_equal "http://example.com/special/#{subject.id}"
+  end
+
+end

data/spec/gearbox/rdf_collection_spec.rb

@@ -6,8 +6,8 @@ describe RDFCollection do
   
   subject { RDFCollection.new() }
 
-  it "uses RDF::Enumerable " do
-    RDFCollection.included_modules.must_include RDF::Enumerable
+  it "uses RDF::Queryable " do
+    RDFCollection.included_modules.must_include RDF::Queryable
   end
   
   it "adds statements with add_statement or []=" do
@@ -49,4 +49,30 @@ describe RDFCollection do
     subject.has_key?(key, :normalize => false).must_equal false
     subject.has_key?(normalized_key, :normalize => false).must_equal true
   end
+  
+  it "has a local_repository" do
+    subject.local_repository.must_be_kind_of RDF::Repository
+  end
+  
+  it "has a local_repository setter" do
+    subject.local_repository = :blah
+    subject.local_repository.must_equal :blah
+  end
+  
+  it "delegates to the local_repository from each" do
+    subject.local_repository = [1,2,3]
+    subject.to_a.must_equal [1,2,3]
+  end
+  
+  it "uses each_with_field_names to iterate the labeled statements" do
+    statement = RDF::Statement(:a, :b, :c)
+    subject.add_statement :x, statement
+    subject.each_with_field_names.to_a.must_equal [[:x, statement]]
+  end
+  
+  it "has a query method for SPARQL.execute" do
+    statement = RDF::Statement(RDF::Node.new, RDF::FOAF.givenname, "Frank")
+    subject.add_statement :x, statement
+    subject.query("select ?object where {?s ?p ?object}")[0].object.value.must_equal "Frank"
+  end
 end