safety-pin 0.0.9

data/.rspec

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

data/.rvmrc

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

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,21 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    nyan-cat-formatter (0.2.0)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.1)
+    rspec-expectations (2.10.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.10.1)
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  nyan-cat-formatter
+  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/bin/safety-pin

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+require 'optparse'
+
+options = {}
+option_parser = OptionParser.new do |opts|
+  opts.banner = "Usage: #{File.basename(__FILE__)} [-h HOST | -d]"
+
+  opts.on("-h", "--host HOST", "JCR host (e.g., http://localhost:4502)") do |host|
+    options[:host] = host
+  end
+
+  opts.on("-d", "Developer mode -- connects to http://admin:admin@localhost:4502") do |developer_mode|
+    options[:developer_mode] = !!developer_mode
+  end
+
+  opts.on_tail("--help", "Show this message") do
+    puts opts
+    exit
+  end
+end
+
+option_parser.parse!
+
+unless options[:host] || options[:developer_mode]
+  puts option_parser
+  exit 1
+end
+
+if options[:developer_mode]
+  host = "http://localhost:4502"
+  username = "admin"
+  password = "cq4me"
+else
+  host = options.fetch(:host)
+  print "Username: "
+  username = gets.chomp
+  print "Password: "
+  password = gets.chomp
+end
+
+ENV["HOST"] = host
+ENV["USERNAME"] = username
+ENV["PASSWORD"] = password
+
+exec "irb -r './console_loader' --simple-prompt"

data/console_loader.rb

@@ -0,0 +1,7 @@
+$:<<File.dirname(__FILE__)
+require 'lib/safety_pin'
+
+include SafetyPin
+
+puts "Connecting to #{ENV["HOST"]}"
+JCR.login(hostname: ENV["HOST"], username: ENV["USERNAME"], password: ENV["PASSWORD"])

data/lib/safety-pin.rb

@@ -0,0 +1,2 @@
+# Make sure `require 'safety-pin'` works too
+require File.dirname(__FILE__) + '/safety_pin'

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,389 @@
+require 'pathname'
+
+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.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)
+      find(path) != nil
+    end
+    
+    def self.session
+      JCR.session
+    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)
+      
+      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
+    rescue javax.jcr.PathNotFoundException => e
+      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(node_blueprint)
+      node = self.build(node_blueprint)
+      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(NodeBlueprint.new(:path => intermediate_path.to_s)) unless exists?(intermediate_path)
+      end
+
+      session.save
+
+      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
+    
+    def path
+      @path ||= j_node.path
+    end
+    
+    def session
+      @session ||= JCR.session
+    end
+
+    def ==(other_node)
+      return false if other_node.nil?
+      return false unless other_node.respond_to?(:path)
+      self.path == other_node.path
+    end
+
+    def parent
+      raise NodeError.new("Root node does not have parent") if path == "/"
+      Node.new(j_node.parent)
+    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.to_s)
+      Node.new(child_j_node)
+    rescue javax.jcr.PathNotFoundException
+      nil
+    end
+    
+    def name
+      @name ||= j_node.name
+    end
+    
+    def read_attribute(name)
+      name = name.to_s
+      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"
+      name = name.to_s
+      
+      if value.nil? and not j_node.has_property(name)
+        return nil
+      end
+      
+      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)
+      elsif value.is_a? Symbol
+        j_node.set_property(name, value.to_s)
+      else
+        begin
+          j_node.set_property(name, value)
+        rescue NameError
+          raise SafetyPin::PropertyTypeError.new("Property value type of #{value.class} is unsupported")
+        end
+      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)
+      property_names = (properties.keys + new_props.keys).uniq
+      property_names.each do |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
+    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
+
+    def primary_type=(primary_type)
+      j_node.set_primary_type(primary_type)
+    end
+    
+    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, 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 node_blueprint_for(name, node_blueprint = nil)
+      path = Pathname(self.path) + name.to_s
+      
+      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
+
+    def replace_property(opts)
+      opts = {recursive: false}.merge(opts)
+      name = opts.fetch(:name)
+      target = opts.fetch(:target)
+      replacement = opts.fetch(:replacement)
+
+      modified_nodes = []
+      if has_property(name) and self[name].match(target)
+        self[name] = replacement 
+        modified_nodes << self
+      end
+
+      modified_nodes << children.map {|child_node| child_node.replace_property(opts) } if opts.fetch(:recursive)
+
+      modified_nodes.flatten
+    end
+
+    def has_property(name)
+      properties.keys.include?(name)
+    end
+  end
+  
+  class NodeError < Exception; end
+  class PropertyTypeError < Exception; end
+  class NilPropertyError < Exception; end
+  class PropertyError < Exception; 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.has_key?(: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/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.9"
+end