monad 0.0.2 → 0.0.3

data/lib/{monad → jekyll}/site.rb

@@ -1,11 +1,9 @@
-require 'set'
-
-module Monad
+module Jekyll
   class Site
     attr_accessor :config, :layouts, :posts, :pages, :static_files,
                   :categories, :exclude, :include, :source, :dest, :lsi, :pygments,
                   :permalink_style, :tags, :time, :future, :safe, :plugins, :limit_posts,
-                  :show_drafts, :keep_files, :baseurl, :data_sources
+                  :show_drafts, :keep_files, :baseurl, :data, :data_sources, :file_read_opts
 
     attr_accessor :converters, :generators
 
@@ -15,20 +13,17 @@ module Monad
     def initialize(config)
       self.config          = config.clone
 
-      self.safe            = config['safe']
+      %w[safe lsi pygments baseurl exclude include future show_drafts limit_posts keep_files].each do |opt|
+        self.send("#{opt}=", config[opt])
+      end
+
       self.source          = File.expand_path(config['source'])
       self.dest            = File.expand_path(config['destination'])
       self.plugins         = plugins_path
-      self.lsi             = config['lsi']
-      self.pygments        = config['pygments']
-      self.baseurl         = config['baseurl']
       self.permalink_style = config['permalink'].to_sym
-      self.exclude         = config['exclude']
-      self.include         = config['include']
-      self.future          = config['future']
-      self.show_drafts     = config['show_drafts']
-      self.limit_posts     = config['limit_posts']
-      self.keep_files      = config['keep_files']
+
+      self.file_read_opts = {}
+      self.file_read_opts[:encoding] = config['encoding'] if config['encoding']
 
       self.reset
       self.setup
@@ -61,6 +56,7 @@ module Monad
       self.static_files    = []
       self.categories      = Hash.new { |hash, key| hash[key] = [] }
       self.tags            = Hash.new { |hash, key| hash[key] = [] }
+      self.data            = {}
       self.data_sources    = {}
 
       if self.limit_posts < 0
@@ -72,13 +68,7 @@ module Monad
     #
     # Returns nothing.
     def setup
-      require 'classifier' if self.lsi
-
-      # Check that the destination dir isn't the source dir or a directory
-      # parent to the source dir.
-      if self.source =~ /^#{self.dest}/
-        raise FatalException.new "Destination directory cannot be or contain the Source directory."
-      end
+      ensure_not_in_dest
 
       # If safe mode is off, load in any Ruby files under the plugins
       # directory.
@@ -90,15 +80,26 @@ module Monad
         end
       end
 
-      self.converters = instantiate_subclasses(Monad::Converter)
-      self.generators = instantiate_subclasses(Monad::Generator)
+      self.converters = instantiate_subclasses(Jekyll::Converter)
+      self.generators = instantiate_subclasses(Jekyll::Generator)
+    end
+
+    # Check that the destination dir isn't the source dir or a directory
+    # parent to the source dir.
+    def ensure_not_in_dest
+      dest = Pathname.new(self.dest)
+      Pathname.new(self.source).ascend do |path|
+        if path == dest
+          raise FatalException.new "Destination directory cannot be or contain the Source directory."
+        end
+      end
     end
 
     # Internal: Setup the plugin search path
     #
     # Returns an Array of plugin search paths
     def plugins_path
-      if (config['plugins'] == Monad::Configuration::DEFAULTS['plugins'])
+      if (config['plugins'] == Jekyll::Configuration::DEFAULTS['plugins'])
         [File.join(self.source, config['plugins'])]
       else
         Array(config['plugins']).map { |d| File.expand_path(d) }
@@ -111,6 +112,7 @@ module Monad
     def read
       self.read_layouts
       self.read_directories
+      self.read_data(config['data_source'])
       self.load_data_sources
     end
 
@@ -122,7 +124,7 @@ module Monad
       base = File.join(self.source, self.config['layouts'])
       return unless File.exists?(base)
       entries = []
-      Dir.chdir(base) { entries = filter_entries(Dir['*.*']) }
+      Dir.chdir(base) { entries = filter_entries(Dir['**/*.*']) }
 
       entries.each do |f|
         name = f.split(".")[0..-2].join(".")
@@ -142,34 +144,19 @@ module Monad
       entries = Dir.chdir(base) { filter_entries(Dir.entries('.')) }
 
       self.read_posts(dir)
-
-      if self.show_drafts
-        self.read_drafts(dir)
-      end
-
+      self.read_drafts(dir) if self.show_drafts
       self.posts.sort!
-
-      # limit the posts if :limit_posts option is set
-      if limit_posts > 0
-        limit = self.posts.length < limit_posts ? self.posts.length : limit_posts
-        self.posts = self.posts[-limit, limit]
-      end
+      limit_posts! if limit_posts > 0 # limit the posts if :limit_posts option is set
 
       entries.each do |f|
         f_abs = File.join(base, f)
-        f_rel = File.join(dir, f)
         if File.directory?(f_abs)
-          next if self.dest.sub(/\/$/, '') == f_abs
-          read_directories(f_rel)
+          f_rel = File.join(dir, f)
+          read_directories(f_rel) unless self.dest.sub(/\/$/, '') == f_abs
+        elsif has_yaml_header?(f_abs)
+          pages << Page.new(self, self.source, dir, f)
         else
-          first3 = File.open(f_abs) { |fd| fd.read(3) }
-          if first3 == "---"
-            # file appears to have a YAML header so process it as a page
-            pages << Page.new(self, self.source, dir, f)
-          else
-            # otherwise treat it as a static file
-            static_files << StaticFile.new(self, self.source, dir, f)
-          end
+          static_files << StaticFile.new(self, self.source, dir, f)
         end
       end
     end
@@ -214,6 +201,42 @@ module Monad
       end
     end
 
+    # Read and parse all yaml files under <source>/<dir>
+    #
+    # Returns nothing
+    def read_data(dir)
+      base = File.join(self.source, dir)
+      return unless File.directory?(base) && (!self.safe || !File.symlink?(base))
+
+      entries = Dir.chdir(base) { Dir['*.{yaml,yml}'] }
+      entries.delete_if { |e| File.directory?(File.join(base, e)) }
+
+      entries.each do |entry|
+        path = File.join(self.source, dir, entry)
+        next if File.symlink?(path) && self.safe
+
+        key = sanitize_filename(File.basename(entry, '.*'))
+        self.data[key] = YAML.safe_load_file(path)
+      end
+    end
+
+    # Load external data sources to @data_sources
+    #
+    # Returns nothing
+    def load_data_sources
+      self.config['data_sources'] && self.config['data_sources'].each do |data_source_config|
+        if data_source_config['name'] !~ /^\w+$/
+          raise FatalException.new "Bad data source name: #{data_source_config['name']}. Only letters or digits allowed in data source name."
+        end
+
+        # create driver
+        driver_name = data_source_config['type'].split('_').collect!{ |w| w.capitalize }.join + 'Driver'
+        driver = Jekyll::Drivers.const_get(driver_name).new(data_source_config)
+
+        @data_sources[data_source_config['name']] = driver.load
+      end
+    end
+
     # Run each of the Generators.
     #
     # Returns nothing.
@@ -227,14 +250,11 @@ module Monad
     #
     # Returns nothing.
     def render
-      payload = site_payload
-      self.posts.each do |post|
-        post.render(self.layouts, payload)
-      end
+      relative_permalinks_deprecation_method
 
-      self.pages.each do |page|
-        relative_permalinks_deprecation_method if page.uses_relative_permalinks
-        page.render(self.layouts, payload)
+      payload = site_payload
+      [self.posts, self.pages].flatten.each do |page_or_post|
+        page_or_post.render(self.layouts, payload)
       end
 
       self.categories.values.map { |ps| ps.sort! { |a, b| b <=> a } }
@@ -247,62 +267,14 @@ module Monad
     #
     # Returns nothing.
     def cleanup
-      # all files and directories in destination, including hidden ones
-      dest_files = Set.new
-      Dir.glob(File.join(self.dest, "**", "*"), File::FNM_DOTMATCH) do |file|
-        if self.keep_files.length > 0
-          dest_files << file unless file =~ /\/\.{1,2}$/ || file =~ keep_file_regex
-        else
-          dest_files << file unless file =~ /\/\.{1,2}$/
-        end
-      end
-
-      # files to be written
-      files = Set.new
-      self.posts.each do |post|
-        files << post.destination(self.dest)
-      end
-      self.pages.each do |page|
-        files << page.destination(self.dest)
-      end
-      self.static_files.each do |sf|
-        files << sf.destination(self.dest)
-      end
-
-      # adding files' parent directories
-      dirs = Set.new
-      files.each { |file| dirs << File.dirname(file) }
-      files.merge(dirs)
-
-      obsolete_files = dest_files - files
-      FileUtils.rm_rf(obsolete_files.to_a)
-    end
-
-    # Private: creates a regular expression from the keep_files array
-    #
-    # Examples
-    #   ['.git','.svn'] creates the following regex: /\/(\.git|\/.svn)/
-    #
-    # Returns the regular expression
-    def keep_file_regex
-      or_list = self.keep_files.join("|")
-      pattern = "\/(#{or_list.gsub(".", "\.")})"
-      Regexp.new pattern
+      site_cleaner.cleanup!
     end
 
     # Write static files, pages, and posts.
     #
     # Returns nothing.
     def write
-      self.posts.each do |post|
-        post.write(self.dest)
-      end
-      self.pages.each do |page|
-        page.write(self.dest)
-      end
-      self.static_files.each do |sf|
-        sf.write(self.dest)
-      end
+      each_site_file { |item| item.write(self.dest) }
     end
 
     # Construct a Hash of Posts indexed by the specified Post attribute.
@@ -327,6 +299,14 @@ module Monad
       hash
     end
 
+    # Prepare site data for site payload. The method maintains backward compatibility
+    # if the key 'data' is already used in _config.yml.
+    #
+    # Returns the Hash to be hooked to site.data.
+    def site_data
+      self.config['data'] || self.data
+    end
+
     # The Hash payload containing site-wide data.
     #
     # Returns the Hash: { "site" => data } where data is a Hash with keys:
@@ -341,13 +321,15 @@ module Monad
     #   "tags"       - The Hash of tag values and Posts.
     #                  See Site#post_attr_hash for type info.
     def site_payload
-      {"site" => self.data_sources.merge(self.config).merge({
+      {"jekyll" => { "version" => Jekyll::VERSION },
+       "site" => self.data_sources.merge(self.config).merge({
           "time"       => self.time,
           "posts"      => self.posts.sort { |a, b| b <=> a },
           "pages"      => self.pages,
           "html_pages" => self.pages.reject { |page| !page.html? },
           "categories" => post_attr_hash('categories'),
-          "tags"       => post_attr_hash('tags')})}
+          "tags"       => post_attr_hash('tags'),
+          "data"       => site_data})}
     end
 
     # Filter out any files/directories that are hidden or backup files (start
@@ -423,33 +405,48 @@ module Monad
     end
 
     def relative_permalinks_deprecation_method
-      if config['relative_permalinks'] && !@deprecated_relative_permalinks
+      if config['relative_permalinks'] && has_relative_page?
         $stderr.puts # Places newline after "Generating..."
-        Monad::Logger.warn "Deprecation:", "Starting in 1.1, permalinks for pages" +
+        Jekyll.logger.warn "Deprecation:", "Starting in 1.1, permalinks for pages" +
                                             " in subfolders must be relative to the" +
                                             " site source directory, not the parent" +
-                                            " directory. Check http://monadrb.com/docs/upgrading/"+
+                                            " directory. Check http://jekyllrb.com/docs/upgrading/"+
                                             " for more info."
-        $stderr.print Monad::Logger.formatted_topic("") + "..." # for "done."
-        @deprecated_relative_permalinks = true
+        $stderr.print Jekyll.logger.formatted_topic("") + "..." # for "done."
       end
     end
 
-    # Load external data sources to @data_sources
-    #
-    # Returns nothing
-    def load_data_sources
-      self.config['data_sources'] && self.config['data_sources'].each do |data_source_config|
-        if data_source_config['name'] !~ /^\w+$/
-          raise FatalException.new "Bad data source name: #{data_source_config['name']}. Only letters or digits allowed in data source name."
+    def each_site_file
+      %w(posts pages static_files).each do |type|
+        self.send(type).each do |item|
+          yield item
         end
+      end
+    end
 
-        # create driver
-        driver_name = data_source_config['type'].split('_').collect!{ |w| w.capitalize }.join + 'Driver'
-        driver = Monad::Drivers.const_get(driver_name).new(data_source_config)
+    private
 
-        @data_sources[data_source_config['name']] = driver.load
-      end
+    def has_relative_page?
+      self.pages.any? { |page| page.uses_relative_permalinks }
+    end
+
+    def has_yaml_header?(file)
+      "---" == File.open(file) { |fd| fd.read(3) }
+    end
+
+    def limit_posts!
+      limit = self.posts.length < limit_posts ? self.posts.length : limit_posts
+      self.posts = self.posts[-limit, limit]
+    end
+
+    def site_cleaner
+      @site_cleaner ||= Cleaner.new(self)
+    end
+
+    def sanitize_filename(name)
+      name = name.gsub(/[^\w\s_-]+/, '')
+      name = name.gsub(/(^|\b\s)\s+($|\s?\b)/, '\\1\\2')
+      name = name.gsub(/\s+/, '_')
     end
   end
 end

data/lib/{monad → jekyll}/static_file.rb

@@ -1,4 +1,4 @@
-module Monad
+module Jekyll
   class StaticFile
     # The cache of last modification times [path] -> mtime.
     @@mtimes = Hash.new

data/lib/jekyll/stevenson.rb

@@ -0,0 +1,89 @@
+module Jekyll
+  class Stevenson
+    attr_accessor :log_level
+
+    DEBUG  = 0
+    INFO   = 1
+    WARN   = 2
+    ERROR  = 3
+
+    # Public: Create a new instance of Stevenson, Jekyll's logger
+    #
+    # level - (optional, integer) the log level
+    #
+    # Returns nothing
+    def initialize(level = INFO)
+      @log_level = level
+    end
+    
+    # Public: Print a jekyll debug message to stdout
+    #
+    # topic - the topic of the message, e.g. "Configuration file", "Deprecation", etc.
+    # message - the message detail
+    #
+    # Returns nothing
+    def debug(topic, message = nil)
+      $stdout.puts(message(topic, message)) if log_level <= DEBUG
+    end
+
+    # Public: Print a jekyll message to stdout
+    #
+    # topic - the topic of the message, e.g. "Configuration file", "Deprecation", etc.
+    # message - the message detail
+    #
+    # Returns nothing
+    def info(topic, message = nil)
+      $stdout.puts(message(topic, message)) if log_level <= INFO
+    end
+
+    # Public: Print a jekyll message to stderr
+    #
+    # topic - the topic of the message, e.g. "Configuration file", "Deprecation", etc.
+    # message - the message detail
+    #
+    # Returns nothing
+    def warn(topic, message = nil)
+      $stderr.puts(message(topic, message).yellow) if log_level <= WARN
+    end
+
+    # Public: Print a jekyll error message to stderr
+    #
+    # topic - the topic of the message, e.g. "Configuration file", "Deprecation", etc.
+    # message - the message detail
+    #
+    # Returns nothing
+    def error(topic, message = nil)
+      $stderr.puts(message(topic, message).red) if log_level <= ERROR
+    end
+
+    # Public: Print a Jekyll error message to stderr and immediately abort the process
+    #
+    # topic - the topic of the message, e.g. "Configuration file", "Deprecation", etc.
+    # message - the message detail (can be omitted)
+    #
+    # Returns nothing
+    def abort_with(topic, message = nil)
+      error(topic, message)
+      abort
+    end
+
+    # Public: Build a Jekyll topic method
+    #
+    # topic - the topic of the message, e.g. "Configuration file", "Deprecation", etc.
+    # message - the message detail
+    #
+    # Returns the formatted message
+    def message(topic, message)
+      formatted_topic(topic) + message.to_s.gsub(/\s+/, ' ')
+    end
+
+    # Public: Format the topic
+    #
+    # topic - the topic of the message, e.g. "Configuration file", "Deprecation", etc.
+    #
+    # Returns the formatted topic statement
+    def formatted_topic(topic)
+      "#{topic} ".rjust(20)
+    end
+  end
+end