harbor 0.16.1

data/lib/harbor/router.rb

@@ -0,0 +1,112 @@
+module Harbor
+  class Router
+
+    URI_CHAR = '[^/?:,&#\.\[\]]'.freeze unless defined?(URI_CHAR)
+    PARAM = /(:(#{URI_CHAR}+))/.freeze unless defined?(PARAM)
+
+    attr_accessor :routes
+
+    def initialize(&routes)
+      @routes = []
+      @route_match_cache = {}
+      instance_eval(&routes) if block_given?
+    end
+
+    def merge!(other)
+      self.routes |= other.routes
+    end
+
+    # Matches a GET request
+    def get(matcher, &handler)
+      register(:get, matcher, &handler)
+    end
+
+    # Matches a POST (create) request
+    def post(matcher, &handler)
+      register(:post, matcher, &handler)
+    end
+
+    # Matches a PUT (update) request
+    def put(matcher, &handler)
+      register(:put, matcher, &handler)
+    end
+
+    # Matches a DELETE request
+    def delete(matcher, &handler)
+      register(:delete, matcher, &handler)
+    end
+
+    def using(container, klass, initializer = nil, &block)
+      self.class::Using.new(self, container, klass, initializer).instance_eval(&block)
+    end
+
+    class Using
+      def initialize(router, container, klass, initializer)
+        @router = router
+        @container = container
+
+        if klass.is_a?(String)
+          @service_name = klass
+        else
+          @service_name = klass.to_s
+          @container.register(@service_name, klass, &initializer)
+        end
+      end
+
+      %w(get post put delete).each do |verb|
+        class_eval <<-EOS
+        def #{verb}(matcher, &handler)
+          @router.send(#{verb.inspect}, matcher) do |request, response|
+            service = @container.get(@service_name, :request => request, :response => response)
+
+            handler.arity == 2 ? handler[service, request] : handler[service]
+          end
+        end
+        EOS
+      end
+    end
+
+    def register(request_method, matcher, &handler)
+      matcher, param_keys = transform(matcher)
+      route = [request_method.to_s.upcase, matcher, param_keys, handler]
+      @routes << route
+      route
+    end
+
+    def clear
+      @routes = []
+    end
+
+    def match(request)
+      @routes.each do |request_method, matcher, param_keys, handler|
+        next unless request.request_method == request_method
+
+        # Strip trailing forward-slash on request path before matching
+        request_path = (request.path_info[-1] == ?/) ? request.path_info[0..-2] : request.path_info
+
+        next unless request_path =~ matcher
+
+        request.params.update(Hash[*param_keys.zip($~.captures).flatten])
+        return handler
+      end
+
+      # No routes matched, so return false
+      false
+    end
+
+    private
+
+    def transform(matcher)
+      param_keys = []
+
+      if matcher.is_a?(String)
+        # Strip trailing forward-slash on routes
+        matcher = matcher[0..-2] if (matcher[-1] == ?/)
+        matcher = /^#{matcher.gsub('.', '[\.]').gsub(PARAM) { param_keys << $2; "(#{URI_CHAR}+)" }}$/
+      end
+
+      [matcher, param_keys]
+    end
+
+  end
+end

data/lib/harbor/script.rb

@@ -0,0 +1,155 @@
+require "harbor/logging"
+
+gem "thin"
+require 'thin/version'
+require 'thin/daemonizing'
+
+module Logging #:nodoc:
+  def log(message)
+    Harbor::Script.logger << message + "\n"
+  end
+  module_function :log
+end
+
+module Harbor
+  ##
+  # Class for defining and running daemonizable scripts.
+  # 
+  #   services = Harbor::Container.new
+  #   services.register("mailer", Harbor::Mailer)
+  #   
+  #   class Processor < Harbor::Script
+  #   
+  #     attr_accessor :mailer
+  #   
+  #     def self.pid_file
+  #       "tmp/processor.pid"
+  #     end
+  #   
+  #     def self.log_file
+  #       "log/processor.log"
+  #     end
+  #   
+  #     def self.run!
+  #       loop do
+  #         # processing code
+  #       end
+  #     end
+  #   end
+  #   
+  #   Harbor::Script::Runner.new(ARGV, services, Processor).run!
+  ##
+  class Script
+    include Thin::Daemonizable
+
+    attr_accessor :options, :services
+
+    def self.logger
+      @logger ||= begin
+        logger = Logging::Logger[self]
+        logger.additive = false
+        logger.level = :info
+        logger.add_appenders(Logging::Appenders::Stdout.new)
+        logger
+      end
+    end
+
+    def logger
+      self.class.logger
+    end
+
+    def self.pid_file
+      raise NotImplementedError.new("#{self}#pid_file must be defined.")
+    end
+
+    def self.log_file
+      raise NotImplementedError.new("#{self}#log_file must be defined.")
+    end
+
+    def initialize
+      @on_restart = lambda do
+        exec("#{$0} #{'--daemonize' if @options[:daemonize]} start")
+      end
+
+      @pid_file = self.class.pid_file
+      @log_file = self.class.log_file
+    end
+
+    def log(message)
+      if @options[:daemonize]
+        self.class.logger << message + "\n"
+      else
+        puts message
+      end
+    end
+
+    def name
+      $0
+    end
+
+    def stop
+      log ">> Stopping"
+    end
+
+    def run!
+      raise NotImplementedError.new("#{self}.run! must be defined.")
+    end
+
+    class Runner
+
+      COMMANDS = %w(start stop restart)
+
+      def initialize(argv, services, script)
+        raise ArgumentError.new("services must be a Harbor::Container but was #{services.inspect}") unless services.is_a?(Harbor::Container)
+
+        @argv = argv
+        @script = script
+        @script_name = @script.to_s
+        @services = services
+
+        @services.register(@script_name, @script) unless services.registered?(@script_name)
+
+        parse!
+      end
+
+      def parse!
+        @options = {
+          :daemonize => false
+        }
+
+        parser = OptionParser.new do |opts|
+          opts.on("-d", "--daemonize", "Daemonize process") { @options[:daemonize] = true }
+        end
+
+        parser.parse!(@argv)
+        @command = @argv.shift
+      end
+
+      def run!
+        unless COMMANDS.include?(@command)
+          puts "#{@command.inspect} is not a valid command. Commands are: #{COMMANDS.join(", ")}"
+          exit 1
+        end
+
+        send(@command)
+      end
+
+      def start
+        script = @services.get(@script_name, :options => @options, :services => @services)
+
+        script.daemonize if @options[:daemonize]
+
+        @argv.empty? ? script.run! : script.run!(*@argv)
+      end
+
+      def restart
+        Harbor::Script.restart(@script.pid_file)
+      end
+
+      def stop
+        Harbor::Script.kill(@script.pid_file)
+      end
+    end
+
+  end
+end

data/lib/harbor/session.rb

@@ -0,0 +1,75 @@
+require Pathname(__FILE__).dirname + 'session/abstract'
+require Pathname(__FILE__).dirname + 'session/cookie'
+
+module Harbor
+
+  class Session
+    DEFAULT_OPTIONS = {
+      :key => "harbor.session",
+      :domain => nil,
+      :path => "/",
+      :expire_after => nil,
+      :store => Cookie
+    }
+
+    ##
+    # Configures non-default session settings.
+    # 
+    #   Harbor::Session.configure do |session|
+    #     session[:domain] = "*.domain.com"
+    #     session[:store] = Custom::Session::Store
+    #   end
+    ##
+    def self.configure #:yields: default_options
+      @options = DEFAULT_OPTIONS.dup
+      yield(@options)
+      @options
+    end
+
+    def self.options
+      @options ||= DEFAULT_OPTIONS.dup
+      @options
+    end
+
+    def initialize(request)
+      @options = self.class.options.dup
+      @cookie = request.cookies[@options[:key]]
+      @store = self.class.options[:store]
+
+      @data ||= @store.load_session(@cookie)
+    end
+
+    def key
+      @options[:key]
+    end
+
+    def []=(key, value)
+      @data[key] = value
+    end
+
+    def [](key)
+      @data[key]
+    end
+
+    def data
+      @data
+    end
+
+    def id
+      @data[:session_id]
+    end
+
+    def save
+      cookie = {}
+      cookie[:domain] = @options[:domain]
+      cookie[:path] = @options[:path]
+      cookie[:expires] = Time.now + @options[:expire_after] unless @options[:expire_after].nil?
+      cookie[:value] = @store.commit_session(@data)
+      cookie
+    end
+
+    def destroy
+      @data.clear
+    end
+  end
+end

data/lib/harbor/session/abstract.rb

@@ -0,0 +1,27 @@
+module Harbor
+  class Session
+
+    ##
+    # Defines the API and default behavior for session stores. See Cookie, and
+    # contrib/session/data_mapper for examples of usage.
+    ##
+    class Abstract
+      ##
+      # Receives the raw cookie data, and should return a hash
+      # of the data for the session.
+      ##
+      def self.load_session(cookie)
+        Marshal.load(cookie.unpack("m*")[0]) rescue {}
+      end
+
+      ##
+      # Receives the session data hash, and should return the data
+      # to be set for the cookie's value
+      ##
+      def self.commit_session(data)
+        [Marshal.dump(data)].pack("m*")
+      end
+    end
+
+  end
+end

data/lib/harbor/session/cookie.rb

@@ -0,0 +1,17 @@
+module Harbor
+  class Session
+
+    ##
+    # Basic enhancement to Abstract session to automatically generate
+    # session_id's.
+    ##
+    class Cookie < Abstract
+      def self.load_session(cookie)
+        cookie = super
+        cookie[:session_id] ||= `uuidgen`.chomp
+        cookie
+      end
+    end
+
+  end
+end

data/lib/harbor/shellwords.rb

@@ -0,0 +1,26 @@
+require 'shellwords'
+
+##
+# This is a backport of ruby-1.8.7's Shellwords.escape function to 1.8.6
+# for safely escaping filenames to be passed directly to the shell.
+##
+module Shellwords #:nodoc:
+  def escape(str)
+    # An empty argument will be skipped, so return empty quotes.
+    return "''" if str.empty?
+
+    str = str.dup
+
+    # Process as a single byte sequence because not all shell
+    # implementations are multibyte aware.
+    str.gsub!(/([^A-Za-z0-9_\-.,:\/@\n])/n, "\\\\\\1")
+
+    # A LF cannot be escaped with a backslash because a backslash + LF
+    # combo is regarded as line continuation and simply ignored.
+    str.gsub!(/\n/, "'\n'")
+
+    return str
+  end
+
+  module_function :escape
+end

data/lib/harbor/test/mailer.rb

@@ -0,0 +1,10 @@
+module Harbor
+  module Test
+    class Mailer < Harbor::Mailer
+
+      def send!
+      end
+
+    end
+  end
+end

data/lib/harbor/test/request.rb

@@ -0,0 +1,28 @@
+module Harbor
+  module Test
+    class Request < Harbor::Request
+
+      attr_accessor :session, :env, :params
+
+      def params
+        @params ||= {}
+      end
+
+      ##
+      # Rack::Response defines self.new(env, *args), which means we can't initialize
+      # a new request via a container without replacing this method.
+      ##
+      def self.new(*args)
+        super(nil, {})
+      end
+
+      def session
+        @session || Session.new
+      end
+
+      def session=(session)
+        @session = Session.new(session)
+      end
+    end
+  end
+end