aem_lookout 0.0.1

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,31 @@
+PATH
+  remote: .
+  specs:
+    aem_lookout (0.0.1)
+      builder (~> 3.2.2)
+      rb-fsevent (~> 0.9.4)
+      vlt_wrapper (~> 2.4.18)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    builder (3.2.2)
+    diff-lcs (1.2.5)
+    rb-fsevent (0.9.4)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.5)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.5)
+    vlt_wrapper (2.4.18)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.5)
+  aem_lookout!
+  rspec (~> 2.14.1)

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 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,33 @@
+# AemLookout
+
+Automatically deploys code changes while developing.
+
+A short loop between when you make changes and when you see those changes is an important step to productivity!
+
+## Install
+
+```
+gem install aem_lookout
+```
+
+or add the following to your Gemfile:
+
+```
+gem 'aem_lookout'
+```
+
+and run `bundle install` from your shell.
+
+## Usage
+
+1. Create a lookout.json file for your code base, similar to the (example config file)[https://github.com/jnraine/aem_lookout/blob/master/example_config.json].
+2. Run `lookout` from the command line. May need to run `bundle exec lookout` if the executable is not found.
+3. Edit files — .java, .css, .content.xml, whatever — and watch them deploy to your local instance.
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/aem_lookout/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/aem_lookout.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'aem_lookout/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "aem_lookout"
+  spec.version       = AemLookout::VERSION
+  spec.authors       = ["Jordan Raine"]
+  spec.email         = ["jnraine@gmail.com"]
+  spec.summary       = %q{Speeds up iteration loop while developing for AEM/CQ.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = ["aem_lookout", "lookout"]
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "vlt_wrapper", "~> 2.4.18"
+  spec.add_runtime_dependency "builder", "~> 3.2.2"
+  spec.add_runtime_dependency "rb-fsevent", "~> 0.9.4"
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rspec", "~> 2.14.1"
+end

data/bin/aem_lookout

@@ -0,0 +1,2 @@
+#!/bin/bash
+echo "Use `lookout` instead"

data/bin/lookout

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+$: << File.dirname(__FILE__) + "/lib"
+require 'aem_lookout'
+require 'rb-fsevent'
+require 'optparse'
+require 'json'
+
+options = {}
+option_parser = OptionParser.new do |opts|
+  opts.banner = "Usage: #{File.basename(__FILE__)} [-p CQ_REPO_PATH]"
+
+  opts.on("-p", "--path CQ_REPO_PATH", "Path to source code repo") do |cq_repo_path|
+    options[:cq_repo_path] = cq_repo_path
+  end
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+end
+
+option_parser.parse!
+
+begin
+  @cq_repo_path = options.fetch(:cq_repo_path, File.expand_path("."))
+rescue KeyError
+  puts option_parser
+  exit 1
+end
+
+def config
+  template = File.read(@cq_repo_path + "/lookout.json")
+  result = ERB.new(template).result
+  JSON.parse(result)
+end
+
+AemLookout::Watcher.run(@cq_repo_path, config)

data/example_config.json

@@ -0,0 +1,21 @@
+// You can use ERB tags in this!
+{
+	// array of CQ/AEM dev instance hostnames with HTTP basic auth and port
+	"instances": [
+		"http://admin:<%= ENV["CQ_PASSWORD"] %>@localhost:4502"
+	],
+	// array of relative paths to vault package roots (where jcr_root and META-INF live)
+	"jcrRootPaths": [
+		"jcr_content/src/content/jcr_root"
+	],
+	// array of objects specifying filesystem to jcr path mappings. Haven't finished this yet.
+	"slingInitialContentPaths": [
+		{"filesystem": "java-core/src/main/resources/components", "jcr": "/apps/clf/components"},
+		{"filesystem": "java-core/src/main/resources/clientlibs", "jcr": "/etc/designs/clf/clientlibs"}
+	],
+	// generic commands to do something when a specific 
+	"commands": [
+		// watch a bundle for changes to classes and install to local instance when it happens
+		{"watch": "java-core/src/main/java", "pwd": "java-core", "command": "mvn install -P author-localhost"}
+	]
+}

data/lib/aem_lookout/lookout_error.rb

@@ -0,0 +1,3 @@
+module AemLookout
+  class LookoutError < Exception; end
+end

data/lib/aem_lookout/sling_initial_content_converter.rb

@@ -0,0 +1,98 @@
+require 'json'
+require 'builder'
+
+module AemLookout
+  class SlingInitialContentConverter
+    def self.convert(json_string)
+      node_data = JSON.parse(json_string)
+      builder = Builder::XmlMarkup.new
+      serialized_attributes, children = group_data(node_data)
+
+      builder.tag!("jcr:root", namespaces.merge(serialized_attributes)) do |b|
+        add_children(children, b)
+      end
+    rescue JSON::ParserError => e
+      raise SlingInitialContentConverterError, "A problem occurred while parsing JSON descriptor file: #{e.message}"
+    end
+
+    def self.convert_package(package_path)
+      json_files = json_files_within(package_path)
+      json_files.each do |json_file|
+        content_xml_path = generate_content_xml_path(json_file)
+        FileUtils.mkdir_p(content_xml_path.parent)
+        xml_string = convert(File.read(json_file))
+        File.open(content_xml_path, 'w') {|f| f.write(xml_string) }
+        FileUtils.rm(json_file)
+      end
+    end
+
+    def self.json_files_within(path)
+      glob_path = Pathname(path).to_s + "/**/*"
+      Dir.glob(glob_path.to_s).delete_if {|path| !path.match(/\.json$/) }
+    end
+
+    def self.generate_content_xml_path(json_path)
+      raise ArgumentError, "#{json_path} must end in .json" unless json_path.end_with?(".json")
+      node_name = File.basename(json_path, ".json")
+      Pathname(json_path).parent + node_name + ".content.xml"
+    end
+
+    def self.add_children(children, builder)
+      children.each do |name, node_data|
+        serialized_attributes, children = group_data(node_data)
+        builder.tag!(name, serialized_attributes) do |b|
+          add_children(children, b)
+        end
+      end
+    end
+
+    # Divide node data into serialized attributes and children
+    def self.group_data(node_data)
+      serialized_attributes = {}
+      children = {}
+      node_data.each do |key,value|
+        if !value.is_a?(Hash)
+          serialized_attributes[key] = convert_to_serialized_jcr_value(value)
+        else
+          children[key] = value
+        end
+      end
+
+      [default_attributes.merge(serialized_attributes), children]
+    end
+
+    def self.default_attributes
+      {
+        "jcr:primaryType" => "nt:unstructured"
+      }
+    end
+
+    # All known namespaces
+    def self.namespaces
+      {
+        "xmlns:cq"    => "http://www.day.com/jcr/cq/1.0",
+        "xmlns:sling" => "http://sling.apache.org/jcr/sling/1.0",
+        "xmlns:jcr"   => "http://www.jcp.org/jcr/1.0",
+        "xmlns:vlt"   => "http://www.day.com/jcr/vault/1.0",
+        "xmlns:nt"    => "http://www.jcp.org/jcr/nt/1.0"
+      }
+    end
+
+    def self.convert_to_serialized_jcr_value(value)
+      if value == true || value == false
+        "{Boolean}#{value}"
+      elsif value.is_a?(Array)
+        values = value.map {|el| convert_to_serialized_jcr_value(el) }
+        "[#{values.join(",")}]"
+      elsif value.is_a?(Time)
+        "{Date}#{value.strftime("%Y-%m-%dT%H:%M:%S.%L%:z")}"
+      elsif value.is_a?(String)
+        value
+      else
+        raise "Unknown type, cannot serialize #{value.class} value: #{value}"
+      end
+    end
+  end
+
+  class SlingInitialContentConverterError < LookoutError; end
+end

data/lib/aem_lookout/sync.rb

@@ -0,0 +1,186 @@
+require 'uri'
+require 'pathname'
+require 'erb'
+require 'tmpdir'
+require 'logger'
+
+module AemLookout
+  class Sync
+    class Hostname
+      attr_accessor :url
+
+      def initialize(hostname)
+        @url = URI.parse(hostname)
+      end
+
+      def url_without_credentials
+        "#{url.scheme}://#{url.host}:#{url.port}/crx/-/jcr:root"
+      end
+
+      def credentials
+        "#{url.user}:#{url.password}"
+      end
+    end
+
+    def self.run(options)
+      self.new(options).run
+    end
+
+    attr_accessor :log, :hostnames, :filesystem_path, :jcr_path
+
+    def initialize(options)
+      default_log = Logger.new(options.fetch(:output, STDOUT))
+      @log = options.fetch(:log, default_log)
+      @hostnames = options.fetch(:hostnames).map {|hostname| Hostname.new(hostname) }
+      @sling_initial_content = options.fetch(:sling_initial_content, false)
+      @filesystem_path = options.fetch(:filesystem)
+      @jcr_path = options.fetch(:jcr)
+    rescue KeyError => e
+      raise ArgumentError.new("#{e.message} (missing a hash argument)")
+    end
+
+    # Locals on the local filesystem to copy into the package
+    def content_paths
+      if @content_paths.nil?
+        paths = if filesystem_path.end_with?(".content.xml")
+          Pathname(filesystem_path).parent.to_s
+        elsif sling_initial_content? and filesystem_path.end_with?(".json")
+          [filesystem_path, filesystem_path.gsub(/.json$/, "")].delete_if { |path| !File.exist?(path) }
+        else
+          filesystem_path
+        end
+
+        @content_paths = Array(paths)
+      end
+
+      @content_paths
+    end
+
+    # Paths in the package to install into the JCR
+    def filter_paths
+      if @filter_paths.nil?
+        paths = if jcr_path.end_with?(".content.xml")
+          Pathname(jcr_path).parent.to_s
+        elsif sling_initial_content? and jcr_path.end_with?(".json")
+          jcr_path.gsub(/.json$/, "")
+        else
+          jcr_path
+        end
+
+        @filter_paths = Array(paths)
+      end
+
+      @filter_paths
+    end
+
+    def run
+      start_timer
+      build_package
+      install_package
+      log_elapsed_time
+    end
+
+    def start_timer
+      @start_time = Time.now
+    end
+
+    def log_elapsed_time
+      elapsed_time = (Time.now.to_f - @start_time.to_f).round(2)
+      log.info "Elapsed time: #{elapsed_time} seconds"
+    end
+
+    def build_package
+      copy_content_to_package
+      create_settings
+      create_filter
+      SlingInitialContentConverter.convert_package(package_path) if sling_initial_content?
+      sleep 0.1 # just in case
+    end
+
+    def copy_content_to_package
+      FileUtils.mkdir_p(target_content_path_root)
+      content_paths.each do |content_path|
+        log.info "Copying content from #{content_path} to target content path root"
+        FileUtils.cp_r(content_path, target_content_path_root)
+      end
+    end
+
+    def create_settings
+      FileUtils.mkdir_p(vault_config_path)
+      File.open(vault_config_path + "settings.xml", 'w') {|f| f.write(settings_template) }
+    end
+
+    def create_filter
+      File.open(vault_config_path + "filter.xml", 'w') do |f|
+        paths = filter_paths
+        f.write(ERB.new(filter_template).result(binding))
+      end
+    end
+
+    def sling_initial_content_filter_paths_for(jcr_path)
+      
+    end
+
+    def install_package
+      hostnames.map do |hostname|
+        install_package_to_hostname(hostname)
+      end
+    end
+
+    def install_package_multithreaded
+      threads = hostnames.map do |hostname|
+        Thread.new do
+          install_package_to_hostname(hostname)
+        end
+      end
+
+      threads.each {|thread| thread.join } # wait for threads
+    end
+
+    def install_package_to_hostname(hostname)
+      log.info "Installing package at #{package_path} to #{hostname.url_without_credentials}"
+      command = "#{AemLookout.vlt_executable} --credentials #{hostname.credentials} -v import #{hostname.url_without_credentials} #{package_path} /"
+      Terminal.new(log).execute_command(command)
+    end
+
+    def vault_config_path
+      package_path + "META-INF/vault"
+    end
+
+    def target_content_path_root
+      (jcr_root_path + jcr_path.gsub(/^\//, "")).parent
+    end
+
+    def package_path
+      @package_path ||= Pathname(Dir.mktmpdir("vlt-sync"))
+    end
+
+    def jcr_root_path
+      @jcr_root ||= package_path + "jcr_root"
+    end
+
+    def sling_initial_content?
+      @sling_initial_content
+    end
+
+    def settings_template
+      <<-EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<vault version="0.1">
+  <ignore name=".svn"/>
+  <ignore name=".gitignore"/>
+  <ignore name=".DS_Store"/>
+</vault>
+      EOF
+    end
+
+    def filter_template
+      <<-EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<workspaceFilter vesion="0.1">
+<% paths.each do |path| %>  <filter root="<%= path %>" mode="replace"/>\n<% end %>
+</workspaceFilter>
+      EOF
+    end
+  end
+end

data/lib/aem_lookout/terminal.rb

@@ -0,0 +1,41 @@
+require 'open3'
+
+# A helper class for running terminal commands in the background while 
+# streaming to a Ruby logger.
+module AemLookout
+  class Terminal
+    attr_reader :log
+
+    def initialize(log = Logger.new(STDOUT))
+      @log = log
+    end
+
+    def execute_command(command)
+      Open3.popen3(command) do |stdin, stdout, stderr, thread|
+        flush(stdout: stdout, stderr: stderr) until !thread.alive?
+        flush(stdout: stdout, stderr: stderr)
+      end
+    end
+
+    def flush(options = {})
+      stdout_thread = stream_to_log(options.fetch(:stdout))
+      stderr_thread = stream_to_log(options.fetch(:stderr), error: true)
+      sleep 0.1 until !stdout_thread.alive? and !stdout_thread.alive?
+    end
+
+    def stream_to_log(io, options = {})
+      options = options.merge({error: false})
+      thread = Thread.new do
+        while message = io.gets
+          if options.fetch(:error)
+            log.error message.chomp
+          else
+            log.info message.chomp
+          end
+
+          sleep 0.01 # to ensure line isn't still being written to
+        end
+      end
+    end
+  end
+end

data/lib/aem_lookout/version.rb

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

data/lib/aem_lookout/watcher.rb

@@ -0,0 +1,223 @@
+module AemLookout
+  class Watcher
+    def self.run(repo_path, config)
+      self.new(repo_path, config).run
+    end
+
+    attr_accessor :repo_path, :config, :log
+
+    def initialize(repo_path, config, log = nil)
+      @repo_path = repo_path
+      @config = config
+      @log = log || Logger.new(STDOUT)
+    end
+
+    def run
+      threads = jcr_root_paths.map do |jcr_root_paths|
+        Thread.new { watch_vault_package(jcr_root_paths) }
+      end
+
+      threads += sling_initial_content_paths.map do |sling_initial_content_path|
+        Thread.new { watch_sling_initial_content(sling_initial_content_path) }
+      end
+
+      threads += command_configs.map do |command_config|
+        Thread.new { watch_command_config(command_config) }
+      end
+
+      wait_for(threads)
+    end
+
+    def wait_for(threads)
+      sleep 1 until Array(threads).map {|thread| thread.join(1) }.all? {|result| result }
+    end
+
+    def watch_vault_package(jcr_root)
+      if !File.exist?(jcr_root)
+        log.warn "jcr_root points to non-existing directory: #{jcr_root}"
+        return
+      end
+
+      options = {:latency => 0.1, :file_events => true}
+      fsevent = create_threaded_fsevent jcr_root.to_s, options do |paths|
+        sync_vault_package_paths(paths)
+      end
+
+      log.info "Watching jcr_root at #{jcr_root} for changes..."
+      fsevent.run
+    end
+
+    # Watch a given path with speified options and call action_block when a 
+    # non-ignored path is modified. This also ensures that only one 
+    # action_block is running at a time, killing any other running
+    # blocks before starting a new one.
+    def create_threaded_fsevent(watch_path, options, &action_block)
+      fsevent = FSEvent.new
+      running_jobs = Set.new
+
+      fsevent.watch watch_path, options do |paths|
+        paths.delete_if {|path| ignored?(path) }
+        log.warn "Detected change inside: #{paths.inspect}" unless paths.empty?
+
+        if running_jobs.length > 0
+          log.warn "A job is currently running for this watcher, killing..."
+          running_jobs.each {|thread| thread.kill }
+        else
+          log.warn "Phew, no running jobs: #{running_jobs}"
+        end
+
+        job = Thread.new do
+          action_block.call(paths)
+          Thread.exit
+        end
+
+        track_job_on_list(job, running_jobs)
+      end
+
+      fsevent
+    end
+
+    # Adds to running job list and removes from list when thread completes.
+    def track_job_on_list(job, running_jobs)
+      Thread.new do
+        running_jobs << job
+        log.warn "Waiting for #{job} to finish"
+        wait_for(job)
+        log.warn "#{job} job finished"
+        running_jobs.delete(job)
+        Thread.exit
+      end
+    end
+
+    def sync_vault_package_paths(paths)
+      paths.each do |path|
+        if !File.exist?(path)
+          log.warn "#{path} no longer exists, syncing parent instead"
+          path = File.dirname(path)
+        end
+
+        jcr_path = discover_jcr_path_from_file_in_vault_package(path)
+
+        AemLookout::Sync.new(
+          hostnames: hostnames,
+          filesystem: path,
+          jcr: jcr_path,
+          log: log
+        ).run
+      end
+    end
+
+    def watch_sling_initial_content(path)
+      filesystem_path = path.fetch("filesystem")
+      jcr_path = path.fetch("jcr")
+
+      if !File.exist?(filesystem_path)
+        log.warn "Filesystem path for Sling-Initial-Content points to non-existing directory: #{filesystem_path}"
+        return
+      end
+
+      options = {:latency => 0.1, :file_events => true}
+      fsevent = create_threaded_fsevent filesystem_path.to_s, options do |paths|
+        begin
+          handle_sling_initial_content_change(paths, filesystem_path, jcr_path)
+        rescue LookoutError => e
+          log.error "An error occurred while handling sling initial content change: #{e.message}"
+        end
+      end
+
+      log.info "Watching Sling-Initial-Content at #{filesystem_path} for changes..."
+      fsevent.run
+    end
+
+    def handle_sling_initial_content_change(paths, filesystem_path, jcr_path)
+      paths.each do |path|
+        if !File.exist?(path)
+          log.info "#{path} no longer exists, syncing parent instead"
+          path = File.dirname(path)
+        end
+
+        relative_jcr_path = path.gsub(/^.+#{filesystem_path}\//, "")
+
+        AemLookout::Sync.new(
+          hostnames: hostnames,
+          filesystem: path,
+          jcr: (Pathname(jcr_path) + relative_jcr_path).to_s,
+          log: log,
+          sling_initial_content: true
+        ).run
+      end
+    end
+
+    def watch_command_config(command_config)
+      watch_path = command_config.fetch("watch")
+      pwd = Pathname(repo_path) + command_config.fetch("pwd", "")
+      command = command_config.fetch("command")
+
+      options = {:latency => 1, :file_events => true}
+      fsevent = create_threaded_fsevent watch_path, options do |paths|
+        break if paths.empty?
+        log.info "Running command"
+        Terminal.new(log).execute_command("cd #{pwd} && #{command}")
+      end
+
+      log.info "Watching #{watch_path}, changes will run #{command.inspect}..."
+      fsevent.run
+    end
+
+    def jcr_root_paths
+      config.fetch("jcrRootPaths", []).map {|jcr_root_path| Pathname(repo_path) + jcr_root_path }.map(&:to_s)
+    end
+
+    def sling_initial_content_paths
+      config.fetch("slingInitialContentPaths", []).map do |sling_initial_content_path|
+        validate_sling_initial_content_path!(sling_initial_content_path)
+        sling_initial_content_path
+      end
+    end
+
+    # Something like this [{"watch" => "java-core/src/main/java", "pwd" => "java-core", "command" => "mvn install -P author-localhost"}]
+    def command_configs
+      config.fetch("commands", []).map do |command_config|
+        validate_command_config!(command_config)
+        command_config
+      end
+    end
+
+    # Ensures required keys are present. This is ugly.
+    def validate_command_config!(command_config)
+      required_keys = ["watch", "command"]
+      unless command_config.has_key?(required_keys.first) and command_config.has_key?(required_keys.last)
+        raise "commands entry is malformed (requires these keys: #{required_keys.join(", ")}): #{command_config.inspect}"
+      end
+    end
+
+    def validate_sling_initial_content_path!(path)
+      unless path.has_key?("filesystem") and path.has_key?("jcr")
+        raise "slingInitialContentPaths entry is malformed (requires \"filesystem\" and \"jcr\" entry): #{path.inspect}"
+      end
+    end
+
+    def hostnames
+      config.fetch("instances")
+    end
+
+    # Return true if file should not trigger a sync
+    def ignored?(file)
+      return true if File.extname(file) == ".tmp"
+      return true if file.match(/___$/)
+      return true if File.basename(file) == ".DS_Store"
+      return false
+    end
+
+    # Find the root of the package to determine the path used for the filter
+    def discover_jcr_path_from_file_in_vault_package(filesystem_path)
+      possible_jcr_root = Pathname(filesystem_path).parent
+      while !possible_jcr_root.root?
+        break if possible_jcr_root.basename.to_s == "jcr_root"
+        possible_jcr_root = possible_jcr_root.parent
+      end
+
+      filesystem_path.gsub(/^#{possible_jcr_root.to_s}/, "")
+    end
+  end
+end

data/lib/aem_lookout.rb

@@ -0,0 +1,17 @@
+require 'vlt_wrapper'
+
+require 'aem_lookout/version'
+require 'aem_lookout/lookout_error'
+require 'aem_lookout/sling_initial_content_converter'
+require 'aem_lookout/sync'
+require 'aem_lookout/terminal'
+require 'aem_lookout/watcher'
+
+
+module AemLookout
+  def vlt_executable
+    VltWrapper.executable
+  end
+
+  extend self
+end

data/spec/lib/aem_lookout/sling_initial_content_converter_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe AemLookout::SlingInitialContentConverter do
+  it "converts a json file into a .content.xml file" do
+    node_example = {
+      "cq:isContainer" => false,
+      "jcr:description" => "A list of upcoming events pulled from a calendar",
+      "jcr:primaryType" => "cq:Component",
+      "jcr:title" => "Upcoming Events",
+      "componentGroup" => "Social"
+    }
+    content_xml = AemLookout::SlingInitialContentConverter.convert(node_example.to_json)
+    xml_exemplar = '<jcr:root xmlns:cq="http://www.day.com/jcr/cq/1.0" xmlns:sling="http://sling.apache.org/jcr/sling/1.0" xmlns:jcr="http://www.jcp.org/jcr/1.0" xmlns:vlt="http://www.day.com/jcr/vault/1.0" xmlns:nt="http://www.jcp.org/jcr/nt/1.0" cq:isContainer="{Boolean}false" jcr:description="A list of upcoming events pulled from a calendar" jcr:primaryType="cq:Component" jcr:title="Upcoming Events" componentGroup="Social"></jcr:root>'
+    expect(content_xml).to eq(xml_exemplar)
+  end
+
+  # xit "prints an example of a complex JSON desciptor file" do
+  #   json = File.read("/Users/jnraine/projects/cq/java-core/src/main/resources/components/twitter-timeline.json")
+  #   puts AemLookout::SlingInitialContentConverter.convert(json)
+  # end
+
+  describe ".convert_to_serialized_jcr_value" do
+    let(:klass) { AemLookout::SlingInitialContentConverter }
+
+    it "converts booleans to serialized JCR booleans" do
+      klass.convert_to_serialized_jcr_value(true).should == "{Boolean}true"
+      klass.convert_to_serialized_jcr_value(false).should == "{Boolean}false"
+    end
+
+    it "converts arrays to serialized JCR arrays" do
+      klass.convert_to_serialized_jcr_value(["foo", "bar", "baz"]).should == "[foo,bar,baz]"
+    end
+
+    it "converts dates to serialized JCR dates" do
+      # this only handles local time
+      local_time = Time.parse("2010-03-17T17:14:41.775")
+      klass.convert_to_serialized_jcr_value(local_time).should == "{Date}2010-03-17T17:14:41.775-07:00"
+    end
+  end
+
+
+  describe "#convert_json_descriptor_files" do
+    def build_fake_package
+      tmp_dir = Pathname(Dir.mktmpdir("sync-test"))
+      File.open(tmp_dir + "#{node_name}.json", 'w') {|f| f.write(properties.to_json) }
+      tmp_dir
+    end
+
+    let(:properties) do
+      {foo: "hello", bar: "world", baz: "ur nice"}
+    end
+
+    let(:node_name) { "foo" }
+    let(:fake_package_path) { build_fake_package }
+
+    it "takes any json files at a given path and converts them to .content.xml files" do
+      AemLookout::SlingInitialContentConverter.convert_package(fake_package_path)
+      content_xml_path = fake_package_path + "foo" + ".content.xml"
+      expect(File).to exist(content_xml_path)
+      expect(File.read(content_xml_path)).to match("foo=\"hello\" bar=\"world\" baz=\"ur nice\"")
+    end
+  end
+
+  describe ".json_files_within" do
+    it "returns all json files found within a directory structure recursively" do
+      # setup
+      tmp_dir = Pathname(Dir.mktmpdir("test"))
+      nested_dir = tmp_dir + "foo" + "bar" + "baz"
+      FileUtils.mkdir_p(nested_dir.to_s)
+      sleep 0.01
+      FileUtils.touch([tmp_dir + "my.json", nested_dir + "another.json"])
+      # execute and assert
+      json_files = AemLookout::SlingInitialContentConverter.json_files_within(tmp_dir)
+      expect(json_files.length).to eq(2)
+      json_files.each {|json_file| expect(json_file).to end_with(".json") }
+    end
+  end
+
+  describe ".generate_content_xml_path" do
+    it "creates a content XML path for the named node" do
+      content_xml_path = AemLookout::SlingInitialContentConverter.generate_content_xml_path("/foo/my_node.json")
+      expect(content_xml_path).to eq(Pathname("/foo/my_node/.content.xml"))
+    end
+
+    it "raises an error when passed a path to a non-json file" do
+      expect { 
+        AemLookout::SlingInitialContentConverter.generate_content_xml_path("/foo/my_node.txt")
+      }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/lib/aem_lookout/sync_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe AemLookout::Sync do
+end

data/spec/lib/aem_lookout_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe AemLookout do
+  it "knows where the vlt executable lives" do
+    vlt_executable = AemLookout.vlt_executable
+    expect(File.basename(vlt_executable)).to eq("vlt")
+    expect(File.executable?(vlt_executable)).to eq(true)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+$: << File.expand_path("..", File.dirname(__FILE__))
+require 'aem_lookout'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.order = 'random'
+end

data/sync.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+VLT=/Users/jnraine/projects/cq/instances/author/crx-quickstart/opt/filevault/vault-cli-2.4.18/bin/vlt
+WHERE_JCR_ROOT_AND_META_INF_IS=/tmp/playground
+JCR_ROOT_PATH=/
+CQ_HOST="http://localhost:4502"
+CREDENTIALS="admin:cq4me"
+
+$VLT --credentials $CREDENTIALS -v import $CQ_HOST/crx/-/jcr:root $WHERE_JCR_ROOT_AND_META_INF_IS $JCR_ROOT_PATH

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification
+name: aem_lookout
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jordan Raine
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: vlt_wrapper
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.4.18
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.4.18
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.2
+- !ruby/object:Gem::Dependency
+  name: rb-fsevent
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.4
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+description: 
+email:
+- jnraine@gmail.com
+executables:
+- aem_lookout
+- lookout
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- aem_lookout.gemspec
+- bin/aem_lookout
+- bin/lookout
+- example_config.json
+- lib/aem_lookout.rb
+- lib/aem_lookout/lookout_error.rb
+- lib/aem_lookout/sling_initial_content_converter.rb
+- lib/aem_lookout/sync.rb
+- lib/aem_lookout/terminal.rb
+- lib/aem_lookout/version.rb
+- lib/aem_lookout/watcher.rb
+- spec/lib/aem_lookout/sling_initial_content_converter_spec.rb
+- spec/lib/aem_lookout/sync_spec.rb
+- spec/lib/aem_lookout_spec.rb
+- spec/spec_helper.rb
+- sync.sh
+homepage: ''
+licenses:
+- MIT
+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.23
+signing_key: 
+specification_version: 3
+summary: Speeds up iteration loop while developing for AEM/CQ.
+test_files:
+- spec/lib/aem_lookout/sling_initial_content_converter_spec.rb
+- spec/lib/aem_lookout/sync_spec.rb
+- spec/lib/aem_lookout_spec.rb
+- spec/spec_helper.rb
+has_rdoc: