pandocfilters 0.0.1.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d03820dd1432a65258ce231a8c33965755bd6d7e
+  data.tar.gz: 3539e051a195ada06037daa752569b618033e725
+SHA512:
+  metadata.gz: babf25b565f5fcb466f38afcb7baeecfc81c18a24f48c6fc473350803ddb2f028ea1d78ffdc81b981a4e16fdd1462aaf2423aa554ffeeb7654da91bacbe8d11c
+  data.tar.gz: 0da641977ceace8e8802afddb0a57bc8a99472188045b13b05d70da9b89a7670b4aee29c0616dd90b1a0d48f4dcef6486c8bd254127a477abdfb9fd53e8c03de

data/lib/pandocfilters.rb

@@ -0,0 +1,115 @@
+require 'json'
+require_relative 'pandocfilters/node'
+
+module PandocFilters
+
+  # Fetch prebuild filter.
+  #
+  # @param name [String] Filter name.
+  # @return     [String] Path to the filter.
+  def self.filter(name)
+    glob = File.expand_path('../pandocfilters/filters/*' ,__FILE__)
+    filters = Dir.glob(glob).map { |f| File.basename(f) }
+
+    raise "No build-in filter names #{name}" unless filters.include?(name)
+
+    File.expand_path("../pandocfilters/filters/#{name}" ,__FILE__)
+  end
+
+  # Converts an action into a filter that reads a JSON-formatted
+  # pandoc document from stdin, transforms it by walking the tree
+  # with the action, and returns a new JSON-formatted pandoc document
+  # to stdout.  The argument is a function action(key, value, format, meta),
+  # where key is the type of the pandoc object (e.g. 'Str', 'Para'),
+  # value is the contents of the object (e.g. a string for 'Str',
+  # a list of inline elements for 'Para'), format is the target
+  # output format (which will be taken for the first command line
+  # argument if present), and meta is the document's metadata.
+  # If the function returns None, the object to which it applies
+  # will remain unchanged.  If it returns an object, the object will
+  # be replaced.    If it returns a list, the list will be spliced in to
+  # the list to which the target object belongs.    (So, returning an
+  # empty list deletes the object.)
+  #
+  # action Callable object
+  #
+  # Return Manuplated JSON
+  def self.process(&action)
+    doc = JSON.load($stdin.read)
+    if ARGV.size > 1
+      format = ARGV[1]
+    else
+      format = ""
+    end
+    altered = self.walk(doc, format, doc[0]['unMeta'], &action)
+    JSON.dump(altered, $stdout)
+  end
+
+  # Walks the tree x and returns concatenated string content,
+  # leaving out all formatting.
+  def self.stringify(x)
+    result = []
+
+    go = lambda do |key, val, format, meta|
+      if ['Str', 'MetaString'].include? key
+        result.push(val)
+      elsif key == 'Code'
+        result.push(val[1])
+      elsif key == 'Math'
+        result.push(val[1])
+      elsif key == 'LineBreak'
+        result.push(" ")
+      elsif key == 'Space'
+        result.push(" ")
+      end
+    end
+
+    self.walk(x, "", {}, &go)
+
+    result.join('')
+  end
+
+  # Returns an attribute list, constructed from the
+  # dictionary attrs.
+  def attributes(attrs)
+    attrs ||= {}
+    ident = attrs.fetch('id', '')
+    classes = attrs.fetch("classes", [])
+    keyvals = []
+    attrs.keep_if { |k, v| k != "classes" && k != "id" }.each do |k, v|
+      keyvals << [k, v]
+    end
+
+    [ident, classes, keyvals]
+  end
+
+  # Walk a tree, applying an action to every object.
+  # Returns a modified tree.
+  def self.walk(x, format, meta, &action)
+    if x.is_a? Array
+      array = []
+      x.each do |item|
+        if item.is_a?(Hash) && item.has_key?('t')
+          res = action.call(item['t'], item['c'], format, meta)
+          if res.nil?
+            array.push(self.walk(item, format, meta, &action))
+          elsif res.is_a? Array
+            res.each { |z| array.push(self.walk(z, format, meta, &action)) }
+          else
+            array.push(self.walk(res, format, meta, &action))
+          end
+        else
+          array.push(self.walk(item, format, meta, &action))
+        end
+      end
+      return array
+    elsif x.is_a? Hash
+      hash = {}
+      x.each { |k, _| hash[k] = self.walk(x[k], format, meta, &action) }
+      return hash
+    else
+      return x
+    end
+  end
+
+end

data/lib/pandocfilters/core_ext/string.rb

@@ -0,0 +1,11 @@
+class String
+
+  # Strips off underscores in string, then capitalize each words.
+  #
+  # @return [String] Camelized string.
+  def camelize
+    string = self
+    string.split('_').map(&:capitalize).join('')
+  end
+
+end

data/lib/pandocfilters/filters/blockquote_cite

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+# Paragraph starts with `CITE:' act like blockquote cite.
+# Align the cite to right.
+
+require 'pandocfilters'
+
+filter = lambda do |key, value, format, meta|
+  if key == 'Para' && (cite = PandocFilters.stringify(value)).start_with?('CITE:')
+    cite.sub!(/CITE:\s?/, '')
+    xml = %(<w:p>
+    <w:pPr>
+        <w:pStyle w:val="BlockquoteCite"/>
+    </w:pPr>
+    <w:r>
+        <w:t xml:space="preserve">#{cite}</w:t>
+    </w:r>
+</w:p>)
+
+    return PandocFilters::Node.raw_block('openxml', xml)
+  end
+end
+
+PandocFilters.process &filter

data/lib/pandocfilters/filters/dedication

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+# Identify paragraph starts with `DEDICATION:' as dedication.
+# Then replace the dedication with raw OOXML xml, and trip off the `DEDICATION:'.
+# THe dedication is placed on a new page, and center aligned.
+
+require 'pandocfilters'
+
+filter = lambda do |key, value, format, meta|
+  if key == 'Para'
+    if value[0]['c'] == 'DEDICATION:'
+      dedication = PandocFilters.stringify(value).sub(/DEDICATION:\s?/, '')
+      xml = %(<w:p>
+      <w:pPr>
+          <w:pStyle w:val="DedicationText"/>
+      </w:pPr>
+      <w:r>
+          <w:t xml:space="preserve">#{dedication}</w:t>
+      </w:r>
+  </w:p>)
+
+      PandocFilters::Node.raw_block('openxml', xml)
+    elsif value[0]['c'] == 'DEDICATION_FIRST:'
+      dedication = PandocFilters.stringify(value).sub(/DEDICATION_FIRST:\s?/, '')
+      xml = %(<w:p>
+      <w:pPr>
+          <w:pStyle w:val="DedicationTextFirst"/>
+      </w:pPr>
+      <w:r>
+          <w:t xml:space="preserve">#{dedication}</w:t>
+      </w:r>
+  </w:p>)
+
+      PandocFilters::Node.raw_block('openxml', xml)
+    end
+  end
+end
+
+PandocFilters.process &filter

data/lib/pandocfilters/filters/page_break

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+# Identify paragraph contains `<!--PAGEBREAK-->' as page break in docx.
+# Then replace the page break with raw OOXML xml'.
+
+require 'pandocfilters'
+
+filter = lambda do |key, value, format, meta|
+  if key == 'RawBlock' && value[1] == '<!--PAGEBREAK-->'
+    xml = %(<w:p><w:r><w:br w:type="page"/></w:r></w:p>)
+
+    return PandocFilters::Node.raw_block('openxml', xml)
+  end
+end
+
+PandocFilters.process &filter

data/lib/pandocfilters/node.rb

@@ -0,0 +1,80 @@
+require_relative 'core_ext/string'
+
+module PandocFilters
+  class Node
+    # Pandoc build-in node types
+    # see http://hackage.haskell.org/package/pandoc-types-1.12.4.3/docs/Text-Pandoc-Definition.html
+    #
+    # key: node type
+    # value: expected arguments number
+    NODES = {
+      # block elements
+      plain: 1,
+      para: 1,
+      code_block: 2,
+      raw_block: 2,
+      block_quote: 1,
+      ordered_list: 2,
+      bullet_list: 1,
+      definition_list: 1,
+      header: 3,
+      horizontal_rule: 0,
+      table: 5,
+      div: 2,
+      null: 0,
+
+      # inline elements
+      str: 1,
+      emph: 1,
+      strong: 1,
+      strikeout: 1,
+      superscript: 1,
+      subscript: 1,
+      small_caps: 1,
+      quoted: 2,
+      cite: 2,
+      code: 2,
+      space: 0,
+      line_break: 0,
+      math: 2,
+      raw_inline: 2,
+      link: 2,
+      image: 2,
+      note: 1,
+      span: 2
+    }
+
+    class << self
+      def method_missing(name, *args)
+        raise "undefined #{name} node type" unless NODES.keys.include?(name)
+        unless args.size == NODES[name]
+          raise "#{name} expects #{NODES[name]} arguments, but given #{args.size}"
+        end
+
+        new(name.to_s.camelize, *args).to_hash
+      end
+    end
+
+    attr_reader :type
+    attr_reader :args
+
+    def initialize(type, *args)
+      @type = type
+      @args = args
+    end
+
+    def to_hash
+      xs = case args.size
+      when 0
+        []
+      when 1
+        args[0]
+      else
+        args
+      end
+
+      {'t': type, 'c': xs}
+    end
+
+  end
+end

data/lib/pandocfilters/version.rb

@@ -0,0 +1,3 @@
+module PandocFilters
+  VERSION = '0.0.1.alpha'
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: pandocfilters
+version: !ruby/object:Gem::Version
+  version: 0.0.1.alpha
+platform: ruby
+authors:
+- Andor Chen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+description: A Ruby gem for writing pandoc filters.
+email: andor.chen.27@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/pandocfilters.rb
+- lib/pandocfilters/core_ext/string.rb
+- lib/pandocfilters/filters/blockquote_cite
+- lib/pandocfilters/filters/dedication
+- lib/pandocfilters/filters/page_break
+- lib/pandocfilters/node.rb
+- lib/pandocfilters/version.rb
+homepage: https://github.com/andorchen/pandocfilters.rb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements:
+- pandoc >= 1.14
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 2
+summary: A Ruby gem for writing pandoc filters.
+test_files: []