mdoc 0.0.3 → 0.0.5

data/.rubocop.yml

@@ -0,0 +1,2 @@
+Encoding:
+  Enabled: false

data/README.md

@@ -1,47 +1,134 @@
-
-MDOC: markdown document converting/management tool
-=======================================================
-
-Requirement
-----------------
-
-- Ruby 1.9.x
-- pandoc in path for docx/rtf conversion
-- xelatex in path for pdf conversion
-
-Command line options
--------------------------
-
-Convert a markdown file (`readme.md`) to docx (`readme.docx`):
-
-    mdoc -t docx readme.md
-
-Use `mdoc --help` for more options.
-
-Online Preview
------------------
-
-Put a markdown document to an temporary url for revew:
-
-    mdoc --preview readme.md
-
-This will open your browser to show a converted document (use documentup).
-
-Meta information in header
------------------------------
-
-Three different formats are supported:
-
-1. pandoc like three line header:
-
-    % title
-    % author
-    % date
-
-2. multi-header (separate by first blank line)
-
-    Title: some key
-    Author: some key
-
-3. separator: 
-  if `% ---` is the first no-blank line, the contents between until the next `% ---` will be treated as header.
+# Mdoc-gem
+
+A tool for convert document between several different formats.
+
+Mdoc has a modularized structure, easily extensible with custom processors.
+
+## Install
+
+    gem install mdoc
+
+(requires ruby 1.9.x)
+
+## Synopsis
+
+- Convert a markdown file (`readme.md` in this example) to html (use `default.html` template):
+
+    mdoc readme.md
+
+This will create a `readme.html` file besides `readme.md`.
+
+- Convert a markdown file with a custom template:
+
+    mdoc -t custom.html readme.md
+
+Mdoc will try to find `custom.html.erb` from `./templates` folder, or you can specify it by:
+
+    mdoc -t custom.html -d ~/mdoc_templates readme.md
+
+- Specify output filename:
+
+    mdoc -o README.html readme.md
+
+Or print out to STDOUT:
+
+    mdoc -O readme.md
+
+## Markdown with Meta Information
+
+The default source file format is markdown[^1]. Mdoc convert it into a document class
+`Mdoc::Document::Kramdown`, with supports all extensions from Kramdown[^2].
+
+[^1]: Wikipedia: http://en.wikipedia.org/wiki/Markdown
+[^2]: Kramdown Syntax: http://kramdown.rubyforge.org/quickref.html
+
+Additionally, you can put meta informations in the begin of your source file, in two
+different format:
+
+1. pandoc like three line header (max 3 lines)
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    % title
+    % author
+    % date
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+2. multi-header (first non-blank line with three or more dashes)
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    % ---
+    title: some key
+    author: some key
+    % ---
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The heading `%` is optional. 
+
+You can access those information from erb files by `<%= meta.title %>`
+
+## Processors
+
+The following processors are enabled by default:
+
+- `add_toc`: Add `table of contents` field in the contents body;
+- `add_title`: Add a `meta.title` as a first level header in the contents body;
+- `smart_code_block`: delete extra heading/trailing blank lines in code blocks;
+
+You can disable some of the processors by:
+
+    mdoc -z add_toc,smart_code_block readme.md
+
+## Use Mdoc as a Library
+
+~~~~~~~~~~~~~~~~~~~~~~~~~ ruby
+
+    require 'mdoc'
+    module Mdoc
+      class Processor
+        class Custom < Processor
+          def process!(document) 
+            document.meta.title += ' (draft)' # edit the document title
+            document.body.gsub!(/https/, 'http')  # change the source body text
+          end
+
+          def repeatable?
+            true # default is false
+          end
+        end
+
+        class Other < Processor
+          def process!(document)
+            # do some thing ...
+          end
+        end
+      end
+
+      class Writer
+        class CustomWriter
+          def process!(document)
+            # fh.puts ...
+          end
+        end
+      end
+    end
+
+    Mdoc.convert!('somefile.md') do |pipeline|
+      pipeline.insert :custom # insert into the begin of the processor pipeline
+      pipeline.insert :other, :before => :custom # or :after => :some_processor
+      pipeline.remove :todo
+
+      pipeline.writer = CustomWriter
+    end
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Unless you define a method `repeatable?` and returns `true`, one processor will
+process a document at most once.
+
+## Tests
+
+    rubocop && rspec

data/bin/mdoc

@@ -1,32 +1,11 @@
-#!/usr/bin/env ruby
-# vim: ft=ruby
-
-$: << 'lib' # debug only
-
-require "mdoc"
-require "optparse"
-
-options = {}
-
-optparse = OptionParser.new do |opts|
-  opts.banner = "Usage: mdoc [options] filename.md"
-  opts.separator "Options:"
-
-  options[:type] = 'odt'
-  opts.on('-t TYPE', '--type TYPE', 'output file type') do |type|
-    options[:type] = type
-  end
-
-  opts.on_tail('-h', '--help', 'Display this screen') do
-    puts opts
-    exit
-  end
-end
-
-optparse.parse!(ARGV)
-
-file = ARGV[0]
-raise "Only markdown file (`*.md`) can be parsed" unless file =~ /\.md$/
-
-klass = options[:type].to_s.capitalize
-eval("Mdoc::" + klass).new(file).convert
+#!/usr/bin/env ruby
+# encoding: utf-8
+# vi: ft=ruby
+
+# $LOAD_PATH.unshift 'lib' # debug only
+require 'mdoc'
+
+Mdoc.load_conf_files %w[/etc/mdoc.conf ~/.mdoc.conf]
+Mdoc.load_cli_options ARGV
+
+Mdoc.execute!

data/lib/mdoc/document/kramdown.rb

@@ -0,0 +1,25 @@
+require 'kramdown'
+
+module Mdoc
+  class Document
+    class Kramdown < Document
+      def kramdown
+        # TODO: toc and other preprocessors
+        @kramdown = ::Kramdown::Document.new(@body) unless @kramdown
+        @kramdown
+      end
+
+      def body_html
+        kramdown.to_html
+      end
+
+      def body_latex
+        kramdown.to_latex
+      end
+
+      alias_method :body_tex, :body_latex
+      alias_method :to_latex, :body_latex
+      alias_method :to_html, :body_html
+    end
+  end
+end

data/lib/mdoc/document.rb

@@ -0,0 +1,87 @@
+require 'forwardable'
+
+module Mdoc
+  class Document
+
+    LOOP_MAX = 99
+
+    extend Forwardable
+    attr_accessor :file, :meta, :body, :tpl_file, :out_file,
+                  :smeta, # meta from source file
+                  :performed # performed processor
+
+    # rubocop:disable MethodLength
+    def initialize(path)
+      if path.is_a?(String)
+        @file = path
+        path = File.new(@file, 'r:utf-8')
+      end
+
+      # initialize performed processor list
+      @performed = {}
+
+      position = nil # before meta, :meta, :body, :between, :pandoc_header
+      pandoc_meta, raw_meta = [], ''
+      @meta, @body = Meta.new, ''
+      path.each do |line|
+        # puts position.to_s + line if position
+        line.chomp!
+
+        if line.match(/^\s*$/)
+          next if position.nil? || position == :between
+        else
+          position = :body if position == :between
+        end
+
+        if line.match(/^\%?\s*\-{3,}\s*$/) # meta headers
+          position = :between if position == :meta
+          position = :meta unless position
+          next
+        elsif line.match(/^\%\s*/)
+          position = :pandoc_header if position.nil?
+        else
+          position = :body unless position # if position == :pandoc_header
+        end
+
+        if position == :pandoc_header
+          pandoc_meta << line.gsub(/^\%\s*/, '')
+          position = :between if pandoc_meta.size >= 3
+        end
+
+        raw_meta << line << "\n" if position == :meta
+        @body << line << "\n" if position == :body
+      end
+
+      @meta.load(raw_meta) if raw_meta.size > 0
+      if pandoc_meta.size > 0
+        @meta.title, @meta.author, @meta.date = pandoc_meta[0 .. 2]
+      end
+
+      # source meta holds meta information from source file only
+      @smeta = @meta.dup
+    end
+    # rubocop:ensable MethodLength
+
+    # apply processors by processor name (if corresponding processor)
+    # class defined.
+    # rubocop:disable MethodLength
+    def apply!(pn)
+      prc = Mdoc.get_processor(pn)
+      if performed[prc]
+        if prc.new.repeatable?
+          prc.new.process! self
+          performed[prc] += 1
+          # error if performed too many times (prevent dead loop)
+          raise "loop max reached: #{prc}" if performed[prc] > LOOP_MAX
+        end
+      else # not performed
+        prc.new.process! self
+        performed[prc] = 1
+      end
+    end
+    # rubocop:enable MethodLength
+
+    def_delegators :@meta, :title, :author, :date
+
+  end
+end

data/lib/mdoc/meta.rb

@@ -0,0 +1,14 @@
+require 'yaml'
+require 'ostruct'
+
+module Mdoc
+  ## parsed meta information from the source file
+  class Meta < OpenStruct
+
+    def load(contents)
+      # contents is expected as a hash in yaml format
+      YAML.load(contents).each { |k, v| self.send("#{k}=".to_sym, v) }
+      self
+    end
+  end
+end

data/lib/mdoc/options.rb

@@ -0,0 +1,104 @@
+require 'optparse'
+
+module Mdoc
+
+  # default configurations
+  # rubocop:disable MethodLength
+  def load_defaults
+    hsh = {
+      template: 'html',
+      output: nil,
+      no_output: false,
+      processors: [],
+      no_processors: [],
+      tpl_directories: [],
+      s_files: [],
+    }
+
+    # create a dynamic struct with default values
+    @opts = Struct.new(*hsh.keys).new(*hsh.values)
+  end
+  # rubocop:enable MethodLength
+
+  # load configuration files (if exists)
+  # from a list of candidates
+  def load_conf_files(file_ary)
+    load_defaults unless opts
+
+    file_ary.each do |file|
+      yml = YAML.load(File.open(file, 'r:utf-8').read) if File.exists? file
+      set_option! yml if yml
+    end
+  end
+
+  # load command line options
+  # rubocop:disable LineLength, MethodLength
+  def load_cli_options(argv = ARGV)
+    load_defaults unless opts
+    argv = %w[-h] if argv.size == 0
+
+    OptionParser.new do |opts|
+      opts.banner = 'Usage: mdoc [options] file.md [file2.md]'
+      opts.separator ''
+      opts.separator 'Options: '
+
+      opts.on('-t TPL', '--template TPL', 'output file template') do |tpl|
+        set_option!({ template: tpl })
+      end
+
+      opts.on('-o FILE', '--output FILE', 'output file template') do |file|
+        set_option!({ output: file })
+      end
+
+      opts.on('-p P,P2', '--processors P,P2', 'enable processors') do |p|
+        p.split(',').each do |pr|
+          @opts.processors << pr unless @opts.processors.include?(pr)
+        end
+      end
+
+      opts.on('-z P,P2', '--disable P,P2', 'disable processors') do |op|
+        op.split(',').each do |pr|
+          @opts.no_processors << pr unless @opts.processors.include?(pr)
+        end
+      end
+
+      opts.on('-d D,D2', '--template_directories D,D2', 'directories for finding template') do |d|
+        d.split(',').each do |dir|
+          dir = File.expand_path(dir)
+          @opts.tpl_directories << dir unless @opts.tpl_directories.include?(dir)
+        end
+      end
+
+      opts.on('-O', '--no-output', 'dump result to STDOUT') do
+        @opts.no_output = true
+      end
+
+      opts.on_tail('-v', '--version', 'show mdoc version') do
+        puts Mdoc::VERSION
+        exit
+      end
+
+      opts.on_tail('-h', '--help', 'display this screen') do
+        puts opts
+        exit
+      end
+
+    end.parse!(argv)
+
+    set_option!({ s_files: argv })
+
+    # check consistency for related options
+    raise 'you can not specify output file when there are more than on source files.' if opts.output && opts.s_files.size > 0
+    raise 'you can not speficy output file with --no-output option' if opts.output && opts.no_output
+  end
+  # rubocop:enable LineLength, MethodLength
+
+  private
+
+  # set options from a hash, raise errors
+  # if a key not exists in default hash
+  def set_option!(hsh)
+    hsh.each { |k, v| @opts.send(:"#{k}=", v) }
+  end
+
+end

data/lib/mdoc/pipeline.rb

@@ -0,0 +1,59 @@
+module Mdoc
+  class Pipeline
+    attr_accessor :writer
+    attr_reader :processors
+
+    def initialize(ary = [])
+      @processors = []
+      append ary
+    end
+
+    # get processor class in name
+    def get_prc(prc)
+      prc = [prc] unless prc.is_a?(Array)
+      prc.map { |pn| Mdoc.get_processor(pn) }
+    end
+
+    def insert(prc, opts = {})
+      prc = get_prc(prc)
+      raise 'can not set before with after' if opts[:before] && opts[:after]
+      ankor = opts[:before] || opts[:after]
+      offset = get_offset(opts) if ankor
+      ankor ? @processors.insert(offset, *prc) :
+              @processors = prc.concat(@processors)
+    end
+
+    # from :before, :after, calculate insert offset
+    def get_offset(opts)
+      phash = Hash[@processors.map.with_index.to_a]
+      if opts[:before]
+        offset = phash[Mdoc.get_processor(opts[:before])]
+      elsif opts[:after]
+        offset = phash[Mdoc.get_processor(opts[:after])] + 1
+      end
+      offset
+    end
+
+    def append(prc)
+      prc = get_prc(prc)
+      prc.each { |p| @processors << p }
+    end
+
+    def remove(prc)
+      prc = get_prc(prc)
+      prc.map { |pn| @processors.delete(pn) }
+    end
+
+    # recursively apply processors to document
+    def apply!(document)
+      @processors.each do |pn|
+        prc = Mdoc.get_processor(pn)
+        prc.new.pre_processors.each { |p| document.apply!(p) }
+        document.apply!(prc)
+        prc.new.post_processors.each { |p| document.apply!(p) }
+      end
+
+      writer.new.process!(document)
+    end
+  end
+end

data/lib/mdoc/processor/add_title.rb

@@ -0,0 +1,15 @@
+module Mdoc
+  class Processor
+    class AddTitle < Processor
+      def process!(doc)
+        title = doc.title
+        if title
+          unless doc.body =~ /^\s*\#*\s*#{title}/
+            title = '# ' + title + "\n\n"
+            doc.body = title + doc.body
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mdoc/processor/add_toc.rb

@@ -0,0 +1,11 @@
+module Mdoc
+  class Processor
+    class AddToc < Processor
+      def process!(doc)
+        unless doc.body =~ /\{\:toc\}/
+          doc.body = "\n* Table of Contents\n{:toc}\n\n" + doc.body
+        end
+      end
+    end
+  end
+end

data/lib/mdoc/processor/smart_code_block.rb

@@ -0,0 +1,37 @@
+# Delete extra blank lines inside ~~~~~ code bloks
+#
+# rubocop:disable MethodLength
+module Mdoc
+  class Processor
+    class SmartCodeBlock < Processor
+      def process!(doc)
+        odd, last, hold = false, false, 0
+        new_body = ''
+        doc.body.split(/\n/).each do |line|
+          if line =~ /^\s*~{3,}\s*\w*\s*/
+            hold = 0 if odd
+            odd = odd ? false : true
+            last = true
+          else
+            next if last && odd && (line =~ /^\s*$/)
+
+            if line =~ /^\s*$/
+              hold += 1 # hold the line
+              next
+            end
+
+            last = false
+          end
+
+          hold.times { new_body << "\n" }
+          hold = 0
+          new_body << line << "\n"
+        end
+
+        doc.body = new_body.chomp
+        # puts doc.body
+      end
+    end
+  end
+end
+# rubocop:enable MethodLength

data/lib/mdoc/processor.rb

@@ -0,0 +1,21 @@
+module Mdoc
+  class Processor
+    # add processors apply before self
+    def pre_processors
+      []
+    end
+
+    # apply those processors after self
+    def post_processors
+      []
+    end
+
+    # do the real jobs, raise for errors
+    def process!(document); end
+
+    # by default, can not perform more than one times for a single document
+    def repeatable?
+      false
+    end
+  end
+end

data/lib/mdoc/version.rb

@@ -1,4 +1,3 @@
-module Mdoc
-  VERSION = '0.0.3'
-end
-
+module Mdoc
+  VERSION = '0.0.5'
+end

data/lib/mdoc/writer.rb

@@ -0,0 +1,18 @@
+require 'tilt/erb'
+
+module Mdoc
+  class Writer
+    attr_accessor :tilt
+
+    def out(doc)
+      Mdoc.opts.no_output ? $stdout : File.new(doc.out_file, 'w:utf-8')
+    end
+
+    def process!(doc)
+      @tilt = Tilt::ERBTemplate.new(doc.tpl_file)
+      oh = out(doc)
+      oh.write @tilt.render doc
+      oh.close unless oh == $stdout
+    end
+  end
+end