hx 0.6.1 → 0.7.0

data/VERSION

@@ -1 +1 @@
-0.6.1
+0.7.0

data/lib/hx.rb

@@ -22,6 +22,7 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 require 'rubygems'
+require 'thread'
 require 'set'
 require 'pathname'
 require 'yaml'
@@ -36,49 +37,72 @@ end
 class EditingNotSupportedError < RuntimeError
 end
 
-module Source
+module Filter
   def edit_entry(path, prototype=nil)
     raise EditingNotSupportedError, "Editing not supported for #{path}"
   end
 
+  def each_entry_path
+    each_entry { |path, entry| yield path }
+  end
+
   def each_entry
-    raise NotImplementedError, "#{self.class}#each_entry not implemented"
+    each_entry_path do |path|
+      begin
+        entry = get_entry(path)
+      rescue NoSuchEntryError
+        next # entries may come and go during the enumeration
+      end
+      yield path, entry
+    end
+  end
+
+  def get_entry(path)
+    each_entry do |entry_path, entry|
+      return entry if entry_path == path
+    end
+    raise NoSuchEntryError, path
   end
 end
 
-class NullSource
-  include Source
+class NullInput
+  include Filter
 
   def each_entry
     self
   end
 end
 
-NULL_SOURCE = NullSource.new
+NULL_INPUT = NullInput.new
 
 class PathSubset
-  include Source
+  include Filter
 
-  def initialize(source, options)
-    @source = source
+  def initialize(input, options)
+    @input = input
     @path_filter = Predicate.new(options[:only], options[:except])
   end 
 
   def edit_entry(path, prototype=nil)
     if @path_filter.accept? path
-      @source.edit_entry(path, prototype) { |text| yield text }
+      @input.edit_entry(path, prototype) { |text| yield text }
     else
       raise EditingNotSupportedError, "Editing not supported for #{path}"
     end
     self
   end
 
-  def each_entry
-    @source.each_entry do |path, entry|
-      yield path, entry if @path_filter.accept? path
+  def each_entry_path
+    @input.each_entry_path do |path|
+      yield path if @path_filter.accept? path
     end
     self
   end
+
+  def get_entry(path)
+    raise NoSuchEntryError, path unless @path_filter.accept? path
+    @input.get_entry(path)
+  end
 end
 
 class PathSubset::Predicate
@@ -115,29 +139,39 @@ class PathSubset::Predicate
 end
 
 class Overlay
-  include Source
+  include Filter
 
-  def initialize(*sources)
-    @sources = sources
+  def initialize(*inputs)
+    @inputs = inputs
   end
 
-  def each_entry
+  def each_entry_path
     seen = Set[]
-    @sources.each do |source|
-      source.each_entry do |path, entry|
-        yield path, entry unless seen.include? path
+    @inputs.each do |input|
+      input.each_entry_path do |path|
+        yield path unless seen.include? path
         seen.add path
       end
     end
     self
   end
+
+  def get_entry(path)
+    @inputs.each do |input|
+      begin
+        return input.get_entry(path)
+      rescue NoSuchEntryError
+      end
+    end
+    raise NoSuchEntryError, path
+  end
 end
 
 module CircumfixPath
-  include Source
+  include Filter
 
-  def initialize(source, options)
-    @source = source
+  def initialize(input, options)
+    @input = input
     @prefix = options[:prefix]
     @suffix = options[:suffix]
     prefix = Regexp.quote(@prefix.to_s)
@@ -161,16 +195,20 @@ class AddPath
   def edit_entry(path, prototype=nil)
     path = strip_circumfix(path)
     raise EditingNotSupportedError, "Editing not supported for #{path}" unless path
-    @source.edit_entry(path, prototype) { |text| yield text }
+    @input.edit_entry(path, prototype) { |text| yield text }
     self
   end
 
-  def each_entry
-    @source.each_entry do |path, entry|
-      yield add_circumfix(path), entry
-    end
+  def each_entry_path
+    @input.each_entry_path { |path| yield add_circumfix(path) }
     self
   end
+
+  def get_entry(path)
+    path = strip_circumfix(path)
+    raise NoSuchEntryError, path unless path
+    @input.get_entry(path)
+  end
 end
 
 class StripPath
@@ -178,64 +216,89 @@ class StripPath
 
   def edit_entry(path, prototype=nil)
     path = add_circumfix(path)
-    @source.edit_entry(path, prototype) { |text| yield text }
+    @input.edit_entry(path, prototype) { |text| yield text }
     self
   end
 
-  def each_entry
-    @source.each_entry do |path, entry|
+  def each_entry_path
+    @input.each_entry_path do |path|
       path = strip_circumfix(path)
-      yield path, entry if path
+      yield path if path
     end
     self
   end
+
+  def get_entry(path)
+    @input.get_entry(add_circumfix(path))
+  end
 end
 
 class Cache
-  include Source
+  include Filter
 
-  def initialize(source, options={})
-    @source = source
+  def initialize(input, options={})
+    @input = input
+    @lock = Mutex.new
     @entries = nil
+    @entries_by_path = {}
   end
 
   def edit_entry(path, prototype=nil)
-    @source.edit_entry(path, prototype) { |text| yield text }
+    @input.edit_entry(path, prototype) { |text| yield text }
     self
   end
 
   def each_entry
-    unless @entries
-      entries = []
-      @source.each_entry do |path, entry|
-        entries << [path, entry]
+    entries = nil
+    @lock.synchronize do
+      if @entries
+        entries = @entries
+      else
+        entries = []
+        @input.each_entry do |path, entry|
+          @entries_by_path[path] = entry
+          entries << [path, entry]
+        end
+        @entries = entries
       end
-      @entries = entries
     end
-    @entries.each do |path, entry|
+    entries.each do |path, entry|
       yield path, entry.dup
     end
     self
   end
+
+  def get_entry(path)
+    entry = nil
+    @lock.synchronize do
+      if @entries_by_path.has_key? path
+        entry = @entries_by_path[path]
+      else
+        entry = @input.get_entry(path)
+        @entries_by_path[path] = entry
+      end
+    end
+    return entry.dup
+  end
 end
 
 class Sort
-  include Source
+  include Filter
 
-  def initialize(source, options)
-    @source = source
+  def initialize(input, options)
+    @input = input
     @key_fields = Array(options[:sort_by] || []).map { |f| f.to_s }
     @reverse = !!options[:reverse]
   end
 
   def edit_entry(path, prototype=nil)
-    @source.edit_entry(path, prototype) { |text| yield text }
+    @input.edit_entry(path, prototype) { |text| yield text }
     self
   end
 
   def each_entry
     entries = []
-    @source.each_entry do |path, entry|
+    @input.each_entry do |path, entry|
       entries << [path, entry]
     end
     unless @key_fields.empty?
@@ -249,17 +312,21 @@ class Sort
     end
     self
   end
+
+  def get_entry(path)
+    @input.get_entry(path)
+  end
 end
 
 Chain = Object.new
-def Chain.new(source, options)
+def Chain.new(input, options)
   filters = options[:chain] || []
   options = options.dup
   options.delete(:chain) # prevent inheritance
   for raw_filter in filters
-    source = Hx.build_source(options, source, {}, raw_filter)
+    input = Hx.build_source(options, input, {}, raw_filter)
   end
-  source
+  input
 end
 
 def self.make_default_title(options, path)
@@ -286,8 +353,15 @@ def self.local_require(options, library)
   saved_require_path = $:.dup
   begin
     $:.delete(".")
-    $:.push Hx.get_pathname(options, :lib_dir).to_s
+    lib_dir = Hx.get_pathname(options, :lib_dir)
+    if lib_dir.relative?
+      $:.push "./#{lib_dir}"
+    else
+      $:.push lib_dir.to_s
+    end
     require library
+  rescue LoadError
+    raise
   ensure
     $:[0..-1] = saved_require_path
   end
@@ -301,32 +375,32 @@ def self.resolve_constant(qualified_name, root=Object)
   end
 end
 
-def self.expand_chain(raw_source)
-  case raw_source
+def self.expand_chain(raw_input)
+  case raw_input
   when Array # rewrite array to Hx::Chain
-    return NULL_SOURCE if raw_source.empty?
+    return NULL_INPUT if raw_input.empty?
 
-    filter_defs = raw_source.dup
+    filter_defs = raw_input.dup
     first_filter = filter_defs[0] = filter_defs[0].dup
 
-    raw_source = {
+    raw_input = {
       'filter' => 'Hx::Chain',
       'options' => {'chain' => filter_defs}
     }
 
-    if first_filter.has_key? 'source' # use input of first filter for chain
-      raw_source['source'] = first_filter['source']
-      first_filter.delete('source')
+    if first_filter.has_key? 'input' # use input of first filter for chain
+      raw_input['input'] = first_filter['input']
+      first_filter.delete('input')
     end
   end
-  raw_source
+  raw_input
 end
 
 def self.build_source(options, default_input, sources, raw_source)
   raw_source = expand_chain(raw_source)
 
-  if raw_source.has_key? 'source'
-    input_name = raw_source['source']
+  if raw_source.has_key? 'input'
+    input_name = raw_source['input']
     begin
       source = sources.fetch(input_name)
     rescue IndexError
@@ -383,7 +457,7 @@ def self.build_source(options, default_input, sources, raw_source)
 end
 
 class Site
-  include Source
+  include Filter
 
   attr_reader :options
   attr_reader :sources
@@ -392,6 +466,12 @@ class Site
   class << self
     private :new
 
+    def load_file(config_file)
+      File.open(config_file, 'r') do |stream|
+        load(stream, config_file)
+      end
+    end
+
     def load(io, config_path)
       raw_config = YAML.load(io)
       options = {}
@@ -409,16 +489,16 @@ class Site
       raw_sources_by_name = raw_config.fetch('sources', {})
       source_names = raw_sources_by_name.keys
 
-      # build source dependency graph
+      # build input dependency graph
       source_dependencies = {}
       for name, raw_source in raw_sources_by_name
         raw_source = Hx.expand_chain(raw_source)
-        if raw_source.has_key? 'source'
-          source_dependencies[name] = raw_source['source']
+        if raw_source.has_key? 'input'
+          source_dependencies[name] = raw_source['input']
         end
       end
 
-      # calculate depth for each source in the graph
+      # calculate depth for each input in the graph
       source_depths = Hash.new(0)
       for name in source_names
         seen = Set[] # for cycle detection
@@ -439,13 +519,13 @@ class Site
       sources = {}
       for name in depth_first_names
         raw_source = raw_sources_by_name[name]
-        sources[name] = Hx.build_source(options, NULL_SOURCE, sources,
+        sources[name] = Hx.build_source(options, NULL_INPUT, sources,
                                         raw_source)
       end
 
       outputs = []
       for raw_output in raw_config.fetch('outputs', [])
-        outputs << Hx.build_source(options, NULL_SOURCE, sources, raw_output)
+        outputs << Hx.build_source(options, NULL_INPUT, sources, raw_output)
       end
 
       new(options, sources, outputs)
@@ -464,52 +544,45 @@ class Site
     self
   end
 
-  def each_entry
-    @combined_output.each_entry do |path, entry|
-      yield path, entry
-    end
+  def each_entry_path
+    @combined_output.each_entry_path { |path| yield path }
     self
   end
-end
 
-class FileBuilder
-  def initialize(output_dir)
-    @output_dir = Pathname.new(output_dir)
-  end
-
-  def build_file(path, entry)
-    build_file_helper(path, entry, false)
+  def get_entry(path)
+    @combined_output.get_entry(path)
   end
+end
 
-  def build_file_if_updated(path, entry)
-    build_file_helper(path, entry, true)
+def self.refresh_file(pathname, content, update_time)
+  begin
+    return false if update_time and update_time < pathname.mtime
+  rescue Errno::ENOENT
   end
+  write_file(pathname, content)
+  true
+end
 
-  def build_file_helper(path, entry, update_only)
-    filename = @output_dir + path
-    return self if update_only and filename.exist? and \
-                   entry['updated'] and filename.mtime >= entry['updated']
-    dirname = filename.parent
-    dirname.mkpath()
-    filename.open("wb") do |stream|
-      stream.write entry['content'].to_s
-    end
-    self
-  end
-  private :build_file_helper
+def self.write_file(pathname, content)
+  pathname.parent.mkpath()
+  pathname.open("wb") { |stream| stream << content.to_s }
+  nil
 end
 
 class LazyContent
   def initialize(&block)
     raise ArgumentError, "No block given" unless block
+    @lock = Mutex.new
     @content = nil
     @block = block
   end
 
   def to_s
-    if @block
-      @content = @block.call
-      @block = nil
+    @lock.synchronize do
+      if @block
+        @content = @block.call
+        @block = nil
+      end
     end
     @content
   end

data/lib/hx/backend/couchdb.rb

@@ -33,7 +33,7 @@ module Hx
 module Backend
 
 class CouchDB
-  include Hx::Source
+  include Hx::Filter
 
   class HTTPError < RuntimeError
     attr_reader :path
@@ -51,7 +51,7 @@ class CouchDB
     end
   end
 
-  def initialize(source, options)
+  def initialize(input, options)
     couchdb_server = options.fetch(:couchdb_server, "http://localhost:5984/")
     couchdb_database = options.fetch(:couchdb_database, "entries")
     uri = URI.parse(couchdb_server)
@@ -81,25 +81,25 @@ class CouchDB
     self
   end
 
-  def each_entry
+  def each_entry_path
     listing = JSON.parse(get_document('_all_docs'))
-    for row in listing['rows']
-      path = row['id']
-      begin
-        entry = JSON.parse(get_document(path))
-      rescue HTTPError => e
-        raise e unless e.code == 404
-        # the document may have gone away since we requested the list
-        next
-      end
-      for field in %(created updated)
-        entry[field] = Time.parse(entry[field] || "")
-      end
-      yield path, entry
-    end
+    listing['rows'].each { |row| yield row['id'] }
     self
   end
 
+  def get_entry(path)
+    begin
+      entry = JSON.parse(get_document(path))
+    rescue HTTPError => e
+      raise e unless e.code == 404
+      raise Hx::NoSuchEntryError, path
+    end
+    for field in %(created updated)
+      entry[field] = Time.parse(entry[field] || "")
+    end
+    entry
+  end
+
 private
   def request_path_for(id)
     "#{@prefix}#{CGI.escape(id)}"

data/lib/hx/backend/hobix.rb

@@ -22,19 +22,19 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 require 'rubygems'
-require 'time'
-require 'pathname'
 require 'yaml'
 require 'hx'
+require 'hx/backend/rawfiles'
 
 module Hx
 module Backend
 
 class Hobix
-  include Hx::Source
+  include Hx::Filter
 
-  def initialize(source, options)
-    @entry_dir = Hx.get_pathname(options, :entry_dir)
+  def initialize(input, options)
+    files = Hx::Backend::RawFiles.new(input, options)
+    @source = Hx::StripPath.new(files, :suffix => ".yaml")
   end
 
   def yaml_repr(value)
@@ -43,49 +43,48 @@ class Hobix
   private :yaml_repr
 
   def edit_entry(path, prototype=nil)
-    entry_filename = @entry_dir + "#{path}.yaml"
-    begin
-      text = entry_filename.read
-      previous_mtime = entry_filename.mtime
-    rescue Errno::ENOENT
-      raise Hx::NoSuchEntryError, path unless prototype
+    if prototype
       prototype = prototype.dup
       prototype['content'] = (prototype['content'] || "").dup
       content = prototype['content']
       def content.to_yaml_style ; :literal ; end
       native = YAML::DomainType.new('hobix.com,2004', 'entry', prototype)
-      text = YAML.dump(native)
-      previous_mtime = nil
+      prototype = { 'content' => YAML.dump(native) }
+    end
+    @source.edit_entry(path, prototype) do |text|
+      begin
+        previous_mtime = @source.get_entry(path)['updated']
+      rescue Hx::NoSuchEntryError
+        previous_mtime = nil
+      end
+      text = yield text
+      repr = YAML.parse(text)
+      keys = {}
+      repr.value.each_key { |key| keys[key.value] = key }
+      %w(created updated).each { |name| keys[name] ||= yaml_repr(name) }
+      update_time = Time.now
+      update_time_repr = yaml_repr(update_time)
+      previous_mtime ||= update_time
+      previous_mtime_repr = yaml_repr(previous_mtime)
+      repr.add(keys['created'], previous_mtime_repr) unless repr['created']
+      repr.add(keys['updated'], update_time_repr)
+      repr.emit
     end
-    text = yield text
-    repr = YAML.parse(text)
-    keys = {}
-    repr.value.each_key { |key| keys[key.value] = key }
-    %w(created updated).each { |name| keys[name] ||= yaml_repr(name) }
-    update_time = Time.now
-    update_time_repr = yaml_repr(update_time)
-    previous_mtime ||= update_time
-    previous_mtime_repr = yaml_repr(previous_mtime)
-    repr.add(keys['created'], previous_mtime_repr) unless repr['created']
-    repr.add(keys['updated'], update_time_repr)
-    entry_filename.parent.mkpath()
-    entry_filename.open('w') { |stream| stream << repr.emit }
     self
   end
 
-  def each_entry
-    Pathname.glob(@entry_dir + '**/*.yaml') do |entry_filename|
-      path = entry_filename.relative_path_from(@entry_dir).to_s
-      path.sub!(/\.yaml$/, '')
-      entry = entry_filename.open('r') do |stream|
-        YAML.load(stream).value
-      end
-      entry['updated'] ||= entry_filename.mtime
-      entry['created'] ||= entry['updated']
-      yield path, entry
-    end
+  def each_entry_path
+    @source.each_entry_path { |path| yield path }
     self
   end
+
+  def get_entry(path)
+    raw_entry = @source.get_entry(path)
+    entry = YAML.load(raw_entry['content'].to_s).value
+    entry['updated'] ||= raw_entry['updated']
+    entry['created'] ||= raw_entry['created'] || raw_entry['updated']
+    entry
+  end
 end
 
 end

data/lib/hx/backend/rawfiles.rb

@@ -0,0 +1,78 @@
+# hx/backend/hobix - Hobix filesystem backend for Hx
+#
+# Copyright (c) 2009-2010 MenTaLguY <mental@rydia.net>
+# 
+# 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.
+
+require 'rubygems'
+require 'pathname'
+require 'hx'
+
+module Hx
+module Backend
+
+class RawFiles
+  include Hx::Filter
+
+  def initialize(input, options)
+    @entry_dir = Hx.get_pathname(options, :entry_dir)
+  end
+
+  def path_to_pathname(path) ; @entry_dir + path ; end
+  private :path_to_pathname
+
+  def pathname_to_path(pathname)
+    pathname.relative_path_from(@entry_dir).to_s
+  end
+  private :pathname_to_path
+
+  def edit_entry(path, prototype=nil)
+    pathname = path_to_pathname(path)
+    begin
+      body = pathname.read
+    rescue Errno::ENOENT
+      raise NoSuchEntryError, path unless prototype
+      text = prototype['content'].to_s
+    end
+    text = yield text
+    Hx.write_file(pathname, text)
+    self
+  end
+
+  def each_entry_path
+    Pathname.glob(@entry_dir + '**/*') do |pathname|
+      yield pathname_to_path(pathname) if pathname.file?
+    end
+    self
+  end
+
+  def get_entry(path)
+    pathname = path_to_pathname(path)
+    begin
+      { 'updated' => pathname.mtime,
+        'content' => Hx::LazyContent.new { pathname.read } }
+    rescue Errno::ENOENT
+      raise Hx::NoSuchEntryError, path
+    end
+  end
+end
+
+end
+end

data/lib/hx/commandline.rb

@@ -104,14 +104,16 @@ end
 
 def self.do_gen(site, update_only)
   output_dir = Hx.get_pathname(site.options, :output_dir)
-  builder = Hx::FileBuilder.new(output_dir.to_s)
   site.each_entry do |path, entry|
-    puts "===> #{path}"
+    pathname = output_dir + path
+    content = entry['content']
     if update_only
-      builder.build_file_if_updated(path, entry)
+      update_time = entry['updated']
     else
-      builder.build_file(path, entry)
+      update_time = nil
     end
+    written = Hx.refresh_file(pathname, content, update_time)
+    puts "===> #{path}" if written
   end
 end
 

data/lib/hx/listing/limit.rb

@@ -28,15 +28,15 @@ module Hx
 module Listing
 
 class Limit
-  include Hx::Source
+  include Hx::Filter
 
-  def initialize(source, options)
-    @source = source
+  def initialize(input, options)
+    @input = input
     @limit = options[:limit]
   end
 
   def each_entry
-    @source.each_entry do |path, entry|
+    @input.each_entry do |path, entry|
       if entry['items']
         trimmed_entry = entry.dup
         trimmed_entry['items'] = entry['items'][0...@limit]

data/lib/hx/listing/paginate.rb

@@ -28,15 +28,15 @@ module Hx
 module Listing
 
 class Paginate
-  include Hx::Source
+  include Hx::Filter
 
-  def initialize(source, options)
-    @source = source
+  def initialize(input, options)
+    @input = input
     @page_size = options[:page_size]
   end
 
   def each_entry
-    @source.each_entry do |index_path, index_entry|
+    @input.each_entry do |index_path, index_entry|
       items = index_entry['items'] || []
       if items.empty?
         index_entry = index_entry.dup

data/lib/hx/listing/recursiveindex.rb

@@ -30,10 +30,10 @@ module Hx
 module Listing
 
 class RecursiveIndex
-  include Hx::Source
+  include Hx::Filter
 
-  def self.new(source, options)
-    listing = super(source, options)
+  def self.new(input, options)
+    listing = super(input, options)
     if options.has_key? :limit
       listing = Limit.new(listing, :limit => options[:limit])
     end
@@ -43,13 +43,13 @@ class RecursiveIndex
     listing
   end
 
-  def initialize(source, options)
-    @source = source
+  def initialize(input, options)
+    @input = input
   end
 
   def each_entry
     indexes = Hash.new { |h,k| h[k] = {'items' => []} }
-    @source.each_entry do |path, entry|
+    @input.each_entry do |path, entry|
       components = path.split("/")
       until components.empty?
         components.pop

data/lib/hx/output/liquidtemplate.rb

@@ -32,7 +32,7 @@ module Hx
 module Output
 
 class LiquidTemplate
-  include Hx::Source
+  include Hx::Filter
 
   module TextFilters
     def textilize(input)
@@ -61,8 +61,8 @@ class LiquidTemplate
     end
   end
 
-  def initialize(source, options)
-    @source = source
+  def initialize(input, options)
+    @input = input
     @options = {}
     for key, value in options
       @options[key.to_s] = value
@@ -73,30 +73,42 @@ class LiquidTemplate
     Liquid::Template.file_system = Liquid::LocalFileSystem.new(template_dir)
     Liquid::Template.register_filter(TextFilters)
     template_file = template_dir + options[:template]
-    @template = template_file.open('r') { |s| Liquid::Template.parse(s.read) }
+    @template = Liquid::Template.parse(template_file.read)
     @extension = options[:extension]
+    @mime_type = options[:mime_type]
+    @strip_extension_re = nil
+    @strip_extension_re = /\.#{Regexp.quote(@extension)}$/ if @extension
   end
 
-  def each_entry
-    @source.each_entry do |path, entry|
+  def each_entry_path
+    @input.each_entry_path do |path|
       unless @extension.nil?
-        output_path = "#{path}.#{@extension}"
+        yield "#{path}.#{@extension}"
       else
-        output_path = path
+        yield path
       end
-      output_entry = entry.dup
-      output_entry['content'] = Hx::LazyContent.new do
-        @template.render(
-          'now' => Time.now,
-          'options' => @options,
-          'path' => path,
-          'entry' => entry
-        )
-      end
-      yield output_path, output_entry
     end
     self
   end
+
+  def get_entry(path)
+    path = path.sub(@strip_extension_re, '') if @strip_extension_re
+    entry = @input.get_entry(path)
+    output_entry = {}
+    output_entry['content'] = Hx::LazyContent.new do
+      @template.render(
+        'now' => Time.now,
+        'options' => @options,
+        'path' => path,
+        'entry' => entry
+      )
+    end
+    output_entry['mime_type'] = @mime_type if @mime_type
+    if entry.has_key? 'updated'
+      output_entry['created'] = output_entry['updated'] = entry['updated']
+    end
+    output_entry
+  end
 end
 
 end

data/lib/hx/rack.rb

@@ -0,0 +1,24 @@
+# hx/rack - Rack bits for Hx
+#
+# Copyright (c) 2009-2010 MenTaLguY <mental@rydia.net>
+# 
+# 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.
+
+require 'hx/rack/application'

data/lib/hx/rack/application.rb

@@ -0,0 +1,97 @@
+# hx/rack/application - Rack application to serve an Hx site dynamically
+#
+# Copyright (c) 2009-2010 MenTaLguY <mental@rydia.net>
+# 
+# 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.
+
+require 'rubygems'
+require 'cgi'
+require 'hx'
+require 'rack/mime'
+
+module Hx
+module Rack
+
+class Application
+  def self.load_file(config_path)
+    site = Hx::Site.load_file(config_path)
+    new(site, site.options)
+  end
+
+  def initialize(input, options)
+    @input = input
+    @index_names = Array(options[:index_names] || ['index.html'])
+  end
+
+  def call(env)
+    path = CGI.unescape(env['PATH_INFO'])
+    path = '/' if path.empty?
+    entry = nil
+
+    has_trailing_slash = (path[-1..-1] == '/')
+
+    # for non-slash-terminated paths, try the path directly
+    unless has_trailing_slash
+      begin
+        effective_path = path[1..-1]
+        entry = @input.get_entry(effective_path)
+      rescue NoSuchEntryError
+      end
+    end
+
+    # no entry? maybe it's a directory; look for an index entry
+    unless entry
+      path =~ %r(^/(.*?)/?$)
+      prefix = $1
+      prefix = "#{prefix}/" unless prefix.empty?
+      for index_name in @index_names
+        begin
+          effective_path = "#{prefix}#{index_name}"
+          entry = @input.get_entry(effective_path)
+          break
+        rescue NoSuchEntryError
+        end
+      end
+
+      # directory exists, but missing trailing slash?
+      if entry and not has_trailing_slash
+        return [301, {'Content-Type' => 'text/plain',
+                      'Location' => "#{env['SCRIPT_NAME']}#{path}/"},
+                ["301 Moved Permanently"]]
+      end
+    end
+
+    if entry
+      mime_type = entry['mime_type'] 
+      unless mime_type
+        effective_path =~ /(\.[^.]+)$/
+        mime_type = ::Rack::Mime.mime_type($1 || '')
+      end
+      content = entry['content'].to_s
+      [200, {'Content-Type' => mime_type}, [content]]
+    else
+      message = "#{env['SCRIPT_NAME']}#{path} not found"
+      [404, {'Content-Type' => "text/plain"}, [message]]
+    end
+  end
+end
+
+end
+end

data/spec/cache_spec.rb

@@ -5,7 +5,7 @@ require 'set'
 
 describe Hx::Cache do
   before(:each) do
-    @source = FakeSource.new
+    @source = FakeInput.new
     @source.add_entry('foo', 'BLAH')
     @source.add_entry('bar', 'EEP')
     @cache = Hx::Cache.new(@source)

data/spec/{nullsource_spec.rb → nullinput_spec.rb}

@@ -2,9 +2,9 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 require 'hx'
 
-describe Hx::NullSource do
+describe Hx::NullInput do
   before(:each) do
-    @null_source = Hx::NullSource.new
+    @null_source = Hx::NullInput.new
   end
 
   it "should return itself from each_entry" do
@@ -18,8 +18,8 @@ describe Hx::NullSource do
   end
 end
 
-describe Hx::NULL_SOURCE do
-  it "is an instance of Hx::NullSource" do
-    Hx::NULL_SOURCE.should be_an_instance_of(Hx::NullSource)
+describe Hx::NULL_INPUT do
+  it "is an instance of Hx::NullInput" do
+    Hx::NULL_INPUT.should be_an_instance_of(Hx::NullInput)
   end
 end

data/spec/overlay_spec.rb

@@ -4,10 +4,10 @@ require 'hx'
 
 describe Hx::Overlay do
   before(:each) do
-    @a = FakeSource.new
+    @a = FakeInput.new
     @a.add_entry('foo', 'foo:A')
     @a.add_entry('bar', 'bar:A')
-    @b = FakeSource.new
+    @b = FakeInput.new
     @b.add_entry('bar', 'bar:B')
     @b.add_entry('baz', 'baz:B')
     @overlay = Hx::Overlay.new(@a, @b)

data/spec/pathops_spec.rb

@@ -7,7 +7,7 @@ describe Hx::AddPath do
   before(:each) do
     @before_paths = Set['foo', 'bar']
     @after_paths = Set['XXXfooYYY', 'XXXbarYYY']
-    @source = FakeSource.new
+    @source = FakeInput.new
     @source.add_entry('foo', 'FOO')
     @source.add_entry('bar', 'BAR')
     @add = Hx::AddPath.new(@source, :prefix => 'XXX', :suffix => 'YYY')
@@ -29,7 +29,7 @@ end
 describe Hx::StripPath do
   before(:each) do @before_paths = Set['XXXfooYYY', 'XXXbarYYY', 'lemur']
     @after_paths = Set['foo', 'bar']
-    @source = FakeSource.new
+    @source = FakeInput.new
     @source.add_entry('XXXfooYYY', 'FOO')
     @source.add_entry('XXXbarYYY', 'BAR')
     @strip = Hx::StripPath.new(@source, :prefix => 'XXX', :suffix => 'YYY')
@@ -50,7 +50,7 @@ end
 
 describe Hx::PathSubset do
   before(:each) do
-    @source = FakeSource.new
+    @source = FakeInput.new
     @all_paths = Set['lemur', 'foo/bar', 'foo/baz', 'hoge/hoge']
     @all_paths.each do |path|
       @source.add_entry(path, path)

data/spec/rack_spec.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'hx'
+require 'hx/rack'
+require 'rack/mock'
+
+describe Hx::Rack::Application do
+  before(:each) do
+    @input = FakeInput.new
+    @app = Hx::Rack::Application.new(@input, {})
+    @service = Rack::MockRequest.new(@app)
+  end
+
+  it "should return 404 for unknown paths" do
+    response = @service.get("/bogus", :lint => true, :fatal => true)
+    response.status.to_i.should == 404
+  end
+
+  it "should return 200 with content for known paths" do
+    path = "existing"
+    content = "BLAH"
+    @input.add_entry(path, content)
+    response = @service.get("/#{path}", :lint => true, :fatal => true)
+    response.status.to_i.should == 200
+    response.body.to_s.should == content
+  end
+
+  it "should infer content type from file extension by default" do
+    cases = { "html" => "text/html",
+              "jpeg" => "image/jpeg" }
+    for extension, mime_type in cases
+      path = "blah.#{extension}"
+      @input.add_entry(path, "")
+      response = @service.get("/#{path}", :lint => true, :fatal => true)
+      response.status.to_i.should == 200
+      response['Content-Type'].should == mime_type
+    end
+  end
+
+  it "should allow entries to specify their mime type" do
+    path = "blah.html"
+    mime_type = "junk/garbage"
+    @input.add_entry(path, "", 'mime_type' => mime_type)
+    response = @service.get("/#{path}", :lint => true, :fatal => true)
+    response.status.to_i.should == 200
+    response['Content-Type'].should == mime_type
+  end
+
+  it "should redirect for directories with indices" do
+    @input.add_entry("dir/index.html", "")
+    response = @service.get("/dir", :lint => true, :fatal => true)
+    response.status.to_i.should == 301
+    response['Location'].should == "/dir/"
+  end
+
+  it "should return index for directories" do
+    content = "SOME INDEX STUFF"
+    @input.add_entry("dir/index.html", content)
+    response = @service.get("/dir/", :lint => true, :fatal => true)
+    response.status.to_i.should == 200
+    response.body.to_s.should == content
+  end
+
+  it "should return index for the root" do
+    content = "ROOT INDEX YAY"
+    @input.add_entry("index.html", content)
+    response = @service.get("/", :lint => true, :fatal => true)
+    response.status.to_i.should == 200
+    response.body.to_s.should == content
+  end
+end

data/spec/spec_helper.rb

@@ -5,26 +5,30 @@ require 'ostruct'
 require 'spec'
 require 'spec/autorun'
 
-class FakeSource
-  include Hx::Source
+class FakeInput
+  include Hx::Filter
 
   def initialize
     @entries = {}
   end
 
   def add_entry(path, content, metadata={})
-    entry = OpenStruct.new(metadata)
-    entry.content = content
+    entry = metadata.dup
+    entry['content'] = content
     @entries[path] = entry
   end
 
-  def each_entry
-    @entries.each { |path, entry| yield path, entry }
+  def each_entry_path
+    @entries.each_key { |path| yield path }
     self
   end
 
   def get_entry(path)
-    @entries[path]
+    begin
+      @entries.fetch(path)
+    rescue IndexError
+      raise Hx::NoSuchEntryError, path
+    end  
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: hx
 version: !ruby/object:Gem::Version 
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors: 
 - MenTaLguY
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-07 00:00:00 -05:00
+date: 2010-02-16 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -47,18 +47,22 @@ files:
 - lib/hx.rb
 - lib/hx/backend/couchdb.rb
 - lib/hx/backend/hobix.rb
+- lib/hx/backend/rawfiles.rb
 - lib/hx/commandline.rb
 - lib/hx/listing/limit.rb
 - lib/hx/listing/paginate.rb
 - lib/hx/listing/recursiveindex.rb
 - lib/hx/output/liquidtemplate.rb
+- lib/hx/rack.rb
+- lib/hx/rack/application.rb
 - spec/cache_spec.rb
 - spec/hx_dummy.rb
 - spec/hx_dummy2.rb
-- spec/nullsource_spec.rb
+- spec/nullinput_spec.rb
 - spec/overlay_spec.rb
 - spec/pathfilter_spec.rb
 - spec/pathops_spec.rb
+- spec/rack_spec.rb
 - spec/site_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
@@ -95,8 +99,9 @@ test_files:
 - spec/cache_spec.rb
 - spec/hx_dummy.rb
 - spec/pathfilter_spec.rb
-- spec/nullsource_spec.rb
+- spec/nullinput_spec.rb
 - spec/site_spec.rb
 - spec/hx_dummy2.rb
+- spec/rack_spec.rb
 - spec/overlay_spec.rb
 - spec/pathops_spec.rb