safety_pin 0.0.1

data/.rspec

@@ -0,0 +1 @@
+--format progress --color

data/.rvmrc

@@ -0,0 +1 @@
+rvm use --create jruby-1.6.7@safety_pin

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gem "rspec", "~> 2.10.0"

data/Gemfile.lock

@@ -0,0 +1,18 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.0)
+    rspec-expectations (2.10.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.10.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rspec (~> 2.10.0)

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Jordan Raine
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# SafetyPin
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'safety_pin'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install safety_pin
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/safety_pin/jcr.rb

@@ -0,0 +1,42 @@
+module SafetyPin
+  class JCR
+    include_class('java.lang.String') {|package,name| "J#{name}" }
+    include_class 'javax.jcr.SimpleCredentials'
+    include_class 'org.apache.jackrabbit.commons.JcrUtils'
+
+    def self.login(opts = {})
+      repository = JcrUtils.get_repository(parse_hostname(opts[:hostname]))
+      creds = SimpleCredentials.new(opts[:username], JString.new(opts[:password]).to_char_array)
+      @@session = repository.login(creds)
+    end
+
+    def self.logout
+      session.logout
+      not session.live?
+    end
+
+    def self.logged_in?
+      session.live?
+    end
+
+    def self.logged_out?
+      not logged_in?
+    end
+
+    def self.session
+      @@session
+    end
+
+    def self.parse_hostname(hostname)
+      if hostname.end_with?("/crx/server")
+        hostname
+      else
+        hostname + "/crx/server"
+      end
+    end
+
+    def self.dev_login
+      login(:hostname => "http://localhost:4502", :username => "admin", :password => "admin")
+    end
+  end
+end

data/lib/safety_pin/node.rb

@@ -0,0 +1,242 @@
+module SafetyPin
+  class Node
+    include_class 'javax.jcr.PropertyType'
+    include_class 'java.util.Calendar'
+    include_class 'java.util.Date'
+
+    attr_reader :j_node
+    
+    def self.find(path)
+      raise ArgumentError unless path.to_s.start_with?("/")
+      Node.new(session.get_node(path.to_s))
+    rescue javax.jcr.PathNotFoundException
+      nil
+    end
+    
+    def self.session
+      JCR.session
+    end
+    
+    def self.build(path, node_type = nil)
+      node_type ||= "nt:unstructured"
+      rel_path = nil
+      if path.start_with?("/")
+        rel_path = path.sub("/","")
+      else
+        raise ArgumentError.new("Given path not absolute: #{path}")
+      end
+      
+      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))
+      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)
+      node.save
+      node
+    end
+
+    def initialize(j_node)
+      @j_node = j_node
+    end
+    
+    def path
+      @path ||= j_node.path
+    end
+    
+    def session
+      @session ||= JCR.session
+    end
+    
+    def children
+      child_nodes = []
+      j_node.get_nodes.each do |child_j_node|
+        child_nodes << Node.new(child_j_node)
+      end
+      child_nodes
+    end
+    
+    def child(relative_path)
+      child_j_node = j_node.get_node(relative_path)
+      Node.new(child_j_node)
+    rescue javax.jcr.PathNotFoundException
+      nil
+    end
+    
+    def name
+      @name ||= j_node.name
+    end
+    
+    def read_attribute(name)
+      property = j_node.get_property(name)
+      if property_is_multi_valued?(property)
+        retrieve_property_multi_value(property)
+      else
+        retrieve_property_value(property)
+      end
+    rescue javax.jcr.PathNotFoundException
+      raise NilPropertyError.new("#{name} property not found on node")
+    end
+    
+    def property_is_multi_valued?(property)
+      property.values
+      true
+    rescue javax.jcr.ValueFormatException
+      false
+    end
+    
+    def retrieve_property_multi_value(property)
+      property.values.map {|value| retrieve_value(value) }
+    end
+    
+    def retrieve_property_value(property)
+      retrieve_value(property.value)
+    end
+    
+    def retrieve_value(value)
+      property_type = PropertyType.name_from_value(value.type)
+      case property_type
+      when "String"
+        value.string
+      when "Boolean"
+        value.boolean
+      when "Double"
+        value.double
+      when "Long"
+        value.long
+      when "Date"
+        Time.at(value.date.time.time / 1000)
+      when "Name"
+        value.string # Not sure if these should be handled differently
+      else
+        raise PropertyTypeError.new("Unknown property type: #{property_type}")
+      end
+    end
+    
+    def write_attribute(name, value)
+      raise PropertyError.new("Illegal operation: cannot change jcr:primaryType property") if name == "jcr:primaryType"
+      
+      if value.is_a? Array
+        values = value
+        val_fact = value_factory
+        j_values = []
+        values.each do |value|
+          j_values << val_fact.create_value(value.to_java)
+        end
+        j_node.set_property(name, j_values.to_java(Java::JavaxJcr::Value))
+      elsif value.is_a? Time or value.is_a? Date
+        calendar_value = Calendar.instance
+        calendar_value.set_time(value.to_java)
+        j_node.set_property(name, calendar_value)
+      else
+        j_node.set_property(name, value)
+      end
+    end
+    
+    def save
+      if new?
+        j_node.parent.save
+      else
+        j_node.save
+      end
+      
+      not changed?
+    end
+    
+    def reload
+      j_node.refresh(false)
+    end
+    
+    def [](name)
+      read_attribute(name)
+    end
+    
+    def []=(name, value)
+      write_attribute(name, value)
+    end
+    
+    def changed?
+      j_node.modified?
+    end
+    
+    def new?
+      j_node.new?
+    end
+    
+    def properties
+      props = {}
+      prop_iter = j_node.properties
+      while prop_iter.has_next
+        prop = prop_iter.next_property        
+        unless prop.definition.protected?
+          prop_name = prop.name
+          props[prop_name] = self[prop_name]
+        end
+      end
+      props
+    end
+    
+    def protected_properties
+      props = {}
+      prop_iter = j_node.properties
+      while prop_iter.has_next
+        prop = prop_iter.next_property        
+        if prop.definition.protected?
+          prop_name = prop.name
+          props[prop_name] = self[prop_name]
+        end
+      end
+      props
+    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]
+      end
+    end
+    
+    def value_factory
+      session.value_factory
+    end
+    
+    def destroy
+      path = self.path
+      parent_j_node = j_node.parent
+      j_node.remove
+      parent_j_node.save
+      # raise NodeError.new("Unable to destroy #{path} node") unless self.class.find(path).nil?
+    rescue javax.jcr.RepositoryException => e
+      raise NodeError.new("Unable to destroy #{path} node: #{e.message}")
+    end
+    
+    def mixin_types
+      j_node.mixin_node_types.map(&:name)
+    end
+    
+    def add_mixin(mixin_name)
+      j_node.add_mixin(mixin_name)
+    end
+    
+    def remove_mixin(mixin_name)
+      j_node.remove_mixin(mixin_name)
+    end
+    
+    def primary_type
+      self["jcr:primaryType"]
+    end
+  end
+  
+  class NodeError < Exception; end
+  class PropertyTypeError < Exception; end
+  class NilPropertyError < Exception; end
+  class PropertyError < Exception; end
+end

data/lib/safety_pin/query/where_condition.rb

@@ -0,0 +1,25 @@
+module SafetyPin
+  class Query
+    class WhereCondition
+      attr_reader :name, :value, :comparator
+      
+      def initialize(name, value, comparator = "=")
+        @name = name
+        @value = value
+        @comparator = comparator
+      end
+    
+      def sql_fragment
+        "[#{name}] #{comparator} '#{value}'"
+      end
+      
+      def ==(object)
+        self.name == object.name and self.value == object.value and self.comparator == object.comparator
+      end
+      
+      def eql?(object)
+        self == object
+      end
+    end
+  end
+end

data/lib/safety_pin/query.rb

@@ -0,0 +1,70 @@
+module SafetyPin
+  class Query
+    def self.execute(query_string)
+      query = query_manager.create_query(query_string, "JCR-SQL2")
+      node_iter = query.execute.nodes
+      nodes = []
+      while node_iter.has_next
+        nodes << Node.new(node_iter.next_node)
+      end
+      nodes
+    end
+    
+    def self.query_manager
+      JCR.session.workspace.query_manager
+    end
+    
+    def sql
+      [select_statement, where_statement].compact.join(" ")
+    end
+    
+    def type(type)
+      @type = type
+    end
+    
+    def where(properties)
+      self.where_conditions = where_conditions + properties.map {|name, value| WhereCondition.new(name, value) }
+    end
+    
+    def within(path)
+      @within ||= []
+      if path.is_a? String
+        @within << path
+      elsif path.is_a? Array
+        @within += path
+      end
+    end
+    
+    def where_conditions
+      @where_conditions ||= []
+    end
+    
+    def where_conditions=(where_conditions)
+      @where_conditions = where_conditions
+    end
+    
+    private
+    def select_statement
+      type = @type || "nt:base"
+      "SELECT * FROM [#{type}]"
+    end
+    
+    def where_statement
+      "WHERE #{where_sql.join(" AND ")}" unless where_conditions.empty? and within_path_conditions.empty?
+    end
+    
+    def where_sql
+      (where_conditions + within_path_conditions).map(&:sql_fragment)
+    end
+    
+    def within_path_conditions
+      unless @within.nil?
+        @within.map {|path| WhereCondition.new("jcr:path", "#{path}%", "LIKE") }
+      else 
+        []
+      end
+    end
+  end
+  
+  class InvalidQuery < Exception; end
+end

data/lib/safety_pin/version.rb

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

data/lib/safety_pin.rb

@@ -0,0 +1,10 @@
+$: << File.dirname(__FILE__)
+
+require 'java'
+require 'safety_pin/jcr'
+require 'safety_pin/node'
+require 'safety_pin/query'
+require 'safety_pin/query/where_condition'
+
+module SafetyPin
+end

data/safety_pin.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/safety_pin/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Jordan Raine"]
+  gem.email         = ["jnraine@gmail.com"]
+  gem.description   = %q{An easy-to-use JCR connector for JRuby}
+  gem.summary       = %q{JCR connector for JRuby}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "safety_pin"
+  gem.require_paths = ["lib"]
+  gem.version       = SafetyPin::VERSION
+end

data/spec/jcr_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper.rb'
+
+describe SafetyPin::JCR do
+  it "should login to a remote SafetyPin::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
+    SafetyPin::JCR.logout
+  end
+  
+  it "should logout of a remote SafetyPin::JCR" do
+    SafetyPin::JCR.login(:hostname => "http://localhost:4502", :username => "admin", :password => "admin")
+    SafetyPin::JCR.logout
+    SafetyPin::JCR.should be_logged_out
+  end
+  
+  context ".parse_hostname" do
+    it "ensures the hostname ends with /crx/server" do
+      hostname = SafetyPin::JCR.parse_hostname("http://localhost:4502")
+      hostname.end_with?("/crx/server").should be_true
+    end
+  end
+end

data/spec/jcr_sql2_spec.rb

@@ -0,0 +1,93 @@
+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
+  
+  before do
+    @node = SafetyPin::Node.create("/content/foo")
+    @node.properties = {"bar" => "baz", "qux" => "qax"}
+    @node.save
+  end
+  
+  after { @node.destroy }
+  
+  it "can lookup a node based on property presence" do
+    nodes = SafetyPin::Query.execute("SELECT * FROM [nt:base] WHERE [nt:base].bar IS NOT NULL")
+    nodes.first["bar"].should_not be_nil
+  end
+  
+  it "can lookup a node based on a property's value" do
+    nodes = SafetyPin::Query.execute("SELECT * FROM [nt:base] WHERE bar = 'baz'")
+    values = nodes.map {|e| e["bar"] }.uniq
+    values.length.should eql(1)
+    values.first.should eql("baz")
+  end
+  
+  it "can lookup a node based on multiple property values" do
+    nodes = SafetyPin::Query.execute("SELECT * FROM [nt:base] WHERE bar = 'baz' AND qux = 'qax'")
+    bar_values = nodes.map {|e| e["bar"] }.uniq
+    qux_values = nodes.map {|e| e["qux"] }.uniq
+    bar_values.length.should eql(1)
+    qux_values.length.should eql(1)
+    bar_values.first.should eql("baz")
+    qux_values.first.should eql("qax")
+  end
+  
+  it "can lookup a node based on node name" do
+    nodes = SafetyPin::Query.execute("SELECT * FROM [nt:base] WHERE NAME([nt:base]) = 'foo'")
+    names = nodes.map(&:name).uniq
+    names.length.should eql(1)
+    names.first.should eql("foo")
+  end
+  
+  it "can lookup a node based on a path" do
+    pending "can't do this yet"
+    nodes = SafetyPin::Query.execute("SELECT * FROM [nt:base] AS base WHERE base.[jcr:path] LIKE '/content/%'")
+    nodes.length.should be > 0
+    nodes.map(&:path).each {|name| name.starts_with?("/content").should be_true }
+  end
+  
+  it "can lookup a node based on node type" do
+    nodes = SafetyPin::Query.execute("SELECT * FROM [cq:Page]")
+    nodes.first.primary_type.should eql("cq:Page")
+  end
+  
+  it "can lookup a node based on its node super type" do
+    nodes = SafetyPin::Query.execute("SELECT * FROM [rep:Authorizable]")
+    primary_types = nodes.map(&:primary_type)
+    primary_types.should include("rep:User")
+  end
+  
+  # context "given some nodes and child nodes" do
+  #   before do
+  #     @parent2 = SafetyPin::Node.create("/content/foo2")
+  #     @child1 = SafetyPin::Node.create("/content/foo2/child")
+  #     @child1.properties = {"bar" => "baz", "qux" => "qax", "child" => "yes"}
+  #     @child1.save
+  #     @child2 = SafetyPin::Node.create("/content/foo/child")
+  #     @child2.properties = {"bar" => "baz", "qux" => "qax", "child" => "yes"}
+  #     @child2.save      
+  #   end
+  #   
+  #   after do
+  #     @parent2.destroy
+  #   end
+  #   
+  #   it "can lookup a node based on nested WHERE conditions" do
+  #     sql_statement = "SELECT * FROM [nt:base] 
+  #                      WHERE [jcr:path] LIKE '/content/foo%'"
+  #     nodes = SafetyPin::Query.execute(sql_statement)
+  #     nodes.map(&:path).sort.should eql(["/content/foo/child", "/content/foo2/child"])
+  #   end
+  # end
+end

data/spec/node_spec.rb

@@ -0,0 +1,494 @@
+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
+    context "given a node name" do
+      context "that exists" do
+        it "should return a node with a matching path" do
+          SafetyPin::Node.find("/content").path.should eql("/content")
+        end
+      end
+    
+      context "that doesn't exist" do
+        it "should return nil" do
+          SafetyPin::Node.find("/foo/bar/baz").should be_nil
+        end
+      end
+    end
+    
+    it "complains if the path isn't an absolute path" do
+      lambda { node = SafetyPin::Node.find("content") }.should raise_exception(ArgumentError)
+    end
+  end
+  
+  context ".session" do
+    it "should return a session" do
+      SafetyPin::Node.session.should be_a(Java::JavaxJcr::Session)
+    end
+  end
+  
+  context "#session" do
+    it "should return a session" do
+      SafetyPin::Node.find("/content").session.should be_a(Java::JavaxJcr::Session)
+    end
+    
+    it "should cache session in an instance variable" do
+      node = SafetyPin::Node.find("/content")
+      node.session
+      node.instance_eval { @session }.should be_a(Java::JavaxJcr::Session)
+    end
+  end
+  
+  context "#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
+    context "given a node name" do
+      let(:node) { SafetyPin::Node.find("/") }
+      
+      context "that exists" do
+        it "should return a child node with a matching name" do
+          node.child("content").name.should eql("content")
+        end
+        
+        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
+      
+      context "that doesn't exist" do
+        it "should return nil" do
+          node.child("foobarbaz").should be_nil
+        end
+      end
+    end
+  end
+  
+  context "#name" do
+    it "should return a string name" do
+      SafetyPin::Node.find("/content").name.should eql("content")
+    end
+  end
+  
+  describe "#save" do
+    context "on an existing node with changes" do
+      before 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
+        @node.reload
+        @node["bar"].should eql("baz")
+      end
+  
+      it "should return true if the save was successful" do
+        save_successful = @node.save
+        (save_successful and not @node.changed?).should be_true
+      end
+    end
+    
+    context "on a new 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
+        parent_node = SafetyPin::Node.create("/content/foo")
+        node = SafetyPin::Node.build("/content/foo/bar")
+        parent_node["baz"] = "qux"
+        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 }
+    
+      it "should return the string value of a string property" do
+        @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)
+      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)
+      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)
+      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)
+      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"])
+        end
+      end
+    end
+    
+    it "should return the string value of a name property" do
+      SafetyPin::Node.find("/")["jcr:primaryType"].should eql("rep:root")
+    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)
+    end
+  end
+  
+  context "#write_attribute" do
+    before { @node = SafetyPin::Node.create("/content/foo") }
+    after { @node.destroy }
+     
+    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")
+      end
+    
+      context "given a Time object" 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)
+        end
+      end
+    end
+
+    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"])
+        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)
+      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)
+      end
+    end
+  end
+  
+  context "#reload" do
+    before { @node = SafetyPin::Node.create("/content/foo") }
+    after { @node.destroy }
+    
+    it "should discard pending changes" do
+      @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"
+      another_node = SafetyPin::Node.find("/content")
+      another_node["bar"] = "baz"
+      @node.reload
+      lambda { @node["bar"] }.should raise_error(SafetyPin::NilPropertyError)
+      another_node["bar"].should eql("baz")
+    end
+  end
+  
+  describe "#[]" do
+    it "should return the value of a given property name" do
+      node = SafetyPin::Node.create("/content/foo")
+      node.write_attribute("bar","baz")
+      node.save
+      node["bar"].should eql("baz")
+      node.destroy
+    end
+  end
+  
+  describe "#[]=" do    
+    it "should set the value of a given property name" do
+      node = SafetyPin::Node.create("/content/foo")
+      node.write_attribute("bar","baz")
+      node["bar"] = "qux"
+      node["bar"].should eql("qux")
+      node.destroy
+    end
+  end
+  
+  context "#changed?" do
+    let(:node) { SafetyPin::Node.find("/content") }
+
+    it "should return false if the node does not have unsaved changes" do
+      node.should_not be_changed
+    end
+    
+    it "should return true if the node has unsaved changes" do
+      node["foo"] = "bar"
+      node.should be_changed
+    end
+  end
+  
+  context "#new?" do
+    it "should return true if node has never been saved to JCR" do
+      SafetyPin::Node.build("/content/foo").should be_new
+    end
+    
+    it "should return false if node has been saved to JCR" do
+      SafetyPin::Node.find("/content").should_not be_new
+    end
+  end
+
+  describe "#properties" do
+    it "should return hash of all unprotected properties" do
+      SafetyPin::Node.find("/").properties.should eql({"sling:target"=>"/index.html", "sling:resourceType"=>"sling:redirect"})
+    end
+  end
+  
+  describe "#properties=" do
+    before { @node = SafetyPin::Node.create("/content/foo") }
+    after  { @node.destroy }
+    
+    it "should set the properties of a node" do
+      @node.properties = {"foo" => "bar"}
+      @node.properties.should eql({"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"})
+    end
+  end
+  
+  describe "#protected_properties" do
+    it "should return hash of all protected properties" do
+      SafetyPin::Node.find("/").protected_properties.should eql({"jcr:primaryType"=>"rep:root", "jcr:mixinTypes"=>["rep:AccessControllable", "rep:RepoAccessControllable"]})
+    end
+  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"])
+    end
+  end
+  
+  describe "#add_mixin" do
+    before { @node = SafetyPin::Node.create("/content/foo") }
+    after  { @node.destroy }
+  
+    it "should add a mixin type to node" do
+      @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([])
+    end
+  end
+  
+  describe "#remove_mixin" do
+    before do 
+      @node = SafetyPin::Node.create("/content/foo") 
+      @node.add_mixin("mix:created")
+      @node.save
+    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([])
+    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
+    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
+      
+      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
+
+      context "that already exists" do
+        it "should raise an error" do
+          lambda { SafetyPin::Node.build("/content") }.should raise_error(SafetyPin::NodeError)
+        end
+      end
+    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
+    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
+  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
+    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
+        node.destroy
+      end
+    end
+  end
+  
+  context "#value_factory" do
+    it "should return a value factory instance" do
+      SafetyPin::Node.find("/content").value_factory.should be_a(Java::JavaxJcr::ValueFactory)
+    end
+  end
+  
+  describe "#property_is_multi_valued" do
+    it "should return true if property is multi-valued" do
+      node = SafetyPin::Node.create("/content/foo")
+      node["bar"] = ["baz", "qux"]
+      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
+      node = SafetyPin::Node.create("/content/foo")
+      node["bar"] = "baz"
+      node.save
+      property = node.j_node.get_property("bar")
+      node.property_is_multi_valued?(property).should be_false
+      node.destroy
+    end
+  end
+  
+  describe "#destroy" do
+    it "should remove node from JCR" do
+      path = "/content/foo"
+      node = SafetyPin::Node.create(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["baz"] = "qux"
+      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 }
+      
+      it "should raise an error" do
+        @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 }
+    
+    it "should return the primary type of the node" do
+      @node.primary_type.should eql("nt:unstructured")
+    end
+  end
+end

data/spec/query_spec.rb

@@ -0,0 +1,126 @@
+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
+  
+  let(:query) { SafetyPin::Query.new }
+
+  describe ".execute" do
+    before do
+      @node = SafetyPin::Node.create("/content/foo")
+      @node["bar"] = "baz"
+      @node.save
+    end
+    
+    after { @node.destroy }
+    
+    it "should lookup nodes given a valid JCR-SQL2 query string" do
+      nodes = SafetyPin::Query.execute("SELECT * FROM [nt:base] WHERE [nt:base].bar IS NOT NULL")
+      nodes.first["bar"].should_not be_nil
+    end
+  end
+  
+  describe "#sql" do
+    it "should compile a default query string to return all nodes" do
+      query.sql.should eql("SELECT * FROM [nt:base]")
+    end
+    
+    it "should compile a query string to search for nodes of a specific type" do
+      query.type("cq:Page")
+      query.sql.should eql("SELECT * FROM [cq:Page]")
+    end
+    
+    it "should compile a query string to search for a node with a property and value" do
+      query.where("foo" => "bar")
+      query.sql.should eql("SELECT * FROM [nt:base] WHERE [foo] = 'bar'")
+    end
+    
+    it "should compile a query string to search for a node with multiple properties and values" do
+      query.where("foo" => "bar", "baz" => "quux")
+      query.sql.should eql("SELECT * FROM [nt:base] WHERE [foo] = 'bar' AND [baz] = 'quux'")
+    end
+    
+    it "should compile a query string to search for a node within a path" do
+      query.within("/content/")
+      query.sql.should eql("SELECT * FROM [nt:base] WHERE [jcr:path] LIKE '/content/%'")
+    end
+    
+    it "should compile a query string to search a node within multiple nodes" do
+      
+    end
+  end
+  
+  describe "#within" do
+    context "given string paths" do
+      it "should append to @within instance variable" do
+        query.within("/foo")
+        query.within("/bar")
+        query.instance_eval { @within }.should eql(["/foo", "/bar"])
+      end
+    end
+    
+    context "given an array of string paths" do
+      it "should append to @within instance variable" do
+        query.within("/foo")
+        query.within(["/bar", "/baz"])
+        query.instance_eval { @within }.should eql(["/foo", "/bar", "/baz"])
+      end
+    end
+    
+    context "given an invalid argument" do
+      it "should ignore it" do
+        query.within("/foo")
+        query.within(nil)
+        query.instance_eval { @within }.should eql(["/foo"])
+      end
+    end
+  end
+  
+  describe "#where" do
+    it "should append to where_conditions" do
+      query.where("foo" => "bar")
+      query.where("baz" => "quux")
+      query.where_conditions.should eql([SafetyPin::Query::WhereCondition.new("foo", "bar"), SafetyPin::Query::WhereCondition.new("baz", "quux")])
+    end
+  end
+  
+  describe "#type" do
+    it "should set the node type" do
+      query = SafetyPin::Query.new
+      query.type("cq:Page")
+      query.instance_eval { @type }.should eql("cq:Page")
+    end
+  end
+  
+  describe "#where_conditions" do
+    it "should return an empty array by default" do
+      query.where_conditions.should eql([])
+    end
+  end
+  
+  # 
+  # it "should query for nodes beneath a specific path" do
+  #   pending
+  #   nodes = SafetyPin::Query.path("/content/sfu")
+  # end
+  # 
+  # it "should query for nodes with a specific property" do
+  #   pending
+  #   nodes = SafetyPin::Query.where("cq:Template" => "/apps/sfu/templates/basicpage")
+  # end
+  # 
+  # it "should chain together query methods to build a query" do
+  #   pending
+  #   nodes = SafetyPin::Query.path("/content").type("nt:unstructured").where("jcr:title" => "Open House")
+  # end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$:<<File.join(File.dirname(__FILE__), '/../lib')
+
+require 'safety_pin'

data/spec/where_condition_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe SafetyPin::Query::WhereCondition do
+  it "should be instantiated with a name, value, and comparator" do
+    where_condition = SafetyPin::Query::WhereCondition.new("foo", "bar", "LIKE")
+    where_condition.should_not be_nil
+  end
+  
+  it "should generate a SQL WHERE string fragment" do
+    where_condition = SafetyPin::Query::WhereCondition.new("foo", "bar", "LIKE")
+    where_condition.sql_fragment.should eql("[foo] LIKE 'bar'")
+  end
+  
+  it "should be equal based on its main attributes" do
+    condition1 = SafetyPin::Query::WhereCondition.new("foo", "bar", "LIKE")
+    condition2 = SafetyPin::Query::WhereCondition.new("foo", "bar", "LIKE")
+    condition1.should == condition2
+    condition1.should eql(condition2)
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: safety_pin
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+  - Jordan Raine
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-05-10 00:00:00 Z
+dependencies: []
+
+description: An easy-to-use JCR connector for JRuby
+email: 
+  - jnraine@gmail.com
+executables: []
+
+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: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.15
+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