harbor 0.16.1

data/lib/harbor/cache/disk.rb

@@ -0,0 +1,99 @@
+require Pathname(__FILE__).dirname.parent + "cache"
+
+class Harbor::Cache::Disk
+
+  def initialize(path)
+    @path = path.is_a?(Pathname) ? path : Pathname(path)
+
+    FileUtils.mkdir_p(@path) unless ::File.directory?(@path.to_s)
+  end
+
+  def get(key)
+    if (path = filename_for_key(key))
+      item_for_path(path)
+    else
+      nil
+    end
+  end
+
+  alias [] get
+
+  def put(key, ttl, maximum_age, content, cached_at)
+    item = Harbor::Cache::Item.new(key, ttl, maximum_age, content, cached_at)
+
+    FileUtils.rm(filenames_for_key(key))
+
+    ::File.open(path_for_item(item), 'w') do |file|
+      file.write(content)
+    end
+
+    item
+  end
+
+  def delete(key)
+    if (path = filename_for_key(key))
+      FileUtils.rm(path) rescue nil
+    end
+  end
+
+  def delete_matching(key)
+    filenames_for_key(key).each do |path|
+      FileUtils.rm(path) rescue nil
+    end
+  end
+
+  def bump(key)
+    if item = get(key)
+      current_path = path_for_item(item)
+
+      item.bump
+
+      new_path = path_for_item(item)
+      FileUtils.mv(current_path, new_path) unless current_path == new_path
+    end
+  end
+
+  private
+
+  def filenames_for_key(key)
+    if key.is_a?(Regexp)
+      Dir[@path + "*"].select { |path| path[/.*?__INFO__/] =~ key }
+    else
+      Dir[@path + "c_#{key}.*"]
+    end
+  end
+
+  def filename_for_key(key)
+    filenames_for_key(key).first
+  end
+
+  def item_for_path(path)
+    components = ::File.basename(path).split('.')
+
+    return nil if components.size < 6
+
+    expires_at = Time.parse(components.pop)
+    cached_at = Time.parse(components.pop)
+
+    if (maximum_age = components.pop).size > 0
+      maximum_age = maximum_age.to_i
+    else
+      maximum_age = nil
+    end
+
+    if (ttl = components.pop).size > 0
+      ttl = ttl.to_i
+    else
+      ttl = nil
+    end
+
+    key = components.reject { |c| c == "__INFO__" }.join('.').sub(/^c\_/, '')
+
+    Harbor::Cache::Item.new(key, ttl, maximum_age, Pathname(path), cached_at, expires_at)
+  end
+
+  def path_for_item(item)
+    @path + "c_#{item.key}.__INFO__.#{item.ttl}.#{item.maximum_age}.#{item.cached_at.strftime('%Y%m%dT%H%M%S%Z')}.#{item.expires_at.strftime('%Y%m%dT%H%M%S%Z')}"
+  end
+
+end

data/lib/harbor/cache/item.rb

@@ -0,0 +1,48 @@
+class Harbor::Cache
+
+  class Item
+
+    attr_reader :key, :ttl, :expires_at, :cached_at, :content, :maximum_age, :ultimate_expiration_time
+
+    def initialize(key, ttl, maximum_age, string_or_io, cached_at, expires_at = nil)
+      raise ArgumentError.new("Harbor::Cache::Item#initialize expects a String value for 'key', got #{key}") unless key.is_a?(String)
+      raise ArgumentError.new("Harbor::Cache::Item#initialize expects a Fixnum value greater than 0 for 'ttl', got #{ttl}") unless ttl.is_a?(Fixnum) && ttl > 0
+      raise ArgumentError.new("Harbor::Cache::Item#initialize expects nil, or a Fixnum value greater than 0 for 'maximum_age', got #{maximum_age}") unless maximum_age.nil? || (maximum_age.is_a?(Fixnum) && maximum_age > 0)
+      raise ArgumentError.new("Harbor::Cache::Item#initialize expects a Time value for 'cached_at', got #{cached_at}") unless cached_at.is_a?(Time)
+      raise ArgumentError.new("Harbor::Cache::Item#initialize expects a maximum_age greater than the ttl, got ttl: #{ttl}, maximum_age: #{maximum_age}") if maximum_age && ttl && (maximum_age <= ttl)
+
+      @key = key
+      @ttl = ttl
+      @maximum_age = maximum_age
+      @cached_at = cached_at
+      @expires_at = expires_at || (cached_at + ttl)
+      @ultimate_expiration_time = (maximum_age ? cached_at + maximum_age : nil)
+
+      if string_or_io.respond_to?(:read)
+        @io = string_or_io
+      else
+        @content = string_or_io
+      end
+    end
+
+    def content
+      @content ||= @io.read
+    end
+
+    def fresh?
+      Time.now < expires_at
+    end
+
+    def expired?
+      Time.now >= expires_at
+    end
+
+    def bump
+      if @ultimate_expiration_time
+        @expires_at = [Time.now + ttl, @ultimate_expiration_time].min
+      end
+    end
+
+  end
+
+end

data/lib/harbor/cache/memory.rb

@@ -0,0 +1,35 @@
+require Pathname(__FILE__).dirname.parent + "cache"
+
+class Harbor::Cache::Memory
+
+  def initialize
+    @cache = {}
+  end
+
+  def put(key, ttl, maximum_age, content, cached_at)
+    @cache[key] = Harbor::Cache::Item.new(key, ttl, maximum_age, content, cached_at)
+  end
+
+  def get(key)
+    @cache[key]
+  end
+
+  def [](key)
+    @cache[key]
+  end
+
+  def delete(key)
+    @cache.delete(key)
+  end
+
+  def delete_matching(key_regex)
+    @cache.reject! { |key, value| key =~ key_regex }
+  end
+
+  def bump(key)
+    if item = @cache[key]
+      item.bump
+    end
+  end
+
+end

data/lib/harbor/cascade.rb

@@ -0,0 +1,75 @@
+module Harbor
+  class Cascade
+
+    def initialize(environment, services, application, *ports)
+      unless services.is_a?(Harbor::Container)
+        raise ArgumentError.new("Harbor::Cascade#initialize[services] must be a Harbor::Container")
+      end
+
+      @services = services
+      @applications = []
+      @public_paths = []
+
+      begin
+        @applications << application.new(services, environment)
+      rescue ArgumentError => e
+        raise ArgumentError.new("#{application}: #{e.message}")
+      end
+
+      @public_paths << Pathname(application.public_path) if application.respond_to?(:public_path)
+
+      ports.each do |port|
+        begin
+          @applications << port.new(services, environment)
+        rescue ArgumentError => e
+          raise ArgumentError.new("#{port}: #{e.message}")
+        end
+
+        @public_paths << Pathname(port.public_path) if port.respond_to?(:public_path)
+      end
+
+      @public_paths << Pathname("public")
+    end
+
+    def call(env)
+      request = Request.new(self, env)
+      response = Response.new(request)
+
+      catch(:abort_request) do
+        if file = find_public_file(request.path_info[1..-1])
+          response.cache(nil, ::File.mtime(file), 86400) do
+            response.stream_file(file)
+          end
+          return response.to_a
+        end
+
+        application, handler = nil
+
+        @applications.each do |application|
+          break if handler = application.router.match(request)
+        end
+
+        application = @applications.first unless handler
+        request.application = application
+
+        application.dispatch_request(handler, request, response)
+      end
+
+      response.to_a
+    end
+
+    def find_public_file(file)
+      result = nil
+
+      @public_paths.each do |public_path|
+        if (path = public_path + file).file?
+          result = path
+          break
+        end
+      end
+
+      result
+    end
+
+  end
+end

data/lib/harbor/console.rb

@@ -0,0 +1,34 @@
+module Harbor
+  ##
+  # Heplful to include in your config.ru for getting an interative IRB
+  # session.
+  # 
+  #    #!/usr/bin/env ruby
+  #    # require app, set up ORM, etc.
+  #    
+  #    if $0 == __FILE__
+  #      Harbor::Console.start
+  #    else
+  #      run MyApplication
+  #    end
+  ##
+  class Console
+
+    def self.start
+      require 'irb'
+
+      begin
+        require 'irb/completion'
+      rescue Exception
+        # No readline available, proceed anyway.
+      end
+
+      if ::File.exists? ".irbrc"
+        ENV['IRBRC'] = ".irbrc"
+      end
+
+      IRB.start
+    end
+
+  end
+end

data/lib/harbor/container.rb

@@ -0,0 +1,134 @@
+require 'set'
+
+module Harbor
+  ##
+  # Harbor::Container is an inversion of control container for simple
+  # dependency injection. For more information on dependency injection, see
+  # http://martinfowler.com/articles/injection.html.
+  # 
+  # Simple Example:
+  # 
+  #   services = Harbor::Container.new
+  #   services.register("mailer", Harbor::Mailer)
+  # 
+  #   class Controller
+  #     attr_accessor :mailer
+  #   end
+  # 
+  #   services.register("Controller", Controller)
+  # 
+  #   services.get("Controller") # => #<Controller: @mailer=#<Mailer>>
+  ##
+  class Container
+    
+    class RegistrationTypeMismatchError < StandardError
+      def initialize(registration_name, previously_registered_type, mismatched_type)
+        super(<<-EOS.split($/).join(' '))
+          "#{registration_name}" has already been registered as a #{previously_registered_type.inspect}
+          but a modification of Type to #{mismatched_type.inspect} was attempted.
+        EOS
+      end
+    end
+
+    class ServiceRegistration
+
+      attr_reader :name, :service, :initializers
+
+      def initialize(name, service)
+        @name, @service = name, service
+        @initializers = Set.new
+      end
+
+    end
+
+    def initialize #:nodoc:
+      @services = {}
+      @dependencies = {}
+    end
+
+    ##
+    # Retrieve a service by name from the set of registered services, initializing
+    # any dependencies from the container, and optionally setting any additional
+    # properties on the service.
+    # 
+    #   class Controller
+    #     attr_accessor :request, :response, :mailer
+    #   end
+    # 
+    #   services.get("Controller", :request => Request.new(env), :response => Response.new(request))
+    ##
+    def get(name, optional_properties = {})
+      raise ArgumentError.new("#{name} is not a registered service name") unless registered?(name)
+      service_registration = @services[name]
+      service = service_registration.service.is_a?(Class) ? service_registration.service.new : service_registration.service
+
+      dependencies(name).each do |dependency|
+        service.send("#{dependency}=", get(dependency, optional_properties))
+      end
+
+      optional_instances = {}
+      optional_properties.each_pair do |k,v|
+        instance = v.is_a?(Class) ? v.new : v
+        optional_instances[k] = instance
+      end
+
+      optional_instances.each_pair do |k, v|
+        writer = "#{k}="
+        service.send(writer, v) if service.respond_to?(writer)
+        optional_instances.each_pair do |k2,v2|
+          next if k2 == k || !v2.respond_to?(writer)
+          v2.send(writer, v)
+        end
+      end
+
+      service_registration.initializers.each do |initializer|
+        initializer.call(service)
+      end
+
+      service
+    end
+
+    ##
+    # Register a service by name, with an optional initializer block.
+    # 
+    #   services.register("mail_server", Harbor::SendmailServer.new(:sendmail => "/sbin/sendmail"))
+    #   services.register("mailer", Harbor::Mailer)
+    #   services.get("mailer") # => #<Harbor::Mailer @from=nil @mail_server=#<SendmailServer...>>
+    # 
+    #   services.register("mailer", Harbor::Mailer) { |mailer| mailer.from = "admin@example.com" }
+    #   services.get("mailer") # => #<Harbor::Mailer @from="admin@example.com" @mail_server=#<SendmailServer...>>
+    ##
+    def register(name, service, &setup)
+      if (existing_registration = @services[name]) && existing_registration.service != service
+        raise RegistrationTypeMismatchError.new(name, existing_registration.service, service)
+      end
+
+      type_dependencies = dependencies(name)
+      type_methods = service.is_a?(Class) ? service.instance_methods.grep(/\=$/) : []
+
+      @services.values.each do |service_registration|
+        if service_registration.service.is_a?(Class) && service_registration.service.instance_methods.include?("#{name}=")
+          dependencies(service_registration.name) << name
+        end
+
+        if type_methods.include?("#{service_registration.name}=")
+          type_dependencies << service_registration.name
+        end
+      end
+
+      @services[name] ||= ServiceRegistration.new(name, service)
+      @services[name].initializers << setup if setup
+
+      self
+    end
+
+    def registered?(name)
+      @services.key?(name)
+    end
+
+    private
+    def dependencies(service)
+      @dependencies[service] ||= Set.new
+    end
+  end
+end

data/lib/harbor/contrib/debug.rb

@@ -0,0 +1,236 @@
+module Harbor
+  module Contrib
+    ##
+    # USAGE:
+    # Add the following code to your config.ru, just before 'run'
+    #   if ENV['ENVIRONMENT'] == 'development'
+    #     require "harbor/contrib/debug"
+    #     DataObjects::Postgres.logger = Logging::Logger.root
+    #     use Harbor::Contrib::Debug
+    #   end
+    ##
+    class Debug
+      def initialize(app)
+        @app = app
+        @levels = %w(DEBUG INFO WARN ERROR FATAL)
+      end
+
+      def call(env)
+        start_time = Time.now
+        status, headers, body = @app.call(env)
+        load_time = Time.now - start_time
+
+        appenders = Logging::Logger.root.instance_variable_get(:@appenders)
+        logger = appenders.find { |appender| appender.name == "harbor_debug_messages" }
+        messages = logger.messages.dup
+        logger.messages.clear
+
+        return [status, headers, body] unless (headers["Content-Type"] =~ /html/) && body.is_a?(String)
+
+        debugger = @@template.dup
+
+        if body["jquery"]
+          debugger.gsub!("{{jquery}}", "")
+        else
+          debugger.gsub!("{{jquery}}", '<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js"></script>')
+        end
+
+        debugger.gsub!("{{load_time}}", "%2.2f" % load_time)
+
+        queries = messages.map do |level, message|
+          ("<p>[#{@levels[level]}] " + message.gsub("<", "&lt;") + "</p>") if message =~ /^\(/
+        end.compact
+
+        messages = messages.map do |level, message|
+          ("<p>[#{@levels[level]}] " + message.gsub("<", "&lt;") + "</p>") if message !~ /^\(/
+        end.compact
+
+        debugger.gsub!("{{query_count}}", "%s" % queries.size)
+        debugger.gsub!("{{message_count}}", "%s" % messages.size)
+
+        if messages.any?
+          debugger.gsub!("{{messages}}", '<div class="messages" style="display: none">' + messages.join("\n") + '</div>')
+        else
+          debugger.gsub!("{{messages}}", "")
+        end
+
+        if queries.any?
+          debugger.gsub!("{{queries}}", '<div class="queries" style="display: none">' + queries.join("\n") + '</div>')
+        else
+          debugger.gsub!("{{queries}}", "")
+        end
+
+        body.gsub!("</body>", debugger + "</body>")
+        headers["Content-Length"] = body.length.to_s
+
+        [status, headers, body]
+      end
+
+      class LogAppender < Logging::Appender
+        def initialize
+          @messages = []
+
+          super("harbor_debug_messages", :level => :debug)
+        end
+
+        def messages
+          @messages
+        end
+
+        def write(event)
+          messages << [event.level, event.data]
+        end
+      end
+
+      @@template = <<-HTML
+{{jquery}}
+<style type="text/css" media="screen">
+
+  body:last-child { margin-bottom: 60px; }
+
+  #logger {
+    position: fixed; bottom: 0; font-family: "Lucida Grande"; z-index: 99000;
+    width: 100%;
+  }
+
+  #logger ul {
+    margin: 0; padding: 0; list-style: none; overflow: auto;
+    width: 293px;
+    margin: 0 auto;
+    -webkit-border-top-right-radius: 5px;
+    -webkit-border-top-left-radius: 5px;
+    -moz-border-radius-topright: 5px;
+    -moz-border-radius-topleft: 5px;
+    -webkit-box-shadow: 0 0 10px #222;
+    -moz-box-shadow: 0 0 10px #222;
+  }
+
+  #logger > div {
+    -webkit-border-top-right-radius: 5px;
+    -webkit-border-top-left-radius: 5px;
+    -moz-border-radius-topright: 5px;
+    -moz-border-radius-topleft: 5px;
+    background-color: #222;
+    padding: 10px;
+    height: 200px;
+    margin: 0 20px;
+  }
+
+  #logger > div div {
+    overflow: auto;
+    height: 200px;
+  }
+
+  #logger p { margin: 0; color: #eee; padding: 10px; line-height: 14px; font-size: 12px; font-family: monaco; border-bottom: 1px solid #555; }
+
+  #logger ul li:first-of-type a {
+    -webkit-border-top-left-radius: 5px;
+    -moz-border-radius-topleft: 5px;
+  }
+  #logger ul li:last-of-type a {
+    -webkit-border-top-right-radius: 5px;
+    -moz-border-radius-topright: 5px;
+  }
+
+  #logger ul li { float: left; border-right: 1px solid #111; }
+  #logger ul li:last-of-type { border: 0; }
+  #logger ul li a {
+    padding: 6px 10px; display: block; text-decoration: none; width: 77px; text-align: center; font-weight: bold;
+    text-shadow: 1px 1px 1px #222; font-size: 14px; font-family: "Lucida Grande";
+    line-height: 14px; border: 0;
+  }
+  #logger ul li a:hover, #logger ul li a.selected { text-shadow: 1px 1px 1px #444; }
+  #logger ul li a span { display: block; font-size: 9px; line-height: 14px; text-transform: uppercase; text-align: center; }
+  #logger .load_time a {
+    color: #fff;
+    background-color: #c62;
+    background-image: -webkit-gradient(
+      linear,
+      left top,
+      left bottom,
+      color-stop(0.0, #e72),
+      color-stop(0.5, #a62),
+      color-stop(0.51, #a51)
+    );
+  }
+  #logger .queries a {
+    color: #fff;
+    background-color: #248;
+    background-image: -webkit-gradient(
+      linear,
+      left top,
+      left bottom,
+      color-stop(0.0, #47b),
+      color-stop(0.5, #349),
+      color-stop(0.51, #248)
+    );
+  }
+  #logger .messages a {
+    color: #fff;
+    background-color: #482;
+    background-image: -webkit-gradient(
+      linear,
+      left top,
+      left bottom,
+      color-stop(0.0, #7b4),
+      color-stop(0.5, #493),
+      color-stop(0.51, #482)
+    );
+  }
+  {}
+</style>
+
+<div id="logger">
+  <ul>
+    <li class="load_time"><a href="#">{{load_time}}<span>seconds</span></a></li>
+    <li class="queries"><a href="#">{{query_count}}<span>queries</span></a></li>
+    <li class="messages"><a href="#">{{message_count}}<span>messages</span></a></li>
+  </ul>
+
+  <div style="display: none">
+    {{queries}}
+    {{messages}}
+</div>
+
+</div>
+<script type="text/javascript" charset="utf-8">
+  var _body = document.body;
+  var _html = $("html").get(0);
+  $(window).keyup(function(event) {
+    if ( event.which == 76 && (event.target == _body || event.target == _html) ) {
+      $("#logger").slideToggle();
+    }
+  });
+  $("#logger li a").click(function() {
+    var info = $("#logger div." + $(this).parent().attr("class"));
+    if ( info.get(0) ) {
+      if ( (siblings = info.siblings("div:visible")).get(0) ) {
+        siblings.hide();          
+        info.toggle();
+      }
+      else {
+        if ( info.css("display") == "block" ) {
+          $("#logger > div").slideToggle(function() {
+            info.hide();
+          });
+        }
+        else {
+          info.show();
+          $("#logger > div").slideToggle();
+        }
+      }
+    }
+    else {
+      $("#logger > div:visible").slideToggle(function() {
+        $("#logger > div div").hide();
+      });
+    }
+    return false;
+  });
+</script>
+HTML
+    end
+  end
+end
+
+Logging::Logger.root.add_appenders(Harbor::Contrib::Debug::LogAppender.new)