usmu 0.1.0 → 0.2.0

data/lib/usmu/plugin/core.rb

@@ -0,0 +1,23 @@
+
+module Usmu
+  class Plugin
+    class Core
+      def commands(ui, c)
+        @log = Logging.logger[self]
+        @log.debug('Adding core console commands...')
+        @ui = ui
+        c.command(:generate) do |command|
+          command.syntax = 'usmu generate'
+          command.description = 'Generates your website using the configuration specified.'
+          command.action &method(:command_generate)
+        end
+      end
+
+      # @return [void]
+      def command_generate(args, options)
+        @site_generator = Usmu::SiteGenerator.new(@ui.configuration)
+        @site_generator.generate
+      end
+    end
+  end
+end

data/lib/usmu/site_generator.rb

@@ -1,17 +1,21 @@
 require 'fileutils'
+require 'usmu/configuration'
+require 'usmu/page'
+require 'usmu/static_file'
 
 module Usmu
   # This is the class that brings everything together to generate a new website.
   class SiteGenerator
     # @param [Usmu::Configuration] configuration The configuration to use for generating the website
     def initialize(configuration)
+      @log = Logging.logger[self]
       @configuration = configuration
     end
 
     # @!attribute [r] layouts
     # @return [Array<Usmu::Layout>] a list of layouts available in this website.
     def layouts
-      get_renderables @configuration.layouts_path, true
+      @configuration.layouts_files.map {|l| Usmu::Layout.new(@configuration, l) }
     end
 
     # @!attribute [r] renderables
@@ -24,7 +28,13 @@ module Usmu
     # The only guarantee made for individual files is that they will conform to the interface defined by
     # Usmu::StaticFile and thus be renderable, however most files will be one of the subclasses of that class.
     def renderables
-      get_renderables @configuration.source_path, false
+      @configuration.source_files.map do |filename|
+        if Usmu::Layout.is_valid_file? 'source', filename
+          Usmu::Page.new(@configuration, filename)
+        else
+          Usmu::StaticFile.new(@configuration, filename)
+        end
+      end
     end
 
     # @!attribute [r] pages
@@ -44,7 +54,11 @@ module Usmu
     #
     # @return [void]
     def generate
+      @log.info("Source: #{@configuration.source_path}")
+      @log.info("Destination: #{@configuration.destination_path}")
+
       renderables.each do |page|
+        @log.success("creating #{page.output_filename}...")
         file = File.join(@configuration.destination_path, page.output_filename)
         directory = File.dirname(file)
 
@@ -53,30 +67,9 @@ module Usmu
         end
 
         File.write file, page.render
+        FileUtils.touch file, :mtime => File.stat(page.input_path).mtime
       end
       nil
     end
-
-    private
-
-    # Helper function to search a directory recursively and return a list of files that are renderable.
-    #
-    # @param [String] directory the directory to search
-    # @param [Boolean] layout is this directory a layouts_path
-    # @return [Array<Usmu::Layout>, Array<Usmu::StaticFile>] Either an array of Layouts or StaticFiles in the directory
-    def get_renderables(directory, layout)
-      Dir["#{directory}/**/*"].select {|f| !f.match(/\.meta.yml$/) }.map do |f|
-        filename = f[(directory.length + 1)..f.length]
-        if layout
-          Usmu::Layout.new(@configuration, filename)
-        else
-          if Usmu::Layout.is_valid_file? 'source', filename
-            Usmu::Page.new(@configuration, filename)
-          else
-            Usmu::StaticFile.new(@configuration, filename)
-          end
-        end
-      end
-    end
   end
 end

data/lib/usmu/static_file.rb

@@ -1,8 +1,11 @@
+require 'usmu/configuration'
 
 module Usmu
   # Represents a static file which should be transferred to the destination unchanged. This also acts as the base
   # class for all layouts and page types. The basic interface defined here is used to process all types of files.
   class StaticFile
+    @log = Logging.logger[self]
+
     # @!attribute [r] name
     # @return [String] the name of the file in the source directory
     attr_reader :name
@@ -25,7 +28,13 @@ module Usmu
     # @param variables [Hash] Variables to be used in the template.
     # @return [String] The rendered file
     def render(variables = {})
-      @content || File.read(File.join(@configuration.source_path, @name))
+      @content || File.read(input_path)
+    end
+
+    # @!attribute [r] input_path
+    # @return [String] the full path to the file in the source directory
+    def input_path
+      File.join(@configuration.source_path, @name)
     end
 
     # @!attribute [r] output_filename

data/lib/usmu/ui/console.rb

@@ -1,25 +1,53 @@
 require 'usmu'
-require 'trollop'
+require 'commander'
 
 module Usmu
   module Ui
     # This is the CLI UI controller. This is initialised by the usmu binary to control the generation process.
     class Console
+      # @!attribute [r] site_generator
+      # @return [Usmu::SiteGenerator]
+      attr_reader :site_generator
+
       # @!attribute [r] configuration
+      # Do not access this till your command starts running, eg. in Hooks#commands, otherwise you may not get the right
+      # value for the configuration as option parsing may not have happened yet.
       # @return [Usmu::Configuration] the configuration for the site we will generate.
-      attr_reader :configuration
+      def configuration
+        @configuration || load_configuration('usmu.yml')
+      end
 
-      # @param [Array<String>] args Command line arguments. Typically ARGV should be passed here.
       def initialize(args)
-        @args = args
-        @configuration = Usmu::Configuration.from_file(File.join(args[0] || '.', 'usmu.yml'))
+        @log = Logging.logger[self]
+        @commander = Commander::Runner.new args
+
+        @commander.program :version, Usmu::VERSION
+        @commander.program :description, 'Static site generator powered by Tilt'
+        @commander.program :int_message, 'Interrupt received, closing...'
+
+        @commander.global_option('-v', '--verbose') { Usmu.verbose_logging }
+        @commander.global_option('-q', '--quiet') { Usmu.quiet_logging }
+        @commander.global_option('--log STRING', String) {|log| Usmu.add_file_logger(log) }
+        @commander.global_option('--config STRING', String, &method(:load_configuration))
+
+        Usmu.plugins.load_plugins
+        Usmu.plugins.invoke :commands, self, @commander
+
+        @commander.default_command :generate
+        @commander.run!
       end
 
-      # This will run the command as setup in `#initialize`
-      #
-      # @return [void]
-      def execute
-        Usmu::SiteGenerator.new(@configuration).generate
+      def load_configuration(config)
+        @log.info("Usmu v#{Usmu::VERSION}")
+        @log.info('')
+
+        if File.readable? config
+          @configuration = Usmu::Configuration.from_file(config)
+          @log.info("Configuration: #{config}")
+        else
+          @log.fatal("Unable to find configuration file at #{config}")
+          raise
+        end
       end
     end
   end

data/lib/usmu/version.rb

@@ -1,5 +1,5 @@
 
 module Usmu
-  # The current versions string for the gem
-  VERSION = '0.1.0'
+  # The current version string for the gem
+  VERSION = '0.2.0'
 end

data/test/expected-site/default.html

@@ -1,3 +1,14 @@
-<h1>Default output</h1>
-
-<p>No metadata for this file. Uh oh!</p>
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Default Title | Testing website</title>
+  </head>
+  <body>
+    <div id="content">
+      <h1>Default output</h1>
+      
+      <p>No metadata for this file. Uh oh!</p>
+      
+    </div>
+  </body>
+</html>

data/test/site/layouts/html.meta.yml

@@ -1,2 +1,3 @@
 ---
 title: Default Title
+layout: none

data/test/{features/generator.feature → spec/acceptance/full_site_build.feature}

@@ -8,3 +8,4 @@ Feature:
     Given I have a site at "test/site"
     When I generate the site
     Then the destination directory should match "test/expected-site"
+    And the modification time for the input file "index.md" should match the output file "index.html"

data/test/spec/acceptance/steps/full_site_build_steps.rb

@@ -0,0 +1,24 @@
+require 'usmu/ui/console'
+require 'open3'
+
+step 'I have a site at :location' do |location|
+  @location = "#{location}/usmu.yml"
+end
+
+step 'I generate the site' do
+  @site = Usmu::Ui::Console.new(['generate', '--config', @location])
+end
+
+step 'the destination directory should match :test_folder' do |test_folder|
+  run = %W{diff -qr #{@site.configuration.destination_path} #{test_folder}}
+  Open3.popen2e(*run) do |i, o, t|
+    output = run.join(' ') + "\n" + o.read
+    fail output if t.value != 0
+  end
+end
+
+step 'the modification time for the input file :input should match the output file :output' do |input, output|
+  input_mtime = File.stat(File.join(@site.configuration.source_path, input)).mtime
+  output_mtime = File.stat(File.join(@site.configuration.destination_path, output)).mtime
+  expect(input_mtime).to eq(output_mtime)
+end

data/test/spec/configuration_spec.rb

@@ -1,4 +1,3 @@
-require 'rspec'
 require 'usmu/configuration'
 
 RSpec.describe Usmu::Configuration do
@@ -44,8 +43,98 @@ RSpec.describe Usmu::Configuration do
     end
   end
 
+  it 'should have a list of source files' do
+    @configuration = Usmu::Configuration.from_hash({})
+    allow(Dir).to receive(:'[]').with('src/**/*').and_return(%w(src/index.md src/test.md))
+    expect(@configuration.source_files).to eq(%w(index.md test.md))
+  end
+
+  it 'should ignore metadata files in the source folder' do
+    @configuration = Usmu::Configuration.from_hash({})
+    allow(Dir).to receive(:'[]').with('src/**/*').and_return(%w(src/index.md src/index.meta.yml src/test.md))
+    expect(@configuration.source_files).to eq(%w(index.md test.md))
+  end
+
+  it 'should have a list of layouts files' do
+    @configuration = Usmu::Configuration.from_hash({})
+    allow(Dir).to receive(:'[]').with('layouts/**/*').and_return(%w(layouts/html.slim layouts/page.slim))
+    expect(@configuration.layouts_files).to eq(%w(html.slim page.slim))
+  end
+
+  it 'should ignore metadata files in the layouts folder' do
+    @configuration = Usmu::Configuration.from_hash({})
+    allow(Dir).to receive(:'[]').with('layouts/**/*').and_return(%w(layouts/html.slim layouts/html.meta.yml layouts/page.slim))
+    expect(@configuration.layouts_files).to eq(%w(html.slim page.slim))
+  end
+
   it 'should remember arbitrary configuration' do
     configuration = Usmu::Configuration.from_hash({:test => 'foo'})
     expect(configuration[:test]).to eq('foo')
   end
+
+  context 'should exclude files from source' do
+    it 'as specified' do
+      @configuration = Usmu::Configuration.from_hash({'exclude' => ['foo.md']})
+      allow(Dir).to receive(:'[]').with('src/**/*').and_return(%w(src/index.md src/foo.md))
+      expect(@configuration.source_files).to eq(%w(index.md))
+    end
+
+    it 'in ignored folders if trailing "/" is used' do
+      @configuration = Usmu::Configuration.from_hash({'exclude' => ['test/']})
+      allow(Dir).to receive(:'[]').with('src/**/*').and_return(%w(src/index.md src/test/foo/test.md src/test/foo.md))
+      expect(@configuration.source_files).to eq(%w(index.md))
+    end
+
+    it 'and honor *' do
+      @configuration = Usmu::Configuration.from_hash({'exclude' => ['*/foo.md']})
+      allow(Dir).to receive(:'[]').with('src/**/*').and_return(%w(src/index.md src/test/foo/foo.md src/test/foo.md))
+      expect(@configuration.source_files).to eq(%w(index.md test/foo/foo.md))
+    end
+
+    it 'and * ignores folders without a trailing /' do
+      @configuration = Usmu::Configuration.from_hash({'exclude' => ['*']})
+      allow(Dir).to receive(:'[]').with('src/**/*').and_return(%w(src/index.md src/test/foo.md src/test.md))
+      expect(@configuration.source_files).to eq(%w(test/foo.md))
+    end
+
+    it 'and honor **' do
+      @configuration = Usmu::Configuration.from_hash({'exclude' => ['**/foo.md']})
+      allow(Dir).to receive(:'[]').with('src/**/*').and_return(%w(src/index.md src/test/foo/foo.md src/test/foo.md))
+      expect(@configuration.source_files).to eq(%w(index.md))
+    end
+
+    it 'and honor []' do
+      @configuration = Usmu::Configuration.from_hash({'exclude' => ['[ab].md']})
+      allow(Dir).to receive(:'[]').with('src/**/*').and_return(%w(src/index.md src/a.md src/b.md))
+      expect(@configuration.source_files).to eq(%w(index.md))
+    end
+
+    # FNM_EXTGLOB is supported from MRI 2.0 onwards. We also support the 1.9.3 ABI for JRuby and Rubinius sake. Only
+    # run this test if it's possible for it to pass.
+    if defined?(File::FNM_EXTGLOB)
+      it 'and honor {a,b}' do
+        @configuration = Usmu::Configuration.from_hash({'exclude' => ['{a,b}.md']})
+        allow(Dir).to receive(:'[]').with('src/**/*').and_return(%w(src/index.md src/a.md src/b.md))
+        expect(@configuration.source_files).to eq(%w(index.md))
+      end
+    end
+
+    it 'and honor \\ as an escape' do
+      @configuration = Usmu::Configuration.from_hash({'exclude' => ['\*.md']})
+      allow(Dir).to receive(:'[]').with('src/**/*').and_return(%w(src/index.md src/*.md))
+      expect(@configuration.source_files).to eq(%w(index.md))
+    end
+
+    it 'and honor ?' do
+      @configuration = Usmu::Configuration.from_hash({'exclude' => ['?.md']})
+      allow(Dir).to receive(:'[]').with('src/**/*').and_return(%w(src/index.md src/a.md src/b.md))
+      expect(@configuration.source_files).to eq(%w(index.md))
+    end
+
+    it 'and ignore files inside folders specified via globs with trailing "/"' do
+      @configuration = Usmu::Configuration.from_hash({'exclude' => ['test/*/']})
+      allow(Dir).to receive(:'[]').with('src/**/*').and_return(%w(src/index.md src/test/foo/foo.md src/test/foo.md))
+      expect(@configuration.source_files).to eq(%w(index.md test/foo.md))
+    end
+  end
 end

data/test/spec/layout_spec.rb

@@ -1,27 +1,19 @@
-require 'rspec'
 require 'support/shared_layout'
 require 'usmu/layout'
 
 RSpec.describe Usmu::Layout do
   it_behaves_like 'an embeddable layout'
 
-  let(:configuration) { Usmu::Configuration.from_file('test/site/usmu.yml') }
+  let(:configuration) { Usmu::Configuration.from_hash({}) }
 
   it 'uses the \'layouts\' folder' do
-    layout = Usmu::Layout.new(configuration, 'html.slim')
-    rendered = layout.render({'content' => 'test'})
-    expect(rendered).to eq(<<-EOF)
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>Default Title | Testing website</title>
-  </head>
-  <body>
-    <div id="content">
-      test
-    </div>
-  </body>
-</html>
-    EOF
+    layout = Usmu::Layout.new(configuration, 'html.slim', 'slim', "head\nbody", {})
+    expect(layout.send :content_path).to eq('layouts')
+  end
+
+  it 'has an input path' do
+    layout = Usmu::Layout.new(configuration, 'html.slim', 'slim', "head\nbody", {})
+    expect(layout.respond_to? :input_path).to eq(true)
+    expect(layout.input_path).to eq('layouts/html.slim')
   end
 end

data/test/spec/mock/usmu/mock_plugin.rb

@@ -0,0 +1,8 @@
+
+module Usmu
+  class MockPlugin
+    # This will be stubbed in with a mock if important. This is simply a placeholder to make sure #respond_to? replies
+    # correctly
+    def test(*args); end
+  end
+end

data/test/spec/page_spec.rb

@@ -1,15 +1,19 @@
-require 'rspec'
 require 'support/shared_layout'
 require 'usmu/page'
 
 RSpec.describe Usmu::Page do
   it_behaves_like 'an embeddable layout'
 
-  let(:configuration) { Usmu::Configuration.from_file('test/site/usmu.yml') }
+  let(:configuration) { Usmu::Configuration.from_hash({}) }
 
   it 'uses the \'source\' folder' do
-    page = Usmu::Page.new(configuration, 'index.md')
-    rendered = page.render({})
-    expect(rendered).to eq(File.read('test/expected-site/index.html'))
+    page = Usmu::Page.new(configuration, 'index.md', 'md', '# test', {})
+    expect(page.send :content_path).to eq('src')
+  end
+
+  it 'has an input path' do
+    page = Usmu::Page.new(configuration, 'index.md', 'md', '# test', {})
+    expect(page.respond_to? :input_path).to eq(true)
+    expect(page.input_path).to eq('src/index.md')
   end
 end

data/test/spec/plugin/core_spec.rb

@@ -0,0 +1,5 @@
+require 'usmu/plugin/core'
+
+RSpec.describe Usmu::Plugin::Core do
+
+end