nanoc-filesystem-i18n 0.1.0.pre1

data/lib/nanoc3/data_sources/filesystem_i18n/version.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'nanoc3'
+
+module Nanoc3
+  module DataSources
+    class FilesystemI18n < Nanoc3::DataSource
+      Version = '0.1.0.pre1'
+    end
+  end
+end
+

data/lib/nanoc3/extra/i18n.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'nanoc3'
+require 'i18n'
+
+module I18n
+  class Config
+
+    def localized_site?
+      !available_locales.empty?
+    end
+
+    def exclude_list(kind)
+      @exclude ||= {}
+      @exclude[kind] ||= localized_site? ? [] : ['*']
+    end
+
+    def exclude_list=(exclude)
+      @exclude = exclude
+    end
+
+  end
+
+  class << self
+    def load_config(dir_or_config_hash)
+      if dir_or_config_hash.is_a? String
+        # Read config from config.yaml in given dir
+        config_path = File.join(dir_or_config_hash, 'config.yaml')
+        config_data = YAML.load_file(config_path).symbolize_keys[:locale] rescue {}
+      else
+        # Use passed config hash
+        config_data = dir_or_config_hash || {}
+      end
+
+      config.available_locales = config_data[:availables] ? config_data[:availables].map {|code, data| code.to_sym } : []
+      if I18n.localized_site?
+        config.default_locale = begin config_data[:availables].find{|code, data| data[:default] }[0] rescue config_data[:availables].first[0] end
+        config.exclude_list = config_data[:exclude]
+      end
+    end
+
+    def exclude_list(kind)
+      config.exclude_list(kind)
+    end
+
+    def localized_site?
+      config.localized_site?
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+
+# Load unit testing stuff
+begin
+  require 'minitest/unit'
+  require 'minitest/spec'
+  require 'minitest/mock'
+  require 'mocha'
+rescue => e
+  $stderr.puts "To run the nanoc unit tests, you need minitest and mocha."
+  raise e
+end
+
+# Load nanoc
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + '/../lib'))
+require 'nanoc3'
+require 'nanoc3/cli'
+require 'nanoc3/tasks'
+require 'nanoc3/data_sources/filesystem_i18n'
+
+# Load miscellaneous requirements
+require 'stringio'
+
+module Nanoc3::TestHelpers
+
+  def if_have(*libs)
+    libs.each do |lib|
+      begin
+        require lib
+      rescue LoadError
+        skip "requiring #{lib} failed"
+        return
+      end
+    end
+
+    yield
+  end
+
+  def setup
+    # Clean up
+    GC.start
+
+    # Go quiet
+    unless ENV['QUIET'] == 'false'
+      $stdout = StringIO.new
+      $stderr = StringIO.new
+    end
+
+    # Enter tmp
+    FileUtils.mkdir_p('tmp')
+    FileUtils.cd('tmp')
+  end
+
+  def teardown
+    # Exit tmp
+    FileUtils.cd('..')
+    FileUtils.rm_rf('tmp')
+
+    # Go unquiet
+    unless ENV['QUIET'] == 'false'
+      $stdout = STDOUT
+      $stderr = STDERR
+    end
+  end
+
+  # Adapted from http://github.com/lsegal/yard-examples/tree/master/doctest
+  def assert_examples_correct(object)
+    P(object).tags(:example).each do |example|
+      begin
+        # Get input and output
+        parts = example.text.split(/# ?=>/).map { |s| s.strip }
+        code             = parts[0].strip
+        expected_out_raw = parts[1].strip
+
+        # Evaluate
+        expected_out     = eval(parts[1])
+        actual_out       = instance_eval("#{code}")
+      rescue Exception => e
+        e.message << " (code: #{code}; expected output: #{expected_out_raw})"
+        raise e
+      end
+
+      assert_equal expected_out, actual_out,
+        "Incorrect example: #{code}"
+    end
+  end
+
+end
+
+MiniTest::Unit.autorun

data/test/test_filesystem.rb

@@ -0,0 +1,347 @@
+# encoding: utf-8
+
+require 'test/helper'
+
+class Nanoc3::DataSources::FilesystemTest < MiniTest::Unit::TestCase
+
+  include Nanoc3::TestHelpers
+
+  class SampleFilesystemDataSource < Nanoc3::DataSources::FilesystemI18n
+  end
+
+  def test_setup
+    # Create data source
+    data_source = SampleFilesystemDataSource.new(nil, nil, nil, nil)
+
+    # Remove files to make sure they are recreated
+    FileUtils.rm_rf('content')
+    FileUtils.rm_rf('layouts/default')
+    FileUtils.rm_rf('lib/default.rb')
+
+    # Mock VCS
+    vcs = mock
+    vcs.expects(:add).times(3) # One time for each directory
+    data_source.vcs = vcs
+
+    # Recreate files
+    data_source.setup
+
+    # Ensure essential files have been recreated
+    assert(File.directory?('content/'))
+    assert(File.directory?('layouts/'))
+    assert(File.directory?('lib/'))
+
+    # Ensure no non-essential files have been recreated
+    assert(!File.file?('content/index.html'))
+    assert(!File.file?('layouts/default.html'))
+    assert(!File.file?('lib/default.rb'))
+  end
+
+  def test_items
+    # Create data source
+    data_source = SampleFilesystemDataSource.new(nil, nil, nil, nil)
+
+    # Check
+    data_source.expects(:load_objects).with('content', 'item', Nanoc3::Item)
+    data_source.items
+  end
+
+  def test_layouts
+    # Create data source
+    data_source = SampleFilesystemDataSource.new(nil, nil, nil, nil)
+
+    # Check
+    data_source.expects(:load_objects).with('layouts', 'layout', Nanoc3::Layout)
+    data_source.layouts
+  end
+
+  def test_create_item
+    # Create data source
+    data_source = SampleFilesystemDataSource.new(nil, nil, nil, nil)
+
+    # Check
+    data_source.expects(:create_object).with('content', 'the content', 'the attributes', 'the identifier', {})
+    data_source.create_item('the content', 'the attributes', 'the identifier')
+  end
+
+  def test_create_layout
+    # Create data source
+    data_source = SampleFilesystemDataSource.new(nil, nil, nil, nil)
+
+    # Check
+    data_source.expects(:create_object).with('layouts', 'the content', 'the attributes', 'the identifier', {})
+    data_source.create_layout('the content', 'the attributes', 'the identifier')
+  end
+
+  def test_all_split_files_in_allowing_periods_in_identifiers
+    # Create data source
+    data_source = Nanoc3::DataSources::FilesystemCompact.new(nil, nil, nil, { :allow_periods_in_identifiers => true })
+
+    # Write sample files
+    FileUtils.mkdir_p('foo')
+    %w( foo.html foo.yaml bar.entry.html foo/qux.yaml ).each do |filename|
+      File.open(filename, 'w') { |io| io.write('test') }
+    end
+
+    # Write stray files
+    %w( foo.html~ foo.yaml.orig bar.entry.html.bak ).each do |filename|
+      File.open(filename, 'w') { |io| io.write('test') }
+    end
+
+    # Get all files
+    output_expected = {
+      './foo'       => [ 'yaml', 'html' ],
+      './bar.entry' => [ nil,    'html' ],
+      './foo/qux'   => [ 'yaml', nil    ]
+    }
+    output_actual = data_source.send :all_split_files_in, '.'
+
+    # Check
+    assert_equal output_expected, output_actual
+  end
+
+  def test_all_split_files_in_disallowing_periods_in_identifiers
+    # Create data source
+    data_source = Nanoc3::DataSources::FilesystemCompact.new(nil, nil, nil, nil)
+
+    # Write sample files
+    FileUtils.mkdir_p('foo')
+    %w( foo.html foo.yaml bar.html.erb foo/qux.yaml ).each do |filename|
+      File.open(filename, 'w') { |io| io.write('test') }
+    end
+
+    # Write stray files
+    %w( foo.html~ foo.yaml.orig bar.entry.html.bak ).each do |filename|
+      File.open(filename, 'w') { |io| io.write('test') }
+    end
+
+    # Get all files
+    output_expected = {
+      './foo'       => [ 'yaml', 'html'     ],
+      './bar'       => [ nil,    'html.erb' ],
+      './foo/qux'   => [ 'yaml', nil        ]
+    }
+    output_actual = data_source.send :all_split_files_in, '.'
+
+    # Check
+    assert_equal output_expected, output_actual
+  end
+
+  def test_all_split_files_in_with_multiple_content_files
+    # Create data source
+    data_source = Nanoc3::DataSources::FilesystemCompact.new(nil, nil, nil, nil)
+
+    # Write sample files
+    %w( foo.html foo.xhtml foo.txt foo.yaml bar.html qux.yaml ).each do |filename|
+      File.open(filename, 'w') { |io| io.write('test') }
+    end
+
+    # Check
+    assert_raises RuntimeError do
+      data_source.send :all_split_files_in, '.'
+    end
+  end
+
+  def test_basename_of_allowing_periods_in_identifiers
+    # Create data source
+    data_source = Nanoc3::DataSources::FilesystemCompact.new(nil, nil, nil, { :allow_periods_in_identifiers => true })
+
+    # Get input and expected output
+    expected = {
+      '/'                 => '/',
+      '/foo'              => '/foo',
+      '/foo.html'         => '/foo',
+      '/foo.xyz.html'     => '/foo.xyz',
+      '/foo/'             => '/foo/',
+      '/foo.xyz/'         => '/foo.xyz/',
+      '/foo/bar'          => '/foo/bar',
+      '/foo/bar.html'     => '/foo/bar',
+      '/foo/bar.xyz.html' => '/foo/bar.xyz',
+      '/foo/bar/'         => '/foo/bar/',
+      '/foo/bar.xyz/'     => '/foo/bar.xyz/',
+      '/foo.xyz/bar.xyz/' => '/foo.xyz/bar.xyz/'
+    }
+
+    # Check
+    expected.each_pair do |input, expected_output|
+      actual_output = data_source.send(:basename_of, input)
+      assert_equal(
+        expected_output, actual_output,
+        "basename_of(#{input.inspect}) should equal #{expected_output.inspect}, not #{actual_output.inspect}"
+      )
+    end
+  end
+
+  def test_basename_of_disallowing_periods_in_identifiers
+    # Create data source
+    data_source = Nanoc3::DataSources::FilesystemCompact.new(nil, nil, nil, nil)
+
+    # Get input and expected output
+    expected = {
+      '/'                 => '/',
+      '/foo'              => '/foo',
+      '/foo.html'         => '/foo',
+      '/foo.xyz.html'     => '/foo',
+      '/foo/'             => '/foo/',
+      '/foo.xyz/'         => '/foo.xyz/',
+      '/foo/bar'          => '/foo/bar',
+      '/foo/bar.html'     => '/foo/bar',
+      '/foo/bar.xyz.html' => '/foo/bar',
+      '/foo/bar/'         => '/foo/bar/',
+      '/foo/bar.xyz/'     => '/foo/bar.xyz/',
+      '/foo.xyz/bar.xyz/' => '/foo.xyz/bar.xyz/'
+    }
+
+    # Check
+    expected.each_pair do |input, expected_output|
+      actual_output = data_source.send(:basename_of, input)
+      assert_equal(
+        expected_output, actual_output,
+        "basename_of(#{input.inspect}) should equal #{expected_output.inspect}, not #{actual_output.inspect}"
+      )
+    end
+  end
+
+  def test_ext_of_allowing_periods_in_identifiers
+    # Create data source
+    data_source = Nanoc3::DataSources::FilesystemCompact.new(nil, nil, nil, { :allow_periods_in_identifiers => true })
+
+    # Get input and expected output
+    expected = {
+      '/'                 => '',
+      '/foo'              => '',
+      '/foo.html'         => '.html',
+      '/foo.xyz.html'     => '.html',
+      '/foo/'             => '',
+      '/foo.xyz/'         => '',
+      '/foo/bar'          => '',
+      '/foo/bar.html'     => '.html',
+      '/foo/bar.xyz.html' => '.html',
+      '/foo/bar/'         => '',
+      '/foo/bar.xyz/'     => '',
+      '/foo.xyz/bar.xyz/' => ''
+    }
+
+    # Check
+    expected.each_pair do |input, expected_output|
+      actual_output = data_source.send(:ext_of, input)
+      assert_equal(
+        expected_output, actual_output,
+        "basename_of(#{input.inspect}) should equal #{expected_output.inspect}, not #{actual_output.inspect}"
+      )
+    end
+  end
+
+  def test_ext_of_disallowing_periods_in_identifiers
+    # Create data source
+    data_source = Nanoc3::DataSources::FilesystemCompact.new(nil, nil, nil, nil)
+
+    # Get input and expected output
+    expected = {
+      '/'                 => '',
+      '/foo'              => '',
+      '/foo.html'         => '.html',
+      '/foo.xyz.html'     => '.xyz.html',
+      '/foo/'             => '',
+      '/foo.xyz/'         => '',
+      '/foo/bar'          => '',
+      '/foo/bar.html'     => '.html',
+      '/foo/bar.xyz.html' => '.xyz.html',
+      '/foo/bar/'         => '',
+      '/foo/bar.xyz/'     => '',
+      '/foo.xyz/bar.xyz/' => ''
+    }
+
+    # Check
+    expected.each_pair do |input, expected_output|
+      actual_output = data_source.send(:ext_of, input)
+      assert_equal(
+        expected_output, actual_output,
+        "basename_of(#{input.inspect}) should equal #{expected_output.inspect}, not #{actual_output.inspect}"
+      )
+    end
+  end
+
+  def test_parse_embedded_invalid_2
+    # Create a file
+    File.open('test.html', 'w') do |io|
+      io.write "-----\n"
+      io.write "blah blah\n"
+    end
+
+    # Create data source
+    data_source = Nanoc3::DataSources::FilesystemCombined.new(nil, nil, nil, nil)
+
+    # Parse it
+    assert_raises(RuntimeError) do
+      data_source.instance_eval { parse('test.html', nil, 'foobar') }
+    end
+  end
+
+  def test_parse_embedded_full_meta
+    # Create a file
+    File.open('test.html', 'w') do |io|
+      io.write "-----\n"
+      io.write "foo: bar\n"
+      io.write "-----\n"
+      io.write "blah blah\n"
+    end
+
+    # Create data source
+    data_source = Nanoc3::DataSources::FilesystemCombined.new(nil, nil, nil, nil)
+
+    # Parse it
+    result = data_source.instance_eval { parse('test.html', nil, 'foobar') }
+    assert_equal({ 'foo' => 'bar' }, result[0])
+    assert_equal('blah blah', result[1])
+  end
+
+  def test_parse_embedded_empty_meta
+    # Create a file
+    File.open('test.html', 'w') do |io|
+      io.write "-----\n"
+      io.write "-----\n"
+      io.write "blah blah\n"
+    end
+
+    # Create data source
+    data_source = Nanoc3::DataSources::FilesystemCombined.new(nil, nil, nil, nil)
+
+    # Parse it
+    result = data_source.instance_eval { parse('test.html', nil, 'foobar') }
+    assert_equal({}, result[0])
+    assert_equal('blah blah', result[1])
+  end
+
+  def test_parse_embedded_no_meta
+    content = "blah\n" \
+      "blah blah blah\n" \
+      "blah blah\n"
+
+    # Create a file
+    File.open('test.html', 'w') { |io| io.write(content) }
+
+    # Create data source
+    data_source = Nanoc3::DataSources::FilesystemCombined.new(nil, nil, nil, nil)
+
+    # Parse it
+    result = data_source.instance_eval { parse('test.html', nil, 'foobar') }
+    assert_equal({}, result[0])
+    assert_equal(content, result[1])
+  end
+
+  def test_parse_external
+    # Create a file
+    File.open('test.html', 'w') { |io| io.write("blah blah") }
+    File.open('test.yaml', 'w') { |io| io.write("foo: bar") }
+
+    # Create data source
+    data_source = Nanoc3::DataSources::FilesystemCombined.new(nil, nil, nil, nil)
+
+    # Parse it
+    result = data_source.instance_eval { parse('test.html', 'test.yaml', 'foobar') }
+    assert_equal({ "foo" => "bar"}, result[0])
+    assert_equal("blah blah",       result[1])
+  end
+
+end