hx 0.3.2

data/lib/hx/commandline.rb

@@ -0,0 +1,161 @@
+# hx/commandline - A very small website generator; commandline interface
+#
+# Copyright (c) 2009 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'
+require 'ostruct'
+require 'optparse'
+require 'pathname'
+require 'tempfile'
+
+module Hx
+module Commandline
+
+DEFAULT_CONFIG_FILENAME = "hx-config.yaml"
+
+def self.main(*args)
+  options = OpenStruct.new
+  options.config_file = nil
+
+  OptionParser.new do |opts|
+    opts.banner = "Usage: hx [--config CONFIG_FILE]"
+
+    opts.on("-c", "--config CONFIG_FILE",
+            "Use CONFIG_FILE instead of searching for " +
+            DEFAULT_CONFIG_FILENAME) \
+    do |config_file|
+      options.config_file = Pathname.new(config_file)
+    end
+
+    opts.on_tail("-h", "--help", "Show this usage information") do
+      puts opts
+      return
+    end
+
+    opts.parse!(args)
+  end
+
+  options.config_file ||= ENV['HX_CONFIG']
+
+  unless options.config_file
+    Pathname.getwd.ascend do |ancestor|
+      filename = ancestor + DEFAULT_CONFIG_FILENAME
+      if filename.exist?
+        options.config_file = filename
+        break
+      end
+    end
+    unless options.config_file
+      raise RuntimeError, "No #{DEFAULT_CONFIG_FILENAME} found"
+    end
+  end
+
+  site = nil
+  options.config_file.open("r") do |stream|
+    site = Hx::Site.load(stream, options.config_file)
+  end
+
+  subcommand = args.shift || "regen"
+  method_name = "cmd_#{subcommand}".intern
+  begin
+    m = method(method_name)
+  rescue NameError
+    raise ArgumentError, "Unrecognized subcommand: #{subcommand}"
+  end
+  m.call(site, *args)
+end
+
+def self.cmd_regen(site)
+  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}"
+    builder.build_file(path, entry)
+  end
+end
+
+def self.cmd_edit(site, pathspec)
+  do_edit(site, pathspec, false)
+end
+
+def self.cmd_create(site, pathspec)
+  do_edit(site, pathspec, true)
+end
+
+def self.do_edit(site, pathspec, create)
+  source_name, path = pathspec.split(':', 2)
+  path, source_name = source_name, path unless source_name
+
+  if create
+    prototype = {
+      'title' => Hx.make_default_title(site.options, path),
+      'author' => Hx.get_default_author(site.options),
+      'content' => ""
+    }
+  else
+    prototype = nil
+  end
+
+  if source_name
+    source = site.sources[source_name]
+    raise ArgumentError, "No such source #{source_name}" unless source
+  else
+    source = site
+  end
+
+  catch(:unchanged) do
+    begin
+      tempfile = Tempfile.new('hx-entry')
+      original_text = nil
+      loop do
+        begin
+          source.edit_entry(path, prototype) do |text|
+            unless original_text
+              File.open(tempfile.path, 'w') { |s| s << text }
+              original_text = text
+            end
+            # TODO: deal with conflict if text != original_text
+            editor = ENV['EDITOR'] || 'vi'
+            system(editor, tempfile.path)
+            new_text = File.open(tempfile.path, 'r') { |s| s.read }
+            throw(:unchanged) if new_text == text
+            new_text
+          end
+          break
+        rescue Exception => e
+          $stderr.puts e
+          $stderr.print "Edit failed; retry? [Yn] "
+          $stderr.flush
+          response = $stdin.gets.strip
+          unless response =~ /^y/i
+            raise e
+          end
+        end
+      end
+    ensure
+      tempfile.unlink
+    end
+  end
+end
+
+end
+end

data/spec/cache_spec.rb

@@ -0,0 +1,31 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'hx'
+require 'set'
+
+describe Hx::Cache do
+  before(:each) do
+    @source = FakeSource.new
+    @source.add_entry('foo', 'BLAH')
+    @source.add_entry('bar', 'EEP')
+    @cache = Hx::Cache.new(@source)
+  end
+
+  it "should return itself from each_entry" do
+    @cache.each_entry {}.should == @cache
+  end
+
+  it "enumerates the same entries from the source" do
+    @cache.each_entry do |path, entry|
+      entry.should == @source.get_entry(path)
+    end
+  end
+
+  it "only reads the source once" do
+    @cache.each_entry {}
+    def @source.each_entry
+      raise RuntimeError, "should not be called"
+    end
+    @cache.each_entry {}
+  end
+end

data/spec/nullsource_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'hx'
+
+describe Hx::NullSource do
+  before(:each) do
+    @null_source = Hx::NullSource.new
+  end
+
+  it "should return itself from each_entry" do
+    @null_source.each_entry {}.should == @null_source
+  end
+
+  it "enumerates no entry paths" do
+    @null_source.each_entry do |path, entry|
+      raise RuntimeError("No entries")
+    end
+  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)
+  end
+end

data/spec/overlay_spec.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'hx'
+
+describe Hx::Overlay do
+  before(:each) do
+    @a = FakeSource.new
+    @a.add_entry('foo', 'foo:A')
+    @a.add_entry('bar', 'bar:A')
+    @b = FakeSource.new
+    @b.add_entry('bar', 'bar:B')
+    @b.add_entry('baz', 'baz:B')
+    @overlay = Hx::Overlay.new(@a, @b)
+  end
+
+  it "should return itself from each_entry" do
+    @overlay.each_entry {}.should == @overlay
+  end
+
+  it "should expose the union of paths" do
+    actual_paths = []
+    @overlay.each_entry do |path, entry|
+      actual_paths << path
+    end
+    actual_paths.sort.should == %w(foo bar baz).sort
+  end
+
+  it "should give earlier sources precedence" do
+    @overlay.each_entry do |path, entry|
+      entry.should == @a.get_entry('bar') if path == 'bar'
+    end
+  end
+
+  it "should expose entries from all sources" do
+    @overlay.each_entry do |path, entry|
+      entry.should == @a.get_entry('foo') if path == 'foo'
+      entry.should == @b.get_entry('baz') if path == 'baz'
+    end
+  end
+end

data/spec/pathfilter_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'hx'
+
+describe Hx::PathSubset::Predicate do
+  it "accepts anything when the accept and reject patterns are nil" do
+    filter = Hx::PathSubset::Predicate.new(nil, nil)
+    filter.accept?("blah").should be_true
+  end
+
+  it "accepts only paths matching the accept pattern when it is specified" do
+    filter = Hx::PathSubset::Predicate.new("foo", nil)
+    filter.accept?("foo").should be_true
+    filter.accept?("bar").should be_false
+  end
+
+  it "accepts only paths not matching reject, when only that is specified" do
+    filter = Hx::PathSubset::Predicate.new(nil, "foo")
+    filter.accept?("foo").should be_false
+    filter.accept?("bar").should be_true
+  end
+
+  it "matches the difference of accept and reject when both are specified" do
+    filter = Hx::PathSubset::Predicate.new("foo/*", "foo/bar")
+    filter.accept?("foo/bar").should be_false
+    filter.accept?("foo/baz").should be_true
+    filter.accept?("bar").should be_false
+  end
+
+  it "shouldn't match across slashes with single star" do
+    filter = Hx::PathSubset::Predicate.new("foo/*", nil)
+    filter.accept?("bar").should be_false
+    filter.accept?("foo").should be_false
+    filter.accept?("foo/bar").should be_true
+    filter.accept?("foo/bar/baz").should be_false
+  end
+
+  it "should match across slashes with double star" do
+    filter = Hx::PathSubset::Predicate.new("foo/**", nil)
+    filter.accept?("bar").should be_false
+    filter.accept?("foo").should be_false
+    filter.accept?("foo/bar").should be_true
+    filter.accept?("foo/bar/baz").should be_true
+  end
+end

data/spec/pathops_spec.rb

@@ -0,0 +1,72 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'set'
+require 'hx'
+
+describe Hx::AddPath do
+  before(:each) do
+    @before_paths = Set['foo', 'bar']
+    @after_paths = Set['XXXfooYYY', 'XXXbarYYY']
+    @source = FakeSource.new
+    @source.add_entry('foo', 'FOO')
+    @source.add_entry('bar', 'BAR')
+    @add = Hx::AddPath.new(@source, :prefix => 'XXX', :suffix => 'YYY')
+  end
+
+  it "should return itself from each_entry" do
+    @add.each_entry {}.should == @add
+  end
+
+  it "yields augmented paths from each_entry" do
+    paths = Set[]
+    @add.each_entry do |path, entry|
+      paths.add path
+    end
+    paths.should == @after_paths
+  end
+end
+
+describe Hx::StripPath do
+  before(:each) do @before_paths = Set['XXXfooYYY', 'XXXbarYYY', 'lemur']
+    @after_paths = Set['foo', 'bar']
+    @source = FakeSource.new
+    @source.add_entry('XXXfooYYY', 'FOO')
+    @source.add_entry('XXXbarYYY', 'BAR')
+    @strip = Hx::StripPath.new(@source, :prefix => 'XXX', :suffix => 'YYY')
+  end
+
+  it "should return itself from each_entry" do
+    @strip.each_entry {}.should == @strip
+  end
+
+  it "yields stripped paths from each_entry" do
+    paths = Set[]
+    @strip.each_entry do |path, entry|
+      paths.add path
+    end
+    paths.should == @after_paths
+  end
+end
+
+describe Hx::PathSubset do
+  before(:each) do
+    @source = FakeSource.new
+    @all_paths = Set['lemur', 'foo/bar', 'foo/baz', 'hoge/hoge']
+    @all_paths.each do |path|
+      @source.add_entry(path, path)
+    end
+    @subset = Hx::PathSubset.new(@source, :only => 'foo/*')
+  end
+
+  it "returns itself from each_entry" do
+    @subset.each_entry {}.should == @subset
+  end
+
+  it "enumerates paths according to the subset filter" do
+    actual_paths = Set[]
+    @subset.each_entry do |path, entry|
+      actual_paths.add path
+    end
+    actual_paths.should == Set['foo/bar', 'foo/baz']
+  end
+end

data/spec/site_spec.rb

@@ -0,0 +1,65 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'hx'
+
+describe "Hx::Site.load" do
+  it "requires dependencies from the config" do
+    yaml_config = YAML.dump({'require' => ['hx_dummy.rb']})
+    Hx::Site.load yaml_config, __FILE__
+    $".should include('hx_dummy.rb')
+
+    yaml_config = YAML.dump({'require' => 'hx_dummy2.rb'})
+    Hx::Site.load yaml_config, __FILE__
+    $".should include('hx_dummy2.rb')
+  end
+
+  it "returns an Hx::Site object" do
+    yaml_config = YAML.dump({})
+    site = Hx::Site.load yaml_config, __FILE__
+    site.should be_an_instance_of(Hx::Site)
+  end
+
+  it "takes default base_dir from config file path" do
+    yaml_config = YAML.dump({})
+    site = Hx::Site.load yaml_config, 'foo/baz/config.hx'
+    site.options[:base_dir].should == 'foo/baz'
+    yaml_config = YAML.dump({'options' => {'base_dir' => 'foo/bar'}})
+    site = Hx::Site.load yaml_config, 'foo/baz/config.hx'
+    site.options[:base_dir].should == 'foo/bar'
+  end
+
+  it "gets global options from the config, with symbol keys" do
+    input_options = {'foo' => 'bar', 'base_dir' => "xyz"}
+    output_options = {:foo => 'bar', :base_dir => "xyz"}
+    yaml_config = YAML.dump({'options' => input_options})
+    site = Hx::Site.load yaml_config, __FILE__
+    site.options[:foo].should == 'bar'
+    site.options[:base_dir].should == 'xyz'
+  end
+
+  it "creates a source for every entry in sources" do
+    yaml_config = YAML.dump({'sources' => {'foo' => {},
+                                           'bar' => {}}})
+    site = Hx::Site.load(yaml_config, __FILE__)
+    site.sources.size.should == 2
+    site.sources.should include('foo')
+    site.sources.should include('bar')
+  end
+
+  it "creates an output for every entry in outputs" do
+    yaml_config = YAML.dump({'outputs' => [{}, {}]})
+    site = Hx::Site.load(yaml_config, __FILE__)
+    site.outputs.size.should == 2
+  end
+end
+
+describe Hx::Site do
+  before(:each) do
+    yaml_config = YAML.dump({})
+    @site = Hx::Site.load(yaml_config, __FILE__)
+  end
+
+  it "returns itself from each_entry" do
+    @site.each_entry {}.should == @site
+  end
+end