dphil 0.1.4

data/lib/dphil/log_formatter.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "awesome_print"
+
+module Dphil
+  class LogFormatter < ::Logger::Formatter
+    using ::Ragabash::Refinements
+
+    def colorize(severity, string)
+      color = SEVERITY_MAP[severity] || :none
+      String.new("#{COLOR_MAP[color]}#{string}#{COLOR_MAP[:none]}")
+    end
+
+    def call(severity, timestamp, progname, msg)
+      out = colorize(severity, "[#{timestamp.strftime('%Y-%m-%d %H:%M:%S %Z')}][v#{VERSION}] [#{severity}] ")
+      out << colorize("PROGNAME", "[#{progname}]") unless progname.nil?
+      "#{out}\n#{(msg.respond_to?(:to_str) ? msg : msg.ai(indent: -2))}\n"
+    end
+
+    COLOR_MAP = {
+      none:   "\e[0m",
+      bold:   "\e[1m",
+      red:    "\e[31m",
+      yellow: "\e[33m",
+      green:  "\e[32m",
+      cyan:   "\e[36m",
+    }.freeze
+
+    SEVERITY_MAP = {
+      "ERROR" => :red,
+      "FATAL" => :red,
+      "WARN" => :yellow,
+      "INFO" => :green,
+      "DEBUG" => :cyan,
+      "PROGNAME" => :bold,
+    }.freeze
+    private_constant :COLOR_MAP, :SEVERITY_MAP
+  end
+end

data/lib/dphil/logger.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "active_support/logger"
+
+require "dphil/log_formatter"
+
+# Namespace module definition
+module Dphil
+  module_function
+
+  def logger
+    @logger ||= begin
+      if defined?(::Rails) && defined?(::Rails.logger)
+        ::Rails.logger
+      else
+        file_logger = ActiveSupport::Logger.new(File.join(GEM_ROOT, "dphil.log"))
+        file_logger.formatter = LogFormatter.new
+        if Constants::DEBUG
+          logger = ActiveSupport::Logger.new(STDERR)
+          logger.formatter = file_logger.formatter
+          file_logger.extend(ActiveSupport::Logger.broadcast(logger))
+        end
+        file_logger
+      end
+    end
+  end
+end

data/lib/dphil/metrical_data.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "psych"
+require "hashie"
+
+module Dphil
+  #
+  # Metrical Data structure imported and parsed from "metrical_data" module at:
+  # https://github.com/shreevatsa/sanskrit
+  #
+  module MetricalData
+    using ::Ragabash::Refinements
+    class << self
+      attr_reader :version, :meters, :patterns, :regexes, :all
+    end
+
+    private_class_method
+
+    # This loads and processes the data into the module.
+    def self.load_data!
+      yml_data = Psych.load_file(File.join(GEM_ROOT, "vendor", "metrical_data.yml"))
+
+      @version = yml_data["commit"].deep_freeze
+
+      # Hash of meters with names as keys and patterns as values
+      meters_h = yml_data["meters"].each_with_object({}) do |(name, patterns), h|
+        h[Transliterate.unicode_downcase(name)] = patterns
+      end
+      @meters = IHash.new(meters_h)
+
+      # Hash of meters with patterns for keys and names/padas as values
+      patterns_h = yml_data["patterns"].each_with_object({}) do |(type, patterns), type_h|
+        type_h[type.to_sym] = (patterns.each_with_object({}) do |(pattern, meters), pattern_h|
+          pattern_h[pattern] = meters.each_with_object({}) do |(name, value), name_h|
+            name_h[Transliterate.unicode_downcase(name)] = value
+          end
+        end).sort_by { |(k, _)| k.to_s.length }.reverse.to_h
+      end
+      @patterns = IHashM.new(patterns_h)
+
+      # Hash of meters with regular expressions for keys and names/padas as values
+      regexes_h = yml_data["regexes"].each_with_object({}) do |(type, patterns), type_h|
+        type_h[type.to_sym] = (patterns.each_with_object({}) do |(pattern, meters), pattern_h|
+          new_pattern = Regexp.new(pattern.source.gsub(/^\^|\$$/, ""))
+          pattern_h[new_pattern] = meters.each_with_object({}) do |(name, value), name_h|
+            name_h[Transliterate.unicode_downcase(name)] = value
+          end
+        end).sort_by { |(k, _)| k.to_s.length }.reverse.to_h
+      end
+      @regexes = IHashM.new(regexes_h)
+
+      @all = IHashM.new(version: version,
+                        meters: meters,
+                        patterns: patterns,
+                        regexes: regexes)
+      self
+    end
+
+    # Immutable Hash
+    class IHash < ::Hash
+      include Hashie::Extensions::MergeInitializer
+
+      def initialize(*)
+        super
+        deep_freeze
+      end
+    end
+
+    # Immutable Hash with method access (for :full, :half, :pada hashes)
+    class IHashM < IHash
+      include Hashie::Extensions::MethodAccess
+    end
+
+    # Load the data when we load the module
+    # (but keep it in a method for cleanliness)
+    load_data!
+  end
+end

data/lib/dphil/newick.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "bio"
+
+module Dphil
+  module NewickTree
+    module_function
+
+    def tree_from_nex(filename, tree_id: nil, taxa_map: nil) # rubocop:disable MethodLength
+      data = File.read(filename).to_s[/^\s*tree MajRule = \[&R\](.*)$/, 1]
+      tree = Bio::Newick.new(data).tree
+      new_taxa_id = (taxa_map&.keys&.max || 0) + 1
+      tree_hsh = tree.nodes.each_with_object({}) do |n, acc|
+        next if n == tree.root
+        id = taxa_map&.key(n.name)
+        if id.nil?
+          id = new_taxa_id
+          new_taxa_id += 1
+        end
+        acc[id] = n
+      end
+
+      tree_nodes = tree_hsh.each_with_object({}) do |(id, node), acc|
+        out = {
+          id: id,
+          name: node.name || "##{id}",
+        }
+
+        parent = tree.parent(node)
+        out[:parent] = tree_hsh.key(parent) || 0
+        out[:length] = tree.get_edge(node, parent)&.distance
+
+        out[:children] = tree.children(node).map do |n|
+          tree_hsh.key(n)
+        end
+        acc[id] = out
+      end
+
+      stats = {
+        length: nil,
+        ci: nil,
+        hi: nil,
+        ci_ex: nil,
+        hi_ex: nil,
+        ri: nil,
+        rc: nil,
+      }
+
+      Dphil::Tree.new(tree_id, nodes: tree_nodes, stats: stats)
+    end
+  end
+end

data/lib/dphil/paup.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Dphil
+  #
+  # PAUP* Log Processor
+  #
+  module PAUP
+    def self.parse_trees(infile)
+      infile = File.expand_path(infile)
+      return STDERR.puts("File #{infile} not found.") unless File.exist?(infile)
+
+      data = File.read(infile).to_s.split(/^Tree ([0-9]+)\:$/)
+      return data if data.empty?
+
+      hash = { preamble: data.shift.strip }
+
+      trees = {}
+      data.each_slice(2) do |k, v|
+        next trees[:remainder] = k if v.nil?
+        branches = v.match(BRANCH_REGEXP)&.captures
+        changes = v.match(CHGLIST_REGEXP)&.captures
+        arr = []
+        arr.concat(%i[lengths stats].zip(branches)) unless branches.nil?
+        arr << [:changes, changes[0]] unless branches.nil?
+        trees[k.to_i] = arr.to_h
+      end
+
+      hash.merge(trees)
+    end
+
+    BRANCH_REGEXP = /^Branch lengths and linkages.*?\n\-{40,}\n(.*?)\n\-{40,}\n^Sum.*?(^Tree length =.*?)\n\n/m
+    CHGLIST_REGEXP = /^Character change lists:.*?\n\-{40,}\n(.*?)\n\n/m
+  end
+end

data/lib/dphil/refinements.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "dphil/refinements/natural_sort"
+
+module Dphil
+  module Refinements
+  end
+end

data/lib/dphil/refinements/natural_sort.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Dphil
+  module Refinements
+    module NaturalSort
+      refine Hash do
+        def natural_sort_keys
+          sort_by_key(true) do |a, b|
+            NaturalSort.grouped_compare(a, b) || a <=> b
+          end
+        end
+
+        def sort_by_key(recursive = false, &block)
+          keys.sort(&block).each_with_object({}) do |key, acc|
+            acc[key] = self[key]
+            if recursive && acc[key].is_a?(Hash)
+              acc[key] = acc[key].sort_by_key(true, &block)
+            end
+          end
+        end
+      end
+
+      class << self
+        CMP_REGEX = /((?:@{1,2}|[\$\:])?\p{L}+(?:[^\p{L}\d\s]*))|(\d+)/
+        private_constant :CMP_REGEX
+
+        def grouped_compare(a, b) # rubocop:disable CyclomaticComplexity
+          a = a&.scan(CMP_REGEX)
+          b = b&.scan(CMP_REGEX)
+          return if a.blank? || b.blank?
+
+          ret = nil
+          [a.size, b.size].max.times do |index|
+            a_cmp = coerce_chunk(a[index]) || (return -1)
+            b_cmp = coerce_chunk(b[index]) || (return 1)
+            ret = a_cmp <=> b_cmp || (a.is_a?(Integer) && -1 || b.is_a?(Integer) && 1)
+            return ret unless ret == 0 # rubocop:disable NumericPredicate
+          end
+          ret
+        end
+
+        private
+
+        def coerce_chunk(chunk)
+          return if chunk.nil?
+          return chunk[0] unless chunk[0].nil?
+          Integer(chunk[1])
+        end
+      end
+    end
+  end
+end

data/lib/dphil/script_string.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Dphil
+  class ScriptString
+    using ::Ragabash::Refinements
+    extend Forwardable
+    def_delegators :@string, :<=>, :==, :===, :to_s, :to_str, :empty?, :length
+    attr_reader :string
+
+    def initialize(str, script = nil)
+      raise "Source must be a String" unless str.respond_to?(:to_str)
+      str = str.to_str
+      str = str.dup if str.frozen?
+      @string = str.encode!(Encoding::UTF_8)
+      self.script = script || self.script
+    end
+
+    def script
+      @script ||= Transliterate.detect(@string)
+    end
+
+    def script=(script)
+      @script = script.try(:flat_map, &:to_sym) || script.to_sym
+    end
+
+    def transliterate(target)
+      target = target.to_sym
+      string = Transliterate.transliterate(@string, from: @script, to: target)
+      if @script.is_a?(Array)
+        new_target = @script.dup
+        new_target[0] = target
+        new_target.uniq!
+        target = new_target
+      end
+      self.class.new(string, target)
+    end
+
+    def transliterate!(target)
+      target = target.to_sym
+      @string = Transliterate.transliterate(@string, from: @script, to: target)
+      if @script.is_a?(Array)
+        @script[0] = target
+        @script.uniq!
+      end
+      @string
+    end
+
+    # String methods implemented to return ScString intances wherever possible
+
+    def downcase
+      self.class.new(Transliterate.unicode_downcase(@string), @script)
+    end
+
+    def downcase!
+      ret_val = Transliterate.unicode_downcase!(@string)
+      self unless ret_val.nil?
+    end
+
+    def inspect
+      "#{@string.inspect}:#{script}"
+    end
+
+    def gsub(pattern, rep_hash = nil)
+      ret_val = if block_given?
+                  @string.gsub(pattern, &Proc.new)
+                elsif !rep_hash.nil?
+                  @string.gsub(pattern, rep_hash)
+                else
+                  @string.gsub(pattern)
+                end
+      return ret_val if ret_val.is_a?(Enumerator)
+      self.class.new(ret_val, @script)
+    end
+
+    def gsub!(pattern, rep_hash = nil)
+      ret_val = if block_given?
+                  @string.gsub!(pattern, &Proc.new)
+                elsif !rep_hash.nil?
+                  @string.gsub!(pattern, rep_hash)
+                else
+                  @string.gsub!(pattern)
+                end
+      return ret_val if ret_val.is_a?(Enumerator)
+      self unless ret_val.nil?
+    end
+
+    def scan(pattern)
+      ret_val = if block_given?
+                  @string.scan(pattern, &Proc.new)
+                else
+                  @string.scan(pattern)
+                end
+      return self if ret_val == @string
+      ret_val.map do |match|
+        next self.class.new(match, @script) if match.is_a?(String)
+        match.map do |group|
+          self.class.new(group, @script)
+        end
+      end
+    end
+
+    def slice(a, b = nil)
+      slice = b.nil? ? @string.slice(a) : @string.slice(a, b)
+      self.class.new(slice, @script)
+    end
+    alias [] slice
+
+    def slice!(a, b = nil)
+      slice = b.nil? ? @string.slice!(a) : @string.slice!(a, b)
+      self.class.new(slice, @script)
+    end
+
+    def strip
+      self.class.new(@string.strip, @script)
+    end
+
+    def strip!
+      ret_val = @string.strip!
+      self unless ret_val.nil?
+    end
+  end
+end

data/lib/dphil/syllables.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+require "dphil/syllables/syllable"
+
+module Dphil
+  class Syllables
+    using ::Ragabash::Refinements
+    include Enumerable
+    extend Forwardable
+    def_delegators :@syllables, :[], :each, :first, :last, :length
+
+    attr_reader :source, :source_script, :weights, :syllables
+
+    def initialize(source, source_script: nil)
+      @source = source.to_str.safe_copy.freeze
+      @source_script = source_script || Transliterate.detect(@source) || Transliterate.default_script
+      slp1_syllables = VerseAnalysis.syllables(@source, from: @source_script, to: :slp1)
+      @weights = VerseAnalysis.syllables_weights(slp1_syllables, from: :slp1, contextual: true).freeze
+      @syllables = (slp1_syllables.map.with_index do |syl, i|
+        source = @source_script == :slp1 ? syl : Transliterate.t(syl, :slp1, @source_script)
+        Syllables::Syllable.new(source, @weights[i], parent: self, index: i, slp1: syl)
+      end).freeze
+    end
+
+    def inspect
+      "<Syllables \"#{@source}\":#{@source_script} (#{@weights}) (#{@syllables.count}) => #{@syllables.inspect}>"
+    end
+
+    def to_a
+      @syllables.map { |syl| Transliterate.t(syl.source, :slp1, @source_script) }
+    end
+
+    def to_s
+      @source.dup
+    end
+
+    def simple_weights
+      @simple_weights ||= @weights.upcase.freeze
+    end
+  end
+end