emory 0.1.0

data/lib/emory/runner.rb

@@ -0,0 +1,75 @@
+require 'listen'
+require 'pathname'
+require 'emory/configuration_file'
+require 'emory/dsl/dsl'
+
+module Emory
+
+  class Runner
+
+    LOGGER = Logging.logger[self]
+
+    class << self
+      def start
+        begin
+          LOGGER.debug('Looking for the configuration file')
+          emory_config_file = ConfigurationFile.locate
+
+          LOGGER.debug('Reading configuration file contents')
+          emory_config_contents = File.read(emory_config_file)
+
+          LOGGER.debug("Evaluating configuration file contents:\n====\n#{emory_config_contents}===")
+          config = DSL::Dsl.instance_eval_emoryfile(emory_config_contents, emory_config_file)
+
+          LOGGER.debug('Configuring listeners')
+          configure_listeners(config, File.dirname(emory_config_file))
+
+          Thread.current.join
+        rescue Interrupt
+          LOGGER.info('Shutting down Emory')
+        rescue EmoryConfigurationFileNotFoundException => fileNotFoundException
+          LOGGER.error("#{fileNotFoundException.message}. Please refer to http://tacitknowledge.com/emory for information on how to use Emory.")
+        rescue Exception => e
+          LOGGER.error(e)
+        end
+      end
+
+      private
+      
+      def configure_listeners(config, config_location)
+        LOGGER.debug("Config\'s directory is: #{config_location}")
+        config.teleports.each do |teleport|
+          watched_path = normalize_watched_path(config_location, teleport.watched_path)
+          LOGGER.info("Watching directory: #{watched_path}")
+
+          listener = Listen.to(watched_path)
+          listener.ignore(teleport.ignore) unless teleport.ignore.nil?
+          listener.filter(teleport.filter) unless teleport.filter.nil?
+          listener.change(&get_handler_callback(teleport.handler))
+          listener.start(false)
+        end
+      end
+
+      def get_handler_callback(handler)
+        Proc.new do |modified, added, removed|
+          trigger_handler_method(modified, handler, :modified)
+          trigger_handler_method(added, handler, :added)
+          trigger_handler_method(removed, handler, :removed)
+        end
+      end
+
+      def trigger_handler_method(paths, handler, operation)
+        unless paths.empty?
+          paths.each { |path| handler.send(operation, path) } if handler.respond_to?(operation)
+        end
+      end
+
+      def normalize_watched_path(config_location, watched_path)
+        return watched_path if Pathname.new(watched_path).absolute?
+        File.expand_path(watched_path, config_location)
+      end
+
+    end
+  end
+
+end

data/lib/emory/teleport_config.rb

@@ -0,0 +1,7 @@
+module Emory
+
+  class TeleportConfig
+    attr_accessor :watched_path, :handler, :ignore, :filter
+  end
+
+end

data/lib/emory/version.rb

@@ -0,0 +1,3 @@
+module Emory
+  VERSION = "0.1.0"
+end

data/lib/emory.rb

@@ -0,0 +1 @@
+require "emory/version"

data/spec/emory/configuration_file_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'emory/configuration_file'
+
+module Emory
+  
+  describe ConfigurationFile do
+
+    context "class object" do
+
+      it "finds config file on its path" do
+        Dir.should_receive(:pwd).and_return('/qwe/asd/zxc/')
+        File.should_receive(:exists?).with('/qwe/asd/zxc/.emory').and_return(false)
+        File.should_receive(:exists?).with('/qwe/asd/.emory').and_return(false)
+        File.should_receive(:exists?).with('/qwe/.emory').and_return(true)
+
+        ConfigurationFile.locate.should == '/qwe/.emory'
+      end
+
+      it "finds config file in current directory" do
+        Dir.should_receive(:pwd).and_return('/qwe/asd/zxc/')
+        File.should_receive(:exists?).with('/qwe/asd/zxc/.emory').and_return(true)
+
+        ConfigurationFile.locate.should == '/qwe/asd/zxc/.emory'
+      end
+
+      it "raises exception if config file was not found on its path up to root" do
+        Dir.should_receive(:pwd).and_return('/qwe/asd/zxc/')
+        File.should_receive(:exists?).with('/qwe/asd/zxc/.emory').and_return(false)
+        File.should_receive(:exists?).with('/qwe/asd/.emory').and_return(false)
+        File.should_receive(:exists?).with('/qwe/.emory').and_return(false)
+        File.should_receive(:exists?).with('/.emory').and_return(false)
+
+        proc {
+          ConfigurationFile.locate
+        }.should raise_error(EmoryConfigurationFileNotFoundException,
+                             /Configuration file \(\.emory\) was not found/)
+      end
+
+    end
+
+  end
+
+end

data/spec/emory/dsl/dsl_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+require 'emory/dsl/dsl'
+require 'emory/dsl/handler_builder'
+require 'emory/dsl/teleport_config_builder'
+require 'emory/handlers/abstract_handler'
+
+module Emory
+  module DSL
+
+    describe Dsl do
+      let(:dsl) { Dsl.new }
+
+      context "class object" do
+        it "parses the supplied teleport config and configures correct object types in frozen collections" do
+          contents = <<-EOM
+          require 'emory/handlers/abstract_handler'
+
+          handler do
+            name :something
+            implementation Emory::Handlers::AbstractHandler
+            events :all
+          end
+
+          teleport do
+            path '/path/to/dir'
+            handler :something
+          end
+          EOM
+
+          config = Dsl.instance_eval_emoryfile(contents, '/path/to/file')
+          config.should have(1).handlers
+          config.handlers.should be_frozen
+          config.handlers[:something].class.should == Emory::Handlers::AbstractHandler
+          config.should have(1).teleports
+          config.teleports.should be_frozen
+          config.teleports[0].class.should == Emory::TeleportConfig
+        end
+
+        it "detects and reports incorrect usage of DSL" do
+          contents = <<-EOM
+          blah_blah_blah
+          EOM
+
+          proc {
+            Dsl.instance_eval_emoryfile(contents, '/path/to/file')
+          }.should raise_error(EmoryMisconfigurationException,
+                               /Incorrect contents of .emory file/)
+        end
+      end
+
+      context "'handler' method" do
+        it "does not allow to add multiple handlers with the same name" do
+          dsl.handlers[:something] = Object.new
+          builder = double('handler_builder')
+          handler = double('handler')
+          HandlerBuilder.should_receive(:new).and_return(builder)
+          builder.should_receive(:build).and_return(handler)
+          handler.should_receive(:name).twice.and_return(:something)
+
+          proc {
+            dsl.handler {}
+          }.should raise_error(DuplicateHandlerNameException)
+        end
+
+        it "adds a handler to its list" do
+          builder = double('handler_builder')
+          handler = double('handler')
+          HandlerBuilder.should_receive(:new).and_return(builder)
+          builder.should_receive(:build).and_return(handler)
+          handler.should_receive(:name).exactly(3).times.and_return(:something)
+
+          dsl.handler {}
+          dsl.should have(1).handlers
+        end
+      end
+
+      context "'teleport' method" do
+        it "adds a teleport to its list" do
+          builder = double('teleport_builder')
+          teleport = double('teleport')
+          TeleportConfigBuilder.should_receive(:new).and_return(builder)
+          builder.should_receive(:build).and_return(teleport)
+
+          dsl.teleport {}
+          dsl.should have(1).teleports
+        end
+      end
+    end
+
+  end
+end

data/spec/emory/dsl/handler_builder_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+require 'emory/dsl/handler_builder'
+require 'emory/handlers/stdout_handler'
+
+module Emory
+  module DSL
+
+    describe HandlerBuilder do
+
+      it "mandates a block needs to be supplied to builder constructor" do
+        proc {
+          HandlerBuilder.new
+        }.should raise_error(HandlerConfigurationBlockMustBeSuppliedException)
+      end
+
+      it "mandates action of type ':all' to be exclusive of other types" do
+        p = proc {
+          name :test_handler
+          implementation ::Emory::Handlers::StdoutHandler
+          events :added, :all
+        }
+
+        builder = HandlerBuilder.new(&p)
+        proc {
+          builder.build
+        }.should raise_error(HandlerActionAllMustBeSingletonException)
+      end
+
+      it "mandates at least one action type to be supplied to 'events'" do
+        p = proc {
+          name :test_handler
+          implementation ::Emory::Handlers::StdoutHandler
+          events
+        }
+
+        builder = HandlerBuilder.new(&p)
+        proc {
+          builder.build
+        }.should raise_error(HandlerActionMustBeSuppliedException)
+      end
+
+      it "mandates 'events' configuration to be supplied to proc" do
+        p = proc {
+          name :test_handler
+          implementation ::Emory::Handlers::StdoutHandler
+        }
+
+        builder = HandlerBuilder.new(&p)
+        proc {
+          builder.build
+        }.should raise_error(HandlerActionMustBeSuppliedException)
+      end
+
+      it "mandates correct handler action types are required to be supplied" do
+        p = proc {
+          name :test_handler
+          implementation ::Emory::Handlers::StdoutHandler
+          events :foo
+        }
+
+        builder = HandlerBuilder.new(&p)
+        proc {
+          builder.build
+        }.should raise_error(HandlerActionUnsupportedException)
+      end
+
+      it "mandates 'name' configuration to be supplied to proc" do
+        p = proc {
+          implementation ::Emory::Handlers::StdoutHandler
+        }
+
+        builder = HandlerBuilder.new(&p)
+        proc {
+          builder.build
+        }.should raise_error(HandlerNameMustBeSuppliedException)
+      end
+
+      it "mandates 'implementation' configuration to be supplied to proc" do
+        p = proc {
+          name :test_handler
+        }
+
+        builder = HandlerBuilder.new(&p)
+        proc {
+          builder.build
+        }.should raise_error(HandlerImplementationMustBeSuppliedException)
+      end
+
+      it "passes the supplied name and options on to the handler's constructor" do
+        p = proc {
+          name :test_handler
+          implementation ::Emory::Handlers::StdoutHandler
+          events :all
+          options host: 'localhost', port: '8080'
+        }
+
+        Emory::Handlers::StdoutHandler.should_receive(:new).with(:test_handler, {host: 'localhost', port: '8080'})
+
+        builder = HandlerBuilder.new(&p)
+        builder.build
+      end
+
+      it "passes the supplied name and empty hash on to the handler's constructor if options configuration is not supplied" do
+        p = proc {
+          name :test_handler
+          implementation ::Emory::Handlers::StdoutHandler
+          events :all
+        }
+
+        Emory::Handlers::StdoutHandler.should_receive(:new).with(:test_handler, {})
+
+        builder = HandlerBuilder.new(&p)
+        builder.build
+      end
+
+      it "with action of type ':all' does not undefine any handler's methods" do
+        p = proc {
+          name :test_handler
+          implementation ::Emory::Handlers::StdoutHandler
+          events :all
+        }
+
+        builder = HandlerBuilder.new(&p)
+        handler = builder.build
+
+        handler.respond_to?(:added).should == true
+        handler.respond_to?(:modified).should == true
+        handler.respond_to?(:removed).should == true
+      end
+
+      it "with all action types does not undefine any handler's methods" do
+        p = proc {
+          name :test_handler
+          implementation ::Emory::Handlers::StdoutHandler
+          events :added, :modified, :removed
+        }
+
+        builder = HandlerBuilder.new(&p)
+        handler = builder.build
+
+        handler.respond_to?(:added).should == true
+        handler.respond_to?(:modified).should == true
+        handler.respond_to?(:removed).should == true
+      end
+
+      it "undefines handler's methods which are not supplied" do
+        p = proc {
+          name :test_handler
+          implementation ::Emory::Handlers::StdoutHandler
+          events :added
+        }
+
+        builder = HandlerBuilder.new(&p)
+        handler = builder.build
+
+        handler.respond_to?(:added).should == true
+        handler.respond_to?(:modified).should == false
+        handler.respond_to?(:removed).should == false
+      end
+
+    end
+  end
+end

data/spec/emory/dsl/teleport_config_builder_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+require 'emory/dsl/teleport_config_builder'
+
+module Emory
+  module DSL
+
+    describe TeleportConfigBuilder do
+
+      it "mandates handlers and a block need to be supplied to builder constructor" do
+        proc {
+          TeleportConfigBuilder.new({})
+        }.should raise_error(TeleportConfigurationBlockMustBeSuppliedException)
+      end
+
+      it "mandates a handler reference to be supplied" do
+        p = proc {}
+
+        handlers = {test_handler: Object.new}
+        builder = TeleportConfigBuilder.new(handlers, &p)
+        proc {
+          builder.build
+        }.should raise_error(HandlerReferenceMustBeSuppliedException)
+      end
+
+      it "mandates an existing handler reference to be supplied" do
+        p = proc {
+          handler :does_not_exist
+        }
+
+        handlers = {test_handler: Object.new}
+        builder = TeleportConfigBuilder.new(handlers, &p)
+        proc {
+          builder.build
+        }.should raise_error(UndefinedTeleportHandlerException)
+      end
+
+      it "mandates a watched path to be supplied" do
+        p = proc {
+          handler :test_handler
+        }
+
+        handlers = {test_handler: Object.new}
+        builder = TeleportConfigBuilder.new(handlers, &p)
+        proc {
+          builder.build
+        }.should raise_error(WatchedPathMustBeSuppliedException)
+      end
+
+      it "verifies mandatory configuration settings" do
+        p = proc {
+          handler :test_handler
+          path '/path/to/file'
+        }
+
+        handler = Object.new
+        handlers = {test_handler: handler}
+        builder = TeleportConfigBuilder.new(handlers, &p)
+
+        teleport = builder.build
+        teleport.watched_path.should == '/path/to/file'
+        teleport.handler.should == handler
+      end
+
+      it "verifies complete configuration settings" do
+        p = proc {
+          handler :test_handler
+          path '/path/to/file'
+          ignore %r{ignored/}
+          filter /\.txt$/
+        }
+
+        handler = Object.new
+        handlers = {test_handler: handler}
+        builder = TeleportConfigBuilder.new(handlers, &p)
+
+        teleport = builder.build
+        teleport.watched_path.should == '/path/to/file'
+        teleport.handler.should == handler
+        teleport.ignore.should == %r{ignored/}
+        teleport.filter.should == /\.txt$/
+      end
+
+      it "verifies optional 'ignore' configuration setting" do
+        p = proc {
+          handler :test_handler
+          path '/path/to/file'
+          ignore %r{ignored/}
+        }
+
+        handler = Object.new
+        handlers = {test_handler: handler}
+        builder = TeleportConfigBuilder.new(handlers, &p)
+
+        teleport = builder.build
+        teleport.ignore.should == %r{ignored/}
+      end
+
+      it "verifies optional 'filter' configuration setting" do
+        p = proc {
+          handler :test_handler
+          path '/path/to/file'
+          filter /\.txt$/
+        }
+
+        handler = Object.new
+        handlers = {test_handler: handler}
+        builder = TeleportConfigBuilder.new(handlers, &p)
+
+        teleport = builder.build
+        teleport.filter.should == /\.txt$/
+      end
+
+    end
+
+  end
+end

data/spec/emory/handlers/abstract_handler_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'emory/handlers/abstract_handler'
+
+module Emory
+  module Handlers
+
+    describe AbstractHandler do
+      context "is abstract so its method" do
+        let(:handler) { AbstractHandler.new(:test_handler) }
+
+        it "'added' raises NotImplementedError" do
+          proc {
+            handler.added
+          }.should raise_error(NotImplementedError,
+                               /This method is not implemented: Emory::Handlers::AbstractHandler#added/)
+        end
+
+        it "'modified' raises NotImplementedError" do
+          proc {
+            handler.modified
+          }.should raise_error(NotImplementedError,
+                               /This method is not implemented: Emory::Handlers::AbstractHandler#modified/)
+        end
+
+        it "'removed' raises NotImplementedError" do
+          proc {
+            handler.removed
+          }.should raise_error(NotImplementedError,
+                               /This method is not implemented: Emory::Handlers::AbstractHandler#removed/)
+        end
+      end
+    end
+
+  end
+end

data/spec/emory/handlers/stdout_handler_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'emory/handlers/stdout_handler'
+
+module Emory
+  module Handlers
+
+    describe StdoutHandler do
+      context "works with standard output" do
+        let(:handler) { StdoutHandler.new(:test_handler) }
+
+        it "'added' just calls 'puts' with right params" do
+          handler.should_receive(:puts).with(":test_handler ~> The file '/path/to/file' was 'added'")
+          handler.added '/path/to/file'
+        end
+
+        it "'modified' just calls 'puts' with right params" do
+          handler.should_receive(:puts).with(":test_handler ~> The file '/path/to/file' was 'modified'")
+          handler.modified '/path/to/file'
+        end
+
+        it "'removed' just calls 'puts' with right params" do
+          handler.should_receive(:puts).with(":test_handler ~> The file '/path/to/file' was 'removed'")
+          handler.removed '/path/to/file'
+        end
+      end
+    end
+
+  end
+end

data/spec/emory/runner_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+require 'listen'
+require 'pathname'
+require 'emory/runner'
+require 'emory/dsl/dsl'
+require 'emory/teleport_config'
+require 'emory/handlers/stdout_handler'
+
+module Emory
+
+  describe Runner do
+    context "class object" do
+      it "starts the config file location process, creates necessary listener with absolute path and joins current thread" do
+        dsl = DSL::Dsl.new
+        teleport = TeleportConfig.new
+        teleport.watched_path = 'watched_path'
+        teleport.handler = Handlers::StdoutHandler.new(:handler_name)
+        teleport.ignore = 'ignore_path'
+        teleport.filter = 'filter_expression'
+        dsl.teleports << teleport
+
+        path_to_config_file = '/path/to/config/file'
+        ConfigurationFile.stub(:locate => path_to_config_file)
+        File.stub(:read).with(path_to_config_file).and_return('contents')
+        DSL::Dsl.stub(:instance_eval_emoryfile).with('contents', path_to_config_file).and_return(dsl)
+
+        Pathname.any_instance.stub(:absolute?).and_return(true)
+
+        mock_listener = double("listener")
+        Listen.stub(:to).with('watched_path').and_return(mock_listener)
+        mock_listener.should_receive(:ignore).with(teleport.ignore)
+        mock_listener.should_receive(:filter).with(teleport.filter)
+        mock_listener.should_receive(:change)
+        mock_listener.should_receive(:start).with(false)
+
+        mock_thread = double("thread")
+        Thread.stub(:current => mock_thread)
+        mock_thread.should_receive(:join)
+
+        Runner.start
+      end
+
+      it "starts the config file location process, creates necessary listener with relative path and joins current thread" do
+        dsl = DSL::Dsl.new
+        teleport = TeleportConfig.new
+        teleport.watched_path = 'watched_path'
+        teleport.handler = Handlers::StdoutHandler.new(:handler_name)
+        teleport.ignore = 'ignore_path'
+        teleport.filter = 'filter_expression'
+        dsl.teleports << teleport
+
+        path_to_config_file = '/path/to/config/file'
+        ConfigurationFile.stub(:locate => path_to_config_file)
+        File.stub(:read).with(path_to_config_file).and_return('contents')
+        DSL::Dsl.stub(:instance_eval_emoryfile).with('contents', path_to_config_file).and_return(dsl)
+
+        Pathname.any_instance.stub(:absolute?).and_return(false)
+        File.should_receive(:expand_path).with('watched_path', '/path/to/config').and_return('/path/to/config/watched_path')
+
+        mock_listener = double("listener")
+        Listen.stub(:to).with('/path/to/config/watched_path').and_return(mock_listener)
+        mock_listener.should_receive(:ignore).with(teleport.ignore)
+        mock_listener.should_receive(:filter).with(teleport.filter)
+        mock_listener.should_receive(:change)
+        mock_listener.should_receive(:start).with(false)
+
+        mock_thread = double("thread")
+        Thread.stub(:current => mock_thread)
+        mock_thread.should_receive(:join)
+
+        Runner.start
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'rspec'
+require 'logging'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.formatter     = 'documentation'
+end

data/test/emory/test_configuration_file.rb

@@ -0,0 +1,10 @@
+require 'test/unit'
+require 'emory/configuration_file'
+
+class TestConfigurationFile < Test::Unit::TestCase
+  
+  def test_read_file_not_found
+    #TODO: test come here
+  end
+  
+end