llt-helpers 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2736c0ba15940c0b17d92e1750ec75ac57ed15fd
+  data.tar.gz: a466c7dceddeda33740ac15b1b2609ee7584b1a9
+SHA512:
+  metadata.gz: a353333c065c7353cec40220247feff8efba3a7ddacdbc39a09de8a1a46cedb29d0b049ca47cc3190e4f6669c1769a255d41a9d144b21eacea250797e300e033
+  data.tar.gz: ebe615476bf16ca0de06213dd4fb3b1eece1d8bf7c1af58aa2115478b70e0f525834539061328e126ecad95cabae4f7cb5868fddf60191ef79d6e73c96d0464d

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in llt-helpers.gemspec
+gemspec
+gem 'coveralls', require: false
+gem 'llt-constants', git: 'git@github.com:latin-language-toolkit/llt-constants.git'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 LFDM
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# LLT::Helpers
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'llt-helpers'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install llt-helpers
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = '-f d --color --tty'
+end
+
+task :default => :spec

data/lib/llt/helpers.rb

@@ -0,0 +1,15 @@
+require "llt/helpers/version"
+require "llt/helpers/terminology"
+require "llt/helpers/configuration"
+require "llt/helpers/constantize"
+require "llt/helpers/equality"
+require "llt/helpers/functions"
+require "llt/helpers/initialize"
+require "llt/helpers/metrical"
+require "llt/helpers/normalizer"
+require "llt/helpers/pluralize"
+require "llt/helpers/positions"
+require "llt/helpers/primitive_cache"
+require "llt/helpers/query_methods"
+require "llt/helpers/roman_numerals"
+require "llt/helpers/transformer"

data/lib/llt/helpers/configuration.rb

@@ -0,0 +1,44 @@
+module LLT
+  module Helpers
+    # currently not used, implemented slightly differently in LLT::Service class
+    module Configuration
+      def self.included(obj)
+        obj.extend(ClassMethods)
+      end
+
+      def configure(options = {})
+        # It might appeal here to refactor this to us merge.
+        # Don't do it: we don't want everything that might be present in options,
+        # only what we use in the configuration. Cf. specs.
+        configuration.each do |key, (val, _)|
+          val = options[key] || val
+          instance_variable_set("@#{key}", val)
+        end
+      end
+
+      def configuration
+        self.class.configuration
+      end
+
+      module ClassMethods
+        def configuration
+          @configuration ||= {}
+        end
+
+        def reload!
+          configuration.each do |_, arr|
+            arr[0] = arr[1].call
+          end
+        end
+
+        def method_missing(meth, *args, &blk)
+          if meth.to_s.match(/^uses_(.*)/)
+            configuration[$1.to_sym] = [blk.call, blk]
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llt/helpers/constantize.rb

@@ -0,0 +1,25 @@
+module LLT
+  module Helpers
+    module Constantize
+      def constant_by_type(type = @type, prefix: "", suffix: "", namespace: LLT)
+
+        raise ArgumentError.new("type cannot be nil") if type.nil?
+
+        t = begin
+              Terminology.send(type, :full)
+            rescue
+              type
+            end
+        scope = namespace || self.class
+        arg = "#{classified(prefix)}#{classified(t)}#{classified(suffix)}"
+        scope.const_get(arg)
+      end
+
+      private
+
+      def classified(arg)
+        arg.to_s.split("_").map(&:capitalize).join
+      end
+    end
+  end
+end

data/lib/llt/helpers/equality.rb

@@ -0,0 +1,28 @@
+module LLT
+  module Helpers
+    module Equality
+
+      # Intended to be uses as Class Extension.
+      # Responds to class methods in form of
+      # .equality_of_***_defined_by and takes several
+      # params, which define equality operators for the
+      # classes instance.
+      # These instances then respond to #same_***_as?(object).
+      def method_missing(meth, *args, &blk)
+        if meth.to_s.match(/^equality_of_(.*)_defined_by/)
+          equality_definition = "equality_definition_for_#{$1}"
+          define_method(equality_definition) do
+            args.map { |arg| send(arg) }
+          end
+
+          equality_comparator = "same_#{$1}_as?"
+          define_method(equality_comparator) do |other|
+            send(equality_definition) == other.send(equality_definition)
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/llt/helpers/functions.rb

@@ -0,0 +1,26 @@
+module LLT
+  module Helpers
+    module Functions
+
+      # Objects that use this module must implement #functions,
+      # which shall respond to #include?
+      def has_function?(function)
+        functions.include?(function)
+      end
+
+      def has_not_function? function
+        ! has_function?(function)
+      end
+
+      # Shortcut methods
+      def has_f?(function)
+        # Do not alias or delegate.
+        #
+        # It's (slightly) faster that way and this method will usually
+        # get lots of calls.
+        functions.include?(function)
+      end
+      alias :has_not_f? :has_not_function?
+    end
+  end
+end

data/lib/llt/helpers/initialize.rb

@@ -0,0 +1,28 @@
+module LLT
+  module Helpers
+    module Initialize
+
+      # Maps Hash keys to instance_variables
+      #
+      # Recommended usage is to implement #init_keys as an Array of Symbols
+      # Example:
+      # def init_keys
+      #   %i{ type stem inflection_class }
+      # end
+      #
+      # This will set @type, @stem and @inflection_class with their
+      # corresponding values.
+      # Keys not defined in init_keys or as param are untouched.
+      def extract_args!(args, keys = init_keys)
+        keys.each do |var_name|
+          instance_variable_set("@#{var_name}", args[var_name])
+        end
+      end
+
+      def extract_normalized_args!(args, keys = init_keys)
+        args = Helpers::Normalizer.normalize_args(args)
+        extract_args!(args, keys)
+      end
+    end
+  end
+end

data/lib/llt/helpers/metrical.rb

@@ -0,0 +1,31 @@
+module LLT
+  module Helpers
+    module Metrical
+      QUANTIFIED_CHARS = {
+        'a' => ['ă', 'ā'],
+        'e' => ['ĕ', 'ē'],
+        'i' => ['ĭ', 'ī'],
+        'o' => ['ŏ', 'ō'],
+        'u' => ['ŭ', 'ū'],
+        'y' => ['ў', 'ȳ'],
+      }
+      QUANTIFIED_CHARS_REGEXP = /[#{QUANTIFIED_CHARS.values.flatten.join}]/
+      QUANTIFIED_CHARS_SUB_MAP = QUANTIFIED_CHARS.each_with_object({}) do |(norm, quant), h|
+        quant.each { |quantified| h[quantified] = norm }
+      end
+
+      def evaluate_metrical_presence(string)
+        @metrical = string && string.match(QUANTIFIED_CHARS_REGEXP)
+      end
+
+      def metrical?
+        @metrical
+      end
+
+      # without meter
+      def wo_meter(string)
+        string.gsub(QUANTIFIED_CHARS_REGEXP, QUANTIFIED_CHARS_SUB_MAP)
+      end
+    end
+  end
+end

data/lib/llt/helpers/normalizer.rb

@@ -0,0 +1,28 @@
+module LLT
+  module Helpers
+    module Normalizer
+      def normalize_args(args)
+        args.each_with_object({}) do |(orig_k, v), hash|
+          if orig_k == :options
+            hash[orig_k] = normalize_args(v)
+          else
+            norm_k = terminology.key_term_for(orig_k)
+            if norm_k
+              hash[norm_k] = terminology.value_term_for(norm_k, v)
+            else
+              key = (orig_k == 'stem' ? orig_k.to_sym : orig_k)
+              hash[key] = v
+            end
+          end
+        end
+      end
+
+      def terminology
+        Terminology
+      end
+      alias :t :terminology
+
+      extend self
+    end
+  end
+end

data/lib/llt/helpers/pluralize.rb

@@ -0,0 +1,23 @@
+module LLT
+  module Helpers
+    module Pluralize
+      def pluralize(count, sg, pl = nil)
+        if count == 1
+          sg
+        else
+          pl || build_plural(sg)
+        end
+      end
+
+      private
+
+      def build_plural(sg)
+        sg = sg.clone
+        case sg
+        when /y$/ then sg.chop << "ies"
+        else sg << "s"
+        end
+      end
+    end
+  end
+end

data/lib/llt/helpers/positions.rb

@@ -0,0 +1,93 @@
+module LLT
+  module Helpers
+    module Positions
+      # Adds Comparable-like methods and more to an object, that holds an instance variable @position
+      # While the Comparable module itself could be included, defining these methods manually comes with
+      # a significant performance gain.
+
+      def === other
+        @position == other.position
+      end
+
+      def < other
+        @position < other.position
+      end
+
+      def > other
+        @position > other.position
+      end
+
+      def >= other
+        @position >= other.position
+      end
+
+      def <= other
+        @position >= other.position
+      end
+
+      def <=> other
+        @position <=> other.position
+      end
+
+      def - other   # used by Rating
+        @position - other.position
+      end
+
+      def surrounding
+        [@position - 1, @position + 1]
+      end
+
+      def distance_to(other, absolute = false)
+        d = other - self
+        absolute ? d.abs : d
+      end
+
+      def nearest_in(arr)
+        arr.sort_by { |el| distance_to(el, true) }.first
+      end
+
+      def in_front_of?(other, steps = 1)
+        (other - self).between?(1, steps + 1)
+      end
+
+      def next_in(arr, &blk)
+        arr.next_elem(self, &blk)
+      end
+
+      def prev_in(arr, &blk)
+        arr.prev_elem(self, &blk)
+      end
+
+      def at_sentence_start(sos)
+        @position == sos || @position == sos + 1
+      end
+
+      def in_front_of_any?(arr, steps = 1)
+        arr.any? { |e| self.in_front_of?(e, steps) }
+      end
+
+      def behind_any?(arr, steps = 1)
+        arr.any? { |e| self.behind?(e, steps) }
+      end
+
+      def behind?(other, steps = 1)
+        (self - other).between?(1, steps + 1)   # (self - other) < steps + 1 not valid => true for negatives!
+      end
+
+      def close_to?(other, steps = 1)
+        (self - other).abs < steps + 1
+      end
+
+      def between? a, b
+        @position.between?(a.position, b.position)
+      end
+
+      def range_with(other, to_range = false)
+        a, b = [@position, other.position].sort
+
+        range = ((a + 1)...b)
+        to_range ? range : range.to_a
+      end
+    end
+  end
+end