active-triples 0.0.1

data/lib/active_triples/term.rb

@@ -0,0 +1,188 @@
+module ActiveTriples
+  class Term
+    attr_accessor :parent, :value_arguments, :node_cache
+    delegate *(Array.public_instance_methods - [:__send__, :__id__, :class, :object_id] + [:as_json]), :to => :result
+    def initialize(parent, value_arguments)
+      self.parent = parent
+      self.value_arguments = value_arguments
+    end
+
+    def clear
+      set(nil)
+    end
+
+    def result
+      result = parent.query(:subject => rdf_subject, :predicate => predicate)
+      .map{|x| convert_object(x.object)}
+      .reject(&:nil?)
+      return result if !property_config || property_config[:multivalue]
+      result.first
+    end
+
+    def set(values)
+      values = [values].compact unless values.kind_of?(Array)
+      empty_property
+      values.each do |val|
+        set_value(val)
+      end
+      parent.persist! if parent.class.repository == :parent && parent.send(:repository)
+    end
+
+    def empty_property
+      parent.query([rdf_subject, predicate, nil]).each_statement do |statement|
+        if !uri_class(statement.object) || uri_class(statement.object) == class_for_property
+          parent.delete(statement)
+        end
+      end
+    end
+
+    def build(attributes={})
+      new_subject = attributes.key?('id') ? attributes.delete('id') : RDF::Node.new
+      node = make_node(new_subject)
+      node.attributes = attributes
+      if parent.kind_of? List::ListResource
+        parent.list << node
+        return node
+      elsif node.kind_of? RDF::List
+        self.push node.rdf_subject
+        return node
+      end
+      self.push node
+      node
+    end
+
+    def first_or_create(attributes={})
+      result.first || build(attributes)
+    end
+
+    def delete(*values)
+      values.each do |value|
+        parent.delete([rdf_subject, predicate, value])
+      end
+    end
+
+    def << (values)
+      values = Array.wrap(result) | Array.wrap(values)
+      self.set(values)
+    end
+
+    alias_method :push, :<<
+
+    def property_config
+      return type_property if (property == RDF.type || property.to_s == "type") && !parent.send(:properties)[property]
+      parent.send(:properties)[property]
+    end
+
+    def type_property
+      {:multivalue => true, :predicate => RDF.type}
+    end
+
+    def reset!
+    end
+
+    def property
+      value_arguments.last
+    end
+
+    def rdf_subject
+      raise ArgumentError("wrong number of arguments (#{value_arguments.length} for 1-2)") if value_arguments.length < 1 || value_arguments.length > 2
+      if value_arguments.length > 1
+        value_arguments.first
+      else
+        parent.rdf_subject
+      end
+    end
+
+    protected
+
+      def node_cache
+        @node_cache ||= {}
+      end
+
+      def set_value(val)
+        object = val
+        val = val.resource if val.respond_to?(:resource)
+        val = value_to_node(val)
+        if val.kind_of? Resource
+          node_cache[val.rdf_subject] = nil
+          add_child_node(val, object)
+          return
+        end
+        val = val.to_uri if val.respond_to? :to_uri
+        raise 'value must be an RDF URI, Node, Literal, or a valid datatype. See RDF::Literal' unless
+          val.kind_of? RDF::Value or val.kind_of? RDF::Literal
+        parent.insert [rdf_subject, predicate, val]
+      end
+
+      def value_to_node(val)
+        valid_datatype?(val) ? RDF::Literal(val) : val
+      end
+
+      def add_child_node(resource,object=nil)
+        parent.insert [rdf_subject, predicate, resource.rdf_subject]
+        resource.parent = parent unless resource.frozen?
+        self.node_cache[resource.rdf_subject] = (object ? object : resource)
+        resource.persist! if resource.class.repository == :parent
+      end
+
+      def predicate
+        return property_config[:predicate] unless property.kind_of? RDF::URI
+        property
+      end
+
+      def valid_datatype?(val)
+        val.is_a? String or val.is_a? Date or val.is_a? Time or val.is_a? Numeric or val.is_a? Symbol or val == !!val
+      end
+
+      # Converts an object to the appropriate class.
+      def convert_object(value)
+        value = value.object if value.kind_of? RDF::Literal
+        value = make_node(value) if value.kind_of? RDF::Resource
+        value
+      end
+
+      ##
+      # Build a child resource or return it from this object's cache
+      #
+      # Builds the resource from the class_name specified for the
+      # property.
+      def make_node(value)
+        klass = class_for_value(value)
+        value = RDF::Node.new if value.nil?
+        node = node_cache[value] if node_cache[value]
+        node ||= klass.from_uri(value,parent)
+        return nil if (property_config && property_config[:class_name]) && (class_for_value(value) != class_for_property)
+        self.node_cache[value] ||= node
+        node
+      end
+
+      def final_parent
+        @final_parent ||= begin
+          parent = self.parent
+          while parent != parent.parent && parent.parent
+            parent = parent.parent
+          end
+          return parent.datastream if parent.respond_to?(:datastream) && parent.datastream
+          parent
+        end
+      end
+
+      def class_for_value(v)
+        uri_class(v) || class_for_property
+      end
+
+      def uri_class(v)
+        v = RDF::URI.new(v) if v.kind_of? String
+        type_uri = parent.query([v, RDF.type, nil]).to_a.first.try(:object)
+        Resource.type_registry[type_uri]
+      end
+
+      def class_for_property
+        klass = property_config[:class_name] if property_config
+        klass ||= Resource
+        klass = ActiveTriples.class_from_string(klass, final_parent.class) if klass.kind_of? String
+        klass
+      end
+
+  end
+end

data/lib/active_triples/version.rb

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

data/spec/rdf_list_spec.rb

@@ -0,0 +1,183 @@
+require 'spec_helper'
+require 'nokogiri'
+require 'linkeddata'
+
+describe ActiveTriples::List do
+  before :each do
+    class MADS < RDF::Vocabulary("http://www.loc.gov/mads/rdf/v1#")
+      property :complexSubject
+      property :authoritativeLabel
+      property :elementList
+      property :elementValue
+      property :TopicElement
+      property :TemporalElement
+    end
+    class DemoList < ActiveTriples::Resource
+      property :elementList, :predicate => MADS.elementList, :class_name => 'DemoList::List'
+      class List < ActiveTriples::List
+        property :topicElement, :predicate => MADS.TopicElement, :class_name => 'DemoList::List::TopicElement'
+        property :temporalElement, :predicate => MADS.TemporalElement, :class_name => 'DemoList::List::TemporalElement'
+
+        class TopicElement < ActiveTriples::Resource
+          configure :type => MADS.TopicElement
+          property :elementValue, :predicate => MADS.elementValue
+        end
+        class TemporalElement < ActiveTriples::Resource
+          configure :type => MADS.TemporalElement
+          property :elementValue, :predicate => MADS.elementValue
+        end
+      end
+    end
+  end
+  after(:each) do
+    Object.send(:remove_const, :DemoList)
+    Object.send(:remove_const, :MADS)
+  end
+
+  describe "a new list" do
+    let (:ds) { DemoList.new('http://example.org/foo') }
+    subject { ds.elementList.build}
+
+    it "should insert at the end" do
+      subject.should be_kind_of DemoList::List
+      subject.size.should == 0
+      subject[1] = DemoList::List::TopicElement.new
+      subject.size.should == 2
+    end
+
+    it "should insert at the head" do
+      subject.should be_kind_of DemoList::List
+      subject.size.should == 0
+      subject[0] = DemoList::List::TopicElement.new
+      subject.size.should == 1
+    end
+
+    describe "that has 4 elements" do
+      before do
+        subject[3] = DemoList::List::TopicElement.new
+        subject.size.should == 4
+      end
+      it "should insert in the middle" do
+        subject[1] = DemoList::List::TopicElement.new
+        subject.size.should == 4
+      end
+    end
+
+    describe "return updated xml" do
+      it "should be built" do
+        subject[0] = RDF::URI.new "http://library.ucsd.edu/ark:/20775/bbXXXXXXX6"
+        subject[1] = DemoList::List::TopicElement.new
+        subject[1].elementValue = "Relations with Mexican Americans"
+        subject[2] = RDF::URI.new "http://library.ucsd.edu/ark:/20775/bbXXXXXXX4"
+        subject[3] = DemoList::List::TemporalElement.new
+        subject[3].elementValue = "20th century"
+        ds.elementList = subject
+        doc = Nokogiri::XML(ds.dump(:rdfxml))
+        ns = {rdf: "http://www.w3.org/1999/02/22-rdf-syntax-ns#", mads: "http://www.loc.gov/mads/rdf/v1#"}
+        expect(doc.xpath('/rdf:RDF/rdf:Description/@rdf:about', ns).map(&:value)).to eq ["http://example.org/foo"]
+        expect(doc.xpath('//rdf:Description/mads:elementList/@rdf:parseType', ns).map(&:value)).to eq ["Collection"]
+        expect(doc.xpath('//rdf:Description/mads:elementList/*[position() = 1]/@rdf:about', ns).map(&:value)).to eq ["http://library.ucsd.edu/ark:/20775/bbXXXXXXX6"]
+        expect(doc.xpath('//rdf:Description/mads:elementList/*[position() = 2]/mads:elementValue', ns).map(&:text)).to eq ["Relations with Mexican Americans"]
+        expect(doc.xpath('//rdf:Description/mads:elementList/*[position() = 3]/@rdf:about', ns).map(&:value)).to eq ["http://library.ucsd.edu/ark:/20775/bbXXXXXXX4"]
+        expect(doc.xpath('//rdf:Description/mads:elementList/*[position() = 4]/mads:elementValue', ns).map(&:text)).to eq ["20th century"]
+      end
+    end
+  end
+
+  describe "an empty list" do
+    subject { DemoList.new.elementList.build } 
+    it "should have to_ary" do
+      subject.to_ary.should == []
+    end
+  end
+
+  describe "a list that has a constructed element" do
+    let(:ds) { DemoList.new('http://example.org/foo') }
+    let(:list) { ds.elementList.build } 
+    let!(:topic) { list.topicElement.build }
+
+    it "should have to_ary" do
+      list.to_ary.size.should == 1
+      list.to_ary.first.class.should == DemoList::List::TopicElement
+    end
+
+    it "should be able to be cleared" do
+      list.topicElement.build
+      list.topicElement.build
+      list.topicElement.build
+      list.size.should == 4
+      list.clear
+      list.size.should == 0
+    end
+  end
+
+  describe "a list with content" do
+    subject do
+      subject = DemoList.new('http://example.org/foo')
+      subject << RDF::RDFXML::Reader.for(:rdfxml).new(<<END
+  <rdf:RDF
+      xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:mads="http://www.loc.gov/mads/rdf/v1#">
+
+        <mads:ComplexSubject rdf:about="http://example.org/foo">
+          <mads:elementList rdf:parseType="Collection">
+            <rdf:Description rdf:about="http://library.ucsd.edu/ark:/20775/bbXXXXXXX6"/>
+            <mads:TopicElement>
+              <mads:elementValue>Relations with Mexican Americans</mads:elementValue>
+            </mads:TopicElement>
+            <rdf:Description rdf:about="http://library.ucsd.edu/ark:/20775/bbXXXXXXX4"/>
+            <mads:TemporalElement>
+              <mads:elementValue>20th century</mads:elementValue>
+            </mads:TemporalElement>
+          </mads:elementList>
+        </mads:ComplexSubject>
+      </rdf:RDF>
+END
+)
+
+      subject
+    end
+    it "should have a subject" do
+      subject.rdf_subject.to_s.should == "http://example.org/foo"
+    end
+
+    let (:list) { subject.elementList.first }
+
+    it "should have fields" do
+      list.first.rdf_subject.should == "http://library.ucsd.edu/ark:/20775/bbXXXXXXX6"
+      list[1].should be_kind_of DemoList::List::TopicElement
+      list[1].elementValue.should == ["Relations with Mexican Americans"]
+      list[2].rdf_subject.should == "http://library.ucsd.edu/ark:/20775/bbXXXXXXX4"
+      list[3].should be_kind_of DemoList::List::TemporalElement
+      list[3].elementValue.should == ["20th century"]
+    end
+
+    it "should have each" do
+      foo = []
+      list.each { |n| foo << n.class }
+      foo.should == [ActiveTriples::Resource, DemoList::List::TopicElement, ActiveTriples::Resource, DemoList::List::TemporalElement]
+    end
+
+    it "should have to_ary" do
+      ary = list.to_ary
+      ary.size.should == 4
+      ary[1].elementValue.should == ['Relations with Mexican Americans']
+    end
+
+    it "should have size" do
+      list.size.should == 4
+    end
+
+    it "should update fields" do
+      list[3].elementValue = ["1900s"]
+      doc = Nokogiri::XML(subject.dump :rdfxml)
+      ns = {rdf: "http://www.w3.org/1999/02/22-rdf-syntax-ns#", mads: "http://www.loc.gov/mads/rdf/v1#"}
+      expect(doc.xpath('/rdf:RDF/mads:ComplexSubject/@rdf:about', ns).map(&:value)).to eq ["http://example.org/foo"]
+      expect(doc.xpath('//mads:ComplexSubject/mads:elementList/@rdf:parseType', ns).map(&:value)).to eq ["Collection"]
+      expect(doc.xpath('//mads:ComplexSubject/mads:elementList/*[position() = 1]/@rdf:about', ns).map(&:value)).to eq ["http://library.ucsd.edu/ark:/20775/bbXXXXXXX6"]
+      expect(doc.xpath('//mads:ComplexSubject/mads:elementList/*[position() = 2]/mads:elementValue', ns).map(&:text)).to eq ["Relations with Mexican Americans"]
+      expect(doc.xpath('//mads:ComplexSubject/mads:elementList/*[position() = 3]/@rdf:about', ns).map(&:value)).to eq ["http://library.ucsd.edu/ark:/20775/bbXXXXXXX4"]
+      expect(doc.xpath('//mads:ComplexSubject/mads:elementList/*[position() = 4]/mads:elementValue', ns).map(&:text)).to eq ["1900s"]
+    end
+  end
+end
+

data/spec/rdf_nested_attributes_spec.rb

@@ -0,0 +1,183 @@
+require 'spec_helper'
+
+describe "nesting attribute behavior" do
+  describe ".attributes=" do
+    describe "complex properties" do
+      before do
+        class DummyMADS < RDF::Vocabulary("http://www.loc.gov/mads/rdf/v1#")
+          # componentList and Types of components
+          property :componentList
+          property :Topic
+          property :Temporal
+          property :PersonalName
+          property :CorporateName
+          property :ComplexSubject
+
+
+          # elementList and elementList values
+          property :elementList
+          property :elementValue
+          property :TopicElement
+          property :TemporalElement
+          property :NameElement
+          property :FullNameElement
+          property :DateNameElement
+        end
+
+        class ComplexResource < ActiveTriples::Resource
+          property :topic, predicate: DummyMADS.Topic, class_name: "Topic"
+          property :personalName, predicate: DummyMADS.PersonalName, class_name: "PersonalName"
+          property :title, predicate: RDF::DC.title
+
+
+          accepts_nested_attributes_for :topic, :personalName
+
+          class Topic < ActiveTriples::Resource
+            property :elementList, predicate: DummyMADS.elementList, class_name: "ComplexResource::ElementList"
+            accepts_nested_attributes_for :elementList
+          end
+          class PersonalName < ActiveTriples::Resource
+            property :elementList, predicate: DummyMADS.elementList, class_name: "ComplexResource::ElementList"
+            property :extraProperty, predicate: DummyMADS.elementValue, class_name: "ComplexResource::Topic"
+            accepts_nested_attributes_for :elementList, :extraProperty
+          end
+          class ElementList < ActiveTriples::List
+            configure type: DummyMADS.elementList
+            property :topicElement, predicate: DummyMADS.TopicElement, class_name: "ComplexResource::MadsTopicElement"
+            property :temporalElement, predicate: DummyMADS.TemporalElement
+            property :fullNameElement, predicate: DummyMADS.FullNameElement
+            property :dateNameElement, predicate: DummyMADS.DateNameElement
+            property :nameElement, predicate: DummyMADS.NameElement
+            property :elementValue, predicate: DummyMADS.elementValue
+            accepts_nested_attributes_for :topicElement
+          end
+          class MadsTopicElement < ActiveTriples::Resource
+            configure :type => DummyMADS.TopicElement
+            property :elementValue, predicate: DummyMADS.elementValue
+          end
+        end
+      end
+      after do
+        Object.send(:remove_const, :ComplexResource)
+        Object.send(:remove_const, :DummyMADS)
+      end
+      subject { ComplexResource.new }
+      let(:params) do
+        { myResource:
+          {
+            topic_attributes: {
+              '0' =>
+              {
+                elementList_attributes: [{
+                  topicElement_attributes: [{
+                    id: 'http://library.ucsd.edu/ark:/20775/bb3333333x',
+                    elementValue:"Cosmology"
+                     }]
+                  }]
+              },
+              '1' =>
+              {
+                elementList_attributes: [{
+                  topicElement_attributes: {'0' => {elementValue:"Quantum Behavior"}}
+                }]
+              }
+            },
+            personalName_attributes: [
+              {
+                id: 'http://library.ucsd.edu/ark:20775/jefferson',
+                elementList_attributes: [{                         
+                  fullNameElement: "Jefferson, Thomas",
+                  dateNameElement: "1743-1826"
+                }]
+              }
+              #, "Hemings, Sally"
+            ],
+          }
+        }
+      end
+
+      describe "on lists" do
+        subject { ComplexResource::PersonalName.new }
+        it "should accept a hash" do
+          subject.elementList_attributes =  [{ topicElement_attributes: {'0' => { elementValue:"Quantum Behavior" }, '1' => { elementValue:"Wave Function" }}}]
+          subject.elementList.first[0].elementValue.should == ["Quantum Behavior"]
+          subject.elementList.first[1].elementValue.should == ["Wave Function"]
+
+        end
+        it "should accept an array" do
+          subject.elementList_attributes =  [{ topicElement_attributes: [{ elementValue:"Quantum Behavior" }, { elementValue:"Wave Function" }]}]
+          subject.elementList.first[0].elementValue.should == ["Quantum Behavior"]
+          subject.elementList.first[1].elementValue.should == ["Wave Function"]
+        end
+      end
+
+      context "from nested objects" do
+        before do
+          # Replace the graph's contents with the Hash
+          subject.attributes = params[:myResource]
+        end
+
+        it 'should have attributes' do
+          subject.topic[0].elementList.first[0].elementValue.should == ["Cosmology"]
+          subject.topic[1].elementList.first[0].elementValue.should == ["Quantum Behavior"]
+          subject.personalName.first.elementList.first.fullNameElement.should == ["Jefferson, Thomas"]
+          subject.personalName.first.elementList.first.dateNameElement.should == ["1743-1826"]
+        end
+        
+        it 'should build nodes with ids' do
+          expect(subject.topic[0].elementList.first[0].rdf_subject).to eq 'http://library.ucsd.edu/ark:/20775/bb3333333x'
+          expect(subject.personalName.first.rdf_subject).to eq  'http://library.ucsd.edu/ark:20775/jefferson'
+        end
+        
+        it 'should fail when writing to a non-predicate' do
+          attributes = { topic_attributes: { '0' => { elementList_attributes: [{ topicElement_attributes: [{ fake_predicate:"Cosmology" }] }]}}}
+          expect{ subject.attributes = attributes }.to raise_error ArgumentError
+        end
+
+        it 'should fail when writing to a non-predicate with a setter method' do
+          attributes = { topic_attributes: { '0' => { elementList_attributes: [{ topicElement_attributes: [{ name:"Cosmology" }] }]}}}
+          expect{ subject.attributes = attributes }.to raise_error ArgumentError
+        end
+      end
+    end
+
+    describe "with an existing object" do
+      before(:each) do
+        class SpecResource < ActiveTriples::Resource
+          property :parts, predicate: RDF::DC.hasPart, :class_name=>'Component'
+          accepts_nested_attributes_for :parts, allow_destroy: true
+
+          class Component < ActiveTriples::Resource
+            property :label, predicate: RDF::DC.title
+          end
+        end
+
+      end
+
+      after(:each) do
+        Object.send(:remove_const, :SpecResource)
+      end
+      subject { SpecResource.new }
+      before do
+        subject.attributes = { parts_attributes: [
+                                  {label: 'Alternator'},
+                                  {label: 'Distributor'},
+                                  {label: 'Transmission'},
+                                  {label: 'Fuel Filter'}]}
+      end
+      let (:replace_object_id) { subject.parts[1].rdf_subject.to_s }
+      let (:remove_object_id) { subject.parts[3].rdf_subject.to_s }
+
+      it "should update nested objects" do
+        subject.parts_attributes= [{id: replace_object_id, label: "Universal Joint"}, {label:"Oil Pump"}, {id: remove_object_id, _destroy: '1', label: "bar1 uno"}]
+
+        subject.parts.map{|p| p.label.first}.should == ['Alternator', 'Universal Joint', 'Transmission', 'Oil Pump']
+
+      end
+      it "create a new object when the id is provided" do
+       subject.parts_attributes= [{id: 'http://example.com/part#1', label: "Universal Joint"}]
+       expect(subject.parts.last.rdf_subject).to eq RDF::URI('http://example.com/part#1')
+      end
+    end
+  end
+end