pslm 0.0.0

data/lib/pslm/outputter.rb

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+
+module Pslm
+
+  # abstract superclass of all outputters
+  class Outputter
+
+    DEFAULT_SETUP = {
+      :no_formatting => false, # TODO
+      :title => {
+        :template => :semantic,
+      },
+      :pointing => {
+        :accents => [2,2],
+        :preparatory => [0,0],
+        :accent_style => :underline, # :underline|:bold|:semantic
+      },
+      :break_hints => true,
+      :parts => {
+        :marks_type => :semantic, # :simple|:semantic|:no
+        :novydvur_newlines => false,
+      },
+      :verses => {
+        :paragraphify => true
+      },
+      :skip_verses => 0,
+      :strophes => {
+        :end_marks => false,
+        :paragraph_space => true,
+        :mark_last_strophe => false,
+      },
+      :wrapper => {
+        :environment_name => 'psalmus'
+      },
+      :lettrine => nil,
+      :line_break_last_line => false, # TODO
+      :quote => false, # :single|:double|:guillemets|:czech|:delete
+      :mark_short_verses => false, # TODO
+      :final_add_content => false,
+    }
+
+    def process(psalm, options={})
+      raise RuntimeError.new "Abstract class. Method not implemented."
+    end
+
+  end
+end

data/lib/pslm/psalm.rb

@@ -0,0 +1,149 @@
+# -*- coding: utf-8 -*-
+
+require 'ostruct'
+
+# parsed psalm data
+module Pslm
+  class Psalm
+
+    def initialize
+      @header = OpenStruct.new
+      @header.title = ''
+      @strophes = [ Strophe.new ]
+    end
+
+    attr_reader :header, :strophes
+
+    # accesses all verses of the psalm regardless of the strophes
+    def verses
+      @strophes.collect {|s| s.verses }.flatten
+    end
+
+    def add_strophe(s=nil)
+      if s != nil then
+        @strophes << s
+      else
+        @strophes << Strophe.new
+      end
+    end
+
+    def add_verse(v)
+      @strophes.last.verses << v
+    end
+
+    def ==(ps2)
+      ps2.is_a?(Psalm) && self.header == ps2.header && self.strophes == ps2.strophes
+    end
+
+    # returns a new Psalm containing verses of the second appended to the verses
+    # of the first; everything else is copied from the first
+    # (title etc. of the second Psalm get lost)
+    def +(ps2)
+      ps_res = self.dup
+      ps_res.strophes.concat ps2.strophes
+      return ps_res
+    end
+
+    class Strophe
+      def initialize
+        @verses = []
+      end
+
+      attr_reader :verses
+
+      def ==(s2)
+        s2.is_a?(Strophe) && self.verses == s2.verses
+      end
+    end
+
+    class Verse
+      def initialize(flex=nil, first=nil, second=nil)
+        @flex = flex
+        @first = first
+        @second = second
+        if second.nil? then
+          yield self
+        end
+      end
+
+      attr_accessor :flex, :first, :second
+
+      def parts
+        r = [@first, @second]
+        r.unshift @flex if @flex
+        return r
+      end
+
+      def ==(v2)
+        unless v2.is_a? Verse
+          return false
+        end
+
+        [:flex, :first, :second].each do |part|
+          if self.send(part) != v2.send(part) then
+            return false
+          end
+        end
+
+        return true
+      end
+    end
+
+    class VersePart
+      def initialize(words, src, pos)
+        @words = words
+        @src = src
+        @pos = pos
+      end
+
+      # Array of Words
+      attr_reader :words
+
+      # the source text before parsing
+      attr_reader :src
+
+      # position in the verse - one of :flex, :first, :second
+      attr_reader :pos
+
+      def ==(p2)
+        p2.is_a?(VersePart) && self.words == p2.words
+      end
+    end
+
+    class Word
+      def initialize(syllables)
+        @syllables = syllables
+      end
+
+      attr_reader :syllables
+
+      def ==(w2)
+        w2.is_a?(Word) && self.syllables == w2.syllables
+      end
+    end
+
+    class Syllable < String
+      def initialize(chars, accent=false)
+        super(chars)
+        @accent = accent
+      end
+
+      def accent?
+        @accent
+      end
+
+      def ==(s2)
+        s2.is_a? Syllable and (self.to_s == s2.to_s) and (self.accent? == s2.accent?)
+      end
+
+      def to_s
+        String.new self
+      end
+
+      def inspect
+        accent = @accent ? ' accent' : ''
+        return '#' + "<#{self.class}:#{self.object_id} \"#{self}\"#{accent}>"
+      end
+    end
+  end
+end

data/lib/pslm/psalmpatterns.rb

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+
+require 'yaml'
+
+module Pslm
+
+  # holds and provides information on a set of psalm tones:
+  # how many accents and preparatory syllables does each tone
+  # need in first and second half-verse.
+  class PsalmPatterns
+
+    # expects a well-formed data structure -
+    # as an example see the yaml files in directory psalmtones
+    def initialize(data)
+      @data = {}
+
+      # downcase all tone and difference identifiers
+      data.each_pair do |tone, tdata|
+        if tdata[1][1].is_a? Hash then
+          dfrs = {}
+          tdata[1][1].each_pair do |df, num|
+            dfrs[df.downcase] = num
+          end
+          tdata[1][1] = dfrs
+        end
+        @data[tone.downcase] = tdata
+      end
+    end
+
+    # alternative constructors
+    class << self
+
+      def from_yaml(str)
+        new(YAML::load(str))
+      end
+
+      def from_file(fname)
+        from_yaml(File.open(fname).read())
+      end
+
+      # loads and returns data of a default tone-set
+      def default
+        from_file(File.expand_path('psalmtones/solesmes196x.yml', File.dirname(__FILE__)))
+      end
+    end
+
+    # returns an Array like [[1,2], [2,0]]
+    # specifying number of accents and
+    def tone_data(tone, difference='')
+      tone.downcase!
+      difference.downcase!
+
+      unless @data.has_key? tone
+        raise ToneError.new "Unknown tone '#{tone}'"
+      end
+
+      if @data[tone][1][1].is_a? Hash then
+        unless @data[tone][1][1].has_key? difference
+          raise DifferenceError.new "Unknown difference '#{difference}' for tone '#{tone}'"
+        end
+
+        return [ @data[tone][0].dup , [ @data[tone][1][0], @data[tone][1][1][difference] ] ]
+      else
+        return @data[tone]
+      end
+    end
+
+    # returns tone data for a tone identified by a String like 'I.D'
+    def tone_data_str(tonestr)
+      tone_data(*normalize_tone_str(tonestr))
+    end
+
+    # returns [tone, difference]
+    def normalize_tone_str(str)
+      tone, sep, difference = str.rpartition(/[\.\s]/)
+      return [tone, difference]
+    end
+
+    # returns tone data in a data structure containing Hashes
+    # with descriptive keys
+    def tone_data_verbose(tone, difference='')
+      describe_tone_data(tone, difference)
+    end
+
+    def describe_tone_data(data)
+      return data[0..1].collect {|part| {:accents => part[0], :preparatory => part[1] } }
+    end
+
+    # tone unknown
+    class ToneError < KeyError
+    end
+
+    # difference unknown
+    class DifferenceError < KeyError
+    end
+  end
+end

data/lib/pslm/psalmpointer.rb

@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+
+module Pslm
+
+  # Workhorse of the pslm CLI utility.
+  class PsalmPointer
+
+    def initialize(options)
+      @options = options
+
+      # make @options a StructuredSetup - because of deep #dup and recursive #update
+      unless @options.is_a? StructuredSetup
+        @options = StructuredSetup.new @options
+      end
+
+      @reader = PslmReader.new
+    end
+
+    def process(psalm_files, output_file=nil, overwr_options={})
+      options = @options.dup
+      options.update overwr_options
+
+      if output_file != nil then
+        outf = File.open output_file, 'w'
+      else
+        outf = STDOUT
+      end
+
+      unless psalm_files.is_a? Array
+        psalm_files = [ psalm_files ]
+      end
+
+      psalms = psalm_files.collect do |pf|
+        inf = open_psalm_file(pf)
+        if options[:input][:append] then
+          inf = JoinedInput.new inf, StringIO.new(options[:input][:append])
+        end
+        @reader.load_psalm(inf)
+      end
+
+      if options[:input][:join] then
+        while p = psalms.slice!(1) do
+          psalms[0] += p
+        end
+      end
+
+      if options[:input][:title] then
+        psalms.first.header.title = options[:input][:title] # should it be set for all instead of for the first one only?
+      end
+
+      outputter = get_outputter options[:general][:format]
+      psalms.each do |ps|
+        # yield the psalm before producing output to allow modification
+        modified = yield ps if block_given?
+        if modified != ps and modified.is_a?(Psalm) then
+          ps = modified
+        end
+
+        outf.puts outputter.process_psalm ps, options[:output]
+      end
+
+      if outf != STDOUT then
+        outf.close
+      end
+    end
+
+    private
+
+    def open_psalm_file(fname)
+      if fname == '-' then
+        return STDIN
+      else
+        return File.open fname
+      end
+    end
+
+    def get_outputter(format)
+      cls_name = format.to_s.gsub(/_(\w)/) {|m| m[1].upcase }
+      cls_name[0] = cls_name[0].upcase
+      cls_name += 'Outputter'
+
+      if Pslm.const_defined? cls_name then
+        return Pslm.const_get(cls_name).new
+      else
+        return nil
+      end
+    end
+  end
+end

data/lib/pslm/psalmtones/solesmes196x.yml

@@ -0,0 +1,22 @@
+# according to Liber Usualis, Solesmes cca 1962
+---
+I: [[2, 0], [1, 2]]
+II: [[1, 0], [1, 1]]
+III: [
+  [2, 0],
+  [1, {b: 1, a: 1, a2: 2, g: 2, g2: 3}]
+]
+IV: [
+  [1, 2],
+  [1, {g: 0, E: 3}]
+]
+IV alt: [
+  [1, 2],
+  [1, {c: 0, A: 3, 'A*': 3, d: 3}]
+]
+V: [[1, 0], [2, 0]]
+VI: [[2, 0], [1, 2]]
+VI alt: [[1, 1], [1, 2]]
+VII: [[2, 0], [2, 0]]
+VIII: [[1, 0], [1, 2]]
+per: [[1, 3], [1, 1]]

data/lib/pslm/pslmoutputter.rb

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+
+module Pslm
+
+  # reconstructs the input format
+  #
+  # an easier implementation would make use of VersePart#src, but
+  # this should be a simple example of full-depth output preparation
+  class PslmOutputter < Outputter
+
+    # doesn't respect any options; accepts them only because of a common
+    # outputter interface
+    def process(psalm, options={})
+      psalm_assembled = psalm.verses.collect do |verse|
+
+        verse_assembled = verse.parts.collect do |part|
+
+          part_assembled = part.words.collect do |word|
+
+            word_assembled = ''
+            word.syllables.each_with_index do |syll, si|
+
+              if word_assembled.size > 0 and
+                  not word.syllables[si-1].accent? and
+                  not syll.accent? then
+                word_assembled += '/'
+              end
+              word_assembled += syllable_format(syll)
+            end
+
+            word_format word_assembled, word
+
+          end.join ' '
+          part_format part_assembled, part
+
+        end.join "\n"
+        verse_format verse_assembled, verse
+
+      end.join "\n"
+
+      return psalm.header.title + "\n\n" + psalm_assembled
+    end
+
+    def syllable_format(syll)
+      if syll.accent? then
+        return '[' + syll + ']'
+      end
+
+      return syll
+    end
+
+    def word_format(text, word)
+      text
+    end
+
+    def part_format(text, part)
+      case part.pos
+      when :flex
+        return text + ' +'
+      when :first
+        return text + ' *'
+      else
+        return text
+      end
+    end
+
+    def verse_format(text, verse)
+      text
+    end
+  end
+end