nanoc 3.2.4 → 3.3.0

data/lib/nanoc/data_sources/filesystem_unified.rb

@@ -0,0 +1,121 @@
+# encoding: utf-8
+
+module Nanoc::DataSources
+
+  # The filesystem_unified data source stores its items and layouts in nested
+  # directories. Items and layouts are represented by one or two files; if it
+  # is represented using one file, the metadata can be contained in this file.
+  # The root directory for items is the `content` directory; for layouts, this
+  # is the `layouts` directory.
+  #
+  # The metadata for items and layouts can be stored in a separate file with
+  # the same base name but with the `.yaml` extension. If such a file is
+  # found, metadata is read from that file. Alternatively, the content file
+  # itself can start with a metadata section: it can be stored at the top of
+  # the file, between `---` (three dashes) separators. For example:
+  #
+  #     ---
+  #     title: "Moo!"
+  #     ---
+  #     h1. Hello!
+  #
+  # The metadata section can be omitted. If the file does not start with
+  # three or five dashes, the entire file will be considered as content.
+  #
+  # The identifier of items and layouts is determined as follows. A file with
+  # an `index.*` filename, such as `index.txt`, will have the filesystem path
+  # with the `index.*` part stripped as a identifier. For example:
+  #
+  #     foo/bar/index.html → /foo/bar/
+  #
+  # In other cases, the identifier is calculated by stripping the extension.
+  # If the `allow_periods_in_identifiers` attribute in the configuration is
+  # true, only the last extension will be stripped if the file has multiple
+  # extensions; if it is false or unset, all extensions will be stripped.
+  # For example:
+  #
+  #     (`allow_periods_in_identifiers` set to true)
+  #     foo.entry.html → /foo.entry/
+  #     
+  #     (`allow_periods_in_identifiers` set to false)
+  #     foo.html.erb → /foo/
+  #
+  # Note that each item must have an unique identifier. nanoc will display an
+  # error if two items with the same identifier are found.
+  #
+  # Some more examples:
+  #
+  #     content/index.html          → /
+  #     content/foo.html            → /foo/
+  #     content/foo/index.html      → /foo/
+  #     content/foo/bar.html        → /foo/bar/
+  #     content/foo/bar.baz.html    → /foo/bar/ OR /foo/bar.baz/
+  #     content/foo/bar/index.html  → /foo/bar/
+  #     content/foo.bar/index.html  → /foo.bar/
+  #
+  # The file extension does not determine the filters to run on items; the
+  # Rules file is used to specify processing instructors for each item.
+  #
+  # It is possible to set an explicit encoding that should be used when reading
+  # files. In the data source configuration, set `encoding` to an encoding
+  # understood by Ruby’s `Encoding`. If no encoding is set in the configuration,
+  # one will be inferred from the environment.
+  class FilesystemUnified < Nanoc::DataSource
+
+    include Nanoc::DataSources::Filesystem
+
+  private
+
+    # See {Nanoc::DataSources::Filesystem#create_object}.
+    def create_object(dir_name, content, attributes, identifier, params={})
+      # Check for periods
+      if (@config.nil? || !@config[:allow_periods_in_identifiers]) && identifier.include?('.')
+        raise RuntimeError,
+          "Attempted to create an object in #{dir_name} with identifier #{identifier} containing a period, but allow_periods_in_identifiers is not enabled in the site configuration. (Enabling allow_periods_in_identifiers may cause the site to break, though.)"
+      end
+
+      # Determine path
+      ext = params[:extension] || '.html'
+      path = dir_name + (identifier == '/' ? '/index.html' : identifier[0..-2] + ext)
+      parent_path = File.dirname(path)
+
+      # Notify
+      Nanoc::NotificationCenter.post(:file_created, path)
+
+      # Write item
+      FileUtils.mkdir_p(parent_path)
+      File.open(path, 'w') do |io|
+        meta = attributes.stringify_keys
+        unless meta == {}
+          io.write(YAML.dump(meta).strip + "\n")
+          io.write("---\n\n")
+        end
+        io.write(content)
+      end
+    end
+
+    # See {Nanoc::DataSources::Filesystem#filename_for}.
+    def filename_for(base_filename, ext)
+      if ext.nil?
+        nil
+      elsif ext.empty?
+        base_filename
+      else
+        base_filename + '.' + ext
+      end
+    end
+
+    # Returns the identifier derived from the given filename, first stripping
+    # the given directory name off the filename.
+    def identifier_for_filename(filename)
+      if filename =~ /(^|\/)index\.[^\/]+$/
+        regex = ((@config && @config[:allow_periods_in_identifiers]) ? /\/?index\.[^\/\.]+$/ : /\/?index\.[^\/]+$/)
+      else
+        regex = ((@config && @config[:allow_periods_in_identifiers]) ? /\.[^\/\.]+$/         : /\.[^\/]+$/)
+      end
+      filename.sub(regex, '').cleaned_identifier
+    end
+
+  end
+
+end

data/lib/nanoc/data_sources/filesystem_verbose.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+module Nanoc::DataSources
+
+  # The filesystem_verbose data source is the old data source for a new nanoc
+  # site. It stores all data as files on the hard disk.
+  #
+  # None of the methods are documented in this file. See {Nanoc::DataSource}
+  # for documentation on the overridden methods instead.
+  #
+  # The filesystem_verbose data source stores its items and layouts in nested
+  # directories. Each directory represents a single item or layout. The root
+  # directory for items is the `content` directory; for layouts it is the
+  # `layouts` directory.
+  #
+  # Every directory has a content file and a meta file. The content file
+  # contains the actual item content, while the meta file contains the item’s
+  # or the layout’s metadata, formatted as YAML.
+  #
+  # Both content files and meta files are named after its parent directory
+  # (i.e. item). For example, an item/layout 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 not used for determining the filter that
+  # should be run; the meta file defines the list of filters. The meta file
+  # extension must always be `.yaml`, though.
+  #
+  # For backwards compatibility, 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.
+  #
+  # The identifier is calculated by stripping the extension; if there is more
+  # than one extension, only the last extension is stripped and the previous
+  # extensions will be part of the identifier.
+  #
+  # It is possible to set an explicit encoding that should be used when reading
+  # files. In the data source configuration, set `encoding` to an encoding
+  # understood by Ruby’s `Encoding`. If no encoding is set in the configuration,
+  # one will be inferred from the environment.
+  class FilesystemVerbose < Nanoc::DataSource
+
+    include Nanoc::DataSources::Filesystem
+
+  private
+
+    # See {Nanoc::DataSources::Filesystem#create_object}.
+    def create_object(dir_name, content, attributes, identifier, params={})
+      # Determine base path
+      last_component = identifier.split('/')[-1] || dir_name
+      base_path = dir_name + identifier + last_component
+
+      # Get filenames
+      ext = params[:extension] || '.html'
+      dir_path         = dir_name + identifier
+      meta_filename    = dir_name + identifier + last_component + '.yaml'
+      content_filename = dir_name + identifier + last_component + ext
+                                     
+      # Notify
+      Nanoc::NotificationCenter.post(:file_created, meta_filename)
+      Nanoc::NotificationCenter.post(:file_created, content_filename)
+
+      # Create files
+      FileUtils.mkdir_p(dir_path)
+      File.open(meta_filename,    'w') { |io| io.write(YAML.dump(attributes.stringify_keys)) }
+      File.open(content_filename, 'w') { |io| io.write(content) }
+    end
+
+    # See {Nanoc::DataSources::Filesystem#filename_for}.
+    def filename_for(base_filename, ext)
+      return nil if ext.nil?
+
+      last_component = base_filename[%r{[^/]+$}]
+      possibilities = [
+        base_filename + (ext.empty? ? '' : '.' + ext),                        # foo/bar.html
+        base_filename + '/' + last_component + (ext.empty? ? '' : '.' + ext), # foo/bar/bar.html
+        base_filename + '/' + 'index' + (ext.empty? ? '' : '.' + ext)         # foo/bar/index.html
+      ]
+
+      possibilities.find { |p| File.file?(p) }
+    end
+
+    # See {Nanoc::DataSources::Filesystem#identifier_for_filename}.
+    def identifier_for_filename(filename)
+      filename.sub(/[^\/]+\.yaml$/, '')
+    end
+
+  end
+
+end

data/lib/nanoc/extra.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module Nanoc::Extra
+
+  autoload 'AutoCompiler',      'nanoc/extra/auto_compiler'
+  autoload 'CHiCk',             'nanoc/extra/chick'
+  autoload 'Pruner',            'nanoc/extra/pruner'
+  autoload 'Validators',        'nanoc/extra/validators'
+
+  # Deprecated; use {Nanoc::Context} instead
+  # TODO [in nanoc 4.0] remove me
+  Context = ::Nanoc::Context
+
+  # Deprecated
+  # TODO [in nanoc 4.0] remove me
+  autoload 'FileProxy',         'nanoc/extra/file_proxy'
+
+end
+
+require 'nanoc/extra/core_ext'
+require 'nanoc/extra/deployer'
+require 'nanoc/extra/deployers'
+require 'nanoc/extra/vcs'
+require 'nanoc/extra/vcses'

data/lib/nanoc/extra/auto_compiler.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+
+module Nanoc::Extra
+
+  # A web server that will automatically compile items as they are requested.
+  # It also serves static files such as stylesheets and images.
+  class AutoCompiler
+
+    # @return [Nanoc::Site] The site this autocompiler belongs to
+    attr_reader :site
+
+    # Creates a new autocompiler for the given site.
+    #
+    # @param [String] site_path The path to the site to autocompile
+    def initialize(site_path)
+      require 'rack'
+      require 'mime/types'
+
+      # Set site
+      @site_path = site_path
+
+      # Create mutex to prevent parallel requests
+      require 'thread'
+      @mutex = Mutex.new
+    end
+
+    # Calls the autocompiler. The behaviour of this method is defined by the
+    # [Rack specification](http://rack.rubyforge.org/doc/files/SPEC.html).
+    #
+    # @param [Hash] env The environment, as defined by the Rack specification
+    #
+    # @return [Array] An array containing the status, the headers, and the
+    #   body, as defined by the Rack specification
+    def call(env)
+      @mutex.synchronize do
+        # Start with a new site
+        build_site
+
+        # Find rep
+        path = Rack::Utils::unescape(env['PATH_INFO'])
+        reps = site.items.map { |i| i.reps }.flatten
+        rep = reps.find do |r|
+          r.path == path ||
+            r.raw_path == site.config[:output_dir] + path
+        end
+
+        # Recompile
+        site.compile if rep
+
+        # Get paths by appending index filenames
+        if path =~ /\/$/
+          possible_paths = site.config[:index_filenames].map { |f| path + f }
+        else
+          possible_paths = [ path ]
+        end
+
+        # Find matching file
+        modified_path = possible_paths.find { |f| File.file?(site.config[:output_dir] + f) }
+        modified_path ||= path
+
+        # Serve using Rack::File
+        puts "*** serving file #{modified_path}"
+        res = file_server.call(env.merge('PATH_INFO' => modified_path))
+        puts "*** done serving file #{modified_path}"
+        res
+      end
+    rescue StandardError, ScriptError => e
+      # Add compilation stack to env
+      env['nanoc.stack'] = []
+      stack.reverse.each do |obj|
+        if obj.is_a?(Nanoc::ItemRep) # item rep
+          env['nanoc.stack'] << "[item] #{obj.item.identifier} (rep #{obj.name})"
+        else # layout
+          env['nanoc.stack'] << "[layout] #{obj.identifier}"
+        end
+      end
+
+      # Re-raise error
+      raise e
+    end
+
+  private
+
+    def build_site
+      @site = Nanoc::Site.new(@site_path)
+    end
+
+    def mime_type_of(path, fallback)
+      mime_type = MIME::Types.of(path).first
+      mime_type = mime_type.nil? ? fallback : mime_type.simplified
+    end
+
+    def file_server
+      @file_server ||= ::Rack::File.new(site.config[:output_dir])
+    end
+
+    def stack
+      site.compiler.stack
+    end
+
+  end
+
+end

data/lib/nanoc/extra/chick.rb

@@ -0,0 +1,125 @@
+require 'net/http'
+require 'rack'
+require 'rack/cache'
+
+module Nanoc::Extra
+
+  # @deprecated Use a HTTP library such as
+  #   [Net::HTTP](http://ruby-doc.org/stdlib/libdoc/net/http/rdoc/) or
+  #   [Curb](http://curb.rubyforge.org/) instead.
+  module CHiCk
+
+    # @deprecated Use a HTTP library such as
+    #   [Net::HTTP](http://ruby-doc.org/stdlib/libdoc/net/http/rdoc/) or
+    #   [Curb](http://curb.rubyforge.org/) instead.
+    class Client
+
+      DEFAULT_OPTIONS = {
+        :cache => {
+          :metastore   => 'file:tmp/rack/cache.meta', 
+          :entitystore => 'file:tmp/rack/cache.body'
+        },
+        :cache_controller => {
+          :max_age => 60
+        }
+      }
+
+      def initialize(options={})
+        # Get options
+        @options = DEFAULT_OPTIONS.merge(options)
+        @options[:cache] = DEFAULT_OPTIONS[:cache].merge(@options[:cache])
+        @options[:cache_controller] = DEFAULT_OPTIONS[:cache_controller].merge(@options[:cache_controller])
+      end
+
+      def get(url)
+        # Build app
+        options = @options
+        @app ||= Rack::Builder.new {
+          use Rack::Cache, options[:cache].merge(:verbose => true)
+          use Nanoc::Extra::CHiCk::CacheController, options[:cache_controller]
+          run Nanoc::Extra::CHiCk::RackClient
+        }
+
+        # Build environment for request
+        env = Rack::MockRequest.env_for(url, :method => 'GET')
+
+        # Fetch
+        puts "[CHiCk] Fetching #{url}..." if $DEBUG
+        status, headers, body_parts = @app.call(env)
+        puts "[CHiCk] #{url}: #{headers['X-Rack-Cache']}" if $DEBUG
+
+        # Join body
+        body = ''
+        body_parts.each { |part| body << part }
+
+        # Done
+        [ status, headers, body ]
+      end
+
+    end
+
+    # @deprecated Use a HTTP library such as
+    #   [Net::HTTP](http://ruby-doc.org/stdlib/libdoc/net/http/rdoc/) or
+    #   [Curb](http://curb.rubyforge.org/) instead.
+    class CacheController
+
+      def initialize(app, options={})
+        @app = app
+        @options = options
+      end
+
+      def call(env)
+        res = @app.call(env)
+        unless res[1].has_key?('Cache-Control') || res[1].has_key?('Expires')
+          res[1]['Cache-Control'] = "max-age=#{@options[:max_age]}"
+        end
+        res
+      end
+
+    end
+
+    # @deprecated Use a HTTP library such as
+    #   [Net::HTTP](http://ruby-doc.org/stdlib/libdoc/net/http/rdoc/) or
+    #   [Curb](http://curb.rubyforge.org/) instead.
+    class RackClient
+
+      METHOD_TO_CLASS_MAPPING = {
+        'DELETE'  => Net::HTTP::Delete,
+        'GET'     => Net::HTTP::Get,
+        'HEAD'    => Net::HTTP::Head,
+        'POST'    => Net::HTTP::Post,
+        'PUT'     => Net::HTTP::Put
+      }
+
+      def self.call(env)
+        # Build request
+        request = Rack::Request.new(env)
+
+        # Build headers and strip HTTP_
+        request_headers = env.inject({}) do |m,(k,v)|
+          k =~ /^HTTP_(.*)$/ && v ? m.merge($1.gsub(/_/, '-') => v) : m
+        end
+
+        # Build Net::HTTP request
+        http = Net::HTTP.new(request.host, request.port)
+        net_http_request_class = METHOD_TO_CLASS_MAPPING[request.request_method]
+        raise ArgumentError, "Unsupported method: #{request.request_method}" if net_http_request_class.nil?
+        net_http_request = net_http_request_class.new(request.fullpath, request_headers)
+        net_http_request.body = env['rack.input'].read if [ 'POST', 'PUT' ].include?(request.request_method)
+
+        # Perform request
+        http.request(net_http_request) do |response|
+          # Build Rack response triplet
+          return [
+            response.code.to_i,
+            response.to_hash.inject({}) { |m,(k,v)| m.merge(k => v[0]) },
+            [ response.body ]
+          ]
+        end
+      end
+
+    end
+
+  end
+
+end