macaw 0.0.1 → 0.0.40

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4a12149d550e79e2ac52b9804cda48e101604944
-  data.tar.gz: 3a8085b6f2d2cc3727c8ea9a2eb46a4f49c728d2
+  metadata.gz: 06dfef52346c5bafb0f0fc2ee6ffa2f95298cd1a
+  data.tar.gz: 1f11bf5f437fb1c5665385cad0d91541613716e9
 SHA512:
-  metadata.gz: a9330cdb1257c56cb3ecaae185bcf3280d6bc1a2ac58b626a291304dd74d623611a87582d29d4708b1947f69cca74675d9e532c0093d3b5f0be5c18ae5cf8b18
-  data.tar.gz: 43a5e30ef71af18d0094e692d3d739f1c9c7721e4705c617dddaf17fc41d71eea736e7555aac99f182f4fd8229cdd87e0d3a07dc765ac9f4e27cde167b263adc
+  metadata.gz: 6861e834380c57a5a354178c533ebfe9cdc084d765a5d063f5ac73c0c7e82c5476aae0e85f0788f1165f015ad72cb7c0d12527e0053ef3355762680d96a7a0a0
+  data.tar.gz: dd05f1a8f17e67eb2f2506010e5fce59688597fc63683c2d5d2589c8e21ab8c1d070f450fe1b04aa3178724b26bb1226cca6193c11ee76704730d6a9a3f19618

data/.gitignore

@@ -1,17 +1,3 @@
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
 pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp
+test.*
+arara

data/Gemfile

@@ -1,3 +1,7 @@
+#ruby=2.1
+#ruby-gemset=macaw
+
 source 'https://rubygems.org'
 
+# Specify your gem's dependencies in macaw.gemspec
 gemspec

data/Gemfile.lock

@@ -0,0 +1,27 @@
+PATH
+  remote: .
+  specs:
+    macaw (0.0.40)
+      i18n
+      json_pure
+      os
+      require_all
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    i18n (0.6.9)
+    java_properties (0.0.4)
+    json_pure (1.8.1)
+    os (0.9.6)
+    rake (10.3.2)
+    require_all (1.3.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  java_properties
+  macaw!
+  rake

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2013 Martin Jagusch
+Copyright (c) 2013 friflaj
 
 MIT License
 

data/README.md

@@ -1 +1,83 @@
 # Macaw
+
+Macaw is a Ruby Arara, a Ruby port of http://cereda.github.io/arara/. This is in many aspects very rough around the
+edges at this moment as it was written in a weekend while I was busy doing other things. Ruby does rock.
+
+## Installation
+
+To install, make sure you have Ruby 1.9 or later installed, and then (on a command line, sorry) type
+
+    gem install macaw
+
+To update Macaw, you type
+
+    gem update macaw
+    gem cleanup macaw
+
+## Usage
+
+In day-to-day use it will (should) behave exactly like Arara. It accepts the same command line parameters and reads the
+same *standard* rules that are bundled with Arara; if you use only those, there's no need to change anything in your
+LaTeX documents. Instead of
+
+    arara
+
+you call
+
+    macaw
+
+(or macaw.bat if you want to run it from a Windows IDE)
+
+## Custom rules
+
+Macaw doesn't use yaml for its rules; rules are Ruby scripts. Macaw will read your araraconfig.yaml to find the paths to
+your custom rules; in that location, you can drop files that end in '.rb', which are structured like this:
+
+    class Macaw # this line is mandatory
+      # define your macaw rule here. The name after 'def' is the name of your rule,
+      # the options between parenthesis are the parameters your rule will accept.
+      # Optional parameters are marked using '=nil'.
+      #
+      # For those of you who know ruby, this looks familiar but behaves oddly;
+      # using anything else than 'nil' will likewise make the parameter optional,
+      # but you will *always* be passed 'nil' if the Arara rule in the tex file
+      # did not pass the parameters).
+      def zoterobib(collection, format=nil, port=nil, exportCharset=nil, exportNotes=nil, useJournalAbbreviation=nil)
+        # ||= assigns a value if it wasn't set; set your default values here
+        format ||= 'biblatex'
+        port ||= 23119
+
+        # this adds the optional parameters to the url
+        params = []
+        params << "&exportCharset=#{exportCharset}" if exportCharset
+        params << "&exportNotes=#{exportNotes}" if exportNotes
+        params << "&useJournalAbbreviation=#{useJournalAbbreviation}" if useJournalAbbreviation
+
+        # the ~ is a Macaw feature -- it will escape the path of the string after it to be
+        # safe to be passed on the command line. It will do the right thing depending on
+        # the platform it's being run on.
+        bib = ~"#{@base}.bib"
+        url = ~"http://localhost:#{port}/better-bibtex/collection?#{collection}.#{format}#{params}"
+
+        # Macaw.system executes the command, captures output, does logging, etc
+        Macaw.system "curl --connect-timeout 5 -z #{bib} -o #{bib} #{url}"
+      end
+    end
+
+You are not required to use Macaw.system BTW; Arara is mainly focused on running shell programs, but since Macaw rules
+are ruby scripts, they can do some things natively:
+
+    # Clean rule for arara
+    # author: Paulo Cereda
+    # requires arara 3.0+
+    class Macaw
+      def clean(files)
+        files.reject{|f| f.downcase == @file.downcase}.each{|f|
+          Macaw.log "removing #{f}"
+          File.unlink(f)
+        }
+      end
+    end
+
+If you don't use Macaw.system, you can use *Macaw.log* to pass output to the logging system (which will be subject to
+choices the user makes on the command line, or *Macaw.error* to show a fatal error message and halt the build.

data/Rakefile

@@ -1 +1,133 @@
 require 'bundler/gem_tasks'
+require 'fileutils'
+require 'yaml'
+require 'pp'
+require 'java_properties'
+
+task :default => :build
+
+task :bump do
+  version = Macaw::VERSION.split('.').collect{|v| Integer(v)}
+  version[2] += 1
+  version = version.collect{|v| v.to_s}.join('.')
+  File.open('lib/macaw/version.rb', 'w'){|f| f.write("class Macaw\n  VERSION = #{version.inspect}\nend\n") }
+  puts `git add lib/macaw/version.rb Gemfile.lock`
+end
+
+task :publish do
+  sh "git tag #{Macaw::VERSION}"
+  Dir['pkg/*.gem'].each{|f| File.unlink(f)}
+  Rake::Task["build"].invoke
+  sh "gem push #{Dir['pkg/*.gem'].join(' ')}"
+  sh "git push"
+end
+
+task :test do
+  sh "cp test/test.tex ."
+  sh "./bin/macaw -p -l"
+  sh "rm test.*"
+end
+
+
+class LanguageManager
+  class NoTranslation < StandardError; end
+
+  def initialize
+    @translations = {}
+    Dir['lib/macaw/i18n/*.yml'].each{|yml|
+      @translations[File.basename(yml, File.extname(yml))] = YAML.load_file(yml)
+    }
+    @en = @translations.delete('en')
+    @keys = keys(@en[@en.keys[0]])
+  end
+
+  def keys(h, prefix=[])
+    c = []
+    h.each_pair{|k, v|
+      if v.is_a?(Hash)
+        c += keys(v, prefix + [k])
+      else
+        c << prefix + [k]
+    end
+    }
+    c
+  end
+
+  def resolve(h, k)
+    raise NoTranslation if h.nil?
+    h = h[k.shift]
+    return h if k.empty?
+    return resolve(h, k)
+  end
+
+  def vars(s)
+    v = []
+    s.gsub(/%\{([^}]+)\}/){|k| v << k}
+    return v.sort
+  end
+
+  def port
+    Dir['arara/translations/*.input'].each{|prop|
+      lang = File.basename(prop, File.extname(prop)).gsub('_', '-').gsub(/^Messages-/, '')
+      lang = 'en' if lang == 'Messages'
+      next if lang == 'Messages.sample'
+      strings = JavaProperties::Properties.new(prop)
+
+      tr = {lang => {}}
+      strings.each{|key, value|
+        section, localkey = *key.to_s.split('_', 2)
+        section.downcase!
+
+        case key
+          when :Log_ProcessingFile, :Msg_NoDirectivesFound, :Error_FileDoesNotExist
+            value.gsub!('{0}', '%{file}')
+          when :Msg_SpecialThanks
+            value.gsub!(/Alan.*Kottwitz/i, '%{contributors}')
+          when :Error_InvalidLanguageConfigurationFile
+            value.gsub!('{0}', '%{languages}')
+        end
+
+        value.gsub!(/(\{[0-9]+\})/){"%#{$1}"}
+        value.gsub!('arara', 'macaw')
+        value.gsub!('Arara', 'Macaw')
+        value.gsub!("''", '"')
+
+        tr[lang][section] ||= {}
+        tr[lang][section][localkey] = value
+      }
+      tr[lang]['help']['Usage'] ||= 'Usage'
+      tr[lang]['help']['Progress'] ||= 'Print dots to mark progress'
+      File.open("lib/macaw/i18n/#{lang}.yml", 'w'){|f| f.write(tr.to_yaml)}
+    }
+  end
+
+
+  def test
+    @translations.values.each{|l|
+      @keys.each{|k|
+        ens = resolve(@en[@en.keys[0]], k.dup)
+        ls = nil
+        begin
+          ls = resolve(l[l.keys[0]], k.dup)
+        rescue NoTranslation
+          ls = nil
+        end
+
+        if ls.to_s == ''
+          puts "No translation: #{l.keys[0]}: #{k.join('.')}"
+          next
+        end
+
+        puts "Var mismatch: #{l.keys[0]}: #{k.join('.')}\n  #{vars(ens).inspect}\n  #{vars(ls).inspect}" if vars(ens) != vars(ls)
+      }
+    }
+  end
+end
+
+task :gettranslations do
+  LanguageManager.new.port
+end
+
+task :checktranslations do
+  LanguageManager.new.test
+end

data/bin/macaw

@@ -0,0 +1,308 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require 'yaml'
+require 'pp'
+require_relative '../lib/macaw'
+require_relative '../lib/macaw/version'
+require 'json/pure'
+require 'os'
+require 'ostruct'
+require 'shellwords'
+require 'optparse'
+require 'timeout'
+require 'i18n'
+require 'open3'
+
+puts [
+' __  __                          ',
+'|  \/  | __ _  ___ __ ___      __',
+'| |\/| |/ _` |/ __/ _` \ \ /\ / /',
+'| |  | | (_| | (_| (_| |\ V  V / ',
+'|_|  |_|\__,_|\___\__,_| \_/\_/  ',
+'                                 ',
+].join("\n")
+
+CONTRIBUTORS = [
+  'Alan Munn',
+  'Andrew Stacey',
+  'Brent Longborough',
+  'Clemens Niederberger',
+  'David Carlisle',
+  'Enrico Gregorio',
+  'Francesco Endrici',
+  'Gonzalo Medina',
+  'Harish Kumar',
+  '?lhan Polat',
+  'Joseph Wright',
+  'Marco Daniel',
+  'Mikaδl Maunier',
+  'Patrick Gundlach',
+  'Rasmus Roulund',
+  'Sergey Ulyanov',
+  'Stefan Kottwitz'
+].join(', ')
+
+I18n.enforce_available_locales = true
+I18n.load_path = Dir[File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'macaw', 'i18n', '*.yml'))]
+I18n.default_locale = :en
+
+def options!
+  options = {}
+  [true, false].collect{|dryrun|
+    opts = OptionParser.new{|parser|
+      parser.banner = "#{I18n.t('help.Usage')}: macaw [options] FILE"
+      parser.separator ""
+
+      options[:language] = I18n.default_locale
+      parser.on('-L', '--language LANG', I18n.t('help.Language')){|lang|
+        begin
+          I18n.locale = lang.intern
+          options[:language] = lang.intern
+        rescue I18n::InvalidLocale
+          if !dryrun
+            puts I81n.t('error.InvalidLanguageConfigurationFile', languages: I18n.available_locales.collect{|l| l.to_s}.join(', '))
+            exit
+          end
+        end
+      }
+
+      parser.on('-p', '--progress', I18n.t('help.Progress')) {|v|
+        options[:progress] = v
+      }
+      parser.on('-l', '--log', I18n.t('help.Log')) {|v|
+        options[:log] = v
+      }
+
+      parser.on('-t', '--timeout MILLISECONDS', I18n.t('help.Timeout')){|timeout|
+        options[:timeout] = Float(timeout) / 1000
+      }
+
+      parser.on('-r', '--rules', 'Available rules') {|v|
+        options[:rules] = v
+      }
+
+      parser.on('-v', '--verbose', I18n.t('help.Verbose')) {|v|
+        options[:verbose] = v
+      }
+
+      parser.on_tail('-h', '--help', '--usage', I18n.t('help.Help')){
+        if !dryrun
+          puts parser.help
+          exit
+        end
+      }
+
+      parser.on_tail('-V', '--version', I18n.t('help.Version')){
+        if !dryrun
+          puts "macaw #{Macaw::VERSION} - #{I18n.t('header.Slogan')}\nCopyright (c) 2012, Paulo Roberto Massa Cereda\n"
+          puts I18n.t('header.AllRightsReserved')
+          puts "\n"
+          puts I18n.t('msg.SpecialThanks', :contributors => CONTRIBUTORS).gsub(/(.{1,#{60}})(?: +|$)\n?|(.{#{60}})/, "\\1\\2\n")
+          exit
+        end
+      }
+    }
+    if dryrun
+      opts.parse!(ARGV.dup)
+    else
+      opts.parse!
+    end
+  }
+  OpenStruct.new(options)
+end
+
+CONFIGFILE = [File.join(Dir.home, 'araraconfig.yaml'), File.join(Dir.home, '.araraconfig.yaml')].detect{|config| File.file?(config) }
+CONFIG = CONFIGFILE ? YAML.load_file(CONFIGFILE) : {}
+
+class String
+  def ~
+    if OS.windows?
+      return '"' + self.gsub('"', '""') + '"'
+    else
+      return self.shellescape
+    end
+  end
+end
+
+class JSON::Pure::Parser
+  IDENTIFIER = /[^:\s\\",{}\[\]]+/i
+  alias :parse_quoted_string :parse_string
+
+  def parse_string
+    if match?(IDENTIFIER)
+      str = scan(IDENTIFIER)
+      return true if str == 'yes'
+      return false if str == 'no'
+      return str
+    end
+
+    return parse_quoted_string
+  end
+end
+
+class Macaw
+  class CommandlineError < StandardError; end
+
+  @@log = nil
+
+  def initialize(tex)
+    @file = tex
+    @base = File.join(File.dirname(@file), File.basename(@file, File.extname(@file)))
+  end
+  attr_reader :file, :base
+
+  def halt
+    error 'Halted on user request'
+  end
+
+  ERRORMODES=[:exit, :throw, :ignore]
+  def self.error(msg, onfail=:exit)
+    throw "errormode can only be #{ERRORMODES.inspect}" unless ERRORMODES.include?(onfail)
+    case onfail
+      when :exit
+        @@log.close if @@log
+        puts "\n\n#{msg}"
+        exit 1
+      when :throw
+        raise CommandlineError, msg
+      else
+        puts msg
+    end
+  end
+
+  def self.options
+    @@options ||= options!
+  end
+
+  def self.run
+    @@options ||= options!
+
+    if @@options.rules
+      vars = Macaw.new('').instance_variables.collect{|v| v.to_s.sub(/^@/, '').intern}
+      w = 0
+      rules = {}
+      self.instance_methods(false).sort{|a, b| a.to_s <=> b.to_s }.each{|method|
+        next if vars.include?(method)
+        w = [w, method.to_s.length].max
+        rules[method.to_s] = self.instance_method(method).parameters.sort{|a, b|
+          a = a.collect{|v| v.to_s}
+          b = b.collect{|v| v.to_s}
+          if a[0] != b[0]
+            a[0] <=> b[0]
+          else
+            b[1] <=> a[1]
+          end
+        }.collect{|p| "#{p[1]}:#{p[0]}"}.join(', ')
+      }
+      rules.each_pair{|method, params|
+        if params.length == 0
+          puts method
+        else
+          puts "#{method.ljust(w, ' ')}: #{params}"
+        end
+      }
+      exit
+    end
+
+
+    if ARGV.size == 0 && Dir['*.tex'].size == 1
+      puts "No TeX file offered, defaulting to #{Dir['*.tex'][0]}"
+      ARGV.push(Dir['*.tex'][0])
+    end
+    error("No filename to process") if ARGV.size == 0
+    error("Expected exactly one filename to process #{ARGV.inspect}") if ARGV.size != 1
+    tex = File.file?(ARGV[0]) ? ARGV[0] : ARGV[0] + '.tex'
+    error(I18n.t('error.FileDoesNotExist', file: tex)) if !File.exists?(tex)
+
+    Macaw.load_rules
+
+    puts I18n.t('log.ProcessingFile', file: tex)
+
+    macaw = Macaw.new(tex)
+    @@log = File.open(macaw.base + '.log', 'w') if @@options.log
+
+    executed = 0
+    IO.readlines(tex).each_with_index{|line, lineno|
+      @@lineno = lineno + 1
+
+      next unless line =~ /^% arara: /
+      executed += 1
+      line.strip!
+      line.sub!(/^%\s+arara\s*:\s*/, '')
+      data = line.split(':', 2).collect{|v| v.strip}
+
+      cmd = data[0]
+      next if cmd == ''
+
+      params = {}
+      begin
+        params = JSON.parse(data[1]) if data[1]
+      rescue => e
+        error("cannot parse command #{line.inspect}: #{e}")
+      end
+
+      cmd = cmd.intern
+
+      error "no such rule #{cmd}" unless macaw.respond_to?(cmd)
+
+      accept = Macaw.instance_method(cmd).parameters
+      required = accept.collect{|k, v| k == :req ? v : nil}.compact
+      optional = accept.collect{|k, v| k != :req ? v : nil}.compact
+
+      missing = required - params.keys.collect{|k| k.intern}
+      error "#{line}: missing required parameter#{missing.size > 1 ? 's' : ''}: #{missing.inspect}" if missing.size > 0
+
+      unexpected = params.keys.collect{|k| k.intern} - (required + optional)
+      error "#{line}: unexpected parameter#{unexpected.size > 1 ? 's' : ''}: #{unexpected.inspect}" if unexpected.size > 0
+
+      puts "\n** #{line} **\n"
+      macaw.send(cmd, *accept.collect{|k, v| params[v.to_s]})
+    }
+
+    if executed == 0
+      puts I18n.t('log.NoDirectivesFound', file: tex)
+    else
+      puts I18n.t('log.Done')
+    end
+  end
+
+  def self.log(line, force=false)
+    if @@options.verbose || @@options.progress || force
+      print (options.progress && !force ? '.' : line)
+      STDOUT.flush
+    end
+    @@log.write(line) if @@log
+  end
+
+  def self.system(cmd, onfail=:exit)
+    throw "errormode can only be #{ERRORMODES.inspect}" unless ERRORMODES.include?(onfail)
+
+    cmd = cmd.compact.join(' ') if cmd.is_a?(Array)
+    log(cmd)
+
+    output = ''
+    begin
+      Timeout::timeout(@@options.timeout || 0) {
+        Open3.popen2e(cmd) do |stdin, stdout_err, wait_thr|
+          while line = stdout_err.gets
+            self.log(line)
+            output += line + "\n"
+          end
+
+          exit_status = wait_thr.value
+          error "cmd failed: #{cmd}", onfail unless exit_status.success?
+        end
+      }
+    rescue Timeout::Error
+      error "#{cmd}: timed out after #{@@options.timeout} seconds" if failonerror
+    end
+    return output
+  end
+
+  def self.load_rules
+    CONFIG['paths'].each{|path| require_all path} if CONFIG['paths']
+  end
+end
+
+Macaw.run