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

nanoc 1.6.2 → 2.0

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