hx 0.13.0 → 0.14.0

data/README.rdoc

@@ -1,7 +1,22 @@
 = hx
 
-A miniature web site generator.
+A miniature web site generator; a spiritual successor to Hobix.
+
+== History
+
+== The Concept
+
+== Tutorial
+
+=== A Trivial Static Site
+
+ options:
+   output_dir: site
+ output:
+   - filter: Hx::Backend::RawFiles
+     options:
+       entry_dir: static
 
 == Copyright
 
-Copyright (c) 2010 MenTaLguY. See LICENSE for details.
+Copyright (c) 2009-2011 MenTaLguY. See LICENSE for details.

data/VERSION

@@ -1 +1 @@
-0.13.0
+0.14.0

data/lib/hx.rb

@@ -220,52 +220,80 @@ class StripPath
   end
 end
 
+def self.cache_scope
+  saved_records = Thread.current[:hx_cache_records]
+  Thread.current[:hx_cache_records] = {}
+  begin
+    yield
+  ensure
+    Thread.current[:hx_cache_records] = saved_records
+  end
+end
+
 class Cache
   include Filter
 
+  class Record
+    def initialize
+      @paths = nil
+      @entries = {}
+    end
+
+    def clear_path(path)
+      @paths = nil
+      @entries.delete path
+    end
+
+    def get_entry_paths
+      @paths || (@paths = yield)
+    end
+
+    def get_entry(path)
+      begin
+        entry = @entries.fetch(path)
+      rescue IndexError
+        begin
+          entry = yield
+        rescue NoSuchEntryError
+          entry = nil
+        end
+        @entries[path] = entry
+      end
+      raise NoSuchEntryError, path unless entry
+      entry
+    end
+  end
+
+  attr_reader :input
+
   def initialize(input, options={})
+    input = input.input while Cache === input
     @input = input
-    @lock = Mutex.new
-    @entries = nil
-    @entries_by_path = {}
+  end
+
+  def get_cache_record
+    (Thread.current[:hx_cache_records] ||= {})[@input] ||= Record.new
   end
 
   def edit_entry(path, prototype=nil)
     @input.edit_entry(path, prototype) { |text| yield text }
+    get_cache_record.clear_path(path)
     self
   end
 
-  def each_entry(selector)
-    entries = nil
-    @lock.synchronize do
-      if @entries
-        entries = @entries
-      else
-        entries = []
-        @input.each_entry(Path::ALL) do |path, entry|
-          @entries_by_path[path] = entry
-          entries << [path, entry]
-        end
-        @entries = entries
-      end
-    end
-    entries.each do |path, entry|
-      yield path, entry.dup if selector.accept_path? path
+  def each_entry_path(selector)
+    get_cache_record.get_entry_paths do
+      paths = []
+      @input.each_entry_path(Path::ALL) { |path| paths << path }
+      paths
+    end.each do |path|
+      yield path if selector.accept_path? path
     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
+    get_cache_record.get_entry(path) { @input.get_entry(path) }
   end
 end
 
@@ -273,7 +301,7 @@ class Sort
   include Filter
 
   def initialize(input, options)
-    @input = input
+    @input = Cache.new(input)
     @key_fields = Array(options[:sort_by] || []).map { |f| f.to_s }
     @reverse = !!options[:reverse]
   end
@@ -438,8 +466,6 @@ def self.build_source(options, default_input, sources, raw_source)
                               :reverse => raw_source['reverse'])
   end
 
-  source = Cache.new(source) if raw_source['cache']
-
   source
 end
 
@@ -452,24 +478,21 @@ class Site
   class << self
     private :new
 
-    def load_file(config_file)
+    def load_file(config_file, option_overrides={})
       File.open(config_file, 'r') do |stream|
-        load(stream, config_file)
+        load(stream, config_file, option_overrides)
       end
     end
 
-    def load(io, config_path)
+    def load(io, config_file, option_overrides={})
       raw_config = YAML.load(io)
-      load_raw(raw_config, config_path)
-    end
-
-    def load_raw(raw_config, config_path)
       options = {}
-      options[:base_dir] = File.dirname(config_path)
+      options[:base_dir] = File.dirname(config_file)
       for key, value in raw_config.fetch('options', {})
         options[key.intern] = value
       end
-      options[:config_file] = config_path
+      options[:config_file] = config_file
+      options.update(option_overrides)
 
       if raw_config.has_key? 'require'
         for library in raw_config['require']
@@ -478,14 +501,25 @@ class Site
       end
 
       raw_sources_by_name = raw_config.fetch('sources', {})
+      raw_outputs = raw_config.fetch('output', [])
       source_names = raw_sources_by_name.keys
 
       # build input dependency graph
       source_dependencies = {}
+      source_count_by_dependency = Hash.new(0)
       for name, raw_source in raw_sources_by_name
         raw_source = Hx.expand_chain(raw_source)
         if raw_source.has_key? 'input'
-          source_dependencies[name] = raw_source['input']
+          input_name = raw_source['input']
+          source_dependencies[name] = input_name
+          source_count_by_dependency[input_name] += 1
+        end
+      end
+      for raw_output in raw_outputs
+        raw_output = Hx.expand_chain(raw_output)
+        if raw_output.has_key? 'input'
+          input_name = raw_source['input']
+          source_count_by_dependency[input_name] += 1
         end
       end
 
@@ -510,12 +544,15 @@ class Site
       sources = {}
       for name in depth_first_names
         raw_source = raw_sources_by_name[name]
-        sources[name] = Hx.build_source(options, NULL_INPUT, sources,
-                                        raw_source)
+        source = Hx.build_source(options, NULL_INPUT, sources, raw_source)
+        if source_count_by_dependency[name] > 1
+          source = Cache.new(source, options)
+        end
+        sources[name] = source
       end
 
       outputs = []
-      for raw_output in raw_config.fetch('output', [])
+      for raw_output in raw_outputs
         outputs << Hx.build_source(options, NULL_INPUT, sources, raw_output)
       end
 

data/lib/hx/cli.rb

@@ -107,9 +107,7 @@ def self.cmd_serve(site, port=nil)
 
   # reload the site/config, folding in the new base URL
   config_file = site.options[:config_file]
-  raw_config = File.open(config_file, 'r') { |s| YAML.load(s) }
-  (raw_config['options'] ||= {})['base_url'] = base_url
-  site = Hx::Site.load_raw(raw_config, config_file)
+  site = Hx::Site.load_file(config_file, :base_url => base_url)
 
   app = Hx::Rack::Application.new(site, site.options)
   server.mount('/', ::Rack::Handler::WEBrick, app)
@@ -127,17 +125,19 @@ end
 
 def self.do_gen(site, update_only)
   output_dir = Hx.get_pathname(site.options, :output_dir)
-  site.each_entry(Path::ALL) do |path, entry|
-    pathname = output_dir + path
-    content = entry['content']
-    if update_only
-      update_time = entry['updated']
-    else
-      update_time = nil
+  Hx.cache_scope do
+    site.each_entry(Path::ALL) do |path, entry|
+      pathname = output_dir + path
+      content = entry['content']
+      if update_only
+        update_time = entry['updated']
+      else
+        update_time = nil
+      end
+      written = Hx.refresh_file(pathname, content, update_time,
+                                entry['executable'])
+      puts "===> #{path}" if written
     end
-    written = Hx.refresh_file(pathname, content, update_time,
-                              entry['executable'])
-    puts "===> #{path}" if written
   end
 end
 

data/lib/hx/listing/paginate.rb

@@ -30,7 +30,7 @@ class Paginate
   include Hx::Filter
 
   def initialize(input, options)
-    @input = input
+    @input = Cache.new(input)
     @page_size = options[:page_size]
   end
 

data/lib/hx/listing/recursiveindex.rb

@@ -24,6 +24,7 @@
 require 'hx'
 require 'hx/listing/limit'
 require 'hx/listing/paginate'
+require 'set'
 
 module Hx
 module Listing
@@ -52,28 +53,37 @@ class RecursiveIndex
   end
   private :merge_updated
 
-  def each_entry(selector)
-    indexes = Hash.new { |h,k| h[k] = {'items' => []} }
-    @input.each_entry(Path::ALL) do |path, entry|
+  def each_entry_path(selector)
+    emitted = Set.new
+    @input.each_entry_path(Path::ALL) do |path, entry|
       components = path.split("/")
-      if components.last == "index"
-        index = indexes[path] = entry.merge(indexes[path])
-        merge_updated(index, entry)
-      else
-        until components.empty?
-          components.pop
-          index_path = (components + ["index"]).join("/")
-          index = indexes[index_path]
-          index['items'] << {'path' => path, 'entry' => entry}
-          merge_updated(index, entry)
-        end
+      until components.empty?
+        components.pop
+        index_path = (components + ["index"]).join("/")
+        break if emitted.include? index_path
+        yield index_path if selector.accept_path? index_path
+        emitted.add index_path
       end
     end
-    indexes.each do |path, entry|
-      yield path, entry if selector.accept_path? path
-    end
     self
   end
+
+  def get_entry(path)
+    raise NoSuchEntryError, path unless path =~ %r!^((?:.*/)?)index$!
+    prefix = $1
+    selector = Path.parse_pattern("#{prefix}**")
+    index = {'items' => []}
+    @input.each_entry(selector) do |child_path, entry|
+      if child_path == path
+        index = entry.merge(index)
+      else
+        index['items'] << {'path' => child_path, 'entry' => entry}
+      end
+      merge_updated(index, entry)
+    end
+    raise NoSuchEntryError, path if index['items'].empty?
+    index
+  end
 end
 
 end

data/lib/hx/rack/application.rb

@@ -40,6 +40,18 @@ class Application
   end
 
   def call(env)
+    Hx.cache_scope { _call(env) }
+  end
+
+  def _call(env)
+    request_method = env["REQUEST_METHOD"]
+
+    if request_method != "GET" and request_method != "HEAD"
+      return [405, {'Content-Type' => 'text/plain',
+                    'Allow' => "GET, HEAD"},
+              ["405 Method Not Allowed"]]
+    end
+
     path = CGI.unescape(env['PATH_INFO'])
     path = '/' if path.empty?
     entry = nil
@@ -83,8 +95,12 @@ class Application
         effective_path =~ /(\.[^.]+)$/
         content_type = ::Rack::Mime.mime_type($1 || '')
       end
-      content = entry['content'].to_s
-      [200, {'Content-Type' => content_type}, [content]]
+      if request_method != "HEAD"
+        content = [entry['content'].to_s]
+      else
+        content = []
+      end
+      [200, {'Content-Type' => content_type}, content]
     else
       message = "#{env['SCRIPT_NAME']}#{path} not found"
       [404, {'Content-Type' => "text/plain"}, [message]]

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: hx
 version: !ruby/object:Gem::Version 
-  hash: 43
+  hash: 39
   prerelease: false
   segments: 
   - 0
-  - 13
+  - 14
   - 0
-  version: 0.13.0
+  version: 0.14.0
 platform: ruby
 authors: 
 - MenTaLguY
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-02 00:00:00 -08:00
+date: 2011-03-04 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency