pslm 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fcfdfd901e4bdd0796aa7d85ca0037cb8c0b2e1e
+  data.tar.gz: 99ab169ac0873ce40653ebfb91f1a599f3fd1775
+SHA512:
+  metadata.gz: 141897655cd0db39adb3b32822cbd2ac9f77884e383297bfa1d7caf06c1cf11b1ac51452d6292fbfc5e15f424bfcdf5d3d53a5ccc71f74af6bd57ad017947899
+  data.tar.gz: 3c777f32f4dc5f914afcc0cf57799dff9b82f00963f2abf8f489cbf73af0de0f2943211626a1b13add3354e74c3ca0780a14bdea7f594d8896be146a0204abb9

data/bin/pslm.rb

@@ -0,0 +1,150 @@
+#!/usr/bin/env/ruby
+# -*- coding: utf-8 -*-
+# pslm - psalm processing utility
+
+require 'pslm'
+require 'optparse'
+
+require 'pslm/structuredsetup'
+
+DEFAULT_SETUP = {
+  :general => {
+    :format => 'latex', # latex|pslm
+  },
+  :input => {
+    :has_title => true,
+    :title => nil, # to overwrite the title loaded from the input file
+    :join => false,
+  },
+  :output => Pslm::Outputter::DEFAULT_SETUP.dup
+}
+
+setup = StructuredSetup.new DEFAULT_SETUP
+[:accents, :preparatory].each do |o|
+  setup[:output][:pointing].delete o
+end
+
+# TODO the setup below doesn't yet respect the structure of the options above
+# TODO many of the options aren't implemented yet, some will never be
+optparse = OptionParser.new do |opts|
+
+  opts.separator "== General options"
+
+  opts.on "-o", "--output FILE", "Save output to given path." do |out|
+    setup[:general][:output_file] = out
+  end
+
+  opts.on "-f", "--format F", "Select output format." do |f|
+    setup[:general][:format] = f
+  end
+
+  opts.separator "== Input interpretation"
+
+  opts.on "--no-title", "Don't consider the first line to contain a psalm title" do
+    setup[:input][:has_title] = false
+  end
+  opts.on "--set-title TITLE", "Manually set title" do |t|
+    setup[:input][:title] = t
+  end
+  opts.on "--append TEXT", "Text to be appended at the end (before processing)." do |t|
+    setup[:input][:append] = t
+  end
+  opts.on "-j", "--join", "Join all given input files" do
+    setup[:input][:join] = true
+  end
+
+  opts.separator "== Output formatting"
+
+  opts.on "--skip-title", "Don't set the title" do
+    setup[:output][:title][:template] = :no
+  end
+  opts.on "--title-template [TEMPLATE]", "Use a specified template instead of the default one." do |p|
+    setup[:output][:title][:template] = p
+  end
+  opts.on "-k", "--skip-verses NUM", Integer, "Skip initial verses" do |i|
+    setup[:output][:skip_verses] = i
+  end
+
+  opts.on "-a", "--accents NUMS", "a:b - Numbers of accents to be pointed in each half-verse" do |str|
+    a1, a2 = str.split ':'
+    if a1 && a1 != "" then
+      setup.get_dv(:output, :pointing, :accents, [])[0] = a1.to_i
+    end
+    if a2 && a2 != "" then
+      setup.get_dv(:output, :pointing, :accents, [])[1] = a2.to_i
+    end
+  end
+  # TODO merge with the previous option to a1[,p1]:a2[,p2]
+  opts.on "-p", "--preparatory-syllables NUMS", "a:b - How many preparatory syllables in each half-verse" do |str|
+    a1, a2 = str.split ':'
+    if a1 && a1 != "" then
+      setup.get_dv(:output, :pointing, :preparatory, [])[0] = a1.to_i
+    end
+    if a2 && a2 != "" then
+      setup.get_dv(:output, :pointing, :preparatory, [])[1] = a2.to_i
+    end
+  end
+  opts.on "-t", "--tone TONE", "point accents and preparatory syllables for a given psalm tone (like I.f or VIII.G)" do |str|
+    setup[:output][:pointing][:tone] = str
+  end
+
+  opts.on "-s", "--accents-style SYM", "underline (default) | bold" do |s|
+    sym = s.to_sym
+    setup[:output][:pointing][:accent_style] = sym
+  end
+  # Needs LaTeX package lettrine!
+  # TODO
+  opts.on "--lettrine", "Large first character of the psalm." do
+    setup[:output][:lettrine] = {}
+  end
+  opts.on "--split-verses", "Each verse part on it's own line" do
+    setup[:output][:parts][:novydvur_newlines] = true # like in the psalter of the Novy Dvur Trappist abbey
+  end
+  # TODO
+  opts.on "--pretitle TEXT", "Text to be printed as beginning of the title." do |t|
+    setup[:output][:prepend_text] = t
+  end
+  opts.on "--output-append TEXT", "Text to be appended at the end (of the last line after processing)." do |t|
+    setup[:output][:final_add_content] = {:append => t}
+  end
+  # This is useful when we want to append a doxology after the psalm
+  # as a separate paragraph
+  # TODO
+  opts.on "--linebreak-at-the-end", "Make a line-break after the last line" do
+    setup[:output][:line_break_last_line] = true
+  end
+  opts.on "--dashes", "Dash at the end of each psalm paragraph" do
+    setup[:output][:strophes][:end_marks] = :semantic
+  end
+  # TODO
+  opts.on "--no-paragraph", "No empty line after each psalm paragraph." do
+    setup[:output][:paragraph_space] = false
+  end
+  opts.on "--guillemets", "Convert american quotes to french ones (guillemets)." do
+    setup[:output][:quote] = :guillemets
+  end
+  # TODO
+  opts.on "-m", "--mark-short-verses", "Insert warning marks in verses that are too short" do
+    setup[:output][:mark_short_verses] = true
+  end
+  opts.on "--wrapper NAME", "Wrap output in a wrapper with the given name" do |n|
+    setup[:output][:wrapper][:environment_name] = n
+  end
+end
+
+optparse.parse!
+
+# use default pointing setup if necessary
+unless setup[:output][:pointing].has_key? :tone
+  [:accents, :preparatory].each do |o|
+    unless setup[:output][:pointing].has_key? o
+      setup[:output][:pointing][o] = DEFAULT_SETUP[:output][:pointing][o].dup
+    end
+  end
+end
+
+if ARGV.empty? then
+  raise "Program expects filenames as arguments."
+end
+
+Pslm::PsalmPointer.new(setup).process(ARGV, setup[:general][:output_file])

data/lib/pslm.rb

@@ -0,0 +1,17 @@
+# main file of the pslm library
+
+module Pslm
+end
+
+require_relative 'pslm/pslmreader'
+require_relative 'pslm/psalm'
+require_relative 'pslm/psalmpointer'
+require_relative 'pslm/psalmpatterns'
+
+require_relative 'pslm/outputter'
+require_relative 'pslm/latexoutputter'
+require_relative 'pslm/pslmoutputter'
+require_relative 'pslm/consoleoutputter'
+
+require_relative 'pslm/structuredsetup'
+require_relative 'pslm/joinedinput'

data/lib/pslm/consoleoutputter.rb

@@ -0,0 +1,281 @@
+# -*- coding: utf-8 -*-
+
+require 'colorize'
+
+module Pslm
+
+  # formats a psalm for console output
+  class ConsoleOutputter < Outputter
+
+    FORMATTER_ORDER = [
+      :pointing,
+      :parts,
+      :verses,
+      :skip_verses,
+      :title,
+      :strophes,
+      :prepend_text,
+      :output_append_text,
+      :line_break_last_line,
+      :mark_short_verses
+    ]
+
+    # takes a Psalm, returns a String with the psalm formatted
+    def process_psalm(psalm, opts={})
+      formatters = get_formatters(opts)
+
+      # build the output; on each step apply the appropriate method
+      # of each formatter in the given order
+      psalm_assembled = psalm.verses.collect do |verse|
+        process_verse(verse, opts, psalm, formatters)
+      end.delete_if {|v| v == '' }.join "\n"
+
+      return Formatter.format(formatters, :psalm,
+                              psalm_assembled,
+                              psalm)
+    end
+
+    alias :process :process_psalm
+
+    def process_verse(verse, opts, psalm=nil, formatters=nil)
+      formatters = formatters || get_formatters(opts)
+
+      verse_assembled = verse.parts.collect do |part|
+
+        part_assembled = part.words.reverse.collect do |word|
+
+          word_assembled = word.syllables.reverse.collect do |syll|
+            Formatter.format(formatters, :syllable,
+                              syll, part, word, syll)
+          end.reverse.join ''
+
+          Formatter.format(formatters, :word,
+                            word_assembled, word)
+        end.reverse.join ' '
+
+        Formatter.format(formatters, :part,
+                          part_assembled, part)
+      end.join ''
+
+      return Formatter.format(formatters, :verse,
+                              verse_assembled, psalm, verse)
+    end
+
+    # takes a Hash of options,
+    # returns a list of accordingly initialized Formatter instances
+    def get_formatters(options)
+      return FORMATTER_ORDER.collect do |f|
+        next unless options.include? f
+
+        get_formatter(f, options[f])
+      end.compact!
+    end
+
+    # takes a Symbol - name of a configuration option, and option/s value;
+    # returns an instance of a corresponding Formatter class or nil
+    def get_formatter(sym, options)
+      cls_name = sym.to_s.gsub(/_(\w)/) {|m| m[1].upcase }
+      cls_name[0] = cls_name[0].upcase
+      cls_name += 'Formatter'
+
+      if self.class.const_defined? cls_name then
+        return self.class.const_get(cls_name).new(options)
+      else
+        return nil
+      end
+    end
+
+    # abstract superclass of the formatters providing dumb implementation
+    # of all formatting methods
+    class Formatter
+
+      class << self
+        # lets all the :formatters: subsequently format :text: assembled from :obj: on the assembly :level:
+        def format(formatters, level, text, *args)
+          formatters.each do |f|
+            text = f.send("#{level}_format", text, *args)
+          end
+          return text
+        end
+      end
+
+      def initialize(options)
+        @options = options
+        @syll_counter = 0
+        @word_counter = 0
+        @part_counter = 0
+        @verse_counter = 0
+      end
+
+      def psalm_format(text, psalm)
+        @syll_counter = 0
+        @word_counter = 0
+        @part_counter = 0
+        @verse_counter = 0
+        text
+      end
+
+      def verse_format(text, psalm, verse)
+        @verse_counter += 1
+        @syll_counter = 0
+        @word_counter = 0
+        @part_counter = 0
+        text
+      end
+
+      def part_format(text, part)
+        @part_counter += 1
+        @syll_counter = 0
+        @word_counter = 0
+        text
+      end
+
+      def word_format(text, word)
+        @word_counter += 1
+        text
+      end
+
+      def syllable_format(text, part, word, syll)
+        @syll_counter += 1
+        text
+      end
+    end
+
+    # marks accentuated and preparatory syllables
+    class PointingFormatter < Formatter
+      def initialize(options)
+        super(options)
+        @accent_counter = 0
+        @preparatories_counter = 0
+
+        # validate options
+        if @options.has_key? :tone and
+            (@options.has_key? :accents or @options.has_key? :preparatory) then
+          raise RuntimeError.new('Overconfigured: both accents/preparatories number and psalm tone specified.')
+        elsif @options.has_key? :accents then
+          # ok, nothing to do
+        elsif @options.has_key? :tone
+          # convert psalm tone identifier to numbers
+          tone = PsalmPatterns.default.tone_data_str(@options[:tone])
+          @options[:accents] = tone.collect {|part| part[0] }
+          @options[:preparatory] = tone.collect {|part| part[1] }
+        end
+
+        if @options[:accent_style] != nil then
+          if MARKS.has_key? @options[:accent_style] then
+            @accent_style = MARKS[@options[:accent_style]]
+          else
+            # user_defined style
+            @accent_style = @options[:accent_style].to_sym
+          end
+        else
+          @accent_style = :blue
+        end
+
+        @preparatory_style = :magenta
+      end
+
+      def part_format(text, part)
+        super(text, part)
+        @accent_counter = 0
+        @preparatories_counter = 0
+        text
+      end
+
+      MARKS = {
+        :underline => {:color => :blue, :mode => :underline},
+        :bold => {:color => :blue, :mode => :bold},
+        :semantic => {:color => :blue, :mode => :bold}
+      }
+
+      def syllable_format(text, part, word, syll)
+        super(text, part, word, syll)
+        r = text
+        if syll.accent? then
+          @accent_counter += 1
+          if @accent_counter <= num_accents_for(part) then
+            r = r.colorize @accent_style
+          end
+        end
+
+
+        if num_preparatory_syllables_for(part) > 0 and
+            @accent_counter >= num_accents_for(part) then
+
+          if @preparatories_counter >= 1 and
+              @preparatories_counter <= num_preparatory_syllables_for(part) then
+            r = r.colorize @preparatory_style
+          end
+
+          @preparatories_counter += 1
+        end
+
+        return r
+      end
+
+      private
+
+      # how many accents to mark in this verse-part?
+      def num_accents_for(part)
+        case part.pos
+        when :flex
+          1
+        when :first
+          @options[:accents][0]
+        when :second
+          @options[:accents][1]
+        end
+      end
+
+      # how many preparatory syllables to mark in this verse-part?
+      def num_preparatory_syllables_for(part)
+        case part.pos
+        when :flex
+          0
+        when :first
+          @options[:preparatory][0]
+        when :second
+          @options[:preparatory][1]
+        end
+      end
+    end
+
+    # formatting of verse parts -
+    # adds part dividing marks (flex, asterisk),
+    # eventually inserts newlines
+    class PartsFormatter < Formatter
+
+      MARKS = { :flex => ' + ', :first => ' * ', :second => ' ' }
+
+      def part_format(text, part)
+        text + MARKS[part.pos].colorize(:color => :light_blue) +
+          ((@options[:novydvur_newlines] && part.pos != :second) ? "\n" : '')
+      end
+    end
+
+    # skips verses at the beginning
+    class SkipVersesFormatter < Formatter
+      def initialize(options)
+        super(options)
+        @skip_verses = @options # takes just one number as a parameter
+      end
+
+      def verse_format(text, psalm, verse)
+        #super(text, psalm, verse)
+        @verse_counter += 1
+        if @verse_counter <= @skip_verses then
+          return ""
+        end
+
+        return text
+      end
+    end
+
+    # formats title
+    class TitleFormatter < Formatter
+      def psalm_format(text, psalm)
+        psalm.header.title.colorize(:mode => :bold) + "\n\n" + text
+      end
+    end
+  end
+end