tigefa 1.0.0 → 1.1.1

data/lib/tigefa/commands/build.rb

@@ -0,0 +1,70 @@
+module Tigefa
+  module Commands
+    class Build < Command
+      def self.process(options)
+        site = Tigefa::Site.new(options)
+
+        self.build(site, options)
+        self.watch(site, options) if options['watch']
+      end
+
+      # Private: Build the site from source into destination.
+      #
+      # site - A Tigefa::Site instance
+      # options - A Hash of options passed to the command
+      #
+      # Returns nothing.
+      def self.build(site, options)
+        source = options['source']
+        destination = options['destination']
+        Tigefa.logger.info "Source:", source
+        Tigefa.logger.info "Destination:", destination
+        print Tigefa.logger.formatted_topic "Generating..."
+        self.process_site(site)
+        puts "done."
+      end
+
+      # Private: Watch for file changes and rebuild the site.
+      #
+      # site - A Tigefa::Site instance
+      # options - A Hash of options passed to the command
+      #
+      # Returns nothing.
+      def self.watch(site, options)
+        require 'listen'
+
+        source = options['source']
+        destination = options['destination']
+
+        begin
+          dest = Pathname.new(destination).relative_path_from(Pathname.new(source)).to_s
+          ignored = Regexp.new(Regexp.escape(dest))
+        rescue ArgumentError
+          # Destination is outside the source, no need to ignore it.
+          ignored = nil
+        end
+
+        Tigefa.logger.info "Auto-regeneration:", "enabled"
+
+        listener = Listen::Listener.new(source, :ignore => ignored) do |modified, added, removed|
+          t = Time.now.strftime("%Y-%m-%d %H:%M:%S")
+          n = modified.length + added.length + removed.length
+          print Tigefa.logger.formatted_topic("Regenerating:") + "#{n} files at #{t} "
+          self.process_site(site)
+          puts  "...done."
+        end
+        listener.start
+
+        unless options['serving']
+          trap("INT") do
+            listener.stop
+            puts "     Halting auto-regeneration."
+            exit 0
+          end
+
+          loop { sleep 1000 }
+        end
+      end
+    end
+  end
+end

data/lib/tigefa/commands/doctor.rb

@@ -0,0 +1,67 @@
+module Tigefa
+  module Commands
+    class Doctor < Command
+      class << self
+        def process(options)
+          site = Tigefa::Site.new(options)
+          site.read
+
+          if healthy?(site)
+            Tigefa.logger.info "Your test results", "are in. Everything looks fine."
+          else
+            abort
+          end
+        end
+
+        def healthy?(site)
+          [
+            !deprecated_relative_permalinks(site),
+            !conflicting_urls(site)
+          ].all?
+        end
+
+        def deprecated_relative_permalinks(site)
+          contains_deprecated_pages = false
+          site.pages.each do |page|
+            if page.uses_relative_permalinks
+              Tigefa.logger.warn "Deprecation:", "'#{page.path}' uses relative" +
+                                  " permalinks which will be deprecated in" +
+                                  " Tigefa v1.2 and beyond."
+              contains_deprecated_pages = true
+            end
+          end
+          contains_deprecated_pages
+        end
+
+        def conflicting_urls(site)
+          conflicting_urls = false
+          urls = {}
+          urls = collect_urls(urls, site.pages, site.dest)
+          urls = collect_urls(urls, site.posts, site.dest)
+          urls.each do |url, paths|
+            if paths.size > 1
+              conflicting_urls = true
+              Tigefa.logger.warn "Conflict:", "The URL '#{url}' is the destination" +
+                " for the following pages: #{paths.join(", ")}"
+            end
+          end
+          conflicting_urls
+        end
+
+        private
+
+        def collect_urls(urls, things, destination)
+          things.each do |thing|
+            dest = thing.destination(destination)
+            if urls[dest]
+              urls[dest] << thing.path
+            else
+              urls[dest] = [thing.path]
+            end
+          end
+          urls
+        end
+      end
+    end
+  end
+end

data/lib/tigefa/commands/new.rb

@@ -0,0 +1,67 @@
+require 'erb'
+
+module Tigefa
+  module Commands
+    class New < Command
+      def self.process(args, options = {})
+        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
+        if preserve_source_location?(new_blog_path, options)
+          Tigefa.logger.error "Conflict:", "#{new_blog_path} exists and is not empty."
+          exit(1)
+        end
+
+        if options[:blank]
+          create_blank_site new_blog_path
+        else
+          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)
+          end
+        end
+
+        puts "New tigefa site installed in #{new_blog_path}."
+      end
+
+      def self.create_blank_site(path)
+        Dir.chdir(path) do
+          FileUtils.mkdir(%w(_layouts _posts _drafts))
+          FileUtils.touch("index.html")
+        end
+      end
+
+      def self.scaffold_post_content
+        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-jekyll.markdown"
+      end
+
+      private
+
+      def self.preserve_source_location?(path, options)
+        !options[:force] && !Dir["#{path}/**/*"].empty?
+      end
+
+      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-jekyll.markdown.erb"
+      end
+    end
+  end
+end

data/lib/tigefa/commands/serve.rb

@@ -0,0 +1,65 @@
+# -*- encoding: utf-8 -*-
+module Jekyll
+  module Commands
+    class Serve < Command
+      def self.process(options)
+        require 'webrick'
+        include WEBrick
+
+        destination = options['destination']
+
+        FileUtils.mkdir_p(destination)
+
+        # recreate NondisclosureName under utf-8 circumstance
+        fh_option = WEBrick::Config::FileHandler
+        fh_option[:NondisclosureName] = ['.ht*','~*']
+
+        s = HTTPServer.new(webrick_options(options))
+
+        s.mount(options['baseurl'], HTTPServlet::FileHandler, destination, fh_option)
+
+        Jekyll.logger.info "Server address:", "http://#{s.config[:BindAddress]}:#{s.config[:Port]}"
+
+        if options['detach'] # detach the server
+          pid = Process.fork { s.start }
+          Process.detach(pid)
+          Jekyll.logger.info "Server detatched with pid '#{pid}'.", "Run `kill -9 #{pid}' to stop the server."
+        else # create a new server thread, then join it with current terminal
+          t = Thread.new { s.start }
+          trap("INT") { s.shutdown }
+          t.join()
+        end
+      end
+
+      def self.webrick_options(config)
+        opts = {
+          :Port => config['port'],
+          :BindAddress => config['host'],
+          :MimeTypes => self.mime_types,
+          :DoNotReverseLookup => true,
+          :StartCallback => start_callback(config['detach'])
+        }
+
+        if !config['verbose']
+          opts.merge!({
+            :AccessLog => [],
+            :Logger => Log::new([], Log::WARN)
+          })
+        end
+
+        opts
+      end
+
+      def self.start_callback(detached)
+        unless detached
+          Proc.new { Jekyll.logger.info "Server running...", "press ctrl-c to stop." }
+        end
+      end
+
+      def self.mime_types
+        mime_types_file = File.expand_path('../mime.types', File.dirname(__FILE__))
+        WEBrick::HTTPUtils::load_mime_types(mime_types_file)
+      end
+    end
+  end
+end

data/lib/tigefa/configuration.rb

@@ -0,0 +1,238 @@
+# encoding: UTF-8
+
+module Tigefa
+  class Configuration < Hash
+
+    # Default options. Overridden by values in _config.yml.
+    # Strings rather than symbols are used for compatibility with YAML.
+    DEFAULTS = {
+      'source'        => Dir.pwd,
+      'destination'   => File.join(Dir.pwd, '_site'),
+      'plugins'       => '_plugins',
+      'layouts'       => '_layouts',
+      'data_source'   =>  '_data',
+      'keep_files'    => ['.git','.svn'],
+      'gems'          => [],
+
+      'timezone'      => nil,           # use the local timezone
+
+      'encoding'      => nil,           # use the system encoding
+
+      'safe'          => false,
+      'detach'        => false,          # default to not detaching the server
+      'show_drafts'   => nil,
+      'limit_posts'   => 0,
+      'lsi'           => false,
+      'future'        => true,           # remove and make true just default
+      'pygments'      => true,
+
+      'relative_permalinks' => true,     # backwards-compatibility with < 1.0
+                                         # will be set to false once 2.0 hits
+
+      'markdown'      => 'maruku',
+      'permalink'     => 'date',
+      'baseurl'       => '/',
+      'include'       => ['.htaccess'],
+      'exclude'       => [],
+      'paginate_path' => '/page:num',
+
+      'markdown_ext'  => 'markdown,mkd,mkdn,md',
+      'textile_ext'   => 'textile',
+
+      'port'          => '4000',
+      'host'          => '0.0.0.0',
+
+      'excerpt_separator' => "\n\n",
+
+      'maruku' => {
+        'fenced_code_blocks' => true,
+        'use_tex'    => false,
+        'use_divs'   => false,
+        'png_engine' => 'blahtex',
+        'png_dir'    => 'images/latex',
+        'png_url'    => '/images/latex'
+      },
+
+      'rdiscount' => {
+        'extensions' => []
+      },
+
+      'redcarpet' => {
+        'extensions' => []
+      },
+
+      'kramdown' => {
+        'auto_ids'      => true,
+        'footnote_nr'   => 1,
+        'entity_output' => 'as_char',
+        'toc_levels'    => '1..6',
+        'smart_quotes'  => 'lsquo,rsquo,ldquo,rdquo',
+        'use_coderay'   => false,
+
+        'coderay' => {
+          'coderay_wrap'              => 'div',
+          'coderay_line_numbers'      => 'inline',
+          'coderay_line_number_start' => 1,
+          'coderay_tab_width'         => 4,
+          'coderay_bold_every'        => 10,
+          'coderay_css'               => 'style'
+        }
+      },
+
+      'redcloth' => {
+        'hard_breaks' => true
+      }
+    }
+
+    # Public: Turn all keys into string
+    #
+    # Return a copy of the hash where all its keys are strings
+    def stringify_keys
+      reduce({}) { |hsh,(k,v)| hsh.merge(k.to_s => v) }
+    end
+
+    # Public: Directory of the Tigefa source folder
+    #
+    # override - the command-line options hash
+    #
+    # Returns the path to the Tigefa source directory
+    def source(override)
+      override['source'] || self['source'] || DEFAULTS['source']
+    end
+
+    def safe_load_file(filename)
+      case File.extname(filename)
+      when '.toml'
+        TOML.load_file(filename)
+      when /\.y(a)?ml/
+        YAML.safe_load_file(filename)
+      else
+        raise ArgumentError, "No parser for '#{filename}' is available. Use a .toml or .y(a)ml file instead."
+      end
+    end
+
+    # Public: Generate list of configuration files from the override
+    #
+    # override - the command-line options hash
+    #
+    # Returns an Array of config files
+    def config_files(override)
+      # Get configuration from <source>/_config.yml or <source>/<config_file>
+      config_files = override.delete('config')
+      if config_files.to_s.empty?
+        config_files = File.join(source(override), "_config.yml")
+        @default_config_file = true
+      end
+      config_files = [config_files] unless config_files.is_a? Array
+      config_files
+    end
+
+    # Public: Read configuration and return merged Hash
+    #
+    # file - the path to the YAML file to be read in
+    #
+    # Returns this configuration, overridden by the values in the file
+    def read_config_file(file)
+      next_config = safe_load_file(file)
+      raise ArgumentError.new("Configuration file: (INVALID) #{file}".yellow) unless next_config.is_a?(Hash)
+      Tigefa.logger.info "Configuration file:", file
+      next_config
+    rescue SystemCallError
+      if @default_config_file
+        Tigefa.logger.warn "Configuration file:", "none"
+        {}
+      else
+        Tigefa.logger.error "Fatal:", "The configuration file '#{file}' could not be found."
+        raise LoadError, "The Configuration file '#{file}' could not be found."
+      end
+    end
+
+    # Public: Read in a list of configuration files and merge with this hash
+    #
+    # files - the list of configuration file paths
+    #
+    # Returns the full configuration, with the defaults overridden by the values in the
+    # configuration files
+    def read_config_files(files)
+      configuration = clone
+
+      begin
+        files.each do |config_file|
+          new_config = read_config_file(config_file)
+          configuration = configuration.deep_merge(new_config)
+        end
+      rescue ArgumentError => err
+        Tigefa.logger.warn "WARNING:", "Error reading configuration. " +
+                     "Using defaults (and options)."
+        $stderr.puts "#{err}"
+      end
+
+      configuration.fix_common_issues.backwards_compatibilize
+    end
+
+    # Public: Split a CSV string into an array containing its values
+    #
+    # csv - the string of comma-separated values
+    #
+    # Returns an array of the values contained in the CSV
+    def csv_to_array(csv)
+      csv.split(",").map(&:strip)
+    end
+
+    # Public: Ensure the proper options are set in the configuration to allow for
+    # backwards-compatibility with Jekyll pre-1.0
+    #
+    # Returns the backwards-compatible configuration
+    def backwards_compatibilize
+      config = clone
+      # Provide backwards-compatibility
+      if config.has_key?('auto') || config.has_key?('watch')
+        Tigefa.logger.warn "Deprecation:", "Auto-regeneration can no longer" +
+                            " be set from your configuration file(s). Use the"+
+                            " --watch/-w command-line option instead."
+        config.delete('auto')
+        config.delete('watch')
+      end
+
+      if config.has_key? 'server'
+        Tigefa.logger.warn "Deprecation:", "The 'server' configuration option" +
+                            " is no longer accepted. Use the 'jekyll serve'" +
+                            " subcommand to serve your site with WEBrick."
+        config.delete('server')
+      end
+
+      if config.has_key? 'server_port'
+        Tigefa.logger.warn "Deprecation:", "The 'server_port' configuration option" +
+                            " has been renamed to 'port'. Please update your config" +
+                            " file accordingly."
+        # copy but don't overwrite:
+        config['port'] = config['server_port'] unless config.has_key?('port')
+        config.delete('server_port')
+      end
+
+      %w[include exclude].each do |option|
+        if config.fetch(option, []).is_a?(String)
+          Tigefa.logger.warn "Deprecation:", "The '#{option}' configuration option" +
+            " must now be specified as an array, but you specified" +
+            " a string. For now, we've treated the string you provided" +
+            " as a list of comma-separated values."
+          config[option] = csv_to_array(config[option])
+        end
+      end
+      config
+    end
+
+    def fix_common_issues
+      config = clone
+
+      if config.has_key?('paginate') && (!config['paginate'].is_a?(Integer) || config['paginate'] < 1)
+        Tigefa.logger.warn "Config Warning:", "The `paginate` key must be a" +
+          " positive integer or nil. It's currently set to '#{config['paginate'].inspect}'."
+        config['paginate'] = nil
+      end
+
+      config
+    end
+
+  end
+end

data/lib/tigefa/converter.rb

@@ -0,0 +1,48 @@
+module Tigefa
+  class Converter < Plugin
+    # Public: Get or set the pygments prefix. When an argument is specified,
+    # the prefix will be set. If no argument is specified, the current prefix
+    # will be returned.
+    #
+    # pygments_prefix - The String prefix (default: nil).
+    #
+    # Returns the String prefix.
+    def self.pygments_prefix(pygments_prefix = nil)
+      @pygments_prefix = pygments_prefix if pygments_prefix
+      @pygments_prefix
+    end
+
+    # Public: Get or set the pygments suffix. When an argument is specified,
+    # the suffix will be set. If no argument is specified, the current suffix
+    # will be returned.
+    #
+    # pygments_suffix - The String suffix (default: nil).
+    #
+    # Returns the String suffix.
+    def self.pygments_suffix(pygments_suffix = nil)
+      @pygments_suffix = pygments_suffix if pygments_suffix
+      @pygments_suffix
+    end
+
+    # Initialize the converter.
+    #
+    # Returns an initialized Converter.
+    def initialize(config = {})
+      @config = config
+    end
+
+    # Get the pygments prefix.
+    #
+    # Returns the String prefix.
+    def pygments_prefix
+      self.class.pygments_prefix
+    end
+
+    # Get the pygments suffix.
+    #
+    # Returns the String suffix.
+    def pygments_suffix
+      self.class.pygments_suffix
+    end
+  end
+end

data/lib/tigefa/converters/identity.rb

@@ -0,0 +1,21 @@
+module Tigefa
+  module Converters
+    class Identity < Converter
+      safe true
+
+      priority :lowest
+
+      def matches(ext)
+        true
+      end
+
+      def output_ext(ext)
+        ext
+      end
+
+      def convert(content)
+        content
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Tigefa
+  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
+          if @config['kramdown']['use_coderay']
+            %w[wrap line_numbers line_numbers_start tab_width bold_every css default_lang].each do |opt|
+              key = "coderay_#{opt}"
+              @config['kramdown'][key] = @config['kramdown']['coderay'][key] unless @config['kramdown'].has_key?(key)
+            end
+          end
+
+          Kramdown::Document.new(content, @config["kramdown"].symbolize_keys).to_html
+        end
+
+      end
+    end
+  end
+end

data/lib/tigefa/converters/markdown/maruku_parser.rb

@@ -0,0 +1,56 @@
+module Tigefa
+  module Converters
+    class Markdown
+      class MarukuParser
+        def initialize(config)
+          require 'maruku'
+          @config = config
+          @errors = []
+          load_divs_library if @config['maruku']['use_divs']
+          load_blahtext_library if @config['maruku']['use_tex']
+          enable_fenced_code_blocks if @config['maruku']['fenced_code_blocks']
+        rescue LoadError
+          STDERR.puts 'You are missing a library required for Markdown. Please run:'
+          STDERR.puts '  $ [sudo] gem install maruku'
+          raise FatalException.new("Missing dependency: maruku")
+        end
+
+        def load_divs_library
+          require 'maruku/ext/div'
+          STDERR.puts 'Maruku: Using extended syntax for div elements.'
+        end
+
+        def load_blahtext_library
+          require 'maruku/ext/math'
+          STDERR.puts "Maruku: Using LaTeX extension. Images in `#{@config['maruku']['png_dir']}`."
+
+          # Switch off MathML output
+          MaRuKu::Globals[:html_math_output_mathml] = false
+          MaRuKu::Globals[:html_math_engine] = 'none'
+
+          # Turn on math to PNG support with blahtex
+          # Resulting PNGs stored in `images/latex`
+          MaRuKu::Globals[:html_math_output_png] = true
+          MaRuKu::Globals[:html_png_engine] =  @config['maruku']['png_engine']
+          MaRuKu::Globals[:html_png_dir] = @config['maruku']['png_dir']
+          MaRuKu::Globals[:html_png_url] = @config['maruku']['png_url']
+        end
+
+        def enable_fenced_code_blocks
+          MaRuKu::Globals[:fenced_code_blocks] = true
+        end
+
+        def print_errors_and_fail
+          print @errors.join
+          raise MaRuKu::Exception, "MaRuKu encountered problem(s) while converting your markup."
+        end
+
+        def convert(content)
+          converted = Maruku.new(content, :error_stream => @errors).to_html.strip
+          print_errors_and_fail unless @errors.empty?
+          converted
+        end
+      end
+    end
+  end
+end