safety_pin 0.0.4 → 0.0.5

data/.rspec

@@ -1 +1 @@
---format progress --color
+--format p --color

data/.rvmrc

@@ -1 +1 @@
-rvm use --create jruby-1.6.7@safety_pin
+rvm use --create jruby-1.6.6@safety_pin

data/Gemfile

@@ -1,3 +1,4 @@
 source "http://rubygems.org"
 
-gem "rspec", "~> 2.10.0"
+gem "rspec", "~> 2.10.0"
+gem "nyan-cat-formatter"

data/Gemfile.lock

@@ -2,6 +2,7 @@ GEM
   remote: http://rubygems.org/
   specs:
     diff-lcs (1.1.3)
+    nyan-cat-formatter (0.0.7)
     rspec (2.10.0)
       rspec-core (~> 2.10.0)
       rspec-expectations (~> 2.10.0)
@@ -12,7 +13,9 @@ GEM
     rspec-mocks (2.10.1)
 
 PLATFORMS
+  java
   ruby
 
 DEPENDENCIES
+  nyan-cat-formatter
   rspec (~> 2.10.0)

data/bin/console

@@ -0,0 +1 @@
+irb -r './console_loader' --simple-prompt

data/console_loader.rb

@@ -0,0 +1,4 @@
+$:<<File.dirname(__FILE__)
+require 'lib/safety_pin'
+include SafetyPin
+JCR.dev_login

data/lib/safety_pin/node.rb

@@ -1,3 +1,5 @@
+require 'pathname'
+
 module SafetyPin
   class Node
     include_class 'javax.jcr.PropertyType'
@@ -13,13 +15,22 @@ module SafetyPin
       nil
     end
     
+    def self.find_or_create(path)
+      find(path) || create(path)
+    end
+
+    def self.exists?(path)
+      find(path) != nil
+    end
+    
     def self.session
       JCR.session
     end
     
-    def self.build(path, node_type = nil)
+    def self.build(path, node_type = nil, properties = nil)
       path = path.to_s
       node_type ||= "nt:unstructured"
+      properties ||= {}
       rel_path = nil
       if path.start_with?("/")
         rel_path = path.sub("/","")
@@ -30,18 +41,39 @@ module SafetyPin
       if session.root_node.has_node(rel_path)
         raise NodeError.new("Node already exists at path: #{path}")
       else
-        self.new(session.root_node.add_node(rel_path, node_type))
+        node = self.new(session.root_node.add_node(rel_path, node_type))
+        node.properties = properties
+
+        node
       end
     rescue javax.jcr.PathNotFoundException => e
       raise NodeError.new("Cannot add a new node to a non-existing parent at #{path}")
     end
     
-    def self.create(path, node_type = nil)
-      node = self.build(path, node_type)
+    def self.create(path, node_type = nil, properties = nil)
+      node = self.build(path, node_type, properties)
       node.save
       node
     end
 
+    def self.create_parents(path)
+      intermediate_paths = []
+
+      current_intermediate_path = Pathname(path)
+      while(current_intermediate_path.to_s != "/")
+        current_intermediate_path = current_intermediate_path.parent
+        intermediate_paths.push(current_intermediate_path)
+      end
+      
+      results = intermediate_paths.reverse.map do |intermediate_path|
+        create(intermediate_path) unless exists?(intermediate_path)
+      end
+
+      session.save
+
+      results
+    end
+
     def initialize(j_node)
       @j_node = j_node
     end
@@ -63,7 +95,7 @@ module SafetyPin
     end
     
     def child(relative_path)
-      child_j_node = j_node.get_node(relative_path)
+      child_j_node = j_node.get_node(relative_path.to_s)
       Node.new(child_j_node)
     rescue javax.jcr.PathNotFoundException
       nil
@@ -140,8 +172,14 @@ module SafetyPin
         calendar_value = Calendar.instance
         calendar_value.set_time(value.to_java)
         j_node.set_property(name, calendar_value)
+      elsif value.is_a? Symbol
+        j_node.set_property(name, value.to_s)
       else
-        j_node.set_property(name, value)
+        begin
+          j_node.set_property(name, value)
+        rescue NameError
+          raise SafetyPin::PropertyTypeError.new("Property value type of #{value.class} is unsupported")
+        end
       end
     end
     
@@ -202,12 +240,13 @@ module SafetyPin
     end
     
     def properties=(new_props)
-      # props.each do |name, value|
-      #   self[name] = value
-      # end
       property_names = (properties.keys + new_props.keys).uniq
       property_names.each do |name|
-        self[name] = new_props[name]
+        if new_props[name].is_a?(Hash)
+          build(name, nil, new_props[name])
+        else
+          self[name] = new_props[name]
+        end
       end
     end
     
@@ -241,10 +280,19 @@ module SafetyPin
       self["jcr:primaryType"]
     end
     
+    def find_or_create(name, type = nil)
+      child(name) || create(name, type)
+    end
+    
     # Create and return a child node with a given name
-    def create(name, type = nil)
-      path = Pathname(self.path) + name
-      Node.create(path, type)
+    def create(name, type = nil, properties = nil)
+      path = Pathname(self.path) + name.to_s
+      Node.create(path, type, properties)
+    end
+
+    def build(name, type = nil, properties = nil)
+      path = Pathname(self.path) + name.to_s
+      Node.build(path, type, properties)
     end
   end
   

data/lib/safety_pin/version.rb

@@ -1,3 +1,3 @@
 module SafetyPin
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/spec/jcr_spec.rb

@@ -1,7 +1,15 @@
 require 'spec_helper.rb'
 
 describe SafetyPin::JCR do
-  it "should login to a remote SafetyPin::JCR" do
+  before(:all) do
+    SafetyPin::JCR.logout
+  end
+  
+  after(:all) do
+    SafetyPin::JCR.dev_login
+  end
+  
+  it "should login to a remote JCR" do
     SafetyPin::JCR.login(:hostname => "http://localhost:4502", :username => "admin", :password => "admin")
     SafetyPin::JCR.session.should be_a(Java::JavaxJcr::Session)
     SafetyPin::JCR.should be_logged_in

data/spec/jcr_sql2_spec.rb

@@ -1,18 +1,6 @@
 require 'spec_helper.rb'
 
-describe "JCR-SQL2 example queries" do
-  before(:all) do
-    SafetyPin::JCR.login(:hostname => "http://localhost:4502", :username => "admin", :password => "admin")
-  end
-  
-  before do
-    SafetyPin::JCR.session.refresh(false)
-  end
-  
-  after(:all) do
-    SafetyPin::JCR.logout
-  end
-  
+describe "JCR-SQL2 example queries" do  
   before do
     @node = SafetyPin::Node.create("/content/foo")
     @node.properties = {"bar" => "baz", "qux" => "qax"}

data/spec/node_spec.rb

@@ -1,19 +1,7 @@
 require 'spec_helper.rb'
 
-describe SafetyPin::Node do
-  before(:all) do
-    SafetyPin::JCR.login(:hostname => "http://localhost:4502", :username => "admin", :password => "admin")
-  end
-  
-  before do
-    SafetyPin::JCR.session.refresh(false)
-  end
-  
-  after(:all) do
-    SafetyPin::JCR.logout
-  end
-  
-  context ".find" do
+describe SafetyPin::Node do  
+  describe ".find" do
     context "given a node name" do
       context "that exists" do
         it "should return a node with a matching path" do
@@ -33,13 +21,40 @@ describe SafetyPin::Node do
     end
   end
   
-  context ".session" do
+  describe ".find_or_create" do    
+    context "given a node path that exists" do
+      it "should return the node at that path" do
+        SafetyPin::Node.create("/content/foo")
+        SafetyPin::Node.find_or_create("/content/foo").path.should eql "/content/foo"
+      end
+    end
+    
+    context "give a node path that doesn't exist" do
+      it "should create a node at the path and return it" do
+        SafetyPin::Node.find("/content/foo").should be_nil
+        SafetyPin::Node.find_or_create("/content/foo").path.should eql "/content/foo"
+      end
+    end
+  end
+
+  describe ".exists?" do
+    it "returns true if node exists at path" do
+      SafetyPin::Node.create("/content/foo")
+      SafetyPin::Node.exists?("/content/foo").should be_true
+    end
+
+    it "returns false if node does not exist" do
+      SafetyPin::Node.exists?("/content/foo").should be_false
+    end
+  end
+  
+  describe ".session" do
     it "should return a session" do
       SafetyPin::Node.session.should be_a(Java::JavaxJcr::Session)
     end
   end
   
-  context "#session" do
+  describe "#session" do
     it "should return a session" do
       SafetyPin::Node.find("/content").session.should be_a(Java::JavaxJcr::Session)
     end
@@ -51,13 +66,13 @@ describe SafetyPin::Node do
     end
   end
   
-  context "#children" do
+  describe "#children" do
     it "should return an array of child nodes" do
       SafetyPin::Node.find("/content").children.first.should be_a(SafetyPin::Node)
     end
   end
   
-  context "#child" do
+  describe "#child" do
     context "given a node name" do
       let(:node) { SafetyPin::Node.find("/") }
       
@@ -69,9 +84,12 @@ describe SafetyPin::Node do
         it "should return a grandchild node given a relative path" do
           SafetyPin::Node.create("/content/foo")
           node.child("content/foo").name.should eql("foo")
-          SafetyPin::Node.find("/content/foo").destroy
         end
       end
+
+      it "should coerce non-string name to string and return child" do
+        node.child(:content).name.should == "content"
+      end
       
       context "that doesn't exist" do
         it "should return nil" do
@@ -81,7 +99,24 @@ describe SafetyPin::Node do
     end
   end
   
-  context "#name" do
+  describe "#find_or_create_child" do
+    let(:parent) { SafetyPin::Node.create("/content/foo") }
+    
+    context "an existing node path" do
+      it "should return the child node" do
+        parent.create("bar")
+        parent.find_or_create("bar").path.should eql "/content/foo/bar"
+      end
+    end
+    
+    context "a non-existing node path" do
+      it "should create a node and return it" do
+        parent.find_or_create("bar").path.should eql "/content/foo/bar"
+      end
+    end
+  end
+  
+  describe "#name" do
     it "should return a string name" do
       SafetyPin::Node.find("/content").name.should eql("content")
     end
@@ -93,8 +128,6 @@ describe SafetyPin::Node do
         @node = SafetyPin::Node.create("/content/foo")
         @node["bar"] = "baz"
       end
-      
-      after { @node.destroy }
     
       it "should save the changes to the JCR" do
         @node.save
@@ -112,7 +145,6 @@ describe SafetyPin::Node do
       it "should save the node" do
         node = SafetyPin::Node.build("/content/foo")
         node.save.should be_true
-        node.destroy
       end
       
       it "should save changes in parent node" do
@@ -122,54 +154,51 @@ describe SafetyPin::Node do
         parent_node.should be_changed
         node.save
         parent_node.should_not be_changed
-        node.destroy
-        parent_node.destroy
       end
     end
   end
   
   describe "#read_attribute" do
     context "on an existing node" do
-      before { @node = SafetyPin::Node.create("/content/foo") }
-      after { @node.destroy }
+      let(:node) { SafetyPin::Node.create("/content/foo") }
     
       it "should return the string value of a string property" do
-        @node["foo"] = "bar"
-        @node.read_attribute("foo").should eql("bar")
+        node["foo"] = "bar"
+        node.read_attribute("foo").should eql("bar")
       end
     
       it "should return the boolean value of a boolean property" do
-        @node["foo"] = true
-        @node.read_attribute("foo").should eql(true)
+        node["foo"] = true
+        node.read_attribute("foo").should eql(true)
       end
     
       it "should return the double value of a double (or Ruby float) property" do
-        @node["foo"] = 3.14
-        @node.read_attribute("foo").should eql(3.14)
+        node["foo"] = 3.14
+        node.read_attribute("foo").should eql(3.14)
       end
     
       it "should return the long value of a long (or Ruby Fixnum) property" do
-        @node["foo"] = 42
-        @node.read_attribute("foo").should eql(42)
+        node["foo"] = 42
+        node.read_attribute("foo").should eql(42)
       end
     
       it "should return the time value of a date property" do
         time = Time.now
-        @node["foo"] = time
-        @node.read_attribute("foo").to_s.should eql(time.to_s)
+        node["foo"] = time
+        node.read_attribute("foo").to_s.should eql(time.to_s)
       end
       
       context "given a multi-value property" do
         it "should return an array of values" do
-          @node["foo"] = ["one", "two"]
-          @node.read_attribute("foo").should eql(["one", "two"])
+          node["foo"] = ["one", "two"]
+          node.read_attribute("foo").should eql(["one", "two"])
         end
       end
       
       context "given a non-string name" do
         it "should co-erce the name into a string and retrieve the property" do
-          @node["foo"] = "bar"
-          @node.read_attribute(:foo).should eql("bar")
+          node["foo"] = "bar"
+          node.read_attribute(:foo).should eql("bar")
         end
       end
     end
@@ -184,33 +213,58 @@ describe SafetyPin::Node do
   end
   
   context "#write_attribute" do
-    before { @node = SafetyPin::Node.create("/content/foo") }
-    after { @node.destroy }
+    let(:node) { SafetyPin::Node.create("/content/foo") }
      
     context "given a single value" do
       it "should set a string property value" do
-        @node.write_attribute("foo", "bar")
-        @node.save
-        @node.reload
-        @node["foo"].should eql("bar")
+        node.write_attribute("foo", "bar")
+        node.save
+        node.reload
+        node["foo"].should eql("bar")
       end
     
-      context "given a Time object" do
+      context "given a Time object value" do
         it "should set a date property value" do
           time = Time.now
-          @node.write_attribute("foo", time)
-          @node.save
-          @node.reload
-          @node["foo"].to_s.should eql(time.to_s)
+          node.write_attribute("foo", time)
+          node.save
+          node.reload
+          node["foo"].to_s.should eql(time.to_s)
+        end
+      end
+
+      context "given a symbol value" do
+        it "coerces value to string" do
+          node.write_attribute("foo", :bar)
+          node["foo"].should == "bar"
+        end
+      end
+
+      context "given another supported value" do
+        it "sets the property" do
+          node.write_attribute("foo", 1)
+          node["foo"].should == 1
+          node.write_attribute("foo", 1.1)
+          node["foo"].should == 1.1
+          node.write_attribute("foo", true)
+          node["foo"].should == true
+          node.write_attribute("foo", "bar")
+          node["foo"].should == "bar"
+        end
+      end
+
+      context "given an unsupported value" do
+        it "raises an error" do
+          lambda { node.write_attribute("foo", {unsupported: :value_type}) }.should raise_error(SafetyPin::PropertyTypeError)
         end
       end
       
       context "given a non-string name" do
         it "should co-erce name into string before setting property" do          
-          @node.write_attribute(:foo, "bar")
-          @node.save
-          @node.reload
-          @node["foo"].should eql("bar")
+          node.write_attribute(:foo, "bar")
+          node.save
+          node.reload
+          node["foo"].should eql("bar")
         end
       end
     end
@@ -218,51 +272,50 @@ describe SafetyPin::Node do
     context "given an array of values" do
       context "of the same type" do
         it "should set a multi-value string array" do
-          @node.write_attribute("foo", ["one", "two"])
-          @node.save
-          @node.reload
-          @node["foo"].should eql(["one", "two"])
+          node.write_attribute("foo", ["one", "two"])
+          node.save
+          node.reload
+          node["foo"].should eql(["one", "two"])
         end
       end
     end
     
     context "given a null value" do
       it "should remove the property" do
-        @node["foo"] = "bar"
-        @node.write_attribute("foo", nil)
-        lambda { @node["foo"] }.should raise_error(SafetyPin::NilPropertyError)
+        node["foo"] = "bar"
+        node.write_attribute("foo", nil)
+        lambda { node["foo"] }.should raise_error(SafetyPin::NilPropertyError)
       end
       
       context "given a non-existent property and a null value" do
         it "should return nil" do
-          @node.write_attribute("foo", nil).should be_nil
+          node.write_attribute("foo", nil).should be_nil
         end
       end
     end
 
     context "changing jcr:primaryType property" do
       it "should raise an error" do
-       lambda { @node.write_attribute("jcr:primaryType", "nt:folder") }.should raise_error(SafetyPin::PropertyError)
+       lambda { node.write_attribute("jcr:primaryType", "nt:folder") }.should raise_error(SafetyPin::PropertyError)
       end
     end
   end
   
   context "#reload" do
-    before { @node = SafetyPin::Node.create("/content/foo") }
-    after { @node.destroy }
+    let(:node) { SafetyPin::Node.create("/content/foo") }
     
     it "should discard pending changes" do
-      @node["foo"] = "bar"
-      @node.reload
-      lambda { @node.read_attribute("foo") }.should raise_error(SafetyPin::NilPropertyError)
+      node["foo"] = "bar"
+      node.reload
+      lambda { node.read_attribute("foo") }.should raise_error(SafetyPin::NilPropertyError)
     end
     
     it "should not discard changes for another node" do
-      @node["bar"] = "baz"
+      node["bar"] = "baz"
       another_node = SafetyPin::Node.find("/content")
       another_node["bar"] = "baz"
-      @node.reload
-      lambda { @node["bar"] }.should raise_error(SafetyPin::NilPropertyError)
+      node.reload
+      lambda { node["bar"] }.should raise_error(SafetyPin::NilPropertyError)
       another_node["bar"].should eql("baz")
     end
   end
@@ -273,7 +326,6 @@ describe SafetyPin::Node do
       node.write_attribute("bar","baz")
       node.save
       node["bar"].should eql("baz")
-      node.destroy
     end
   end
   
@@ -317,18 +369,22 @@ describe SafetyPin::Node do
   end
   
   describe "#properties=" do
-    before { @node = SafetyPin::Node.create("/content/foo") }
-    after  { @node.destroy }
+    let(:node) { SafetyPin::Node.create("/content/foo") }
     
     it "should set the properties of a node" do
-      @node.properties = {"foo" => "bar"}
-      @node.properties.should eql({"foo" => "bar"})
+      node.properties = {"foo" => "bar"}
+      node.properties.should == {"foo" => "bar"}
     end
     
     it "should set unset properties not specified in hash" do
-      @node["foo"] = "bar"
-      @node.properties = {"baz" => "qux"}
-      @node.properties.should eql({"baz" => "qux"})
+      node["foo"] = "bar"
+      node.properties = {"baz" => "qux"}
+      node.properties.should eql({"baz" => "qux"})
+    end
+
+    it "should create child nodes for hash values" do
+      node.properties = {foo: {bar: "baz"}}
+      node.child(:foo).properties.should == {"bar" => "baz"}
     end
   end
   
@@ -339,55 +395,48 @@ describe SafetyPin::Node do
   end
   
   describe "#mixin_types" do
-    before do
-      @node = SafetyPin::Node.create("/content/foo")
-      @node.j_node.add_mixin("mix:created")
-      @node.save
-    end
-    
-    after  { @node.destroy }
-  
     it "should return the mixin types of a node" do
-      @node.mixin_types.should eql(["mix:created"])
+      node = SafetyPin::Node.create("/content/foo")
+      node.j_node.add_mixin("mix:created")
+      node.save
+      node.mixin_types.should eql(["mix:created"])
     end
   end
   
   describe "#add_mixin" do
-    before { @node = SafetyPin::Node.create("/content/foo") }
-    after  { @node.destroy }
+    let(:node) { SafetyPin::Node.create("/content/foo") }
   
     it "should add a mixin type to node" do
-      @node.add_mixin("mix:created")
-      @node.save
-      @node.mixin_types.should eql(["mix:created"])
+      node.add_mixin("mix:created")
+      node.save
+      node.mixin_types.should eql(["mix:created"])
     end
     
     it "should require a save before the mixin addition is detected" do
-      @node.add_mixin("mix:created")
-      @node.mixin_types.should eql([])
+      node.add_mixin("mix:created")
+      node.mixin_types.should eql([])
     end
   end
   
   describe "#remove_mixin" do
-    before do 
-      @node = SafetyPin::Node.create("/content/foo") 
-      @node.add_mixin("mix:created")
-      @node.save
+    let(:node) do 
+      node = SafetyPin::Node.create("/content/foo") 
+      node.add_mixin("mix:created")
+      node.save
+      node
     end
     
-    after  { @node.destroy }
-    
     it "should remove a mixin type from a node" do
-      @node.mixin_types.should eql(["mix:created"])
-      @node.remove_mixin("mix:created")
-      @node.save
-      @node.mixin_types.should eql([])
+      node.mixin_types.should eql(["mix:created"])
+      node.remove_mixin("mix:created")
+      node.save
+      node.mixin_types.should eql([])
     end
     
     it "should require a save before the mixin removal is detected" do
-      @node.remove_mixin("mix:created")
-      @node.mixin_types.should eql(["mix:created"])
-      @node.reload
+      node.remove_mixin("mix:created")
+      node.mixin_types.should eql(["mix:created"])
+      node.reload
     end
   end
 
@@ -398,6 +447,15 @@ describe SafetyPin::Node do
         node.should be_new
         node.properties.should eql({})
       end
+
+
+
+      context "given properties" do
+        it "should build a node with properties" do
+          node = SafetyPin::Node.build("/content/foo", nil, {foo: "bar"})
+          node.properties.should == {"foo" => "bar"}
+        end
+      end
       
       context "and a node type string" do
         it "should create an unsaved node of the given type" do
@@ -446,10 +504,16 @@ describe SafetyPin::Node do
       it "should build and save a node of the specified type" do
         node = SafetyPin::Node.create("/content/foo", "nt:folder")
         SafetyPin::Node.find("/content/foo").should_not be_nil
-        node.destroy
       end
     end
   end
+
+  describe ".create_parents" do
+    it "creates parent nodes if they do not exist" do
+      SafetyPin::Node.create_parents("/content/foo/bar/baz")
+      SafetyPin::Node.create("/content/foo/bar/baz").should_not be_nil
+    end
+  end
   
   context "#value_factory" do
     it "should return a value factory instance" do
@@ -464,7 +528,6 @@ describe SafetyPin::Node do
       node.save
       property = node.j_node.get_property("bar")
       node.property_is_multi_valued?(property).should be_true
-      node.destroy
     end
     
     it "should return false if property is not multi-valued" do
@@ -473,7 +536,6 @@ describe SafetyPin::Node do
       node.save
       property = node.j_node.get_property("bar")
       node.property_is_multi_valued?(property).should be_false
-      node.destroy
     end
   end
   
@@ -492,48 +554,64 @@ describe SafetyPin::Node do
       parent_node.should be_changed
       node.destroy
       parent_node.should_not be_changed
-      parent_node.destroy
     end
     
-    context "when it fails" do
-      before do
-        @node = SafetyPin::Node.create("/content/foo")
-        @node.add_mixin("mix:created")
-        @node.save
-      end
-      
-      after { @node.reload; @node.destroy }
-      
+    context "when it fails" do      
       it "should raise an error" do
-        @node.remove_mixin("mix:created") # make node unremoveable
-        lambda { @node.destroy }.should raise_error(SafetyPin::NodeError)
+        node = SafetyPin::Node.create("/content/foo")
+        node.add_mixin("mix:created")
+        node.save
+        node.remove_mixin("mix:created") # make node unremoveable
+        lambda { node.destroy }.should raise_error(SafetyPin::NodeError)
       end
     end
   end
   
   describe "#primary_type" do
-    before { @node = SafetyPin::Node.create("/content/foo") }
-    after { @node.destroy }
+    let(:node) { SafetyPin::Node.create("/content/foo") }
     
     it "should return the primary type of the node" do
-      @node.primary_type.should eql("nt:unstructured")
+      node.primary_type.should eql("nt:unstructured")
     end
   end
   
-  describe "#create" do
-    before { @node = SafetyPin::Node.create("/content/foo") }
-    after { @node.destroy }
+  describe "#build" do
+    let(:node) { SafetyPin::Node.create("/content/foo") }
     
     it "should create a child node with a given name" do
-      @node.create("bar")
-      SafetyPin::Node.find("/content/foo/bar").should be_a(SafetyPin::Node)
+      node.build("bar").path.should == "/content/foo/bar"
     end
     
     it "should create a child node with a given name and node type" do
-      @node.create("bar", "nt:folder")
-      child_node = SafetyPin::Node.find("/content/foo/bar")
+      child_node = node.build("bar", "nt:folder")
       child_node.should be_a(SafetyPin::Node)
       child_node.primary_type.should eql("nt:folder")
     end
+
+    it "should create a child node with a name, node type, and properties" do
+      node.build("bar", nil, {foo: "bar"}).properties.should == {"foo" => "bar"}
+    end
+  end
+
+  describe "#create" do
+    let(:node) { SafetyPin::Node.create("/content/foo") }
+    
+    it "should create a child node with a given name" do
+      child_node = node.create("bar")
+      child_node.path.should == "/content/foo/bar"
+      child_node.should_not
+    end
+    
+    it "should create a child node with a given name and node type" do
+      child_node = node.create("bar", "nt:folder")
+      child_node.should_not be_new
+      child_node.primary_type.should eql("nt:folder")
+    end
+
+    it "should create a child node with a name, node type, and properties" do
+      child_node = node.create("bar", nil, {foo: "bar"})
+      child_node.should_not be_new
+      child_node.properties.should == {"foo" => "bar"}
+    end
   end
 end

data/spec/query_spec.rb

@@ -1,18 +1,6 @@
 require 'spec_helper.rb'
 
-describe SafetyPin::Query do
-  before(:all) do
-    SafetyPin::JCR.login(:hostname => "http://localhost:4502", :username => "admin", :password => "admin")
-  end
-  
-  before do
-    SafetyPin::JCR.session.refresh(false)
-  end
-
-  after(:all) do
-    SafetyPin::JCR.logout
-  end
-  
+describe SafetyPin::Query do  
   let(:query) { SafetyPin::Query.new }
 
   describe ".execute" do

data/spec/spec_helper.rb

@@ -1,3 +1,27 @@
 $:<<File.join(File.dirname(__FILE__), '/../lib')
 
-require 'safety_pin'
+require 'safety_pin'
+
+RSpec.configure do |config|
+  config.before(:all) do
+    SafetyPin::JCR.dev_login
+  end
+
+  config.before do
+    SafetyPin::JCR.session.refresh(false) if SafetyPin::JCR.logged_in?
+  end
+  
+  config.after(:all) do
+    SafetyPin::JCR.logout
+  end
+  
+  config.after do
+    if SafetyPin::JCR.logged_in?
+      node = SafetyPin::Node.find("/content/foo")
+      unless node.nil?
+        node.reload if node.changed?
+        node.destroy
+      end
+    end
+  end
+end

metadata

@@ -1,79 +1,75 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: safety_pin
-version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.0.4
+version: !ruby/object:Gem::Version
+  prerelease:
+  version: 0.0.5
 platform: ruby
-authors: 
-  - Jordan Raine
-autorequire: 
+authors:
+- Jordan Raine
+autorequire:
 bindir: bin
 cert_chain: []
-
-date: 2012-05-18 00:00:00 Z
+date: 2012-08-23 00:00:00.000000000 Z
 dependencies: []
-
 description: An easy-to-use JCR connector for JRuby
-email: 
-  - jnraine@gmail.com
-executables: []
-
+email:
+- jnraine@gmail.com
+executables:
+- console
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-  - .rspec
-  - .rvmrc
-  - Gemfile
-  - Gemfile.lock
-  - LICENSE
-  - README.md
-  - Rakefile
-  - lib/safety_pin.rb
-  - lib/safety_pin/jcr.rb
-  - lib/safety_pin/node.rb
-  - lib/safety_pin/query.rb
-  - lib/safety_pin/query/where_condition.rb
-  - lib/safety_pin/version.rb
-  - safety_pin.gemspec
-  - spec/jcr_spec.rb
-  - spec/jcr_sql2_spec.rb
-  - spec/node_spec.rb
-  - spec/query_spec.rb
-  - spec/spec_helper.rb
-  - spec/where_condition_spec.rb
-homepage: ""
+files:
+- .rspec
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- console_loader.rb
+- lib/safety_pin.rb
+- lib/safety_pin/jcr.rb
+- lib/safety_pin/node.rb
+- lib/safety_pin/query.rb
+- lib/safety_pin/query/where_condition.rb
+- lib/safety_pin/version.rb
+- safety_pin.gemspec
+- spec/jcr_spec.rb
+- spec/jcr_sql2_spec.rb
+- spec/node_spec.rb
+- spec/query_spec.rb
+- spec/spec_helper.rb
+- spec/where_condition_spec.rb
+homepage: ''
 licenses: []
-
-post_install_message: 
+post_install_message:
 rdoc_options: []
-
-require_paths: 
-  - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
   none: false
-  requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
   none: false
-  requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
 requirements: []
-
-rubyforge_project: 
-rubygems_version: 1.8.15
-signing_key: 
+rubyforge_project:
+rubygems_version: 1.8.24
+signing_key:
 specification_version: 3
 summary: JCR connector for JRuby
-test_files: 
-  - spec/jcr_spec.rb
-  - spec/jcr_sql2_spec.rb
-  - spec/node_spec.rb
-  - spec/query_spec.rb
-  - spec/spec_helper.rb
-  - spec/where_condition_spec.rb
+test_files:
+- spec/jcr_spec.rb
+- spec/jcr_sql2_spec.rb
+- spec/node_spec.rb
+- spec/query_spec.rb
+- spec/spec_helper.rb
+- spec/where_condition_spec.rb
+...