RubyGems - nanoc - Versions diffs - 1.6.2 → 2.0 - Mend

nanoc 1.6.2 → 2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (51) hide show

data/ChangeLog +27 -0
data/Rakefile +34 -27
data/bin/nanoc +153 -49
data/lib/nanoc.rb +15 -33
data/lib/nanoc/base/auto_compiler.rb +124 -0
data/lib/nanoc/base/compiler.rb +55 -0
data/lib/nanoc/base/core_ext/hash.rb +34 -0
data/lib/nanoc/base/data_source.rb +53 -0
data/lib/nanoc/base/enhancements.rb +89 -0
data/lib/nanoc/base/filter.rb +16 -0
data/lib/nanoc/base/layout_processor.rb +33 -0
data/lib/nanoc/base/page.rb +155 -0
data/lib/nanoc/base/page_proxy.rb +31 -0
data/lib/nanoc/base/plugin.rb +19 -0
data/lib/nanoc/base/plugin_manager.rb +33 -0
data/lib/nanoc/base/site.rb +143 -0
data/lib/nanoc/data_sources/database.rb +259 -0
data/lib/nanoc/data_sources/filesystem.rb +308 -0
data/lib/nanoc/data_sources/trivial.rb +145 -0
data/lib/nanoc/filters/erb.rb +34 -0
data/lib/nanoc/filters/haml.rb +16 -0
data/lib/nanoc/filters/markaby.rb +15 -0
data/lib/nanoc/filters/markdown.rb +13 -0
data/lib/nanoc/filters/rdoc.rb +14 -0
data/lib/nanoc/filters/smartypants.rb +13 -0
data/lib/nanoc/filters/textile.rb +13 -0
data/lib/nanoc/layout_processors/erb.rb +35 -0
data/lib/nanoc/layout_processors/haml.rb +18 -0
data/lib/nanoc/layout_processors/markaby.rb +16 -0
metadata +37 -30
data/lib/nanoc/compiler.rb +0 -145
data/lib/nanoc/core_ext.rb +0 -1
data/lib/nanoc/core_ext/array.rb +0 -17
data/lib/nanoc/core_ext/hash.rb +0 -43
data/lib/nanoc/core_ext/string.rb +0 -13
data/lib/nanoc/core_ext/yaml.rb +0 -10
data/lib/nanoc/creator.rb +0 -180
data/lib/nanoc/enhancements.rb +0 -101
data/lib/nanoc/filters.rb +0 -7
data/lib/nanoc/filters/eruby_filter.rb +0 -39
data/lib/nanoc/filters/haml_filter.rb +0 -18
data/lib/nanoc/filters/liquid_filter.rb +0 -47
data/lib/nanoc/filters/markaby_filter.rb +0 -15
data/lib/nanoc/filters/markdown_filter.rb +0 -13
data/lib/nanoc/filters/rdoc_filter.rb +0 -15
data/lib/nanoc/filters/sass_filter.rb +0 -13
data/lib/nanoc/filters/smartypants_filter.rb +0 -13
data/lib/nanoc/filters/textile_filter.rb +0 -13
data/lib/nanoc/page.rb +0 -171
data/lib/nanoc/page_drop.rb +0 -18
data/lib/nanoc/page_proxy.rb +0 -30

data/lib/nanoc/data_sources/filesystem.rb ADDED

@@ -0,0 +1,308 @@
+module Nanoc::DataSource::Filesystem
+  class FilesystemDataSource < Nanoc::DataSource
+    ########## Attributes ##########
+    identifier :filesystem
+    ########## Preparation ##########
+    def up
+    end
+    def down
+    end
+    def setup
+      # Create page
+      FileManager.create_file 'content/content.txt' do
+        "I'm a brand new root page. Please edit me!\n"
+      end
+      FileManager.create_file 'content/content.yaml' do
+        "# Built-in\n" +
+        "\n" +
+        "# Custom\n" +
+        "title: \"A New Root Page\"\n"
+      end
+      # Create page defaults
+      FileManager.create_file 'meta.yaml' do
+        "# This file contains the default values for all metafiles.\n" +
+        "# Other metafiles can override the contents of this one.\n" +
+        "\n" +
+        "# Built-in\n" +
+        "custom_path:  none\n" +
+        "extension:    \"html\"\n" +
+        "filename:     \"index\"\n" +
+        "filters_post: []\n" +
+        "filters_pre:  []\n" +
+        "is_draft:     false\n" +
+        "layout:       \"default\"\n" +
+        "skip_output:  false\n" +
+        "\n" +
+        "# Custom\n"
+      end
+      # Create template
+      FileManager.create_file 'templates/default/default.txt' do
+        "Hi, I'm a new page!\n"
+      end
+      FileManager.create_file 'templates/default/default.yaml' do
+        "# Built-in\n" +
+        "\n" +
+        "# Custom\n" +
+        "title: \"A New Page\"\n"
+      end
+      # Create layout
+      FileManager.create_file 'layouts/default.erb'  do
+        "<html>\n" +
+        "  <head>\n" +
+        "    <title><%= @page.title %></title>\n" +
+        "  </head>\n" +
+        "  <body>\n" +
+        "<%= @page.content %>\n" +
+        "  </body>\n" +
+        "</html>\n"
+      end
+      # Create code
+      FileManager.create_file 'lib/default.rb' do
+        "\# All files in the 'lib' directory will be loaded\n" +
+        "\# before nanoc starts compiling.\n" +
+        "\n" +
+        "def html_escape(str)\n" +
+        "  str.gsub('&', '&amp;').str('<', '&lt;').str('>', '&gt;').str('\"', '&quot;')\n" +
+        "end\n" +
+        "alias h html_escape\n"
+      end
+    end
+    ########## Loading data ##########
+    # The filesystem data source stores its pages in nested directories. Each
+    # directory represents a single page. The root directory is the 'content'
+    # directory.
+    #
+    # Every directory has a content file and a meta file. The content file
+    # contains the actual page content, while the meta file contains the
+    # page's metadata.
+    #
+    # Both content files and meta files are named after its parent directory
+    # (i.e. page). For example, a page named 'foo' will have a directory named
+    # 'foo', with e.g. a 'foo.markdown' content file and a 'foo.yaml' meta
+    # file.
+    #
+    # Content file extensions are ignored by nanoc. The content file extension
+    # does not determine the filters to run on it; the meta file defines the
+    # list of filters. The meta file extension must always be 'yaml', though.
+    #
+    # Content files can also have the 'index' basename. Similarly, meta files
+    # can have the 'meta' basename. For example, a parent directory named
+    # 'foo' can have an 'index.txt' content file and a 'meta.yaml' meta file.
+    # This is to preserve backward compatibility.
+    def pages
+      meta_filenames.inject([]) do |pages, filename|
+        # Read metadata
+        meta = (YAML.load_file(filename) || {}).clean
+        if meta[:is_draft]
+          # Skip drafts
+          pages
+        else
+          # Get extra info
+          path    = filename.sub(/^content/, '').sub(/[^\/]+\.yaml$/, '')
+          file    = content_file_for_dir(File.dirname(filename))
+          extras  = {
+            :path => path,
+            :file => file,
+            :uncompiled_content => file.read
+          }
+          # Add to list of pages
+          pages + [ meta.merge(extras) ]
+        end
+      end
+    end
+    # The page defaults are loaded from a 'meta.yaml' file
+    def page_defaults
+      (YAML.load_file('meta.yaml') || {}).clean
+    end
+    # Layouts are stored as files in the 'layouts' directory. Each layout has
+    # a basename (the part before the extension) and an extension. Unlike page
+    # content files, the extension _is_ used for determining the layout
+    # processor; which extension maps to which layout processor is defined in
+    # the layout processors.
+    def layouts
+      Dir["layouts/*"].reject { |f| f =~ /~$/ }.map do |filename|
+        # Get layout details
+        extension = File.extname(filename)
+        name      = File.basename(filename, extension)
+        content   = File.read(filename)
+        # Build hash for layout
+        { :name => name, :content => content, :extension => extension }
+      end
+    end
+    # Templates are located in the 'templates' directroy. Every template is a
+    # directory consisting of a content file and a meta file, both named after
+    # the template. This is very similar to the way pages are stored, except
+    # that templates cannot be nested.
+    def templates
+      meta_filenames('templates').inject([]) do |templates, filename|
+        # Get template name
+        name = filename.sub(/^templates\/(.*)\/[^\/]+\.yaml$/, '\1')
+        # Get file names
+        meta_filename       = filename
+        content_filenames   = Dir['templates/' + name + '/' + name + '.*'] +
+                              Dir['templates/' + name + '/index.*'] -
+                              Dir['templates/' + name + '/*.yaml' ]
+        # Read files
+        extension = nil
+        content   = nil
+        content_filenames.each do |content_filename|
+          content   = File.read(content_filename)
+          extension = File.extname(content_filename)
+        end
+        meta = File.read(meta_filename)
+        # Add it to the list of templates
+        templates + [{
+          :name       => name,
+          :extension  => extension,
+          :content    => content,
+          :meta       => meta
+        }]
+      end
+    end
+    # Code is stored in '.rb' files in the 'lib' directory. Code can reside
+    # in sub-directories.
+    def code
+      Dir['lib/**/*.rb'].sort.inject('') { |m, f| m + File.read(f) + "\n" }
+    end
+    ########## Creating data ##########
+    # Creating a page creates a page directory with the name of the page in
+    # the 'content' directory, as well as a content file named xxx.txt and a
+    # meta file named xxx.yaml (with xxx being the name of the page).
+    def create_page(path, template)
+      # Make sure path does not start or end with a slash
+      sanitized_path = path.gsub(/^\/+|\/+$/, '')
+      # Get paths
+      dir_path      = 'content/' + sanitized_path
+      name          = sanitized_path.sub(/.*\/([^\/]+)$/, '\1')
+      meta_path     = dir_path + '/' + name + '.yaml'
+      content_path  = dir_path + '/' + name + template[:extension]
+      # Make sure the page doesn't exist yet
+      error "A page named '#{path}' already exists." if File.exist?(meta_path)
+      # Create index and meta file
+      FileManager.create_file(meta_path)    { template[:meta] }
+      FileManager.create_file(content_path) { template[:content] }
+    end
+    # Creating a layout creates a single file in the 'layouts' directory,
+    # named xxx.erb (with xxx being the name of the layout).
+    def create_layout(name)
+      # Get details
+      path = 'layouts/' + name + '.erb'
+      # Make sure the layout doesn't exist yet
+      error "A layout named '#{name}' already exists." if File.exist?(path)
+      # Create layout file
+      FileManager.create_file(path) do
+        "<html>\n" +
+        "  <head>\n" +
+        "    <title><%= @page.title %></title>\n" +
+        "  </head>\n" +
+        "  <body>\n" +
+        "<%= @page.content %>\n" +
+        "  </body>\n" +
+        "</html>\n"
+      end
+    end
+    # Creating a template creates a template directory with the name of the
+    # template in the 'templates' directory, as well as a content file named
+    # xxx.txt and a meta file named xxx.yaml (with xxx being the name of the
+    # template).
+    def create_template(name)
+      # Get paths
+      meta_path    = 'templates/' + name + '/' + name + '.yaml'
+      content_path = 'templates/' + name + '/' + name + '.txt'
+      # Make sure the template doesn't exist yet
+      error "A template named '#{name}' already exists." if File.exist?(meta_path)
+      # Create index and meta file
+      FileManager.create_file(meta_path)    { "# Built-in\n\n# Custom\ntitle: A New Page\n" }
+      FileManager.create_file(content_path) { "Hi, I'm new here!\n" }
+    end
+  private
+    ########## Custom functions ##########
+    # Returns the list of meta files in the given (optional) base directory.
+    def meta_filenames(base='content')
+      # Find all possible meta file names
+      filenames = Dir[base + '/**/*.yaml']
+      # Filter out invalid meta files
+      good_filenames = []
+      bad_filenames  = []
+      filenames.each do |filename|
+        if filename =~ /meta\.yaml$/ or filename =~ /([^\/]+)\/\1\.yaml$/
+          good_filenames << filename
+        else
+          bad_filenames << filename
+        end
+      end
+      # Warn about bad filenames
+      unless bad_filenames.empty?
+        error "The following files appear to be meta files, " +
+              "but have an invalid name:\n  - " +
+              bad_filenames.join("\n  - ")
+      end
+      good_filenames
+    end
+    # Returns a File object for the content file in the given directory
+    def content_file_for_dir(dir)
+      # Find all files
+      filename_glob_1 = dir.sub(/([^\/]+)$/, '\1/\1.*')
+      filename_glob_2 = dir.sub(/([^\/]+)$/, '\1/index.*')
+      filenames = Dir[filename_glob_1] + Dir[filename_glob_2]
+      # Reject meta files
+      filenames.reject! { |f| f =~ /\.yaml$/ }
+      # Reject backups
+      filenames.reject! { |f| f =~ /~$/ }
+      # Make sure there is only one content file
+      if filenames.size != 1
+        error "Expected 1 content file in #{dir} but found #{filenames.size}"
+      end
+      # Read content file
+      File.new(filenames.first)
+    end
+  end
+end

data/lib/nanoc/data_sources/trivial.rb ADDED

@@ -0,0 +1,145 @@
+# This is the module where the trivial data source will live in. It's not
+# really _necessary_ to create a separate module/namespace for each data
+# source, but it can be useful, especially when the data source needs extra
+# classes (for example, the database data source defines uses ActiveRecord, so
+# it needs classes for each table).
+module Nanoc::DataSource::Trivial
+  # This is the implementation of a trivial data source. It doesn't do much
+  # except return bogus data. It is meant to be a very simple example of a
+  # data source, and it should be quite useful for those who want to write
+  # their own data sources.
+  class TrivialDataSource < Nanoc::DataSource
+    ########## Attributes ##########
+    # DataSource.identifier defines the name for this data source. The first
+    # and only argument is the data source name as a symbol.
+    identifier :trivial
+    ########## Preparation ##########
+    # DataSource#up is run before compiling. This is the place where you
+    # should initialize the data source, if necessary. You don't need to
+    # implement it; you can leave it out if you don't need initialization.
+    # This is the ideal place to connect to the database, for example.
+    # If your data source requires any special libraries, require them here
+    # using 'nanoc_require'.
+    def up
+    end
+    # DataSource#down is run after compiling. This is where you should clean
+    # up any resources you used during the site compilation. You don't need to
+    # implement it; you can leave it out if there's nothing to clean up. For
+    # example, this is a good place to close the connection to the database,
+    # if you have one.
+    def down
+    end
+    # DataSource#setup is run when the site is created. This is the place
+    # where you should create the data source for the first time. You don't
+    # need to implement it; you can leave it out if there's nothing to set up.
+    # For example, if you're using a database, this is where you should create
+    # the necessary tables for the data source to function properly.
+    def setup
+      error "Sorry. The trivial data source isn't competent enough."
+    end
+    ########## Loading data ##########
+    # DataSource#pages returns an array of hashes that represent pages. Each
+    # hash must have at least the :uncompiled_content and :path keys. You can
+    # include other metadata in this hash, though.
+    def pages
+      [
+        { :uncompiled_content => 'Hi!',          :path => '/'       },
+        { :uncompiled_content => 'Hello there.', :path => '/about/' }
+      ]
+    end
+    # Datasource#page_defaults returns a hash with default values for page
+    # metadata. This hash can be anything, even an empty hash if you wish.
+    def page_defaults
+      { :layout => 'quux' }
+    end
+    # DataSource#layouts returns an array of hashes that represent layouts.
+    # Each hash must have the :name, :content and :extension keys. The
+    # :extension key determines the layout processor that will be used (they
+    # are defined in layout_processors/*.rb).
+    def layouts
+      [
+        {
+          :name       => 'quux',
+          :content    => "<html>\n" +
+                         "  <head>\n" +
+                         "    <title><%= @page.title %></title>\n" +
+                         "  </head>\n" +
+                         "  <body>\n" +
+                         "<%= @page.content %>\n" +
+                         "  </body>\n" +
+                         "</html>",
+          :extension  => '.erb'
+        }
+      ]
+    end
+    # DataSource#templates returns an array of hashes that represent page
+    # templates. These page templates are used used by DataSource#create_page
+    # to create pages using a template. Each hash must have the :name key for
+    # identifying the template. Apart from that, you can structure the hash
+    # like you desire. I recommend having :content (for the page content) and
+    # :meta (for the page metadata) keys. Note that in this example, the value
+    # corresponding to the :meta key is a hash, but it could just as well have
+    # been a YAML-formatted string. Just make sure that what
+    # DataSource#templates serves is what DataSource#create_page expects.
+    def templates
+      [
+        {
+          :name     => 'default',
+          :content  => 'Hi, I am a new page. Please edit me!',
+          :meta     => { :title => 'A New Page' }
+        }
+      ]
+    end
+    # DataSource#code returns a string containing custom code which will be
+    # loaded before the site is compiled. This can be code for custom filters
+    # and layout processors, but pretty much any code can be put in there
+    # (global helper functions are very useful). It is possible to override
+    # methods of built-in nanoc classes, but doing so will likely cause
+    # massive breakage, so doing so is not recommended.
+    def code
+      "def foo ; 'bar' ; end"
+    end
+    ########## Creating data ##########
+    # DataSource#create_page is run when a page is created. This function
+    # should create a new page with the given name and using the given
+    # template. The template is a hash taken the array of hashes returned by
+    # DataSource#templates, so make sure that what DataSource#templates
+    # returns is what DataSource#create_page expects. This trivial data source
+    # doesn't have a permanent storage, so it can't create any pages.
+    def create_page(path, template)
+      error "Sorry. The trivial data source isn't competent enough."
+    end
+    # DataSource#create_layout is run when a layout is created. This function
+    # should create a new layout with the given name. This trivial data source
+    # doesn't have a permanent storage, so it can't create any layouts.
+    def create_layout(name)
+      error "Sorry. The trivial data source isn't competent enough."
+    end
+    # DataSource#create_template is run when a template is created. This
+    # function should create a new template with the given name. This trivial
+    # data source doesn't have a permanent storage, so it can't create any
+    # templates.
+    def create_template(name)
+      error "Sorry. The trivial data source isn't competent enough."
+    end
+  end
+end