pandocomatic 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9bb00b9f3b336ff545db723e8148c4328f31523f
+  data.tar.gz: 5efa1bc50a8f98269467ef14b72e41715f4f4706
+SHA512:
+  metadata.gz: a0c11901a985c60c0103cd53796fb884c180568cabb35ce001b476c661f07553c9c14bd027603a0cc66f21b233294f60fc46cfd8944ec758b7fe0c8e5596ce7d
+  data.tar.gz: a19731270d23f2ca21acf6fdf5fe017fe8a629aff100661669c69f758396ff59ba0fe33dcd25d7f40aafe853645a7f328860aaaf335b6105f605c7c6ce42135d

data/bin/pandoc2yaml

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+require 'trollop'
+require 'yaml'
+
+require_relative '../lib/pandocomatic/pandoc_metadata.rb'
+
+opts = Trollop::options do
+  version "pandoc2yaml 1"
+  banner <<-EOB
+
+pandoc2yaml collects the metadata in a pandoc markdown file and exports it to
+yaml.
+
+Usage:
+
+    pandoc2yaml [-o output.yaml] input.markdown
+
+Options:
+EOB
+
+  opt :output, "optional output file, use STDOUT as default", :type => :string
+end
+
+begin
+  if ARGV.length != 1 then
+    Trollop::die "pandoc2yaml expects one input file as argument"
+  end
+
+  input = ARGV.first
+
+  Trollop::die "#{input} does not exist" if not File.exist? input
+  Trollop::die "#{input} is not a file" if not File.file? input
+  Trollop::die "#{input} is not readable" if not File.readable? input
+  
+  metadata = YAML.dump Pandocomatic::PandocMetadata.load_file input
+
+  if opts[:output].nil? then
+    $stdout << metadata 
+  else
+    File.open(opts[:output], "w") do |file|
+      file << metadata
+    end
+  end
+
+rescue Exception => e
+  warn "Error while collecting metadata: #{e.message}"
+end

data/bin/pandocomatic

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+
+require 'trollop'
+require 'yaml'
+
+require_relative '../lib/pandocomatic/dir_converter.rb'
+require_relative '../lib/pandocomatic/file_converter.rb'
+require_relative '../lib/pandocomatic/configuration.rb'
+
+def convert_file input, opts
+  puts "converting file"
+end
+
+def convert_dir input, opts
+  puts "converting dir"
+end
+
+def convert_tree input, opts
+  puts "Converting tree"
+end
+
+opts = Trollop::options do
+  version "pandocomatic 0.0.1"
+  banner <<-EOB
+
+Pandocomatic automates the use of pandoc (<http://www.pandoc.org>). It can be
+used to convert a file, a directory, or a directory tree.
+
+Usage:
+
+  Convert a file
+
+      pandocomatic [--config file.yaml] --output output.file input.file
+
+  Convert a directory or directory tree
+
+      pandocomatic [--config file.yaml] [--recursive] --output output.dir input.dir
+
+Options:
+EOB
+  opt :config, "pandocomatic configuration file", :type => :string
+  opt :recursive, "apply pandocomatic recursively"
+  opt :target, "named conversion target", :type => :string
+  opt :output, "output file or directory", :type => :string
+end
+
+# input file/directory
+Trollop::die "Expect exactly one input file or directory" if ARGV.length != 1
+input = ARGV.first
+
+Trollop::die "Expect an output file or directory" if opts[:output].nil?
+output = opts[:output]
+
+# Configuration
+if opts[:config].nil? then
+  config = Pandocomatic::Configuration.new
+else
+  if not File.exist? opts[:config] or not File.readable? opts[:config] then
+    Trollop::die "Cannot read configuration file #{opts[:config]}" if File
+  end
+
+  config = Pandocomatic::Configuration.new YAML.load_file opts[:config]
+end
+
+
+if File.directory? input then
+  if File.exist? output and not File.directory? output then
+    Trollop::die "Expected an output directory, found a file instead"
+  end
+
+  config.configure({'recursive' => true}) if opts[:recursive] 
+  Pandocomatic::DirConverter.new(input, output, config).convert
+
+else 
+  # input is one file
+  Pandocomatic::FileConverter.new.convert input, output, config
+end

data/lib/pandocomatic/configuration.rb

@@ -0,0 +1,124 @@
+module Pandocomatic
+
+  require 'paru/pandoc'
+
+  DEFAULT_CONFIG = {
+        'recursive' => true,
+        'follow_links' => false,
+        'skip' => ['.*', 'pandocomatic.yaml'],
+        'targets' => {
+          'markdown' => {
+            'pattern' => ['*.markdown', '*.md'],
+            'pandoc' => {
+              'from' => 'markdown',
+              'to' => 'html5'
+            }
+          }
+        }
+      }
+
+  FORMAT_TO_EXT = {
+    'native' => 'hs',
+    'markdown_strict' => 'markdown',
+    'markdown_phpextra' => 'markdown',
+    'markdown_github' => 'markdown',
+    'html5' => 'html',
+    'docx' => 'docx',
+    'latex' => 'tex'
+  }
+
+  class Configuration
+
+    def initialize hash = DEFAULT_CONFIG
+      @config = {
+        'recursive' => true,
+        'follow_links' => false,
+        'skip' => ['.*'],
+        'targets' => {}
+      }
+      @convert_patterns = {}
+      configure hash
+    end
+
+    def configure options
+      options.each do |key, value|
+        if key == 'targets' then
+          update_targets value
+        else
+          @config[key] = value
+        end
+      end
+    end
+
+    def reconfigure options
+      new_config = Marshal.load(Marshal.dump(self))
+      new_config.configure options
+      new_config
+    end
+
+    def marshal_dump
+      [@config, @convert_patterns]
+    end
+
+    def marshal_load array
+      @config, @convert_patterns = array
+    end
+
+    def update_targets targets
+      targets.each do |name, options|
+        @config['targets'][name] = options
+        @convert_patterns[name] = options['pattern']
+      end
+    end
+
+    def skip? src
+      @config['skip'].any? {|pattern| File.fnmatch pattern, File.basename(src)}
+    end
+
+    def convert? src
+      @convert_patterns.values.flatten.any? {|pattern| File.fnmatch pattern, File.basename(src)}
+    end
+
+    def recursive?
+      @config['recursive']
+    end
+
+    def follow_links?
+      @config['follow_links']
+    end
+    
+    def set_extension dst
+      dir = File.dirname dst
+      ext = File.extname dst
+      basename = File.basename dst, ext
+      File.join dir, "#{basename}.#{find_extension dst}"
+    end
+
+    def find_extension dst
+      target = determine_target dst
+      if target.nil? then
+        extension = 'html'
+      else
+        to = @config['targets'][target]['pandoc']['to']
+        extension = FORMAT_TO_EXT[to] || to
+      end
+    end
+
+    
+    def get_target_config target
+      @config['targets'][target]
+    end
+
+    def determine_target src
+      @convert_patterns.select do |target, patterns|
+        patterns.any? {|pattern| File.fnmatch pattern, File.basename(src)}
+      end.keys.first
+    end
+
+    def to_s 
+      @config
+    end
+
+  end
+
+end

data/lib/pandocomatic/dir_converter.rb

@@ -0,0 +1,107 @@
+module Pandocomatic
+
+  require 'fileutils'
+
+  require_relative 'file_converter.rb'
+
+  CONFIG_FILE = 'pandocomatic.yaml'
+
+  class DirConverter
+
+    def initialize src, dst, config
+      @src_root = src
+      @dst_root = dst
+      @config = config
+    end
+
+    def convert src_dir = @src_root, dst_dir = @dst_root, config = @config
+
+      ensure_directory dst_dir
+      config = reconfigure config, src_dir
+
+      # Convert each file and subdirectory according to the specifications set in config
+      Dir.foreach src_dir do |filename|
+        src = File.join src_dir, filename
+        
+        next if config.skip? src
+
+        dst = File.join dst_dir, filename
+
+        if File.directory? src and config.recursive?
+          
+          # Convert subdirectories only when the recursivity is set in the
+          # configuration.
+          convert src, dst, config
+
+        elsif File.symlink? src and not config.follow_links
+
+          recreate_link src, dst
+
+        elsif File.file? src 
+
+          raise "Cannot read file #{src}" if not File.readable? src
+          raise "Cannot write file #{dst}" if File.exist? dst and not File.writable? dst
+
+          # Check if the source file has to be converted. If so, convert;
+          # otherwise, copy it to the destination tree
+          if config.convert? src then
+            dst = config.set_extension dst
+            Pandocomatic::FileConverter.new.convert src, dst, config
+          else
+            # copy file
+            FileUtils.cp src, dst
+          end
+
+        else
+          warn "Unclear what to do with #{src}, skipping this file"
+          next        
+        end
+
+      end
+
+    end
+  
+    private
+    
+    # If the source directory contains a configuration file, use it to
+    # reconfigure the converter. Otherwise, use the current configuration
+    def reconfigure current_config, src_dir
+      config_file = File.join src_dir, CONFIG_FILE
+      if File.exist? config_file then
+        require 'yaml'
+        current_config.reconfigure YAML.load_file config_file
+      else
+        current_config
+      end
+    end
+
+    # Ensure that dir exist (and is a directory)
+    def ensure_directory dir
+      if Dir.exist? dir then
+        raise "#{dir} is not a directory" if not File.directory? dir
+      else
+        begin
+          Dir.mkdir dir
+        rescue SystemCallError => e
+          raise "Error trying to create directory #{dir}: #{e.message}"
+        end
+      end
+    end
+
+    # Recreate source link in destination tree if it points to somewhere inside
+    # the source tree
+    def recreate_link src, dst
+      src_target = File.readlink(src)
+      full_src_target = File.realpath src_target
+      if full_src_target.start_with? @src_root
+        dst_target = File.join @dst_root, src_target
+        File.symlink dst_target, dst
+      else
+        warn "Skipping link #{src} because it points to outside the source tree"
+      end
+    end
+
+
+  end
+    
+end

data/lib/pandocomatic/file_converter.rb

@@ -0,0 +1,74 @@
+module Pandocomatic
+
+
+  require 'paru/pandoc'
+  require_relative 'pandoc_metadata.rb'
+
+  class FileConverter
+
+    def initialize
+    end
+
+    def convert src, dst, current_config
+      metadata = PandocMetadata.load_file src
+
+      if metadata.has_target? then
+        target = metadata.target
+      else
+        target = current_config.determine_target src
+      end
+
+      config = current_config.get_target_config target
+      pandoc_options = (config['pandoc'] || {}).merge(metadata.pandoc_options || {})
+
+      input = File.read src
+      input = preprocess input, config
+      input = pandoc input, pandoc_options
+      output = postprocess input, config
+
+      if dst.to_s.empty? and metadata.pandoc_options.has_key? 'output'
+        dst = metadata.pandoc_options['output']
+      end
+     
+      File.open( dst, 'w') do |file| 
+        file << output
+      end
+    end
+
+    private
+
+    def pandoc input, options
+      converter = Paru::Pandoc.new
+      options.each do |option, value|
+        converter.send option, value unless option == 'output'
+        # don't let pandoc write the output to enable postprocessing
+      end
+      converter << input
+    end
+
+    def preprocess input, config
+      process input, 'preprocessors', config
+    end
+
+    def postprocess input, config
+      process input, 'postprocessors', config
+    end
+
+    # Run the input string through a list of filters called processors. There
+    # are to types: preprocessors and postprocessors
+    def process input, type, config
+      if config.has_key? type then
+        processors = config[type]
+        output = input
+        processors.each do |processor|
+          output = processor << output
+        end
+      else
+        input
+      end
+    end
+
+
+  end
+
+end

data/lib/pandocomatic/pandoc_metadata.rb

@@ -0,0 +1,63 @@
+module Pandocomatic
+
+  require 'json'
+  require 'yaml'
+  require 'paru/pandoc'
+
+  require_relative 'configuration.rb'
+
+  class PandocMetadata < Hash
+
+    def initialize hash = {}
+      super
+      merge! hash
+    end
+
+    # Collect the metadata embedded in the src file
+    def self.load_file src
+      begin
+        json_reader = Paru::Pandoc.new {from 'markdown'; to 'json'}
+        json_document = JSON.parse json_reader << File.read(src)
+        if json_document.first["unMeta"].empty? then
+          return PandocMetadata.new 
+        else
+          json_metadata = [json_document.first, []]
+          json_writer = Paru::Pandoc.new {from 'json'; to 'markdown'; standalone}
+          yaml_metadata = json_writer << JSON.generate(json_metadata)
+          return PandocMetadata.new YAML.load yaml_metadata
+        end
+      rescue Exception => e
+        raise "Error while reading metadata from #{src}; Are you sure it is a pandoc markdown file?\n#{e.message}"
+      end
+    end
+
+    def has_target?
+      has_key? 'pandocomatic' and self['pandocomatic'].has_key? 'target'
+    end
+
+    def target
+      if has_target? then
+        self['pandocomatic']['target']
+      else
+        ''
+      end
+    end
+
+    def has_pandoc_options?
+      has_key? 'pandocomatic' and self['pandocomatic'].has_key? 'pandoc'
+    end
+
+    def pandoc_options
+      if has_pandoc_options? then
+        self['pandocomatic']['pandoc']
+      else
+        {}
+      end
+    end
+
+    def to_configuration parent_config = Configuration.new
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: pandocomatic
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Huub de Beer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: paru
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+description: 'Automate the use of pandoc <http://pandoc.org>: use pandocomatic as
+  a makefile to convert one file, a whole directory of files, or even as a static
+  site generator.'
+email: Huub@heerdebeer.org
+executables:
+- pandocomatic
+- pandoc2yaml
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/pandoc2yaml
+- bin/pandocomatic
+- lib/pandocomatic/configuration.rb
+- lib/pandocomatic/dir_converter.rb
+- lib/pandocomatic/file_converter.rb
+- lib/pandocomatic/pandoc_metadata.rb
+homepage: https://github.com/htdebeer/pandocomatic
+licenses:
+- GPL3
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- pandoc, a universal document converer <http://pandoc.org>
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Automate the use of pandoc
+test_files: []