texas 0.1.0

data/bin/texas

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'bundler'
+Bundler.require
+
+Texas::Runner.new

data/contents/_chapter.md.erb

@@ -0,0 +1,13 @@
+<%= page_break %>
+
+<% if o.title.to_s.size > 0 %>
+# <%= o.title %>
+<% end %>
+
+<% templates = o.templates || [] %>
+
+<% templates.each_with_index do |template, index| %>
+<%= render template %>
+
+<%= scene_delimiter unless index == templates.size - 1 %>
+<% end %>

data/contents/_preambel.tex.erb

@@ -0,0 +1,50 @@
+\documentclass[a4paper,parskip=half*,12pt]{scrartcl} 
+
+\usepackage{relsize}
+
+\usepackage{amsmath,amstext,amssymb}
+
+\usepackage[ngerman]{babel}
+\usepackage[utf8]{inputenc} 
+
+%\usepackage[paper=a4paper,left=40mm,right=40mm,top=25mm,bottom=25mm]{geometry} 
+
+\usepackage{courier}
+
+
+\usepackage[T1]{fontenc}
+
+\usepackage[table]{xcolor}
+\usepackage{color}
+
+
+\usepackage{url,hyperref}
+\urlstyle{same}
+
+\usepackage{setspace}
+
+\clubpenalty = 10000
+\widowpenalty = 10000
+\displaywidowpenalty = 10000
+
+\setlength{\parindent}{1em}
+
+\setcounter{secnumdepth}{0}
+\setcounter{tocdepth}{0}
+
+\usepackage{fancyhdr}
+\pagestyle{fancy}
+
+\fancyhead{}
+\fancyfoot{}
+
+\fancyhead[L]{<%= document.author %> -- <%= document.title %>}
+\fancyhead[C]{}
+\fancyhead[R]{}
+
+\fancyfoot[L]{}
+\fancyfoot[C]{}
+\fancyfoot[R]{\thepage}
+
+
+\onehalfspacing

data/contents/master.tex.erb

@@ -0,0 +1,7 @@
+<%= partial :preambel %>
+
+\begin{document}
+
+<%= input build.contents_template %>
+
+\end{document}

data/lib/texas/build/base.rb

@@ -0,0 +1,120 @@
+require 'yaml'
+
+module Texas
+  module Build
+    class Base
+      CONFIG_FILE = ".texasrc"
+      MASTER_TEMPLATE = "master.tex"
+
+      attr_reader :root, :options
+      attr_reader :master_file, :contents_dir, :contents_template
+      attr_reader :current_template, :ran_templates
+
+      def initialize(_options)
+        @options = _options
+        @root = options.work_dir
+        @contents_dir = options.contents_dir
+        @contents_template = options.contents_template
+        @master_file = File.join(__path__, MASTER_TEMPLATE)
+
+        verbose { "Starting #{self.class}" }
+        verbose { "[i] work_dir: #{options.work_dir}".dark }
+        verbose { "[i] contents_dir: #{@contents_dir}".dark }
+        verbose { "[i] contents_template: #{@contents_template}".dark }
+        verbose { "[i] build_path: #{@build_path}".dark }
+      end
+
+      def __path__
+        File.join(root, 'tmp', 'build')
+      end
+
+      def store
+        @store ||= OpenStruct.new
+      end
+
+      def current_template=(t)
+        @ran_templates ||= []
+        @ran_templates << t unless t.nil?
+        @current_template = t
+      end
+
+      def document_struct
+        @document_struct ||= begin
+          hash = config["document"] || {}
+          if options.merge_config
+            hash.merge! config[options.merge_config]
+          end
+          OpenStruct.new(hash)
+        end
+      end
+      
+      def config
+        @config ||= begin
+          filename = File.join(root, CONFIG_FILE)
+          File.exist?(filename) ? YAML.load_file(filename) : {}
+        end
+      end
+
+      def dest_file
+        @dest_file ||= File.join(root, "bin", "#{Template.basename contents_template}.pdf")
+      end
+
+      def run_build_tasks(*tasks)
+        tasks.flatten.each { |t| run_build_task t }
+      end
+
+      def run_build_task(klass)
+        klass = eval("::Texas::Build::Task::#{klass}") if [Symbol, String].include?(klass.class)
+        klass.new(self).run
+      end
+
+      def run
+        run_build_tasks before_tasks, basic_tasks, after_tasks
+      end
+
+      %w(before basic after).each do |method|
+        class_eval <<-INSTANCE_EVAL
+          def #{method}_tasks
+            self.class.tasks(:#{method})
+          end
+        INSTANCE_EVAL
+      end
+
+      class << self
+        def run(options)
+          instance = self.new(options)
+          instance.run
+          instance
+        end
+
+        def tasks(key)
+          @@tasks ||= {}
+          initialize_tasks if @@tasks[self.to_s].nil?
+          @@tasks[self.to_s][key] ||= []
+          @@tasks[self.to_s][key]
+        end
+
+        def initialize_tasks
+          @@tasks[self.to_s] = {}
+          (@@tasks[self.superclass.to_s] || {}).each do |k, v|
+            @@tasks[self.to_s][k] = v.dup
+          end
+        end
+
+        %w(before basic after).each do |method|
+          class_eval <<-CLASS_EVAL
+            def prepend_#{method}_task(*_tasks)
+              tasks(:#{method}).unshift(*_tasks)
+            end
+
+            def append_#{method}_task(*_tasks)
+              tasks(:#{method}).concat(_tasks)
+            end
+            alias #{method}_task append_#{method}_task
+          CLASS_EVAL
+        end
+
+      end
+    end
+  end
+end

data/lib/texas/build/dry.rb

@@ -0,0 +1,11 @@
+module Texas
+  module Build
+    class Dry < Base
+      before_task :RunBeforeScripts, :CopyContentsToBuildPath
+
+      basic_task :AddDefaultTemplatesToBuildPath, :RunMasterTemplate
+
+      after_task :RewriteMarkedTemplates
+    end
+  end
+end

data/lib/texas/build/final.rb

@@ -0,0 +1,7 @@
+module Texas
+  module Build
+    class Final < Dry
+      append_after_task :PublishPDF, :OpenPDF
+    end
+  end
+end

data/lib/texas/build/task/add_default_templates_to_build_path.rb

@@ -0,0 +1,22 @@
+module Texas
+  module Build
+    module Task
+      class AddDefaultTemplatesToBuildPath < Base
+        def build_path
+          build.__path__
+        end
+
+        def run
+          glob = File.join(Texas.texas_dir, Texas.contents_subdir_name, '*.*')
+          Dir[glob].each do |filename|
+            dest = File.join(build_path, File.basename(filename))
+            unless File.exists?(dest)
+              FileUtils.cp filename, build_path
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/texas/build/task/base.rb

@@ -0,0 +1,15 @@
+module Texas
+  module Build
+    module Task
+      class Base
+        attr_reader :build
+        
+        def initialize(_build = nil)
+          @build = _build
+        end
+        def run
+        end
+      end
+    end
+  end
+end

data/lib/texas/build/task/copy_contents_to_build_path.rb

@@ -0,0 +1,31 @@
+module Texas
+  module Build
+    module Task
+      class CopyContentsToBuildPath < Base
+        def run
+          ensure_build_path_exists
+          copy_to_build_path
+        end
+
+        def build_path
+          build.__path__
+        end
+
+        def contents_dir
+          build.contents_dir
+        end
+
+        def ensure_build_path_exists
+          FileUtils.mkdir_p build_path
+          rescue
+        end
+
+        def copy_to_build_path
+          FileUtils.rm_r build_path
+          FileUtils.cp_r contents_dir, build_path
+        end
+
+      end
+    end
+  end
+end

data/lib/texas/build/task/open_pdf.rb

@@ -0,0 +1,36 @@
+module Texas
+  module Build
+    module Task
+      class OpenPDF < Base
+        DEFAULT_OPEN_CMD = "evince"
+
+        def cmd
+          @cmd ||= scripts && scripts['open']
+        end
+
+        def scripts
+          build.config['script']
+        end
+
+        def run
+          return unless build.options.open_pdf
+          if open_pdf_cmd
+            system "#{open_pdf_cmd} #{build.dest_file}"
+          else
+            puts "Can't open PDF: no default command recognized. Specify in #{CONFIG_FILE}"
+          end
+        end
+
+        def open_pdf_cmd
+          if cmd
+            cmd
+          else
+            default = `which #{DEFAULT_OPEN_CMD}`.strip
+            default.empty? ? nil : default
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/texas/build/task/publish_pdf.rb

@@ -0,0 +1,46 @@
+module Texas
+  module Build
+    module Task
+      class PublishPDF < Base
+
+        def master_file
+          build.master_file
+        end
+
+        def build_path
+          build.__path__
+        end
+
+        def dest_file
+          build.dest_file
+        end
+
+        def run
+          run_pdflatex
+          copy_pdf_file_to_dest_dir
+        end
+
+        def copy_pdf_file_to_dest_dir
+          tmp_file = File.join(build_path, "#{File.basename(master_file, '.tex')}.pdf")
+          FileUtils.mkdir_p File.dirname(dest_file)
+          FileUtils.copy tmp_file, dest_file
+          verbose {
+            file = File.join(build_path, "master.log")
+            output = `grep "Output written on" #{file}`
+            numbers = output.scan(/\((\d+?) pages\, (\d+?) bytes\)\./).flatten
+            @page_count = numbers.first.to_i
+            "Written PDF in #{dest_file.gsub(root, '')} (#{@page_count} pages)".green
+          }
+        end
+
+        def run_pdflatex
+          verbose { "Running pdflatex in #{build_path} ..." }
+          Dir.chdir build_path
+          `pdflatex #{File.basename(master_file)}`
+          `pdflatex #{File.basename(master_file)}`
+        end
+
+      end
+    end
+  end
+end

data/lib/texas/build/task/rewrite_marked_templates.rb

@@ -0,0 +1,13 @@
+module Texas
+  module Build
+    module Task
+      class RewriteMarkedTemplates < Base
+        def run
+          build.ran_templates.select { |t| t.marked_for_rewrite? }.each do |t|
+            t.write
+          end
+        end
+      end
+    end
+  end
+end

data/lib/texas/build/task/run_before_scripts.rb

@@ -0,0 +1,22 @@
+module Texas
+  module Build
+    module Task
+      class RunBeforeScripts < Base
+        def cmd
+          @cmd ||= scripts && scripts['before']
+        end
+
+        def scripts
+          build.config['script']
+        end
+
+        def run
+          if cmd
+            verbose { "\n[i] Running before script:\n\n    #{cmd.cyan}\n\n" }
+            system cmd
+          end
+        end
+      end
+    end
+  end
+end

data/lib/texas/build/task/run_master_template.rb

@@ -0,0 +1,23 @@
+module Texas
+  module Build
+    module Task
+      class RunMasterTemplate < Base
+
+        def find_master_template(possible_templates)
+          regexes = Template.handlers.keys
+          valid_master_templates = possible_templates.select do |f| 
+            regexes.any? { |regex| f =~ regex }
+          end
+          valid_master_templates.first
+        end
+
+        def run
+          filename = find_master_template Dir[build.master_file+'*']
+          master_template = Template.create(filename, build)
+          master_template.write
+        end
+
+      end
+    end
+  end
+end

data/lib/texas/build.rb

@@ -0,0 +1,15 @@
+module Texas
+  module Build
+  end
+end
+
+require_relative 'build/base'
+require_relative 'build/dry'
+require_relative 'build/final'
+
+require_relative 'build/task/base'
+
+all_rbs = Dir[ File.join( File.dirname(__FILE__), "build", "task", "*.rb" ) ]
+all_rbs.each do |t|
+  require t
+end

data/lib/texas/core_ext/string.rb

@@ -0,0 +1,132 @@
+require 'term/ansicolor'
+
+class String
+  
+end
+
+module Term
+  # The ANSIColor module can be used for namespacing and mixed into your own
+  # classes.
+  module NoColor
+    # :stopdoc:
+    ATTRIBUTES = [
+      [ :clear              ,   0 ],     # String#clear is already used to empty string in Ruby 1.9
+      [ :reset              ,   0 ],     # synonym for :clear
+      [ :bold               ,   1 ], 
+      [ :dark               ,   2 ], 
+      [ :italic             ,   3 ],     # not widely implemented
+      [ :underline          ,   4 ], 
+      [ :underscore         ,   4 ],     # synonym for :underline
+      [ :blink              ,   5 ], 
+      [ :rapid_blink        ,   6 ],     # not widely implemented
+      [ :negative           ,   7 ],     # no reverse because of String#reverse
+      [ :concealed          ,   8 ], 
+      [ :strikethrough      ,   9 ],     # not widely implemented
+      [ :black              ,  30 ], 
+      [ :red                ,  31 ], 
+      [ :green              ,  32 ], 
+      [ :yellow             ,  33 ], 
+      [ :blue               ,  34 ], 
+      [ :magenta            ,  35 ], 
+      [ :cyan               ,  36 ], 
+      [ :white              ,  37 ], 
+      [ :on_black           ,  40 ], 
+      [ :on_red             ,  41 ], 
+      [ :on_green           ,  42 ], 
+      [ :on_yellow          ,  43 ], 
+      [ :on_blue            ,  44 ], 
+      [ :on_magenta         ,  45 ], 
+      [ :on_cyan            ,  46 ], 
+      [ :on_white           ,  47 ],
+      [ :intense_black      ,  90 ],    # High intensity, aixterm (works in OS X)
+      [ :intense_red        ,  91 ], 
+      [ :intense_green      ,  92 ], 
+      [ :intense_yellow     ,  93 ], 
+      [ :intense_blue       ,  94 ], 
+      [ :intense_magenta    ,  95 ], 
+      [ :intense_cyan       ,  96 ], 
+      [ :intense_white      ,  97 ], 
+      [ :on_intense_black   , 100 ],    # High intensity background, aixterm (works in OS X)
+      [ :on_intense_red     , 101 ], 
+      [ :on_intense_green   , 102 ], 
+      [ :on_intense_yellow  , 103 ], 
+      [ :on_intense_blue    , 104 ], 
+      [ :on_intense_magenta , 105 ], 
+      [ :on_intense_cyan    , 106 ], 
+      [ :on_intense_white   , 107 ]
+    ]
+
+    ATTRIBUTE_NAMES = ATTRIBUTES.transpose.first
+    # :startdoc:
+
+    # Returns true if Term::ANSIColor supports the +feature+.
+    #
+    # The feature :clear, that is mixing the clear color attribute into String,
+    # is only supported on ruby implementations, that do *not* already
+    # implement the String#clear method. It's better to use the reset color
+    # attribute instead.
+    def support?(feature)
+      case feature
+      when :clear
+        !String.instance_methods(false).map(&:to_sym).include?(:clear)
+      end
+    end
+    # Returns true, if the coloring function of this module
+    # is switched on, false otherwise.
+    def self.coloring?
+      @coloring
+    end
+
+    # Turns the coloring on or off globally, so you can easily do
+    # this for example:
+    #  Term::ANSIColor::coloring = STDOUT.isatty
+    def self.coloring=(val)
+      @coloring = val
+    end
+    self.coloring = true
+
+    ATTRIBUTES.each do |c, v|
+      eval <<-EOT
+        def #{c}(string = nil)
+          result = ''
+          if block_given?
+            result << yield
+          elsif string.respond_to?(:to_str)
+            result << string.to_str
+          elsif respond_to?(:to_str)
+            result << to_str
+          else
+            return result #only switch on
+          end
+          result
+        end
+      EOT
+    end
+
+    # Regular expression that is used to scan for ANSI-sequences while
+    # uncoloring strings.
+    COLORED_REGEXP = /\e\[(?:(?:[349]|10)[0-7]|[0-9])?m/
+
+    # Returns an uncolored version of the string, that is all
+    # ANSI-sequences are stripped from the string.
+    def uncolored(string = nil) # :yields:
+      if block_given?
+        yield.to_str.gsub(COLORED_REGEXP, '')
+      elsif string.respond_to?(:to_str)
+        string.to_str.gsub(COLORED_REGEXP, '')
+      elsif respond_to?(:to_str)
+        to_str.gsub(COLORED_REGEXP, '')
+      else
+        ''
+      end
+    end
+
+    module_function
+
+    # Returns an array of all Term::ANSIColor attributes as symbols.
+    def attributes
+      ATTRIBUTE_NAMES
+    end
+    extend self
+  end
+end

data/lib/texas/core_ext.rb

@@ -0,0 +1 @@
+require_relative 'core_ext/string'