latex-project-template 0.0.0

data/README.md

@@ -0,0 +1,58 @@
+# latex-project-template
+
+Management of latex template files.
+latex-project-template creates a latex project directory from a template
+in ~/.latex\_project\_template.
+The directory is git repository and includes Rakefile to compile
+a latex file with latexmk.
+
+- <http://rubygems.org/gems/latex-project-template>
+- <https://github.com/ytaka/latex-project-template>
+
+## Requirements
+
+latex-project-template uses latexmk to compile latex files and
+the project directory is managed by git.
+
+- [latexmk](http://www.phys.psu.edu/~collins/software/latexmk-jcc/)
+- [Git](http://git-scm.com/)
+- some LaTeX environment
+
+latex-project-template depends on the following gems.
+
+- git
+- filename
+- user_config
+
+## Install
+
+We can install by rubygems.
+
+    gem install latex-project-template
+
+## Special notations of template file names
+
+\_\_IMPORT\_\_
+:In \_\_IMPORT\_\_ we write list of files to import from other template.
+\_\_PROJECT\_\_
+:Replace \_\_PROJECT\_\_ by name of project.
+\_\_DOT\_\_
+:Replace \_\_DOT\_\_ by '.'.
+\_\_IGNORE\_\_
+:Files including \_\_IGNORE\_\_ are ignored.
+
+## Contributing to latex-project-template
+ 
+- Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+- Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+- Fork the project
+- Start a feature/bugfix branch
+- Commit and push until you are happy with your contribution
+- Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+- Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Copyright
+
+Copyright (c) 2011 Takayuki YAMAGUCHI. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "latex-project-template"
+  gem.homepage = "http://github.com/ytaka/latex-project-template"
+  gem.license = "GPLv3"
+  gem.summary = "LaTeX Project Template"
+  gem.description = "Create LaTeX project with git from template, which uses latexmk."
+  gem.email = "d@ytak.info"
+  gem.authors = ["Takayuki YAMAGUCHI"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  gem.add_runtime_dependency 'git', '>= 1.2.5'
+  gem.add_runtime_dependency 'filename', '>= 0.1.0'
+  gem.add_runtime_dependency 'user_config', '>= 0.0.1'
+  gem.add_development_dependency 'rspec', '>= 2.5.0'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/bin/latex-project-template

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/latex_project_template'
+require 'optparse'
+
+help_message =<<HELP
+Usage: #{File.basename(__FILE__)} project [template]
+       #{File.basename(__FILE__)} --list
+       #{File.basename(__FILE__)} --delete template
+HELP
+
+options = {
+  :mode => :create
+}
+
+begin
+  OptionParser.new(help_message) do |opt|
+    opt.on("--list", "List templates.") do |v|
+      options[:mode] = :list
+    end
+    opt.on("--delete", "Delete template.") do |v|
+      options[:mode] = :delete
+    end
+    opt.on("--init", "Initialize configuration directory.") do |v|
+      options[:mode] = :init
+    end
+    opt.on("--home DIR", "Set the directory having '.latex_project_template'.") do |v|
+      options[:home] = v
+    end
+    opt.parse!(ARGV)
+  end
+rescue OptionParser::InvalidOption
+  $stderr.print <<MES
+error: Invalid Option
+#{help_message}
+MES
+  exit(2)
+rescue OptionParser::InvalidArgument
+  $stderr.print <<MES
+error: Invalid Argument
+#{help_message}
+MES
+  exit(2)
+end
+
+case options[:mode]
+when :init
+  LaTeXProjectTemplate::Configuration.create_new_config(options[:home])
+when :list
+  LaTeXProjectTemplate::Configuration.new(options[:home]).list_template.each do |template|
+    $stdout.puts template
+  end
+when :delete
+  if template = ARGV[0]
+    LaTeXProjectTemplate::Configuration.new(options[:home]).delete_template(template)
+  else
+    $stderr.puts "Please set template name."
+    $stderr.puts help_message
+    exit(1)
+  end
+when :create
+  dir = ARGV[0]
+  template = ARGV[1] || 'default'
+  if dir
+    LaTeXProjectTemplate.new(dir, template, options[:home]).create(:io => $stdout)
+  else
+    exit(1)
+  end
+end

data/lib/latex_project_template.rb

@@ -0,0 +1,193 @@
+require 'fileutils'
+require 'erb'
+require 'git'
+require 'filename'
+require 'user_config'
+
+class LaTeXProjectTemplate
+  DEFAULT_CONFIG = ".latex_project_template"
+
+  class LPTConfig < UserConfig
+  end
+
+  class Configuration
+    def self.create_new_config(home_path = nil)
+      config = LPTConfig.new(DEFAULT_CONFIG, :home => home_path)
+      dir = config.directory
+      Dir.glob("#{File.expand_path(File.join(File.dirname(__FILE__), '../template/'))}/*").each do |d|
+        FileUtils.cp_r(d, dir)
+      end
+    end
+
+    def initialize(home_path)
+      @config = UserConfig.new(DEFAULT_CONFIG, :home => home_path)
+    end
+
+    def config_directory
+      @config.directory
+    end
+
+    def list_template
+      @config.list_in_directory('.')
+    end
+
+    def template_exist?(template)
+      if path = @config.exist?(template)
+        return LaTeXProjectTemplate::Directory.new(path)
+      end
+      false
+    end
+
+    def template_file(template, name)
+      unless path = @config.template_exist?(File.join(template, name))
+        path = @config.template_exist?(File.join('default', name))
+      end
+      path
+    end
+
+    def delete_template(template)
+      if String === template && template.size > 0
+        @config.delete(template)
+      else
+        raise ArgumentError, "Invalid template name to delete: #{template.inspect}"
+      end
+    end
+  end
+
+  class Directory
+    attr_reader :path, :name
+
+    def initialize(path)
+      @path = File.expand_path(path)
+      @name = File.basename(@path)
+    end
+
+    def create_directory_if_needed(target_dir)
+      if File.exist?(target_dir)
+        unless File.directory?(target_dir)
+          raise "Can not create directory: #{target_dir}"
+        end
+      else
+        File.mkdir_p(target_dir)
+      end
+    end
+    private :create_directory_if_needed
+
+    def target_path(project_name, target_dir, target_name)
+      target_name = target_name.gsub(/__DOT__/, '.')
+      target_name = target_name.gsub(/__PROJECT__/, project_name)
+      File.join(target_dir, target_name.sub(/^#{Regexp.escape(@path)}/, ''))
+    end
+    private :target_path
+
+    # Create file of which name is created by removing '.erb' from name of original file
+    def create_erb_template(erb_file, erb_obj, project_name, target_dir)
+      product_path = target_path(project_name, target_dir, erb_file.sub(/\.erb$/, ''))
+      erb_obj.instance_exec(erb_file, product_path) do |path, out|
+        erb = ERB.new(File.read(path))
+        open(out, 'w') do |f|
+          f.print erb.result(binding)
+        end
+      end
+      product_path
+    end
+    private :create_erb_template
+
+    IGNORE_FILE_REGEXP = /(\/__IMPORT__$|\/__IGNORE__|~$)/
+
+    def copy_to_directory(target_dir, erb_binding_obj, files = nil)
+      create_directory_if_needed(target_dir)
+      if files
+        file_list = files.map do |file_path|
+          fullpath = File.join(@path, file_path)
+          if File.exist?(fullpath)
+            fullpath
+          else
+            nil
+          end
+        end.compact
+      else
+        file_list = Dir.glob(File.join(@path, '**', '*')).sort
+      end
+      created_files = []
+      file_list.each do |file|
+        next if IGNORE_FILE_REGEXP =~ file
+        create_directory_if_needed(File.dirname(file))
+        unless File.directory?(file)
+          case file
+          when /\.erb$/
+            created = create_erb_template(file, erb_binding_obj, erb_binding_obj.project_name, target_dir)
+          else
+            created = target_path(erb_binding_obj.project_name, target_dir, file)
+            FileUtils.cp(file, created)
+          end
+          created_files << created
+        end
+      end
+      created_files
+    end
+
+    def files_to_import
+      import = Hash.new { |h, k| h[k] = [] }
+      import_list_path = File.join(@path, '__IMPORT__')
+      if File.exist?(import_list_path)
+        File.read(import_list_path).each_line do |l|
+          l.strip!
+          if n = l.index('/')
+            k = l.slice!(0...n)
+            import[k] << l[1..-1]
+          end
+        end
+      end
+      import
+    end
+  end
+
+  class ErbObject
+    attr_reader :project_name
+
+    def initialize(project_name)
+      @project_name = project_name
+    end
+  end
+
+  def initialize(dir, template, home_directory = nil)
+    @config = LaTeXProjectTemplate::Configuration.new(home_directory)
+    @target_dir = File.expand_path(dir)
+    unless @template = @config.template_exist?(template)
+      raise ArgumentError, "Can not find template: #{template}"
+    end
+    if File.exist?(@target_dir)
+      raise ArgumentError, "File #{@target_dir} exists."
+    end
+    @project_name = File.basename(dir).sub(/\/$/, '')
+  end
+
+  def create_files
+    erb_obj = LaTeXProjectTemplate::ErbObject.new(@project_name)
+    created_files = @template.copy_to_directory(@target_dir, erb_obj)
+    @template.files_to_import.each do |name, files|
+      if template_to_import = @config.template_exist?(name)
+        created_files.concat(template_to_import.copy_to_directory(@target_dir, erb_obj, files))
+      end
+    end
+    created_files.sort!
+  end
+  private :create_files
+
+  def create(opts = {})
+    FileUtils.mkdir_p(@target_dir)
+    git = Git.init(@target_dir)
+    files = create_files
+    git.add
+    git.commit("Copy template '#{@template.name}'.")
+    if io = opts[:io]
+      files.map! do |path|
+        path.sub!(@target_dir, '')
+        path.sub!(/^\//, '')
+      end
+      io.puts "Create the following files from template '#{@template.name}' and commit to git."
+      io.puts files.join("\n")
+    end
+  end
+end

data/lib/latex_project_template/task.rb

@@ -0,0 +1,222 @@
+require 'rake'
+require 'rake/tasklib'
+require 'filename'
+
+class LaTeXProjectTemplate
+  class Cleaning
+    include Rake::DSL if defined?(Rake::DSL)
+
+    attr_reader :temporary, :product, :pattern
+
+    DEFAULT_PATTERN = ["**/*~", "**/*.bak"]
+
+    def initialize
+      @pattern = Rake::FileList.new(DEFAULT_PATTERN)
+      @pattern.clear_exclude
+    end
+
+    def clean_files(list)
+      list.each do |fn|
+        begin
+          rm_r fn
+        rescue
+          nil
+        end
+      end
+    end
+    private :clean_files
+
+    def clean
+      clean_files(@pattern)
+    end
+  end
+
+  class Latexmk
+    COMMAND_TO_PRODUCE_FILE = [:dvi, :ps, :pdf, :pdfdvi, :pdfps]
+
+    include Rake::DSL if defined?(Rake::DSL)
+
+    attr_accessor :path
+
+    def initialize()
+      @path = 'latexmk'
+      @command = {}
+
+      COMMAND_TO_PRODUCE_FILE.each do |type|
+        set(type) do |target|
+          "#{@path} -#{type.to_s} #{target}"
+        end
+      end
+      set(:clean) do |target|
+        "#{@path} -c"
+      end
+      set(:distclean) do |target|
+        "#{@path} -C"
+      end
+    end
+
+    def set(sym, &block)
+      @command[sym] = block
+    end
+
+    def command(sym, target)
+      @command[sym] && @command[sym].call(target)
+    end
+
+    def execute_command(sym, target)
+      if c = command(sym, target)
+        sh(c)
+      end
+    end
+
+    (COMMAND_TO_PRODUCE_FILE + [:clean, :distclean]).each do |sym|
+      define_method(sym) do |target|
+        execute_command(sym, target)
+      end
+    end
+  end
+
+  class Task < Rake::TaskLib
+    attr_accessor :latexmk, :clean, :default
+
+    def initialize(target, &block)
+      @target = target
+      @latexmk = Latexmk.new
+      @clean = Cleaning.new
+      @default = :pdf
+      yield(self) if block_given?
+      define_task
+    end
+
+    def extension_from_command_type(type)
+      if /^pdf/ =~ type.to_s
+        ".pdf"
+      else
+        ".#{type.to_s}"
+      end
+    end
+    private :extension_from_command_type
+
+    def snapshot_of_current(type)
+      path = FileName.create(@target, :add => :prohibit, :extension => extension_from_command_type(type))
+      snapshot_path = FileName.create("snapshot", File.basename(path),
+                                      :type => :time, :directory => :parent, :position => :middle,
+                                      :delimiter => '', :add => :always, :format => "%Y%m%d_%H%M%S")
+      begin
+        Rake::Task[type].execute
+      rescue
+        $stderr.puts "Can not compile"
+      end
+      if File.exist?(path)
+        move(path, snapshot_path)
+        return snapshot_path
+      end
+      nil
+    end
+    private :snapshot_of_current
+
+    def commit_date(commit)
+      log_data = `git log --date=iso -1 #{commit}`
+      if $? == 0
+        require 'time'
+        l = log_data.split("\n").find { |s| /^Date:.*$/ =~ s }
+        Time.parse(l.sub("Date:", ''))
+      else
+        nil
+      end
+    end
+    private :commit_date
+
+    def extract_source(commit)
+      source_directory = FileName.create('src', :type => :time, :directory => :self, :add => :always)
+      c = "git archive --format=tar #{commit} | tar -C #{source_directory} -xf -"
+      system(c)
+      source_directory
+    end
+    private :extract_source
+
+    def snapshot_of_commit(type, commit)
+      if date = commit_date(commit)
+        source_directory = extract_source(commit)
+        path = FileName.create(source_directory, File.basename(@target), :add => :prohibit, :extension => extension_from_command_type(type))
+        path_base = File.basename(path).sub(/\.#{type}$/, "_#{date.strftime("%Y%m%d_%H%M%S")}.#{type}")
+        snapshot_path = FileName.create("snapshot", path_base, :directory => :parent, :position => :middle)
+        cd source_directory
+        begin
+          sh "rake #{type}"
+        rescue
+          $stderr.puts "Can not compile. Please edit files in #{source_directory}."
+        end
+        if File.exist?(path)
+          move(path, snapshot_path)
+          cd '..'
+          rm_r source_directory
+          return snapshot_path
+        end
+      else
+        $stderr.puts "The commit '#{commit}' does not exist."
+      end
+      nil
+    end
+    private :snapshot_of_commit
+
+    def define_task
+      desc "Default task"
+      task :default => @default
+
+      desc "Clean up temporary files."
+      task :clean do |t|
+        @latexmk.clean(@target)
+        @clean.clean
+      end
+
+      desc "Clean up all files."
+      task :distclean do |t|
+        @latexmk.distclean(@target)
+        @clean.clean
+      end
+
+      Latexmk::COMMAND_TO_PRODUCE_FILE.each do |type|
+        desc "Create #{type.to_s}."
+        task type => [@target] do |t|
+          @latexmk.__send__(type, @target)
+        end
+      end
+
+      desc "Create snapshot file."
+      task :snapshot, [:type,:commit] do |t, args|
+        type = args.type && args.type.size > 0 ? args.type.intern : :pdf
+        unless Latexmk::COMMAND_TO_PRODUCE_FILE.include?(type)
+          raise "Invalid option to produce file: #{type}."
+        end
+        if commit = args.commit
+          path = snapshot_of_commit(type, commit)
+        else
+          path = snapshot_of_current(type)
+        end
+        if path
+          $stdout.puts "Save to #{path}"
+        else
+          $stdout.puts "We can not create a file."
+        end
+      end
+
+      desc "Create source of particular commit."
+      task :source, [:commit] do |t, args|
+        if commit = args.commit
+          if date = commit_date(commit)
+            if source_directory = extract_source(commit)
+              $stdout.puts "Save to #{source_directory}"
+            else
+              $stdout.puts "We can not create directory of source files."
+            end
+          else
+            $stderr.puts "The commit '#{commit}' does not exist."
+          end
+        else
+          $stderr.puts "Please set commit."
+        end
+      end
+    end
+  end
+end