llt-helpers 0.0.4

data/lib/llt/helpers/primitive_cache.rb

@@ -0,0 +1,37 @@
+require 'dalli'
+
+module LLT
+  module Helpers
+    module PrimitiveCache
+      def self.included(obj)
+        obj.extend(ClassMethods)
+      end
+
+      def enable_cache
+        @cache_enabled = true
+      end
+
+      def disable_cache
+        @cache_enabled = false
+      end
+
+      def cache
+        self.class.cache
+      end
+
+      def cached(key)
+        if @cache_enabled
+          self.class.cache.fetch(key) { yield } #[key] ||= yield # with Dalli use
+        else
+          yield
+        end
+      end
+
+      module ClassMethods
+        def cache
+          @cache ||= Dalli::Client.new # {}
+        end
+      end
+    end
+  end
+end

data/lib/llt/helpers/query_methods.rb

@@ -0,0 +1,30 @@
+module LLT
+  module Helpers
+    module QueryMethods
+      def add_query_methods_for(key_term, use: nil, delegate_to: nil)
+        raise ArgumentError, "Can't use :use and :delegate_to together" if use && delegate_to
+
+        meths = t.values_for(key_term)
+        used_var = use || "@#{key_term}"
+        meths.each do |meth|
+          body = if delegate_to
+                   "#{delegate_to}.#{meth}?"
+                 else
+                   "#{used_var} == :#{t.value_for(key_term, meth)}"
+                 end
+
+          class_eval <<-STR
+            def #{meth}?
+              #{body}
+            end
+          STR
+        end
+      end
+
+      private
+      def t
+        Terminology
+      end
+    end
+  end
+end

data/lib/llt/helpers/roman_numerals.rb

@@ -0,0 +1,50 @@
+require 'llt/constants/numerals'
+
+module LLT
+  module Helpers
+    module RomanNumerals
+
+      # Primitive implementation to detect and convert Roman Numerals.
+
+      class << self
+
+        # Uncapitalized numerals will NOT be detected atm.
+        def roman?(value)
+          /^[CDILMVX]*$/.match(value)
+        end
+
+        # 4 to IV
+        def to_roman(value)
+          res = ""
+          numerals.each do |dec, _|
+            while value >= dec
+              value -= dec
+              res << numerals[dec]
+            end
+          end
+
+          res
+        end
+
+        # IV to 4
+        def to_decimal(value)
+          res = 0
+          numerals.each do |_, rom|
+            while value.start_with?(rom)
+              value = value[rom.length..-1]
+              res += numerals.key(rom)
+            end
+          end
+
+          res
+        end
+
+        private
+
+        def numerals
+          LLT::Constants::NUMERALS
+        end
+      end
+    end
+  end
+end

data/lib/llt/helpers/terminology.rb

@@ -0,0 +1,219 @@
+module LLT
+  module Helpers
+    module Terminology
+      class << self
+        def term_for(key)
+          FULL_TABLE[key.to_sym]
+        end
+
+        # rename, scrap term
+        def key_term_for(key)
+          KEY_TABLE[key.to_sym]
+        end
+
+        def value_term_for(key, value)
+          t = VALUE_TABLE[key]
+          if t.nil?
+            # tries to normalize the key
+            k = key_term_for(key)
+
+            # hacky solution to normalize inflection class integers
+            return value.to_i if inflection_class_number_as_string?(key, value)
+
+            t = VALUE_TABLE[k]
+            return value unless t
+          end
+          t[val_to_sym_or_integer(value)] || value
+        end
+        alias :value_for :value_term_for
+
+        def inflection_class_number_as_string?(key, value)
+          key == inflection_class && value.kind_of?(String) && value.match(/^\d*$/)
+        end
+
+        def val_to_sym_or_integer(val)
+          # Normalizes strings to symbols or integers, but leaves fixnums intact
+          case val
+          when /^\d*$/ then val.to_i
+          when String  then val.to_sym
+          else val
+          end
+        end
+
+        def values_for(key_term, exclude: nil)
+          v = VALUE_TABLE[key_term_for(key_term)]
+          v ? v.keys : []
+        end
+
+        def norm_values_for(key_term, format: DEFAULT_FORMAT[key_term])
+          NORM_VALUES[key_term].map { |values| send(values.first, format) }
+        end
+
+        def method_missing(meth, *args, &blk)
+          meth
+        end
+
+        # implement to_ary everytime you do crazy method_missing stuff.
+        # #flatten will bite you otherwise!
+        def to_ary
+          nil
+        end
+
+        # Keywords
+
+        def inflection_class
+          :inflection_class
+        end
+
+        def tempus
+          :tempus
+        end
+
+        def casus
+          :casus
+        end
+
+        def type
+          :type
+        end
+
+        def numerus
+          :numerus
+        end
+
+        def sexus
+          :sexus
+        end
+
+        def noe
+          :number_of_endings
+        end
+
+        def modus
+          :modus
+        end
+
+        def genus
+          :genus
+        end
+
+        def persona
+          :persona
+        end
+
+        def deponens
+          :deponens
+        end
+
+        DEFAULT_FORMAT = { casus:   :numeric,
+                           numerus: :numeric,
+                           tempus:  :abbr,
+                           sexus:   :abbr,
+                           modus:   :abbr,
+                           type:    :full,
+                           genus:   :abbr,
+                           persona: :numeric }
+
+        # Convenience Methods
+
+        def self.create_three_way_getter_methods(abbr, full, i, type)
+          class_eval <<-STR
+            def #{full}(arg = :#{DEFAULT_FORMAT[type]})
+              case arg
+              when :numeric then #{i + 1}
+              when :abbr    then :#{abbr}
+              when :full    then :#{full}
+              when :camelcase then :#{camelcased(full)}
+              end
+            end
+            alias :#{abbr} :#{full}
+          STR
+        end
+
+        def self.camelcased(str)
+          str.to_s.split("_").map(&:capitalize).join
+        end
+
+        NORM_VALUES = { casus:   [[:nom, :nominativus], [:gen, :genetivus], [:dat, :dativus], [:acc, :accusativus], [:voc, :vocativus], [:abl, :ablativus]],
+                        numerus: [[:sg, :singularis], [:pl, :pluralis]],
+                        tempus:  [[:pr, :praesens], [:impf, :imperfectum], [:fut, :futurum], [:pf, :perfectum], [:pqpf, :plusquamperfectum], [:fut_ex, :futurum_exactum]],
+                        sexus:   [[:m, :masculinum], [:f, :femininum], [:n, :neutrum]],
+                        modus:   [[:ind, :indicativus], [:con, :coniunctivus], [:imp, :imperativum], [:part, :participium], [:inf, :infinitivum], [:gerundium, :gerundium], [:gerundivum, :gerundivum]],
+                        type:    [[:noun, :noun], [:adj, :adjective], [:verb, :verb]],#, [:gerundive, :gerundive], [:gerund, :gerund]],
+                        genus:   [[:act, :activum], [:pass, :passivum]],
+                        persona: [[:first, :first], [:second, :second], [:third, :third]]
+        }
+
+        NORM_VALUES.each do |type, getters|
+          getters.each_with_index do |(abbr, full), i|
+            create_three_way_getter_methods(abbr, full, i, type)
+          end
+        end
+      end
+
+      kt = { inflection_class => %i{ inflection_class inflectable_class iclass itype },
+             tempus => %i{ tempus tense },
+             casus => %i{ casus case },
+             numerus => %i{ numerus },
+             modus => %i{ mood modus },
+             sexus => %i{ sexus gender },
+             genus => %i{ genus diathesis voice },
+             type  => %i{ type pos },
+             noe   => %i{ number_of_endings noe },
+             nom(:abbr) => %i{ nominative nom },
+             deponens => %i{ dep deponens },
+      }
+
+      KEY_TABLE = kt.each_with_object({}) do |(norm_term, terms), h|
+        terms.each { |term| h[term] = norm_term }
+      end
+
+
+      vt = {
+        tempus => { pr => %i{ present praesens pr },
+                    pf => %i{ perfect perfectum pf },
+                    fut => %i{ future futurum fut },
+                    pqpf => %i{ pluperfect plusquamperfectum pqpf },
+                    fut_ex => %i{ future_perfect futurum_exactum fut_ex },
+                    impf => %i{ imperfect imperfectum impf }, },
+        casus  => { nom => %i{ nom nominative nominativus } + [1],
+                    gen => %i{ gen genetive   genetivus   } + [2],
+                    dat => %i{ dat dative     dativus     } + [3],
+                    acc => %i{ acc accusative accusativus } + [4],
+                    voc => %i{ voc vocative   vocativus   } + [5],
+                    abl => %i{ abl ablative   ablativus   } + [6], },
+        numerus => { sg => %i{ singularis singular } + [1],
+                     pl => %i{ pluralis   plural   } + [2], },
+        genus   => { activum  => %i{  activum act   },
+                     passivum => %i{  passivum pass }, },
+        modus   => { indicativus  => %i{ indicativus  ind  indicative  },
+                     coniunctivus => %i{ coniunctivus con  conjunctive subjunctive },
+                     imperativus  => %i{ imperativus  imp  imperativum },
+                     participium  => %i{ participium  part participle  },
+                     gerundium =>   %i{  gerundium  gerund },
+                     gerundivum =>  %i{  gerundivum gerundive },
+                     infinitivum => %i{  infinitivum inf infinitive },
+                     supinum =>     %i{  supinum sup }, },
+        sexus   => { m => %i{  m masc masculine masculinum },
+                     f => %i{  f fem  feminine  femininum  },
+                     n => %i{  n neut neuter    neutrum    }, },
+        type    => { noun => %i{ noun substantive },
+                     adj => %i{ adj adjective },
+                     verb => %i{ verb }, },
+                     # ...
+        noe     => { 1 => %i{ one_ending },
+                     2 => %i{ two_endings },
+                     3 => %i{ three_endings }, }
+      }
+
+      VALUE_TABLE = vt.each_with_object({}) do |(key_term, hash), h|
+        nh = hash.each_with_object({}) do |(norm_term, values), nested_h|
+          values.each { |val| nested_h[val] = norm_term }
+        end
+        h[key_term] = nh
+      end
+
+      FULL_TABLE = KEY_TABLE.merge(VALUE_TABLE.values.inject({}) { |new, old| new.merge(old) })
+    end
+  end
+end

data/lib/llt/helpers/transformer.rb

@@ -0,0 +1,33 @@
+module LLT
+  module Helpers
+    module Transformer
+      def to_hash(custom: {}, whitelist: [], blacklist: [], root: false, keys: :to_sym)
+        overwritten = custom.keys.map(&:to_sym)
+        res = instance_variables.each_with_object({}) do |var, hash|
+          sym = inst_to_sym(var)
+
+          next if whitelist.any? && ! whitelist.include?(sym)
+          next if blacklist.include?(sym)
+          next if overwritten.include?(sym)
+
+          hash[sym.send(keys)] = instance_variable_get(var)
+        end
+
+        res.merge!(custom)
+
+        if root
+          root = self.class.name if root == true
+          { root => res }
+        else
+          res
+        end
+      end
+
+      private
+
+      def inst_to_sym(inst_var)
+        inst_var.to_s.delete("@").to_sym
+      end
+    end
+  end
+end

data/lib/llt/helpers/version.rb

@@ -0,0 +1,5 @@
+module LLT
+  module Helpers
+    VERSION = "0.0.4"
+  end
+end

data/llt-helpers.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'llt/helpers/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "llt-helpers"
+  spec.version       = LLT::Helpers::VERSION
+  spec.authors       = ["LFDM", "lichtr"]
+  spec.email         = ["1986gh@gmail.com", "robert.lichtensteiner@gmail.com"]
+  spec.description   = %q{LLT Helpers}
+  spec.summary       = %q{Helper modules used by several llt gems}
+  spec.homepage      = "http://christof.github.io/llt"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "simplecov", "~> 0.7"
+  spec.add_dependency "dalli"
+  spec.add_dependency "llt-constants"
+end

data/spec/lib/llt/helpers/configuration_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe LLT::Helpers::Configuration do
+  class Dummy
+    attr_reader :something
+    include LLT::Helpers::Configuration
+  end
+
+  context "comes with an additional class method" do
+    describe ".configuration" do
+      it "provides a configuration hash" do
+        Dummy.configuration.should be_a Hash
+      end
+    end
+
+    describe ".uses_**" do
+      it "is a method missing implementation" do
+        expect { Dummy.uses_something { "test" } }.not_to raise_error
+      end
+
+      it "fills the classes configuration hash will procs" do
+        pending
+        Dummy.uses_something { "test" }
+        conf = Dummy.configuration[:something]
+        conf.should == "test"
+      end
+
+      it "reloads the configuration which might have changed in the meantime" do
+        Dummy.uses_something { "test" }
+        d1 = Dummy.new
+        d1.configure
+        Dummy.uses_something { "no_test" }
+        d2 = Dummy.new
+        d2.configure
+
+        d1.something.should == "test"
+        d2.something.should == "no_test"
+      end
+
+      it "stores the return value of the blk to avoid needless throw-away service objects" do
+        Dummy.uses_something { "test" }
+        d1 = Dummy.new
+        d2 = Dummy.new
+        d1.something.should be d2.something
+      end
+    end
+  end
+
+  let(:dummy) { Dummy.new }
+
+  describe "#configure" do
+    it "sets instance variables defined in the configuration hash" do
+      Dummy.uses_something { "anything" }
+      dummy.configure
+      dummy.instance_variable_get("@something").should == "anything"
+    end
+
+    it "takes an options hash to overwrite the default configuration" do
+      Dummy.uses_something { "anything" }
+      dummy.configure(something: "nothing")
+      dummy.instance_variable_get("@something").should == "nothing"
+    end
+
+    it "initializes only preconfiguraed variables and does nothing with other options" do
+      Dummy.uses_something { "anything" }
+      dummy.configure(another_thing: "thing")
+      dummy.instance_variable_get("@something").should == "anything"
+      dummy.instance_variable_get("@another_thing").should be_nil
+    end
+  end
+
+  describe "#configuration" do
+    it "returns the classes configuration" do
+      dummy.configuration.should_not be_nil
+    end
+  end
+end