monad 0.0.2 → 0.0.3

data/lib/monad/commands/doctor.rb

@@ -1,29 +0,0 @@
-module Monad
-  module Commands
-    class Doctor < Command
-      class << self
-        def process(options)
-          site = Monad::Site.new(options)
-          site.read
-
-          unless deprecated_relative_permalinks(site)
-            Monad::Logger.info "Your test results", "are in. Everything looks fine."
-          end
-        end
-
-        def deprecated_relative_permalinks(site)
-          contains_deprecated_pages = false
-          site.pages.each do |page|
-            if page.uses_relative_permalinks
-              Monad::Logger.warn "Deprecation:", "'#{page.path}' uses relative" +
-                                  " permalinks which will be deprecated in" +
-                                  " Monad v1.1 and beyond."
-              contains_deprecated_pages = true
-            end
-          end
-          contains_deprecated_pages
-        end
-      end
-    end
-  end
-end

data/lib/monad/commands/new.rb

@@ -1,50 +0,0 @@
-require 'erb'
-
-module Monad
-  module Commands
-    class New < Command
-      def self.process(args)
-        raise ArgumentError.new('You must specify a path.') if args.empty?
-
-        new_blog_path = File.expand_path(args.join(" "), Dir.pwd)
-        FileUtils.mkdir_p new_blog_path
-        unless Dir["#{new_blog_path}/**/*"].empty?
-          Monad::Logger.error "Conflict:", "#{new_blog_path} exists and is not empty."
-          exit(1)
-        end
-
-        create_sample_files new_blog_path
-
-        File.open(File.expand_path(self.initialized_post_name, new_blog_path), "w") do |f|
-          f.write(self.scaffold_post_content(site_template))
-        end
-        puts "New monad site installed in #{new_blog_path}."
-      end
-
-      def self.scaffold_post_content(template_site)
-        ERB.new(File.read(File.expand_path(scaffold_path, site_template))).result
-      end
-
-      # Internal: Gets the filename of the sample post to be created
-      #
-      # Returns the filename of the sample post, as a String
-      def self.initialized_post_name
-        "_posts/#{Time.now.strftime('%Y-%m-%d')}-welcome-to-monad.markdown"
-      end
-
-      private
-      def self.create_sample_files(path)
-        FileUtils.cp_r site_template + '/.', path
-        FileUtils.rm File.expand_path(scaffold_path, path)
-      end
-
-      def self.site_template
-        File.expand_path("../../site_template", File.dirname(__FILE__))
-      end
-
-      def self.scaffold_path
-        "_posts/0000-00-00-welcome-to-monad.markdown.erb"
-      end
-    end
-  end
-end

data/lib/monad/commands/serve.rb

@@ -1,33 +0,0 @@
-# -*- coding: utf-8 -*-
-module Monad
-  module Commands
-    class Serve < Command
-      def self.process(options)
-        require 'webrick'
-        include WEBrick
-
-        destination = options['destination']
-
-        FileUtils.mkdir_p(destination)
-
-        mime_types_file = File.expand_path('../mime.types', File.dirname(__FILE__))
-        mime_types = WEBrick::HTTPUtils::load_mime_types(mime_types_file)
-
-        # recreate NondisclosureName under utf-8 circumstance
-        fh_option = WEBrick::Config::FileHandler
-        fh_option[:NondisclosureName] = ['.ht*','~*']
-
-        s = HTTPServer.new(
-          :Port => options['port'],
-          :BindAddress => options['host'],
-          :MimeTypes => mime_types
-        )
-
-        s.mount(options['baseurl'], HTTPServlet::FileHandler, destination, fh_option)
-        t = Thread.new { s.start }
-        trap("INT") { s.shutdown }
-        t.join()
-      end
-    end
-  end
-end

data/lib/monad/converters/markdown/kramdown_parser.rb

@@ -1,44 +0,0 @@
-module Monad
-  module Converters
-    class Markdown
-      class KramdownParser
-        def initialize(config)
-          require 'kramdown'
-          @config = config
-        rescue LoadError
-          STDERR.puts 'You are missing a library required for Markdown. Please run:'
-          STDERR.puts '  $ [sudo] gem install kramdown'
-          raise FatalException.new("Missing dependency: kramdown")
-        end
-
-        def convert(content)
-          # Check for use of coderay
-          kramdown_configs = if @config['kramdown']['use_coderay']
-            base_kramdown_configs.merge({
-              :coderay_wrap               => @config['kramdown']['coderay']['coderay_wrap'],
-              :coderay_line_numbers       => @config['kramdown']['coderay']['coderay_line_numbers'],
-              :coderay_line_number_start  => @config['kramdown']['coderay']['coderay_line_number_start'],
-              :coderay_tab_width          => @config['kramdown']['coderay']['coderay_tab_width'],
-              :coderay_bold_every         => @config['kramdown']['coderay']['coderay_bold_every'],
-              :coderay_css                => @config['kramdown']['coderay']['coderay_css']
-            })
-          else
-            # not using coderay
-            base_kramdown_configs
-          end
-          Kramdown::Document.new(content, kramdown_configs).to_html
-        end
-
-        def base_kramdown_configs
-          {
-            :auto_ids      => @config['kramdown']['auto_ids'],
-            :footnote_nr   => @config['kramdown']['footnote_nr'],
-            :entity_output => @config['kramdown']['entity_output'],
-            :toc_levels    => @config['kramdown']['toc_levels'],
-            :smart_quotes  => @config['kramdown']['smart_quotes']
-          }
-        end
-      end
-    end
-  end
-end

data/lib/monad/deprecator.rb

@@ -1,32 +0,0 @@
-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/generators/pagination.rb

@@ -1,143 +0,0 @@
-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

data/lib/monad/logger.rb

@@ -1,54 +0,0 @@
-require 'logger'
-
-module Monad
-  class Logger < Logger
-    # Public: Print a monad message to stdout
-    #
-    # topic - the topic of the message, e.g. "Configuration file", "Deprecation", etc.
-    # message - the message detail
-    #
-    # Returns nothing
-    def self.info(topic, message)
-      $stdout.puts message(topic, message)
-    end
-
-    # Public: Print a monad message to stderr
-    #
-    # topic - the topic of the message, e.g. "Configuration file", "Deprecation", etc.
-    # message - the message detail
-    #
-    # Returns nothing
-    def self.warn(topic, message)
-      $stderr.puts message(topic, message).yellow
-    end
-
-    # Public: Print a monad error message to stderr
-    #
-    # topic - the topic of the message, e.g. "Configuration file", "Deprecation", etc.
-    # message - the message detail
-    #
-    # Returns nothing
-    def self.error(topic, message)
-      $stderr.puts message(topic, message).red
-    end
-
-    # Public: Build a Monad topic method
-    #
-    # topic - the topic of the message, e.g. "Configuration file", "Deprecation", etc.
-    # message - the message detail
-    #
-    # Returns the formatted message
-    def self.message(topic, message)
-       formatted_topic(topic) + message.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 self.formatted_topic(topic)
-      "#{topic} ".rjust(20)
-    end
-  end
-end

data/lib/monad/tags/gist.rb

@@ -1,30 +0,0 @@
-# Gist Liquid Tag
-#
-# Example:
-#    {% gist 1234567 %}
-#    {% gist 1234567 file.rb %}
-
-module Monad
-  class GistTag < Liquid::Tag
-    def render(context)
-      if tag_contents = @markup.strip.match(/\A(\d+) ?(\S*)\Z/)
-        gist_id, filename = tag_contents[1].strip, tag_contents[2].strip
-        gist_script_tag(gist_id, filename)
-      else
-        "Error parsing gist id"
-      end
-    end
-
-    private
-
-    def gist_script_tag(gist_id, filename=nil)
-      if filename.empty?
-        "<script src=\"https://gist.github.com/#{gist_id}.js\"> </script>"
-      else
-        "<script src=\"https://gist.github.com/#{gist_id}.js?file=#{filename}\"> </script>"
-      end
-    end
-  end
-end
-
-Liquid::Template.register_tag('gist', Monad::GistTag)

data/lib/monad/tags/include.rb

@@ -1,37 +0,0 @@
-module Monad
-  module Tags
-    class IncludeTag < Liquid::Tag
-      def initialize(tag_name, file, tokens)
-        super
-        @file = file.strip
-      end
-
-      def render(context)
-        includes_dir = File.join(context.registers[:site].source, '_includes')
-
-        if File.symlink?(includes_dir)
-          return "Includes directory '#{includes_dir}' cannot be a symlink"
-        end
-
-        if @file !~ /^[a-zA-Z0-9_\/\.-]+$/ || @file =~ /\.\// || @file =~ /\/\./
-          return "Include file '#{@file}' contains invalid characters or sequences"
-        end
-
-        Dir.chdir(includes_dir) do
-          choices = Dir['**/*'].reject { |x| File.symlink?(x) }
-          if choices.include?(@file)
-            source = File.read(@file)
-            partial = Liquid::Template.parse(source)
-            context.stack do
-              partial.render(context)
-            end
-          else
-            "Included file '#{@file}' not found in _includes directory"
-          end
-        end
-      end
-    end
-  end
-end
-
-Liquid::Template.register_tag('include', Monad::Tags::IncludeTag)