nanoc3 3.0.0

data/lib/nanoc3/data_sources/filesystem_compact.rb

@@ -0,0 +1,232 @@
+# encoding: utf-8
+
+module Nanoc3::DataSources
+
+  # The filesystem_combined data source is the default 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 Nanoc3::DataSource
+  # for documentation on the overridden methods instead.
+  #
+  # = Items
+  #
+  # Items are stored as pairs of two files: a content file, containing the
+  # actual item content, and a meta file, containing the item's attributes,
+  # formatted as YAML. The content file and the corresponding meta file have
+  # the same filename but not the same extension; the meta file's extension is
+  # .yaml.
+  #
+  # Items are stored in the "content" directory of the nanoc site.
+  #
+  # The home page item, located at /, is represented by an index.yaml meta
+  # file, along with its corresponding content file.
+  #
+  # Subitems of other pages can be achieved in two ways: they can either be
+  # nested in directories and named "index" such as the home page item, or
+  # they can simply be given a non-"index" name.
+  #
+  # For example, this directory structure:
+  #
+  #   content/
+  #     index.html
+  #     index.yaml
+  #     about.html
+  #     about.yaml
+  #     journal.html
+  #     journal.yaml
+  #     journal/
+  #       2005.html
+  #       2005.yaml
+  #       2005/
+  #         a-very-old-post.html
+  #         a-very-old-post.yaml
+  #         another-very-old-post.html
+  #         another-very-old-post.yaml
+  #     myst/
+  #       index.html
+  #       index.yaml
+  #
+  # … corresponds with the following items:
+  #
+  #   /
+  #   /about/
+  #   /journal/
+  #   /journal/2005/
+  #   /journal/2005/a-very-old-post/
+  #   /journal/2005/another-very-old-post/
+  #   /myst/
+  #
+  # = Layouts
+  #
+  # Layouts are stored the same way as items, except that they are stored in
+  # the "layouts" directory instead of the "content" directory.
+  #
+  # = Code Snippets
+  #
+  # Code snippets are stored in '.rb' files in the 'lib' directory. Code
+  # snippets can reside in sub-directories.
+  class FilesystemCompact < Nanoc3::DataSource
+
+    include Nanoc3::DataSources::FilesystemCommon
+
+    ########## VCSes ##########
+
+    attr_accessor :vcs
+
+    def vcs
+      @vcs ||= Nanoc3::Extra::VCSes::Dummy.new
+    end
+
+    ########## Preparation ##########
+
+    def setup
+      # Create directories
+      %w( content layouts lib ).each do |dir|
+        FileUtils.mkdir_p(dir)
+        vcs.add(dir)
+      end
+    end
+
+    ########## Loading data ##########
+
+    def items
+      meta_filenames('content').map do |meta_filename|
+        # Read metadata
+        meta = YAML.load_file(meta_filename) || {}
+
+        # Get content
+        content_filename = content_filename_for_meta_filename(meta_filename)
+        content = File.read(content_filename)
+
+        # Get attributes
+        attributes = meta.merge(:file => Nanoc3::Extra::FileProxy.new(content_filename))
+
+        # Get identifier
+        identifier = identifier_for_meta_filename(meta_filename.sub(/^content/, ''))
+
+        # Get modification times
+        meta_mtime    = File.stat(meta_filename).mtime
+        content_mtime = File.stat(content_filename).mtime
+        mtime         = meta_mtime > content_mtime ? meta_mtime : content_mtime
+
+        # Create item object
+        Nanoc3::Item.new(content, attributes, identifier, mtime)
+      end
+    end
+
+    def layouts
+      meta_filenames('layouts').map do |meta_filename|
+        # Get content
+        content_filename  = content_filename_for_meta_filename(meta_filename)
+        content           = File.read(content_filename)
+
+        # Get attributes
+        attributes = YAML.load_file(meta_filename) || {}
+
+        # Get identifier
+        identifier = identifier_for_meta_filename(meta_filename.sub(/^layouts\//, ''))
+
+        # Get modification times
+        meta_mtime    = File.stat(meta_filename).mtime
+        content_mtime = File.stat(content_filename).mtime
+        mtime         = meta_mtime > content_mtime ? meta_mtime : content_mtime
+
+        # Create layout object
+        Nanoc3::Layout.new(content, attributes, identifier, mtime)
+      end
+    end
+
+    ########## Creating data ##########
+
+    # Creates a new item with the given content, attributes and identifier.
+    def create_item(content, attributes, identifier)
+      # Get filenames
+      base_path = 'content' + (identifier == '/' ? '/index' : identifier[0..-2])
+      meta_filename    = base_path + '.yaml'
+      content_filename = base_path + '.html'
+
+      # Notify
+      Nanoc3::NotificationCenter.post(:file_created, meta_filename)
+      Nanoc3::NotificationCenter.post(:file_created, content_filename)
+
+      # Create files
+      FileUtils.mkdir_p(File.dirname(meta_filename))
+      File.open(meta_filename,    'w') { |io| io.write(YAML.dump(attributes.stringify_keys)) }
+      File.open(content_filename, 'w') { |io| io.write(content) }
+    end
+
+    # Creates a new layout with the given content, attributes and identifier.
+    def create_layout(content, attributes, identifier)
+      # Get filenames
+      base_path = 'layouts' + identifier[0..-2]
+      meta_filename    = base_path + '.yaml'
+      content_filename = base_path + '.html'
+
+      # Notify
+      Nanoc3::NotificationCenter.post(:file_created, meta_filename)
+      Nanoc3::NotificationCenter.post(:file_created, content_filename)
+
+      # Create files
+      FileUtils.mkdir_p(File.dirname(meta_filename))
+      File.open(meta_filename,    'w') { |io| io.write(YAML.dump(attributes.stringify_keys)) }
+      File.open(content_filename, 'w') { |io| io.write(content) }
+    end
+
+  private
+
+    ########## Custom functions ##########
+
+    # Returns the identifier for the given meta filename. This method assumes
+    # that the base is already stripped.
+    #
+    # For example:
+    #
+    #   /foo.yaml       -> /foo/
+    #   /foo/index.yaml -> /foo/
+    #   /foo/foo.yaml   -> /foo/foo/
+    #   /foo/bar.yaml   -> /foo/bar/
+    def identifier_for_meta_filename(meta_filename)
+      # Split into components
+      components = meta_filename.gsub(%r{(^/|/$)}, '').split('/')
+      components[-1].sub!(/\.yaml$/, '')
+
+      if components[-1] == 'index'
+        components[0..-2].join('/').cleaned_identifier
+      else
+        components.join('/').cleaned_identifier
+      end
+    end
+
+    # Returns the list of all meta files in the given base directory as well
+    # as its subdirectories.
+    def meta_filenames(base)
+      Dir[base + '/**/*.yaml']
+    end
+
+    # Returns the filename of the content file corresponding to the given meta
+    # file, ignoring any unwanted files (files that end with '~', '.orig',
+    # '.rej' or '.bak')
+    def content_filename_for_meta_filename(meta_filename)
+      # Find all files
+      filenames = Dir[meta_filename.sub(/\.yaml$/, '.*')]
+
+      # Reject meta files
+      filenames.reject! { |f| f =~ /\.yaml$/ }
+
+      # Reject backups
+      filenames.reject! { |f| f =~ /(~|\.orig|\.rej|\.bak)$/ }
+
+      # Make sure there is only one content file
+      if filenames.size != 1
+        raise RuntimeError.new(
+          "Expected 1 content file for the metafile #{meta_filename} but found #{filenames.size}"
+        )
+      end
+
+      # Return content filename
+      filenames.first
+    end
+
+  end
+
+end

data/lib/nanoc3/data_sources/last_fm.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+
+module Nanoc3::DataSources
+
+  # Nanoc3::DataSources::LastFM provides data about recently played tracks
+  # from from a single Last.fm user as items (Nanoc3::Item instances).
+  #
+  # The configuration must have a "username" attribute containing the username
+  # of the account from which to fetch the data, and an "api_key" attribute
+  # containing the API key (which can be obtained from the Last.fm site).
+  #
+  # The items returned by this data source will be mounted at {root}/{id},
+  # where +id+ is a sequence number that is not necessarily unique for this
+  # bookmark (because delicious.com unfortunately does not provide unique IDs
+  # for each track).
+  #
+  # The items returned by this data source will have the following attributes:
+  #
+  # +:name+:: The name of the track.
+  #
+  # +played_at+:: The timestamp when the track was played (a Time instance).
+  #
+  # +url+:: The Last.fm URL corresponding to the track (a String instance).
+  #
+  # +artist+:: A hash containing information about the track's artist.
+  #
+  # The +artist+ hash consists of the following keys:
+  #
+  # +name+:: The name of the artist.
+  #
+  # +url+:: The Last.fm URL corresponding to the artist (a String instance).
+  class LastFM < Nanoc3::DataSource
+
+    def items
+      @items ||= begin
+        require 'json'
+        require 'time'
+        require 'uri'
+
+        # Check configuration
+        if self.config[:username].nil?
+          raise RuntimeError, "LastFM data source requires a username in the configuration"
+        end
+        if self.config[:api_key].nil?
+          raise RuntimeError, "LastFM data source requires an API key in the configuration"
+        end
+
+        # Get data
+        @http_client ||= Nanoc3::Extra::CHiCk::Client.new
+        status, headers, data = *@http_client.get(
+          'http://ws.audioscrobbler.com/2.0/' +
+            '?method=user.getRecentTracks' +
+            '&format=json' +
+            '&user=' + URI.escape(self.config[:username]) +
+            '&api_key=' + URI.escape(self.config[:api_key])
+        )
+
+        # Parse as JSON
+        parsed_data = JSON.parse(data)
+        raw_items = parsed_data['recenttracks']['track']
+
+        # Convert to items
+        raw_items.enum_with_index.map do |raw_item, i|
+          # Get artist data
+          artist_status, artist_headers, artist_data = *@http_client.get(
+            'http://ws.audioscrobbler.com/2.0/' +
+              '?method=artist.getInfo' +
+              '&format=json' +
+              (
+                raw_item['artist']['mbid'].empty? ?
+                '&artist=' + URI.escape(raw_item['artist']['#text']) :
+                '&mbid=' + URI.escape(raw_item['artist']['mbid'])
+              ) +
+              '&api_key=' + URI.escape(self.config[:api_key])
+          )
+
+          # Parse as JSON
+          parsed_artist_data = JSON.parse(artist_data)
+          raw_artist_info = parsed_artist_data['artist']
+
+          # Build data
+          content = ''
+          attributes = {
+            :name      => raw_item['name'],
+            :artist    => {
+              :name      => raw_artist_info['name'],
+              :url       => raw_artist_info['url']
+            },
+            :url       => raw_item['url'],
+            :played_at => Time.parse(raw_item['date']['#text'])
+          }
+          identifier = "/#{i}/"
+          mtime = nil
+
+          # Build item
+          Nanoc3::Item.new(content, attributes, identifier, mtime)
+        end
+      end
+    end
+
+  end
+
+end

data/lib/nanoc3/data_sources/twitter.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module Nanoc3::DataSources
+
+  # Nanoc3::DataSources::Twitter provides tweets from a single user as items
+  # (Nanoc3::Item instances).
+  #
+  # The configuration must have a "username" attribute containing the username
+  # of the account from which to fetch the tweets.
+  #
+  # The items returned by this data source will be mounted at {root}/{id},
+  # where +id+ is the unique identifier of the tweet.
+  #
+  # The items returned by this data source will have the following attributes:
+  #
+  # +:created_at+:: The timestamp when this tweet was posted (a string).
+  #
+  # +source+:: The client used to tweet this message (HTML-encoded).
+  class Twitter < Nanoc3::DataSource
+
+    def items
+      @item ||= begin
+        require 'json'
+        require 'time'
+
+        # Get data
+        @http_client ||= Nanoc3::Extra::CHiCk::Client.new
+        status, headers, data = *@http_client.get("http://twitter.com/statuses/user_timeline/#{self.config[:username]}.json")
+
+        # Parse as JSON
+        raw_items = JSON.parse(data)
+
+        # Convert to items
+        raw_items.enum_with_index.map do |raw_item, i|
+          # Get data
+          content = raw_item['text']
+          attributes = {
+            :created_at  => raw_item['created_at'],
+            :source      => raw_item['source']
+            # TODO add more
+          }
+          identifier = "/#{raw_item['id']}/"
+          mtime = Time.parse(raw_item['created_at'])
+
+          # Build item
+          Nanoc3::Item.new(content, attributes, identifier, mtime)
+        end
+      end
+    end
+
+  end
+
+end

data/lib/nanoc3/data_sources.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Nanoc3::DataSources
+
+  autoload 'Delicious',          'nanoc3/data_sources/delicious'
+  autoload 'Filesystem',         'nanoc3/data_sources/filesystem'
+  autoload 'FilesystemCombined', 'nanoc3/data_sources/filesystem_combined'
+  autoload 'FilesystemCommon',   'nanoc3/data_sources/filesystem_common'
+  autoload 'FilesystemCompact',  'nanoc3/data_sources/filesystem_compact'
+  autoload 'LastFM',             'nanoc3/data_sources/last_fm'
+  autoload 'Twitter',            'nanoc3/data_sources/twitter'
+
+  Nanoc3::DataSource.register '::Nanoc3::DataSources::Delicious',          :delicious
+  Nanoc3::DataSource.register '::Nanoc3::DataSources::Filesystem',         :filesystem
+  Nanoc3::DataSource.register '::Nanoc3::DataSources::FilesystemCombined', :filesystem_combined
+  Nanoc3::DataSource.register '::Nanoc3::DataSources::FilesystemCompact',  :filesystem_compact
+  Nanoc3::DataSource.register '::Nanoc3::DataSources::LastFM',             :last_fm
+  Nanoc3::DataSource.register '::Nanoc3::DataSources::Twitter',            :twitter
+
+end

data/lib/nanoc3/extra/auto_compiler.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+
+module Nanoc3::Extra
+
+  # Nanoc3::Extra::AutoCompiler is a web server that will automatically compile
+  # items as they are requested. It also serves static files such as
+  # stylesheets and images.
+  class AutoCompiler
+
+    attr_reader :site
+
+    # Creates a new autocompiler for the given site.
+    def initialize(site_path)
+      require 'rack'
+      require 'mime/types'
+
+      # Set site
+      @site_path = site_path
+
+      # Create mutex to prevent parallel requests
+      @mutex = Mutex.new
+    end
+
+    def call(env)
+      @mutex.synchronize do
+        # Start with a new site
+        build_site
+
+        # Find rep
+        path = env['PATH_INFO']
+        reps = site.items.map { |i| i.reps }.flatten
+        rep = reps.find { |r| r.path == path }
+
+        if rep
+          serve(rep)
+        else
+          # 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
+          file_server.call(env.merge('PATH_INFO' => modified_path))
+        end
+      end
+    rescue StandardError, ScriptError => e
+      # Add compilation stack to env
+      env['nanoc.stack'] = []
+      site.compiler.stack.reverse.each do |obj|
+        if obj.is_a?(Nanoc3::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 = Nanoc3::Site.new(@site_path)
+      @site.load_data
+    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 serve(rep)
+      # Recompile rep
+      site.compiler.run(rep.item, :force => true)
+
+      # Build response
+      [
+        200,
+        { 'Content-Type' => mime_type_of(rep.raw_path, 'text/html') },
+        [ rep.content_at_snapshot(:last) ]
+      ]
+    end
+
+  end
+
+end

data/lib/nanoc3/extra/chick.rb

@@ -0,0 +1,119 @@
+require 'net/http'
+require 'rack'
+require 'rack/cache'
+
+module Nanoc3::Extra
+
+  # CHiCk is a caching HTTP client that uses Rack::Cache.
+  module CHiCk
+
+    # CHiCk::Client provides a simple API for issuing HTTP requests.
+    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 Nanoc3::Extra::CHiCk::CacheController, options[:cache_controller]
+          run Nanoc3::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
+
+    # CHiCk::CacheController sets the Cache-Control header (and more
+    # specifically, max-age) to limit the number of necessary requests.
+    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
+
+    # CHiCk::RackClient performs the actual HTTP requests. It does not perform
+    # any caching.
+    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

data/lib/nanoc3/extra/context.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module Nanoc3::Extra
+
+  # Nanoc3::Extra::Context provides a context and a Binding for use in various
+  # filters, such as the ERB and Haml one.
+  class Context
+
+    # Creates a new context based off the contents of the hash. Each pair in
+    # the hash will be converted to an instance variable. For example, passing
+    # the hash { :foo => 'bar' } will cause @foo to have the value "bar".
+    def initialize(hash)
+      hash.each_pair do |key, value|
+        instance_variable_set('@' + key.to_s, value)
+      end
+    end
+
+    # Returns a binding for this context.
+    def get_binding
+      binding
+    end
+
+  end
+end

data/lib/nanoc3/extra/core_ext/time.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module Nanoc3::Extra::TimeExtensions
+
+  # Returns a string with the time in an ISO-8601 date format.
+  def to_iso8601_date
+    self.strftime("%Y-%m-%d")
+  end
+
+  # Returns a string with the time in an ISO-8601 time format.
+  def to_iso8601_time
+    self.gmtime.strftime("%Y-%m-%dT%H:%M:%SZ")
+  end
+
+end
+
+class Time
+  include Nanoc3::Extra::TimeExtensions
+end

data/lib/nanoc3/extra/core_ext.rb

@@ -0,0 +1,3 @@
+# encoding: utf-8
+
+require 'nanoc3/extra/core_ext/time'