safety_pin 0.0.5 → 0.0.6

data/lib/safety_pin/node.rb

@@ -15,8 +15,9 @@ module SafetyPin
       nil
     end
     
-    def self.find_or_create(path)
-      find(path) || create(path)
+    def self.find_or_create(path, primary_type = nil)
+      node_blueprint = NodeBlueprint.new(:path => path.to_s, :primary_type => primary_type)
+      find(path) || create(node_blueprint)
     end
 
     def self.exists?(path)
@@ -27,31 +28,31 @@ module SafetyPin
       JCR.session
     end
     
-    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("/","")
-      else
-        raise ArgumentError.new("Given path not absolute: #{path}")
-      end
+    def self.build(node_blueprint)
+      raise NodeError.new("NodeBlueprint is nil") if node_blueprint.nil?
+      raise NodeError.new("NodeBlueprint has non-absolute path") unless node_blueprint.path.to_s.start_with?("/")
+      raise NodeError.new("Node already exists at path: #{node_blueprint.path}") if Node.exists?(node_blueprint.path)
       
-      if session.root_node.has_node(rel_path)
-        raise NodeError.new("Node already exists at path: #{path}")
-      else
-        node = self.new(session.root_node.add_node(rel_path, node_type))
-        node.properties = properties
+      rel_path_to_root_node = node_blueprint.path.to_s[1..-1]
+      node = self.new(session.root_node.add_node(rel_path_to_root_node, node_blueprint.primary_type))
+      node.properties = node_blueprint.properties
 
-        node
-      end
+      node
     rescue javax.jcr.PathNotFoundException => e
-      raise NodeError.new("Cannot add a new node to a non-existing parent at #{path}")
+      raise NodeError.new("Cannot add a new node to a non-existing parent at #{node_blueprint.path}")
+    end
+
+    def self.update(node_blueprint)
+      node = find(node_blueprint.path)
+      # raise NodeError.new("Cannot retrieve node for update -- might not exist") if node.nil?
+      node.properties = node_blueprint.properties
+      node.primary_type = node_blueprint.primary_type
+      node.save
+      node
     end
     
-    def self.create(path, node_type = nil, properties = nil)
-      node = self.build(path, node_type, properties)
+    def self.create(node_blueprint)
+      node = self.build(node_blueprint)
       node.save
       node
     end
@@ -66,7 +67,7 @@ module SafetyPin
       end
       
       results = intermediate_paths.reverse.map do |intermediate_path|
-        create(intermediate_path) unless exists?(intermediate_path)
+        create(NodeBlueprint.new(:path => intermediate_path.to_s)) unless exists?(intermediate_path)
       end
 
       session.save
@@ -74,6 +75,17 @@ module SafetyPin
       results
     end
 
+    def self.create_or_update(node_blueprint_or_node_blueprints)
+      node_blueprints = Array(node_blueprint_or_node_blueprints)
+      node_blueprints.map do |node_blueprint|
+        if exists?(node_blueprint.path)
+          update(node_blueprint)
+        else
+          create(node_blueprint)
+        end
+      end
+    end
+
     def initialize(j_node)
       @j_node = j_node
     end
@@ -242,13 +254,41 @@ module SafetyPin
     def properties=(new_props)
       property_names = (properties.keys + new_props.keys).uniq
       property_names.each do |name|
-        if new_props[name].is_a?(Hash)
-          build(name, nil, new_props[name])
+        # REFACTOR ME PLZ
+        child_path = Pathname(path.to_s) + name.to_s
+        if new_props[name].is_a? Hash
+          new_props[name] = convert_hash_to_node_blueprint(new_props[name])
+        end
+
+        if new_props[name].respond_to?(:node_blueprint?) and new_props[name].node_blueprint?
+          # Handle node blue prints
+          node_blueprint = NodeBlueprint.new(:properties => new_props[name].properties, 
+                                             :path => child_path.to_s, 
+                                             :primary_type => new_props[name].primary_type)
+          if Node.exists?(child_path)
+            Node.update(node_blueprint)
+          else
+            Node.build(node_blueprint)
+          end
         else
+          # handle everything else
           self[name] = new_props[name]
         end
       end
     end
+
+    # Convert a hash (and it's values recursively) to NodeBlueprints. This is a
+    # helper method, allowing a hash to be passed in to Node#properties= when
+    # only properties need to be set. One caveat: all node types will default
+    # to nt:unstructured.
+    def convert_hash_to_node_blueprint(hash)
+      hash.keys.each do |key|
+        if hash[key].is_a? Hash
+          hash[key] = convert_hash_to_node_blueprint(hash[key])
+        end
+      end
+      NodeBlueprint.new(:path => :no_path, :properties => hash)
+    end
     
     def value_factory
       session.value_factory
@@ -279,20 +319,34 @@ module SafetyPin
     def primary_type
       self["jcr:primaryType"]
     end
+
+    def primary_type=(primary_type)
+      j_node.set_primary_type(primary_type)
+    end
     
-    def find_or_create(name, type = nil)
-      child(name) || create(name, type)
+    def find_or_create(name, primary_type = nil)
+      path = Pathname(self.path) + name
+      self.class.find_or_create(path.to_s, primary_type)
     end
     
     # Create and return a child node with a given name
-    def create(name, type = nil, properties = nil)
-      path = Pathname(self.path) + name.to_s
-      Node.create(path, type, properties)
+    def create(name, node_blueprint = nil)
+      Node.create(node_blueprint_for(name, node_blueprint))
+    end
+
+    def build(name, node_blueprint = nil)
+      Node.build(node_blueprint_for(name, node_blueprint))
     end
 
-    def build(name, type = nil, properties = nil)
+    def node_blueprint_for(name, node_blueprint = nil)
       path = Pathname(self.path) + name.to_s
-      Node.build(path, type, properties)
+      
+      unless node_blueprint.nil?
+        properties = node_blueprint.properties
+        primary_type = node_blueprint.primary_type
+      end
+      
+      NodeBlueprint.new(:path => path.to_s, :properties => properties, :primary_type => primary_type)
     end
   end
   

data/lib/safety_pin/node_blueprint.rb

@@ -0,0 +1,18 @@
+module SafetyPin
+  class NodeBlueprint
+    attr_accessor :path, :primary_type, :properties
+
+    def initialize(opts)
+      raise NodeBlueprintError.new("No path specified") unless opts[:path]
+      @path = opts[:path]
+      @primary_type = opts[:primary_type] || "nt:unstructured"
+      @properties = opts[:properties] || {}
+    end
+
+    def node_blueprint?
+      true
+    end
+  end
+
+  class NodeBlueprintError < Exception; end
+end

data/lib/safety_pin/version.rb

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

data/lib/safety_pin.rb

@@ -3,6 +3,7 @@ $: << File.dirname(__FILE__)
 require 'java'
 require 'safety_pin/jcr'
 require 'safety_pin/node'
+require 'safety_pin/node_blueprint'
 require 'safety_pin/query'
 require 'safety_pin/query/where_condition'
 

data/spec/node_blueprint_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe SafetyPin::NodeBlueprint do
+  let(:node_blueprint) { SafetyPin::NodeBlueprint.new(:path => "/content/foo/bar", :primary_type => "nt:folder", :properties => {"foo" => "bar"}) }
+
+  describe "#primary_type" do
+    it "has a primary type" do
+      node_blueprint.primary_type.should == "nt:folder"
+    end
+
+    it "has a default primary type" do
+      SafetyPin::NodeBlueprint.new(:path => "/something").primary_type.should == "nt:unstructured"
+    end
+  end
+
+  describe "#properties" do
+    it "has properties" do
+      node_blueprint.properties.should == {"foo" => "bar"}
+    end
+
+    it "defaults to an empty hash" do
+      SafetyPin::NodeBlueprint.new(:path => "/something").properties.should == {}
+    end
+  end
+
+  describe "#path" do
+    it "requires a path" do
+      lambda { SafetyPin::NodeBlueprint.new({}).path }.should raise_error(NodeBlueprintError)
+    end
+
+    it "has a path" do
+      node_blueprint.path.should == "/content/foo/bar"
+    end
+  end
+end

data/spec/node_spec.rb

@@ -24,22 +24,22 @@ describe SafetyPin::Node 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.create(SafetyPin::NodeBlueprint.new(:path => "/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
+    context "when node doesn't exist" do
+      it "returns node created at path" do
         SafetyPin::Node.find("/content/foo").should be_nil
-        SafetyPin::Node.find_or_create("/content/foo").path.should eql "/content/foo"
+        SafetyPin::Node.find_or_create("/content/foo").path.should == "/content/foo"
       end
     end
   end
 
   describe ".exists?" do
     it "returns true if node exists at path" do
-      SafetyPin::Node.create("/content/foo")
+      SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo"))
       SafetyPin::Node.exists?("/content/foo").should be_true
     end
 
@@ -82,7 +82,7 @@ describe SafetyPin::Node do
         end
         
         it "should return a grandchild node given a relative path" do
-          SafetyPin::Node.create("/content/foo")
+          SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo"))
           node.child("content/foo").name.should eql("foo")
         end
       end
@@ -98,9 +98,35 @@ describe SafetyPin::Node do
       end
     end
   end
+
+  describe ".create_or_update", :focus => true do
+    let(:node_blueprint) { SafetyPin::NodeBlueprint.new(:path => "/content/foo") }
+
+    it "calls Node.create with arg when nothing exists at path" do
+      SafetyPin::Node.should_receive(:create).with(node_blueprint)
+      SafetyPin::Node.create_or_update(node_blueprint)
+    end
+
+    it "calls Node.update with arg when node exists at path" do
+      SafetyPin::Node.create(node_blueprint)
+      SafetyPin::Node.should_receive(:update).with(node_blueprint)
+      SafetyPin::Node.create_or_update(node_blueprint)
+    end
+
+    it "takes a node blueprint" do
+      SafetyPin::Node.create_or_update(node_blueprint)
+      SafetyPin::Node.exists?(node_blueprint.path).should be_true
+    end
+
+    it "takes an array of node blueprints" do
+      node_blueprints = [node_blueprint, SafetyPin::NodeBlueprint.new(:path => "/content/foo/bar")]
+      SafetyPin::Node.create_or_update(node_blueprints)
+      node_blueprints.each {|node_blueprint| SafetyPin::Node.exists?(node_blueprint.path).should be_true }
+    end
+  end
   
   describe "#find_or_create_child" do
-    let(:parent) { SafetyPin::Node.create("/content/foo") }
+    let(:parent) { SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo")) }
     
     context "an existing node path" do
       it "should return the child node" do
@@ -125,7 +151,7 @@ describe SafetyPin::Node do
   describe "#save" do
     context "on an existing node with changes" do
       before do 
-        @node = SafetyPin::Node.create("/content/foo")
+        @node = SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo"))
         @node["bar"] = "baz"
       end
     
@@ -143,13 +169,13 @@ describe SafetyPin::Node do
     
     context "on a new node" do      
       it "should save the node" do
-        node = SafetyPin::Node.build("/content/foo")
+        node = SafetyPin::Node.build(SafetyPin::NodeBlueprint.new(:path => "/content/foo"))
         node.save.should be_true
       end
       
       it "should save changes in parent node" do
-        parent_node = SafetyPin::Node.create("/content/foo")
-        node = SafetyPin::Node.build("/content/foo/bar")
+        parent_node = SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo"))
+        node = SafetyPin::Node.build(SafetyPin::NodeBlueprint.new(:path => "/content/foo/bar"))
         parent_node["baz"] = "qux"
         parent_node.should be_changed
         node.save
@@ -160,7 +186,7 @@ describe SafetyPin::Node do
   
   describe "#read_attribute" do
     context "on an existing node" do
-      let(:node) { SafetyPin::Node.create("/content/foo") }
+      let(:node) { SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo")) }
     
       it "should return the string value of a string property" do
         node["foo"] = "bar"
@@ -208,12 +234,12 @@ describe SafetyPin::Node do
     end
     
     it "should throw an exception when accessing a non-existent (nil) property" do
-      lambda { SafetyPin::Node.build("/content/foo").read_attribute("foo-bar-baz") }.should raise_error(SafetyPin::NilPropertyError)
+      lambda { SafetyPin::Node.build(SafetyPin::NodeBlueprint.new(:path => "/content/foo")).read_attribute("foo-bar-baz") }.should raise_error(SafetyPin::NilPropertyError)
     end
   end
   
   context "#write_attribute" do
-    let(:node) { SafetyPin::Node.create("/content/foo") }
+    let(:node) { SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo")) }
      
     context "given a single value" do
       it "should set a string property value" do
@@ -302,7 +328,7 @@ describe SafetyPin::Node do
   end
   
   context "#reload" do
-    let(:node) { SafetyPin::Node.create("/content/foo") }
+    let(:node) { SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo")) }
     
     it "should discard pending changes" do
       node["foo"] = "bar"
@@ -322,7 +348,7 @@ describe SafetyPin::Node do
   
   describe "#[]" do
     it "should return the value of a given property name" do
-      node = SafetyPin::Node.create("/content/foo")
+      node = SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo"))
       node.write_attribute("bar","baz")
       node.save
       node["bar"].should eql("baz")
@@ -331,7 +357,7 @@ describe SafetyPin::Node do
   
   describe "#[]=" do    
     it "should set the value of a given property name" do
-      node = SafetyPin::Node.create("/content/foo")
+      node = SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo"))
       node.write_attribute("bar","baz")
       node["bar"] = "qux"
       node["bar"].should eql("qux")
@@ -354,7 +380,7 @@ describe SafetyPin::Node do
   
   context "#new?" do
     it "should return true if node has never been saved to JCR" do
-      SafetyPin::Node.build("/content/foo").should be_new
+      SafetyPin::Node.build(SafetyPin::NodeBlueprint.new(:path => "/content/foo")).should be_new
     end
     
     it "should return false if node has been saved to JCR" do
@@ -369,7 +395,7 @@ describe SafetyPin::Node do
   end
   
   describe "#properties=" do
-    let(:node) { SafetyPin::Node.create("/content/foo") }
+    let(:node) { SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo")) }
     
     it "should set the properties of a node" do
       node.properties = {"foo" => "bar"}
@@ -382,9 +408,25 @@ describe SafetyPin::Node do
       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"}
+    it "creates child nodes for node blueprints" do
+      node_blueprint = SafetyPin::NodeBlueprint.new(:path => "/this/path/gets/thrown/away", 
+                                                    :primary_type => "sling:OrderedFolder", 
+                                                    :properties => {"bar" => "baz"})
+      node.properties = {"foo" => node_blueprint}
+      node.child("foo").properties.should == {"bar" => "baz"}
+      node.child("foo").primary_type.should == "sling:OrderedFolder"
+    end
+
+    xit "updates child nodes when they already exist" do
+      # Create /content/foo/bar and /content/foo/bar/baz
+      node.create(:bar, "nt:unstructured", {"bar" => "baz"})
+      node.child(:bar).create(:baz)
+      node.child(:bar).child(:baz).path.should == "/content/foo/bar/baz"
+      # Update /content/foo/bar by updating /content/foo properties
+      node.properties = {bar: SafetyPin::NodeBlueprint.new(:path => "/this/path/gets/thrown/away", :primary_type => "sling:OrderedFolder", :properties => {"updated" => "props"})}
+      node.child(:bar).properties.should == {"updated" => "props"}
+      node.child(:bar).primary_type.should == "sling:OrderedFolder"
+      node.child(:bar).child(:baz).path.should == "/content/foo/bar/baz"
     end
   end
   
@@ -396,7 +438,7 @@ describe SafetyPin::Node do
   
   describe "#mixin_types" do
     it "should return the mixin types of a node" do
-      node = SafetyPin::Node.create("/content/foo")
+      node = SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo"))
       node.j_node.add_mixin("mix:created")
       node.save
       node.mixin_types.should eql(["mix:created"])
@@ -404,7 +446,7 @@ describe SafetyPin::Node do
   end
   
   describe "#add_mixin" do
-    let(:node) { SafetyPin::Node.create("/content/foo") }
+    let(:node) { SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo")) }
   
     it "should add a mixin type to node" do
       node.add_mixin("mix:created")
@@ -420,7 +462,7 @@ describe SafetyPin::Node do
   
   describe "#remove_mixin" do
     let(:node) do 
-      node = SafetyPin::Node.create("/content/foo") 
+      node = SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo")) 
       node.add_mixin("mix:created")
       node.save
       node
@@ -440,78 +482,88 @@ describe SafetyPin::Node do
     end
   end
 
-  describe ".build" do
-    context "given an absolute path" do
-      it "should build and return a property-less, unsaved nt:unstructured child node" do
-        node = SafetyPin::Node.build("/content/foo")
-        node.should be_new
-        node.properties.should eql({})
-      end
+  describe ".update" do
+    let(:node) do 
+      node = SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo"))
+      node.save
+      node
+    end
 
+    it "updates a nodes properties" do
+      SafetyPin::Node.update(SafetyPin::NodeBlueprint.new(:path => node.path, :properties => {"foo" => "barbazbuzzzzz"}))
+      SafetyPin::Node.find(node.path).properties.should == {"foo" => "barbazbuzzzzz"}
+    end
 
+    it "preserves node children" do
+      node.create(:bar)
+      SafetyPin::Node.update(SafetyPin::NodeBlueprint.new(:path => node.path, :primary_type => "sling:OrderedFolder", :properties => {"foo" => "bar"}))
+      SafetyPin::Node.exists?("/content/foo/bar").should be_true
+    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
-          node = SafetyPin::Node.build("/content/foo", "nt:folder")
-          node.should be_new
-          node["jcr:primaryType"].should eql("nt:folder")
-        end
-      end
+    it "modifies the primary type" do
+      SafetyPin::Node.update(SafetyPin::NodeBlueprint.new(:path => node.path, :primary_type => "sling:OrderedFolder"))
+      SafetyPin::Node.find(node.path).primary_type.should == "sling:OrderedFolder"
+    end
+  end
 
-      context "that already exists" do
-        it "should raise an error" do
-          lambda { SafetyPin::Node.build("/content") }.should raise_error(SafetyPin::NodeError)
-        end
-      end
-      
-      it "should coerce path to a string" do
-        node = SafetyPin::Node.build(Pathname("/content/foo"))
-        node.should be_new
-        node.properties.should eql({})
-      end
+  describe "#primary_type=" do
+    let(:node) do 
+      node = SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo"))
+      node.save
+      node
     end
-    
-    context "given an absolute path with a non-existent parent node" do
-      it "should raise an error" do
-        lambda { SafetyPin::Node.build("/content/foo/bar/baz") }.should raise_error(SafetyPin::NodeError)
-      end
+
+    it "sets the primary type" do
+      node.primary_type.should == "nt:unstructured"
+      node.primary_type = "sling:OrderedFolder"
+      node.save
+      SafetyPin::Node.find(node.path).primary_type.should == "sling:OrderedFolder"
     end
-    
-    context "given a relative path" do
-      it "should raise an error" do
-        lambda { SafetyPin::Node.build("content/foo") }.should raise_error(ArgumentError)
-      end
+  end
+
+  describe ".build" do
+    it "returns an unsaved node at path of a specified type with properties set" do
+      node = SafetyPin::Node.build(SafetyPin::NodeBlueprint.new(:path => "/content/foo", :primary_type => "sling:OrderedFolder", :properties => {"foo" => "bar"}))
+      node.should be_new
+      node.primary_type.should == "sling:OrderedFolder"
+      node.properties.should == {"foo" => "bar"}
+    end
+
+    it "complains when the nodes already exists" do
+      node_blueprint = SafetyPin::NodeBlueprint.new(:path => "/content/foo")
+      SafetyPin::Node.create(node_blueprint)
+      lambda { SafetyPin::Node.build(node_blueprint) }.should raise_error(SafetyPin::NodeError)
+    end
+
+    it "complains when given a path with missing parents" do
+      lambda { SafetyPin::Node.build(SafetyPin::NodeBlueprint.new(:path => "/content/foo/bar/baz/doesnt/exist")) }.should raise_error(SafetyPin::NodeError)
+    end
+
+    it "complains when given a relative path" do
+      lambda { SafetyPin::Node.build(SafetyPin::NodeBlueprint.new(:path => "foo/not/absolute")) }.should raise_error(SafetyPin::NodeError)
+    end
+
+    it "complains when given nil" do
+      lambda { SafetyPin::Node.build(nil) }.should raise_error(SafetyPin::NodeError)
     end
   end
   
   describe ".create" do
-    context "given a path" do
-      it "should build and save a node" do
-        node = SafetyPin::Node.create("/content/foo")
-        node.should be_a(SafetyPin::Node)
-        node.destroy
-      end
+    it "creates a node" do
+      node = SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo"))
+      node.should be_a(SafetyPin::Node)
     end
     
-    context "given a path and a node type" 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
-      end
+    it "creates a node of a specific type" do
+      SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo", :primary_type => "sling:OrderedFolder"))
+      SafetyPin::Node.find("/content/foo").primary_type.should == "sling:OrderedFolder"
     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
+      SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo/bar/baz")).should_not be_nil
     end
   end
   
@@ -523,7 +575,7 @@ describe SafetyPin::Node do
   
   describe "#property_is_multi_valued" do
     it "should return true if property is multi-valued" do
-      node = SafetyPin::Node.create("/content/foo")
+      node = SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo"))
       node["bar"] = ["baz", "qux"]
       node.save
       property = node.j_node.get_property("bar")
@@ -531,7 +583,7 @@ describe SafetyPin::Node do
     end
     
     it "should return false if property is not multi-valued" do
-      node = SafetyPin::Node.create("/content/foo")
+      node = SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo"))
       node["bar"] = "baz"
       node.save
       property = node.j_node.get_property("bar")
@@ -542,14 +594,14 @@ describe SafetyPin::Node do
   describe "#destroy" do
     it "should remove node from JCR" do
       path = "/content/foo"
-      node = SafetyPin::Node.create(path)
+      node = SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => path))
       node.destroy
       SafetyPin::Node.find(path).should be_nil
     end
     
     it "should save changes in parent node" do
-      parent_node = SafetyPin::Node.create("/content/foo")
-      node = SafetyPin::Node.create("/content/foo/bar")
+      parent_node = SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo"))
+      node = SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo/bar"))
       parent_node["baz"] = "qux"
       parent_node.should be_changed
       node.destroy
@@ -558,7 +610,7 @@ describe SafetyPin::Node do
     
     context "when it fails" do      
       it "should raise an error" do
-        node = SafetyPin::Node.create("/content/foo")
+        node = SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo"))
         node.add_mixin("mix:created")
         node.save
         node.remove_mixin("mix:created") # make node unremoveable
@@ -568,7 +620,7 @@ describe SafetyPin::Node do
   end
   
   describe "#primary_type" do
-    let(:node) { SafetyPin::Node.create("/content/foo") }
+    let(:node) { SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo")) }
     
     it "should return the primary type of the node" do
       node.primary_type.should eql("nt:unstructured")
@@ -576,25 +628,25 @@ describe SafetyPin::Node do
   end
   
   describe "#build" do
-    let(:node) { SafetyPin::Node.create("/content/foo") }
+    let(:node) { SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo")) }
     
     it "should create a child node with a given name" do
       node.build("bar").path.should == "/content/foo/bar"
     end
     
     it "should create a child node with a given name and node type" do
-      child_node = node.build("bar", "nt:folder")
+      child_node = node.build("bar", SafetyPin::NodeBlueprint.new(:primary_type => "nt:folder", :path => :no_path))
       child_node.should be_a(SafetyPin::Node)
-      child_node.primary_type.should eql("nt:folder")
+      child_node.primary_type.should == "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"}
+      node.build("bar", SafetyPin::NodeBlueprint.new(:path => :no_path, :properties => {foo: "bar"})).properties.should == {"foo" => "bar"}
     end
   end
 
   describe "#create" do
-    let(:node) { SafetyPin::Node.create("/content/foo") }
+    let(:node) { SafetyPin::Node.create(SafetyPin::NodeBlueprint.new(:path => "/content/foo")) }
     
     it "should create a child node with a given name" do
       child_node = node.create("bar")
@@ -603,13 +655,13 @@ describe SafetyPin::Node do
     end
     
     it "should create a child node with a given name and node type" do
-      child_node = node.create("bar", "nt:folder")
+      child_node = node.create("bar", SafetyPin::NodeBlueprint.new(:path => :no_path, :primary_type => "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 = node.create("bar", SafetyPin::NodeBlueprint.new(:path => :no_path, :properties => {foo: "bar"}))
       child_node.should_not be_new
       child_node.properties.should == {"foo" => "bar"}
     end

metadata

@@ -2,14 +2,14 @@
 name: safety_pin
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Jordan Raine
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-08-23 00:00:00.000000000 Z
+date: 2012-10-15 00:00:00.000000000 Z
 dependencies: []
 description: An easy-to-use JCR connector for JRuby
 email:
@@ -31,12 +31,14 @@ files:
 - lib/safety_pin.rb
 - lib/safety_pin/jcr.rb
 - lib/safety_pin/node.rb
+- lib/safety_pin/node_blueprint.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_blueprint_spec.rb
 - spec/node_spec.rb
 - spec/query_spec.rb
 - spec/spec_helper.rb
@@ -68,6 +70,7 @@ summary: JCR connector for JRuby
 test_files:
 - spec/jcr_spec.rb
 - spec/jcr_sql2_spec.rb
+- spec/node_blueprint_spec.rb
 - spec/node_spec.rb
 - spec/query_spec.rb
 - spec/spec_helper.rb