usmu 0.1.0

data/lib/usmu/page.rb

@@ -0,0 +1,19 @@
+
+module Usmu
+  # Represents a page in the source directory of the website.
+  class Page < Layout
+    protected
+
+    # @!attribute [r] content_path
+    # @return [string] the base path to the files used by this class.
+    #
+    # Returns the base path to the files used by this class.
+    #
+    # This folder should be the parent folder for the file named by the name attribute.
+    #
+    # @see #name
+    def content_path
+      @configuration.source_path
+    end
+  end
+end

data/lib/usmu/site_generator.rb

@@ -0,0 +1,82 @@
+require 'fileutils'
+
+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)
+      @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
+    end
+
+    # @!attribute [r] renderables
+    # @return [Array<Usmu::StaticFile>] a list of renderable files from the source folder.
+    #   will be a subclass of this class.
+    # @see Usmu::StaticFile
+    #
+    # Returns a list of renderable files from the source folder.
+    #
+    # 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
+    end
+
+    # @!attribute [r] pages
+    # @return [Array<Usmu::Page>] a list of pages from the source folder. This is any file in the source folder which
+    #   is not static.
+    def pages
+      renderables.select {|r| r.class.name != 'Usmu::StaticFile'}
+    end
+
+    # @!attribute [r] files
+    # @return [Array<Usmu::StaticFile>] a list of static files from the source folder.
+    def files
+      renderables.select {|r| r.class.name == 'Usmu::StaticFile'}
+    end
+
+    # Generate the website according to the configuration given.
+    #
+    # @return [void]
+    def generate
+      renderables.each do |page|
+        file = File.join(@configuration.destination_path, page.output_filename)
+        directory = File.dirname(file)
+
+        unless File.directory?(directory)
+          FileUtils.mkdir_p(directory)
+        end
+
+        File.write file, page.render
+      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

@@ -0,0 +1,39 @@
+
+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
+    # @!attribute [r] name
+    # @return [String] the name of the file in the source directory
+    attr_reader :name
+
+    # @param configuration [Usmu::Configuration] The configuration for the website we're generating.
+    # @param name [String] The name of the file in the source directory.
+    # @param type [String] The type of template to use with the file. Not used for StaticFile.
+    #   Used for testing purposes.
+    # @param content [String] The content of the file. Used for testing purposes.
+    # @param metadata [String] The metadata for the file. Used for testing purposes.
+    def initialize(configuration, name, type = nil, content = nil, metadata = nil)
+      @configuration = configuration
+      @name = name
+      @type = type
+      @content = content
+    end
+
+    # Renders the file with any templating language required and returns the result
+    #
+    # @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))
+    end
+
+    # @!attribute [r] output_filename
+    # @return [String] the filename to use in the output directory.
+    #
+    # Returns the filename to use for the output directory with any modifications to the input filename required.
+    def output_filename
+      @name
+    end
+  end
+end

data/lib/usmu/ui.rb

@@ -0,0 +1,7 @@
+require 'usmu'
+
+module Usmu
+  # This module is for all the different UI's. If you implement a custom UI it should be added here.
+  module Ui
+  end
+end

data/lib/usmu/ui/console.rb

@@ -0,0 +1,26 @@
+require 'usmu'
+require 'trollop'
+
+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] configuration
+      # @return [Usmu::Configuration] the configuration for the site we will generate.
+      attr_reader :configuration
+
+      # @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'))
+      end
+
+      # This will run the command as setup in `#initialize`
+      #
+      # @return [void]
+      def execute
+        Usmu::SiteGenerator.new(@configuration).generate
+      end
+    end
+  end
+end

data/lib/usmu/version.rb

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

data/test/expected-site/default.html

@@ -0,0 +1,3 @@
+<h1>Default output</h1>
+
+<p>No metadata for this file. Uh oh!</p>

data/test/expected-site/embedded.html

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Default Title | Testing website</title>
+  </head>
+  <body>
+    <div id="content">
+      <div class="embedded">
+        <h1>Embedded test</h1>
+        
+      </div>
+      
+    </div>
+  </body>
+</html>

data/test/expected-site/index.html

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Default Title | Testing website</title>
+  </head>
+  <body>
+    <div id="content">
+      <h1>Test index</h1>
+      
+      <p>This is some test content</p>
+      
+    </div>
+  </body>
+</html>

data/test/expected-site/robots.txt

@@ -0,0 +1 @@
+User-agent: *

data/test/features/generator.feature

@@ -0,0 +1,10 @@
+
+Feature:
+  In order to create a website
+  As a user
+  I would like to generate a static website
+
+  Scenario:
+    Given I have a site at "test/site"
+    When I generate the site
+    Then the destination directory should match "test/expected-site"

data/test/features/step_definitions/step_general.rb

@@ -0,0 +1,18 @@
+require 'usmu/ui/console'
+require 'open3'
+
+Given(/^I have a site at "([^"]*)"$/) do |location|
+  @site = Usmu::Ui::Console.new([location])
+end
+
+When(/^I generate the site$/) do
+  @site.execute
+end
+
+Then(/^the destination directory should match "([^"]*)"$/) 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

data/test/site/content/default.md

@@ -0,0 +1,3 @@
+# Default output
+
+No metadata for this file. Uh oh!

data/test/site/content/embedded.md

@@ -0,0 +1 @@
+# Embedded test

data/test/site/content/embedded.meta.yml

@@ -0,0 +1,2 @@
+---
+layout: embedded

data/test/site/content/index.md

@@ -0,0 +1,3 @@
+# Test index
+
+This is some test content

data/test/site/content/index.meta.yml

@@ -0,0 +1,3 @@
+---
+title: Index page
+layout: html

data/test/site/content/robots.txt

@@ -0,0 +1 @@
+User-agent: *

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

@@ -0,0 +1,2 @@
+---
+layout: html

data/test/site/layouts/embedded.slim

@@ -0,0 +1,2 @@
+.embedded
+  | #{{content}}

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

@@ -0,0 +1,2 @@
+---
+title: Default Title

data/test/site/layouts/html.slim

@@ -0,0 +1,8 @@
+doctype html
+html
+  head
+    title #{title} | #{site['title']}
+
+  body
+    #content
+      | #{{content}}

data/test/site/usmu.yml

@@ -0,0 +1,15 @@
+---
+
+source: content
+destination: site
+title: Testing website
+
+default meta:
+  title: Test website
+  layout: html
+
+slim:
+  :pretty: true
+
+kramdown:
+  :auto_ids: false

data/test/spec/configuration_spec.rb

@@ -0,0 +1,51 @@
+require 'rspec'
+require 'usmu/configuration'
+
+RSpec.describe Usmu::Configuration do
+  context 'should prepend configuration folder' do
+    before do
+      hash = {
+          'source' => 'source',
+          'destination' => 'destination',
+          'layouts' => 'templates',
+      }
+      @configuration = Usmu::Configuration.from_hash(hash, 'test/usmu.yaml')
+    end
+
+    it 'to source' do
+      expect(@configuration.source_path).to eq('test/source')
+    end
+
+    it 'to destination' do
+      expect(@configuration.destination_path).to eq('test/destination')
+    end
+
+    it 'to layouts' do
+      expect(@configuration.layouts_path).to eq('test/templates')
+    end
+  end
+
+  context 'should have a default path' do
+    before do
+      hash = {}
+      @configuration = Usmu::Configuration.from_hash(hash)
+    end
+
+    it 'for source' do
+      expect(@configuration.source_path).to eq('src')
+    end
+
+    it 'for destination' do
+      expect(@configuration.destination_path).to eq('site')
+    end
+
+    it 'for layouts' do
+      expect(@configuration.layouts_path).to eq('layouts')
+    end
+  end
+
+  it 'should remember arbitrary configuration' do
+    configuration = Usmu::Configuration.from_hash({:test => 'foo'})
+    expect(configuration[:test]).to eq('foo')
+  end
+end

data/test/spec/layout_spec.rb

@@ -0,0 +1,27 @@
+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') }
+
+  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
+  end
+end

data/test/spec/page_spec.rb

@@ -0,0 +1,15 @@
+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') }
+
+  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'))
+  end
+end

data/test/spec/site_generator_spec.rb

@@ -0,0 +1,32 @@
+require 'rspec'
+require 'usmu/site_generator'
+
+RSpec.describe Usmu::SiteGenerator do
+  let(:configuration) { Usmu::Configuration.from_file('test/site/usmu.yml') }
+  let(:generator) { Usmu::SiteGenerator.new(configuration) }
+
+  it 'should have layouts' do
+    expect(generator.respond_to? :layouts).to eq(true)
+    expect(generator.layouts.map {|l| l.name}.sort).to eq(%w{embedded.slim html.slim})
+  end
+
+  it 'should have a list of renderable items' do
+    expect(generator.respond_to? :renderables).to eq(true)
+    expect(generator.renderables.map {|r| r.name}.sort).to eq(%w{default.md embedded.md index.md robots.txt})
+  end
+
+  it 'should have pages' do
+    expect(generator.respond_to? :pages).to eq(true)
+    expect(generator.pages.map {|p| p.name}.sort).to eq(%w{default.md embedded.md index.md})
+  end
+
+  it 'should have files' do
+    expect(generator.respond_to? :files).to eq(true)
+    expect(generator.files.map {|f| f.name}.sort).to eq(%w{robots.txt})
+  end
+
+  it 'should be able to generate a site' do
+    expect(generator.respond_to? :generate).to eq(true)
+    # Further testing is exercised at the system integration level in the cukes.
+  end
+end