harbor 0.16.1

data/lib/harbor/test/response.rb

@@ -0,0 +1,17 @@
+module Harbor
+  module Test
+    class Response < Harbor::Response
+
+      attr_accessor :request
+
+      ##
+      # We redefine Harbor::Response.initialize(request) with an empty arg
+      # variant for use with a container.
+      ##
+      def initialize
+        super(nil)
+      end
+
+    end
+  end
+end

data/lib/harbor/test/session.rb

@@ -0,0 +1,11 @@
+module Harbor
+  module Test
+    class Session < Harbor::Session
+
+      def initialize(session_data = {})
+        @data = session_data
+      end
+
+    end
+  end
+end

data/lib/harbor/test/test.rb

@@ -0,0 +1,22 @@
+module Harbor
+  module Test
+
+    require Pathname(__FILE__).dirname + "request"
+    require Pathname(__FILE__).dirname + "response"
+    require Pathname(__FILE__).dirname + "session"
+    require Pathname(__FILE__).dirname + "mailer"
+
+    def assert_redirect(response)
+      assert_equal 303, response.status, "Expected Response#status 303 but was #{response.status}"
+    end
+
+    def assert_success(response)
+      assert_equal 200, response.status, "Expected Response#status 200 but was #{response.status}"
+    end
+
+    def assert_unauthorized(response)
+      assert_equal 401, response.status, "Expected Response#status 401 but was #{response.status}"
+    end
+
+  end
+end

data/lib/harbor/version.rb

@@ -0,0 +1,3 @@
+module Harbor
+  VERSION = "0.16.1"
+end

data/lib/harbor/view.rb

@@ -0,0 +1,89 @@
+require "rubygems"
+
+gem "erubis"
+require "erubis"
+
+require Pathname(__FILE__).dirname + "view_context"
+require Pathname(__FILE__).dirname + "layouts"
+require Pathname(__FILE__).dirname + "plugin_list"
+
+module Harbor
+  class View
+
+    class LayoutNotFoundError < StandardError
+      def initialize(name)
+        super("Layout #{name.inspect} not found")
+      end
+    end
+
+    def self.path
+      @path ||= []
+    end
+
+    def self.layouts
+      @layouts ||= Harbor::Layouts.new
+    end
+
+    def self.plugins(key)
+      @plugins ||= Hash.new { |h, k| h[k] = PluginList.new }
+
+      @plugins[key.to_s.gsub(/^\/+/, '')]
+    end
+
+    @cache_templates = false
+    def self.cache_templates?
+      @cache_templates
+    end
+
+    def self.cache_templates!
+      @cache_templates = true
+    end
+
+    def self.exists?(filename)
+      self.path.detect { |dir| ::File.file?(dir + filename) }
+    end
+
+    attr_accessor :content_type, :context, :extension, :path
+
+    def initialize(view, context = {})
+      @content_type = "text/html"
+      @extension = ".html.erb"
+      @context = context.is_a?(ViewContext) ? context : ViewContext.new(self, context)
+      @filename = ::File.extname(view) == "" ? (view + @extension) : view
+    end
+
+    def supports_layouts?
+      true
+    end
+    
+    def content
+      @content ||= _erubis_render(@context)
+    end
+
+    def to_s(layout = nil)
+      layout = self.class.layouts.match(@filename) if layout == :search
+
+      layout ? View.new(layout, @context.merge(:content => content)).to_s : content
+    end
+
+    private
+
+    def _erubis_render(context)
+      @path ||= self.class.exists?(@filename)
+      raise "Could not find '#{@filename}' in #{self.class.path.inspect}" unless @path
+
+      full_path = @path + @filename
+
+      if self.class.cache_templates?
+        (self.class.__templates[full_path] ||= Erubis::FastEruby.new(::File.read(full_path), :filename => full_path)).evaluate(context)
+      else
+        Erubis::FastEruby.new(::File.read(full_path), :filename => full_path).evaluate(context)
+      end
+    end
+
+    def self.__templates
+      @__templates ||= {}
+    end
+  end
+
+end

data/lib/harbor/view_context.rb

@@ -0,0 +1,134 @@
+module Harbor
+  class ViewContext
+    require Pathname(__FILE__).dirname + "view_context/helpers"
+
+    include Helpers::Form
+    include Helpers::Text
+    include Helpers::Html
+    include Helpers::Url
+    include Helpers::Cache
+
+    attr_accessor :view, :keys
+
+    def initialize(view, variables)
+      @view = view
+      @keys = Set.new
+
+      merge(variables)
+    end
+
+    def render(partial, variables = nil)
+      context = to_hash
+
+      result = View.new(partial, merge(variables)).to_s
+
+      replace(context)
+
+      result
+    end
+
+    def plugin(name, variables = {})
+      if (plugin_list = Harbor::View::plugins(name)).any?
+        plugin_list.map do |plugin|
+          Plugin::prepare(plugin, self, variables)
+        end
+      else
+        []
+      end
+    end
+
+    def locale
+      @locale ||= Harbor::Locale.default
+    end
+
+    def capture(*args, &block)
+      # get the buffer from the block's binding
+      buffer = _erb_buffer( block.binding ) rescue nil
+
+      # If there is no buffer, just call the block and get the contents
+      if buffer.nil?
+        block.call(*args)
+      # If there is a buffer, execute the block, then extract its contents
+      else
+        pos = buffer.length
+
+        block.call(*args)
+
+        # extract the block
+        data = buffer[pos..-1]
+
+        # replace it in the original with empty string
+        buffer[pos..-1] = ''
+
+        data
+      end
+    end
+
+    def [](key)
+      instance_variable_get("@#{key}")
+    end
+
+    def []=(key, value)
+      @keys << key
+      instance_variable_set("@#{key}", value)
+    end
+
+    def merge(variables)
+      variables.each do |key, value|
+        self[key] = value
+      end if variables
+
+      self
+    end
+
+    def each
+      keys.each { |key| yield(key, self[key]) }
+    end
+
+    def clear
+      keys.each { |key| remove_instance_variable("@#{key}") }
+      keys.clear
+
+      self
+    end
+
+    def replace(variables)
+      clear
+      merge(variables)
+    end
+
+    def to_hash
+      hash = {}
+      keys.each { |key| hash[key] = self[key] }
+      hash
+    end
+
+    private
+
+    def request
+      @request
+    end
+    
+    def response
+      @response
+    end
+
+    def _erb_buffer( the_binding ) # :nodoc:
+      eval( "_buf", the_binding, __FILE__, __LINE__)
+    end
+
+    ##
+    # Useful when you need to output content to the buffer.
+    # 
+    #   def wrap_with_p_tag(&block)
+    #     with_buffer(block) do |buffer|
+    #       buffer << "<p>" << capture(&block) << "</p>"
+    #     end
+    #   end
+    ##
+    def with_buffer(block)
+      yield(_erb_buffer(block.binding))
+    end
+
+  end
+end

data/lib/harbor/view_context/helpers.rb

@@ -0,0 +1,7 @@
+module Harbor::ViewContext::Helpers
+  autoload :Form, (Pathname(__FILE__).dirname + "helpers/form").to_s
+  autoload :Text, (Pathname(__FILE__).dirname + "helpers/text").to_s
+  autoload :Html, (Pathname(__FILE__).dirname + "helpers/html").to_s
+  autoload :Url, (Pathname(__FILE__).dirname + "helpers/url").to_s
+  autoload :Cache, (Pathname(__FILE__).dirname + "helpers/cache").to_s
+end

data/lib/harbor/view_context/helpers/cache.rb

@@ -0,0 +1,77 @@
+##
+# Set Harbor::View.cache equal to a supported Cache Store for use
+# in the ViewContext#cache helper.
+##
+class Harbor::View
+
+  class << self
+
+    def cache=(value)
+      if value && !value.is_a?(Harbor::Cache)
+        raise ArgumentError.new("Harbor::View.cache must be nil or an instance of Harbor::Cache")
+      end
+
+      @__cache__ = value
+    end
+
+    def cache
+      @__cache__
+    end
+
+  end
+
+end
+
+##
+# Cache helper that provides fragment-caching
+##
+module Harbor::ViewContext::Helpers::Cache
+
+  class CacheRenderError < StandardError
+    def initialize(inner_error, content_item)
+      @inner_error = inner_error
+      @content_item = content_item
+    end
+    
+    def to_s
+      "#{@content_item.class.name}:#{@content_item.inspect}\n\t#{@inner_error.message}"
+    end
+    
+    def inspect
+      "<#CacheRenderError content_item=#{@content_item.class.name}:#{@content_item.inspect} inner_error=#{@inner_error.inspect} backtrace=#{@inner_error.backtrace.join("\n\t")}>"
+    end
+  end
+  
+  ##
+  #   Caches the result of a block using the given TTL and maximum_age values.
+  #   If no ttl is given, a default of 30 minutes is used.  If no maximum_age value is given
+  #   the item will expire after Time.now + ttl.  If a maximum_age is specified, "get" requests
+  #   to the cache for a given key will push the expiration time up for the item by the TTL, until
+  #   Time.now + TTL is equal to or greater than the cache-insertion-time + maximum_age.
+  ##
+  def cache(key, ttl = 30 * 60, max_age = nil, &generator)
+    store = @cache_store || Harbor::View.cache
+
+    if store.nil?
+      raise ArgumentError.new("Cache Store Not Defined.  Please set Harbor::View.cache to your desired cache store.")
+    end
+
+    content = if item = store.get(key)
+      begin
+        item.content
+      rescue => e
+        raise CacheRenderError.new(e, item)
+      end
+    else
+      data = capture(&generator)
+      store.put(key, data, ttl, max_age)
+
+      data
+    end
+
+    with_buffer(generator) do |buffer|
+      buffer << content
+    end
+  end
+
+end

data/lib/harbor/view_context/helpers/form.rb

@@ -0,0 +1,34 @@
+module Harbor::ViewContext::Helpers::Form
+
+  ##
+  # Form helper which abstracts away setting necessary information:
+  #   1. If no enctype is passed, and a file input is found, uses
+  #      multipart/form-data.
+  #   2. Creates a hidden input for setting _method when method option
+  #      is put or delete.
+  ##
+  def form(action, options = {}, &block)
+    method = options.delete(:method) || :post
+
+    get = method == :get
+    post = method == :post
+
+    body = capture(&block)
+
+    enctype = options.delete(:enctype) || (body =~ /\<input[^>]+?type\=["']file["']/ ? "multipart/form-data" : nil)
+
+    with_buffer(block) do |buffer|
+      buffer << "<form action=\"#{action}\" method=\"#{get ? "get" : "post"}\""
+      buffer << " enctype=\"#{enctype}\"" if enctype
+      buffer << " #{options.map { |k, v| "#{k}=\"#{v}\"" }.join(" ")}" unless options.empty?
+      buffer << ">\n"
+
+      unless get || post
+        buffer << "  <input type=\"hidden\" name=\"_method\" value=\"#{method}\">\n"
+      end
+
+      buffer << body
+      buffer << "</form>\n"
+    end
+  end
+end

data/lib/harbor/view_context/helpers/html.rb

@@ -0,0 +1,26 @@
+module Harbor::ViewContext::Helpers::Html
+
+  ##
+  # Takes a flat array and yields the data properly separated into columns.
+  ##
+  def split_into_columns(data, columns) #:yields: column
+    return if data.empty?
+
+    per_column = (data.size / columns.to_f).ceil
+
+    columns.times do |i|
+      yield data[i*per_column, per_column]
+    end
+  end
+
+  def split_into_groups(data, groups) #:yields: group
+    return if data.empty?
+
+    rows = (data.size / groups.to_f).ceil
+
+    rows.times do |i|
+      yield data[i*groups, groups]
+    end
+  end
+
+end

data/lib/harbor/view_context/helpers/text.rb

@@ -0,0 +1,120 @@
+##
+# Text helper which provides common routines such as HTML escaping,
+# or truncating (previewing) long pieces of text (such as photo captions).
+##
+module Harbor::ViewContext::Helpers::Text
+
+  # Querystring escape +value+
+  def q(value)
+    # TODO: Remove external dependency!
+    Rack::Utils::escape(value)
+  end
+
+  # HTML escape +value+
+  def h(value, default = nil)
+    # TODO: Remove external dependency!
+    Rack::Utils::escape_html(value.blank? ? default : value)
+  end
+
+  ##
+  # Truncates an object to the specified character count, appending the specified
+  # trailing text. The character count includes the length of the trailer. HTML entities
+  # are counted as 1 character in trailing.
+  # 
+  #   truncate("Lorem ipsum dolor sit amet, consectetur") # => "Lorem ipsum dolor sit amet, c…"
+  #   truncate("Lorem ipsum dolor sit amet, consectetur", 20) # => "Lorem ipsum dolor s…"
+  #   truncate("Lorem ipsum dolor sit amet, consectetur", 20, "...") # => "Lorem ipsum dolor..."
+  # 
+  ##
+  def truncate(value, character_count = 30, trailing = "…")
+    unless character_count.is_a?(Integer)
+      raise ArgumentError.new(
+        "Harbor::ViewContext::Helpers::Text#truncate[character_count] must be an Integer, was #{character_count.inspect}"
+      )
+    end
+
+    unless character_count > 0
+      raise ArgumentError.new(
+        "Harbor::ViewContext::Helpers::Text#truncate[character_count] must be greater than zero, was #{character_count.inspect}."
+      )
+    end
+
+    unless trailing.is_a?(String)
+      raise ArgumentError.new(
+        "Harbor::ViewContext::Helpers::Text#truncate[trailing] must be a String, was #{trailing.inspect}"
+      )
+    end
+
+    if value.nil?
+      ""
+    else
+      string_form = value.to_s
+
+      if string_form.nil? || string_form.empty?
+        ""
+      elsif string_form.size <= character_count
+        string_form
+      else
+        # The Regexp match here is to determine if the +trailing+ value is an HTML entity code,
+        # in which case we assume it's length is 1, or a textual value, in which case we use the
+        # actual size.
+        string_form[0, character_count - (trailing =~ /\&\w+\;/ ? 1 : trailing.size)] + trailing
+      end
+    end
+  end
+
+  ##
+  # Truncates an object on the nearest word to the specified character count, appending the specified
+  # trailing text. 
+  # 
+  #   truncate_on_words("Lorem ipsum dolor sit amet, consectetur") # => "Lorem ipsum dolor sit amet&hellip;"
+  #   truncate_on_words("Lorem ipsum dolor sit amet, consectetur", 20) # => "Lorem ipsum dolor&hellip;"
+  #   truncate_on_words("Lorem ipsum dolor sit amet, consectetur", 20, "...") # => "Lorem ipsum dolor..."
+  # 
+  # The truncation will always look backwards unless the forward word boundary is within 5% of the specified
+  # character count. Thus:
+  # 
+  #   truncate_on_words("Lorem ipsum dolor sit amet, consectetur est.", 38) # => "Lorem ipsum dolor sit amet, consectetur..."
+  # 
+  ##
+  def truncate_on_words(value, character_count = 30, trailing = "&hellip;")
+    unless character_count.is_a?(Integer)
+      raise ArgumentError.new(
+        "Harbor::ViewContext::Helpers::Text#truncate_on_words[character_count] must be an Integer, was #{character_count.inspect}"
+      )
+    end
+
+    unless character_count > 0
+      raise ArgumentError.new(
+        "Harbor::ViewContext::Helpers::Text#truncate_on_words[character_count] must be greater than zero, was #{character_count.inspect}."
+      )
+    end
+
+    unless trailing.is_a?(String)
+      raise ArgumentError.new(
+        "Harbor::ViewContext::Helpers::Text#truncate_on_words[trailing] must be a String, was #{trailing.inspect}"
+      )
+    end
+
+    return "" if value.nil?
+
+    truncated_text = value.to_s.dup
+    text_length = truncated_text.length
+
+    return value if character_count >= text_length
+
+    leftover = truncated_text.slice!(character_count, text_length)
+
+    if (index = leftover.index(/\W|$/)) && index < (character_count * 0.05).ceil
+      truncated_text << leftover.slice(0, index)
+    else
+      truncated_text = truncated_text[0, truncated_text.rindex(/\W/)]
+    end
+
+    # Remove any trailing punctuation.
+    truncated_text.slice!(truncated_text.length - 1) if truncated_text[truncated_text.length - 1, 1] =~ /\W/
+
+    truncated_text + trailing
+  end
+
+end