monad 0.0.1

data/lib/monad/core_ext.rb

@@ -0,0 +1,68 @@
+class Hash
+  # Merges self with another hash, recursively.
+  #
+  # This code was lovingly stolen from some random gem:
+  # http://gemjack.com/gems/tartan-0.1.1/classes/Hash.html
+  #
+  # Thanks to whoever made it.
+  def deep_merge(hash)
+    target = dup
+
+    hash.keys.each do |key|
+      if hash[key].is_a? Hash and self[key].is_a? Hash
+        target[key] = target[key].deep_merge(hash[key])
+        next
+      end
+
+      target[key] = hash[key]
+    end
+
+    target
+  end
+
+  # Read array from the supplied hash favouring the singular key
+  # and then the plural key, and handling any nil entries.
+  #   +hash+ the hash to read from
+  #   +singular_key+ the singular key
+  #   +plural_key+ the plural key
+  #
+  # Returns an array
+  def pluralized_array(singular_key, plural_key)
+    hash = self
+    if hash.has_key?(singular_key)
+      array = [hash[singular_key]] if hash[singular_key]
+    elsif hash.has_key?(plural_key)
+      case hash[plural_key]
+      when String
+        array = hash[plural_key].split
+      when Array
+        array = hash[plural_key].compact
+      end
+    end
+    array || []
+  end
+end
+
+# Thanks, ActiveSupport!
+class Date
+  # Converts datetime to an appropriate format for use in XML
+  def xmlschema
+    strftime("%Y-%m-%dT%H:%M:%S%Z")
+  end if RUBY_VERSION < '1.9'
+end
+
+module Enumerable
+  # Returns true if path matches against any glob pattern.
+  # Look for more detail about glob pattern in method File::fnmatch.
+  def glob_include?(e)
+    any? { |exp| File.fnmatch?(exp, e) }
+  end
+end
+
+if RUBY_VERSION < "1.9"
+  class String
+    def force_encoding(enc)
+      self
+    end
+  end
+end

data/lib/monad/deprecator.rb

@@ -0,0 +1,32 @@
+module Monad
+  class Deprecator
+    def self.process(args)
+      no_subcommand(args)
+      deprecation_message args, "--server", "The --server command has been replaced by the \
+                          'serve' subcommand."
+      deprecation_message args, "--no-server", "To build Monad without launching a server, \
+                          use the 'build' subcommand."
+      deprecation_message args, "--auto", "The switch '--auto' has been replaced with '--watch'."
+      deprecation_message args, "--no-auto", "To disable auto-replication, simply leave off \
+                          the '--watch' switch."
+      deprecation_message args, "--pygments", "The 'pygments' setting can only be set in \
+                          your config files."
+      deprecation_message args, "--paginate", "The 'paginate' setting can only be set in your \
+                          config files."
+      deprecation_message args, "--url", "The 'url' setting can only be set in your config files."
+    end
+
+    def self.no_subcommand(args)
+      if args.size > 0 && args.first =~ /^--/ && !%w[--help --version].include?(args.first)
+        Monad::Logger.error "Deprecation:", "Monad now uses subcommands instead of just \
+                            switches. Run `monad help' to find out more."
+      end
+    end
+
+    def self.deprecation_message(args, deprecated_argument, message)
+      if args.include?(deprecated_argument)
+        Monad::Logger.error "Deprecation:", message
+      end
+    end
+  end
+end

data/lib/monad/draft.rb

@@ -0,0 +1,35 @@
+module Monad
+
+  class Draft < Post
+
+    # Valid post name regex (no date)
+    MATCHER = /^(.*)(\.[^.]+)$/
+
+    # Draft name validator. Draft filenames must be like:
+    # my-awesome-post.textile
+    #
+    # Returns true if valid, false if not.
+    def self.valid?(name)
+      name =~ MATCHER
+    end
+
+    # Get the full path to the directory containing the draft files
+    def containing_dir(source, dir)
+      File.join(source, dir, '_drafts')
+    end
+
+    # Extract information from the post filename.
+    #
+    # name - The String filename of the post file.
+    #
+    # Returns nothing.
+    def process(name)
+      m, slug, ext = *name.match(MATCHER)
+      self.date = File.mtime(File.join(@base, name))
+      self.slug = slug
+      self.ext = ext
+    end
+
+  end
+
+end

data/lib/monad/drivers/json_driver.rb

@@ -0,0 +1,39 @@
+require 'json'
+require 'uri'
+require 'net/http'
+require 'net/https' # ruby 1.8.7 requires explicitly require net/https
+
+module Monad
+  module Drivers
+    class JsonDriver
+      def initialize(options)
+        @url = options['url']
+
+        if !@url
+          raise FatalException.new "'url' must be specified for json data source: #{options['name']}."
+        end
+
+        if @url !~ URI::regexp || URI(@url).scheme !~ /^http|https$/
+          raise FatalException.new "incorrect json data source url: #{@url}"
+        end
+      end
+
+      def load
+        uri = URI(@url)
+
+        if uri.scheme == 'https'
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+          request = Net::HTTP::Get.new(uri.request_uri)
+          response = http.request(request).body
+        else
+          response = Net::HTTP.get(uri)
+        end
+
+        JSON.parse(response)
+      end
+    end
+  end
+end

data/lib/monad/drivers/yaml_driver.rb

@@ -0,0 +1,23 @@
+require 'safe_yaml'
+
+module Monad
+  module Drivers
+    class YamlDriver
+      def initialize(options)
+        @path = options['path']
+
+        if !@path
+          raise FatalException.new "'path' must be specified for yaml data source: #{options['name']}."
+        end
+
+        if !File.exists?(@path)
+          raise FatalException.new "the file '#{@path}' doesn't exist for data source '#{options['name']}'"
+        end
+      end
+
+      def load
+        YAML.safe_load_file(@path)
+      end
+    end
+  end
+end

data/lib/monad/errors.rb

@@ -0,0 +1,4 @@
+module Monad
+  class FatalException < StandardError
+  end
+end

data/lib/monad/filters.rb

@@ -0,0 +1,154 @@
+require 'uri'
+
+module Monad
+  module Filters
+    # Convert a Textile string into HTML output.
+    #
+    # input - The Textile String to convert.
+    #
+    # Returns the HTML formatted String.
+    def textilize(input)
+      site = @context.registers[:site]
+      converter = site.getConverterImpl(Monad::Converters::Textile)
+      converter.convert(input)
+    end
+
+    # Convert a Markdown string into HTML output.
+    #
+    # input - The Markdown String to convert.
+    #
+    # Returns the HTML formatted String.
+    def markdownify(input)
+      site = @context.registers[:site]
+      converter = site.getConverterImpl(Monad::Converters::Markdown)
+      converter.convert(input)
+    end
+
+    # Format a date in short format e.g. "27 Jan 2011".
+    #
+    # date - the Time to format.
+    #
+    # Returns the formatting String.
+    def date_to_string(date)
+      time(date).strftime("%d %b %Y")
+    end
+
+    # Format a date in long format e.g. "27 January 2011".
+    #
+    # date - The Time to format.
+    #
+    # Returns the formatted String.
+    def date_to_long_string(date)
+      time(date).strftime("%d %B %Y")
+    end
+
+    # Format a date for use in XML.
+    #
+    # date - The Time to format.
+    #
+    # Examples
+    #
+    #   date_to_xmlschema(Time.now)
+    #   # => "2011-04-24T20:34:46+08:00"
+    #
+    # Returns the formatted String.
+    def date_to_xmlschema(date)
+      time(date).xmlschema
+    end
+
+    # Format a date according to RFC-822
+    #
+    # date - The Time to format.
+    #
+    # Examples
+    #
+    #   date_to_rfc822(Time.now)
+    #   # => "Sun, 24 Apr 2011 12:34:46 +0000"
+    #
+    # Returns the formatted String.
+    def date_to_rfc822(date)
+      time(date).rfc822
+    end
+
+    # XML escape a string for use. Replaces any special characters with
+    # appropriate HTML entity replacements.
+    #
+    # input - The String to escape.
+    #
+    # Examples
+    #
+    #   xml_escape('foo "bar" <baz>')
+    #   # => "foo &quot;bar&quot; &lt;baz&gt;"
+    #
+    # Returns the escaped String.
+    def xml_escape(input)
+      CGI.escapeHTML(input)
+    end
+
+    # CGI escape a string for use in a URL. Replaces any special characters
+    # with appropriate %XX replacements.
+    #
+    # input - The String to escape.
+    #
+    # Examples
+    #
+    #   cgi_escape('foo,bar;baz?')
+    #   # => "foo%2Cbar%3Bbaz%3F"
+    #
+    # Returns the escaped String.
+    def cgi_escape(input)
+      CGI::escape(input)
+    end
+
+    def uri_escape(input)
+      URI.escape(input)
+    end
+
+    # Count the number of words in the input string.
+    #
+    # input - The String on which to operate.
+    #
+    # Returns the Integer word count.
+    def number_of_words(input)
+      input.split.length
+    end
+
+    # Join an array of things into a string by separating with commes and the
+    # word "and" for the last one.
+    #
+    # array - The Array of Strings to join.
+    #
+    # Examples
+    #
+    #   array_to_sentence_string(["apples", "oranges", "grapes"])
+    #   # => "apples, oranges, and grapes"
+    #
+    # Returns the formatted String.
+    def array_to_sentence_string(array)
+      connector = "and"
+      case array.length
+      when 0
+        ""
+      when 1
+        array[0].to_s
+      when 2
+        "#{array[0]} #{connector} #{array[1]}"
+      else
+        "#{array[0...-1].join(', ')}, #{connector} #{array[-1]}"
+      end
+    end
+
+    private
+    def time(input)
+      case input
+      when Time
+        input
+      when String
+        Time.parse(input)
+      else
+        Monad::Logger.error "Invalid Date:", "'#{input}' is not a valid datetime."
+        exit(1)
+      end
+    end
+  end
+end

data/lib/monad/generator.rb

@@ -0,0 +1,4 @@
+module Monad
+  class Generator < Plugin
+  end
+end

data/lib/monad/generators/pagination.rb

@@ -0,0 +1,143 @@
+module Monad
+  module Generators
+    class Pagination < Generator
+      # This generator is safe from arbitrary code execution.
+      safe true
+
+      # Generate paginated pages if necessary.
+      #
+      # site - The Site.
+      #
+      # Returns nothing.
+      def generate(site)
+        site.pages.dup.each do |page|
+          paginate(site, page) if Pager.pagination_enabled?(site.config, page)
+        end
+      end
+
+      # Paginates the blog's posts. Renders the index.html file into paginated
+      # directories, e.g.: page2/index.html, page3/index.html, etc and adds more
+      # site-wide data.
+      #
+      # site - The Site.
+      # page - The index.html Page that requires pagination.
+      #
+      # {"paginator" => { "page" => <Number>,
+      #                   "per_page" => <Number>,
+      #                   "posts" => [<Post>],
+      #                   "total_posts" => <Number>,
+      #                   "total_pages" => <Number>,
+      #                   "previous_page" => <Number>,
+      #                   "next_page" => <Number> }}
+      def paginate(site, page)
+        all_posts = site.site_payload['site']['posts']
+        pages = Pager.calculate_pages(all_posts, site.config['paginate'].to_i)
+        (1..pages).each do |num_page|
+          pager = Pager.new(site.config, num_page, all_posts, pages)
+          if num_page > 1
+            newpage = Page.new(site, site.source, page.dir, page.name)
+            newpage.pager = pager
+            newpage.dir = File.join(page.dir, Pager.paginate_path(site.config, num_page))
+            site.pages << newpage
+          else
+            page.pager = pager
+          end
+        end
+      end
+
+    end
+  end
+
+  class Pager
+    attr_reader :page, :per_page, :posts, :total_posts, :total_pages,
+      :previous_page, :previous_page_path, :next_page, :next_page_path
+
+    # Calculate the number of pages.
+    #
+    # all_posts - The Array of all Posts.
+    # per_page  - The Integer of entries per page.
+    #
+    # Returns the Integer number of pages.
+    def self.calculate_pages(all_posts, per_page)
+      (all_posts.size.to_f / per_page.to_i).ceil
+    end
+
+    # Determine if pagination is enabled for a given file.
+    #
+    # config - The configuration Hash.
+    # page   - The Monad::Page with which to paginate
+    #
+    # Returns true if pagination is enabled, false otherwise.
+    def self.pagination_enabled?(config, page)
+     !config['paginate'].nil? &&
+        page.name == 'index.html' &&
+        subdirectories_identical(config['paginate_path'], page.dir)
+    end
+
+    # Determine if the subdirectories of the two paths are the same relative to source
+    #
+    # paginate_path - the paginate_path configuration setting
+    # page_dir      - the directory of the Monad::Page
+    #
+    # Returns whether the subdirectories are the same relative to source
+    def self.subdirectories_identical(paginate_path, page_dir)
+      File.dirname(paginate_path).gsub(/\A\./, '') == page_dir.gsub(/\/\z/, '')
+    end
+
+    # Static: Return the pagination path of the page
+    #
+    # site_config - the site config
+    # num_page - the pagination page number
+    #
+    # Returns the pagination path as a string
+    def self.paginate_path(site_config, num_page)
+      return nil if num_page.nil? || num_page <= 1
+      format = File.basename(site_config['paginate_path'])
+      format.sub(':num', num_page.to_s)
+    end
+
+    # Initialize a new Pager.
+    #
+    # config    - The Hash configuration of the site.
+    # page      - The Integer page number.
+    # all_posts - The Array of all the site's Posts.
+    # num_pages - The Integer number of pages or nil if you'd like the number
+    #             of pages calculated.
+    def initialize(config, page, all_posts, num_pages = nil)
+      @page = page
+      @per_page = config['paginate'].to_i
+      @total_pages = num_pages || Pager.calculate_pages(all_posts, @per_page)
+
+      if @page > @total_pages
+        raise RuntimeError, "page number can't be greater than total pages: #{@page} > #{@total_pages}"
+      end
+
+      init = (@page - 1) * @per_page
+      offset = (init + @per_page - 1) >= all_posts.size ? all_posts.size : (init + @per_page - 1)
+
+      @total_posts = all_posts.size
+      @posts = all_posts[init..offset]
+      @previous_page = @page != 1 ? @page - 1 : nil
+      @previous_page_path = Pager.paginate_path(config, @previous_page)
+      @next_page = @page != @total_pages ? @page + 1 : nil
+      @next_page_path = Pager.paginate_path(config, @next_page)
+    end
+
+    # Convert this Pager's data to a Hash suitable for use by Liquid.
+    #
+    # Returns the Hash representation of this Pager.
+    def to_liquid
+      {
+        'page' => page,
+        'per_page' => per_page,
+        'posts' => posts,
+        'total_posts' => total_posts,
+        'total_pages' => total_pages,
+        'previous_page' => previous_page,
+        'previous_page_path' => previous_page_path,
+        'next_page' => next_page,
+        'next_page_path' => next_page_path
+      }
+    end
+  end
+end