llt-db_handler 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 84082e870e818bb1bc72a8b9201b23a80d645b39
+  data.tar.gz: ba26046cb7b5ab0ead5aafbd04648cf2838d8387
+SHA512:
+  metadata.gz: 8dfa39ffb5c43cfb2f22108808d59a44971e5f8a81b6eae7e955bbbe695d2467474ca3a3b09f647e0f710ae2829fd59857e24635765790bc3b865040193a0727
+  data.tar.gz: ab37d71755e9dd08c9f70336dfff0d8b5e8384a3800d17546bb4f0e4948825b0da68e91817f005f46e3e29af1bc7597999ebcb1d4a61c5db4a7352a05b2d6a28

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/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--tty

data/Gemfile

@@ -0,0 +1,18 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in llt-db_handler.gemspec
+gemspec
+gem 'coveralls', require: false
+gem 'llt-core_extensions', git: 'git@github.com:latin-language-toolkit/llt-core_extensions.git'
+gem 'llt-constants', git: 'git@github.com:latin-language-toolkit/llt-constants.git'
+gem 'llt-form_builder', git: 'git@github.com:latin-language-toolkit/llt-form_builder.git'
+gem 'llt-helpers', git: 'git@github.com:latin-language-toolkit/llt-helpers.git'
+
+platform :ruby do
+  gem 'pg'
+end
+
+platform :jruby do
+  gem 'activerecord-jdbcpostgresql-adapter'
+end
+

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,80 @@
+# LLT::DbHandler
+
+LLT abstraction to communicate with stem dictionaries/databases.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'llt-db_handler'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install llt-db_handler
+
+You will also want to install a proper postgresql adapter for the stem
+dictionary. You could add this to your Gemfile:
+
+```ruby
+  platform :ruby do
+    gem 'pg'
+  end
+
+  platform :jruby do
+    gem 'activerecord-jdbcpostgresql-adapter'
+  end
+```
+
+
+## Usage
+
+The Prometheus Stem Dictionary comes with this gem. To use it make sure
+you have postgresql installed and a user called prometheus ready:
+
+```
+  psql
+    create user prometheus with password 'admin'
+    alter user prometheus with create_db
+```
+Create the database and seed data:
+
+```
+  rake db:prometheus:create
+  rake db:prometheus:seed
+```
+
+The database prometheus_stems will now be available.
+<!-->
+# This should not be needed as the db is created by the user prometheus
+anyway.
+You might have to grant privileges to the user prometheus before going
+further:
+
+```
+  psql
+    grant all on database prometheus_stems to prometheus
+```
+-->
+
+```ruby
+  require 'llt/db_handler/prometheus'
+
+  db = LLT::DbHandler::Prometheus.new
+  db.count            # => returns the total number of entries
+  db.all_entries      # => returns all entries as AR models
+  db.lemma_list       # => returns an Array of lemmas as strings
+  db.lemma_list(true) # => returns detailed lemma strings
+```
+
+
+## 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,9 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "llt/db_handler/tasks"
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = '-f d --color'
+end
+
+task :default => :spec

data/lib/llt/db_handler.rb

@@ -0,0 +1,12 @@
+require "llt/db_handler/version"
+require 'llt/db_handler/common_db'
+
+module LLT
+  module DbHandler
+    def self.use(db)
+      db = db.capitalize
+      raise ArgumentError, "No database handler called #{db} defined" unless const_defined?(db)
+      const_get(db.capitalize).new
+    end
+  end
+end

data/lib/llt/db_handler/common_db.rb

@@ -0,0 +1,15 @@
+require 'llt/helpers/normalizer'
+
+module LLT
+  module DbHandler
+    class CommonDb
+      include Helpers::Normalizer
+
+      require 'llt/db_handler/prometheus'
+
+      def look_up_stem(args)
+        @args = normalize_args(args)
+      end
+    end
+  end
+end

data/lib/llt/db_handler/prometheus.rb

@@ -0,0 +1,95 @@
+require 'forwardable'
+require 'llt/db_handler/common_db'
+require 'llt/helpers'
+require 'llt/stem_builder'
+
+module LLT
+  module DbHandler
+    class Prometheus < CommonDb
+      extend Forwardable
+
+      require 'active_record'
+      require 'llt/db_handler/prometheus/db/models'
+      require 'llt/db_handler/prometheus/stats'
+
+      include Helpers::Constantize
+      include Helpers::PrimitiveCache
+
+      def_delegators :stats, :all_entries, :count, :lemma_list
+
+      attr_reader :type
+
+      def initialize(cache: false)
+        @type = :prometheus
+        enable_cache if cache
+      end
+
+      def direct_lookup(table, string)
+        query_db(table, string)
+      end
+
+      def look_up_stem(args)
+        cached(args) { new_lookup(args) }
+      end
+
+      def stats
+        @stats ||= Stats.new
+      end
+
+      private
+
+      def new_lookup(args)
+        table  = args[:type]
+        column = args[:stem_type]
+        column = (column.to_s << "_stem").to_sym if column == :pr || column == :pf
+        stem   = args[:stem]
+        restrictions = args[:restrictions]
+
+        entries = query_db(table, stem, column)
+
+        if restrictions
+          restr_type = normalized(restrictions[:type])
+          valids     = restrictions[:values]
+          entries.keep_if { |entry| valids.include?(entry.send(restr_type)) }
+        end
+
+        stemify(entries)
+      end
+
+      def query_db(table, string, column = :word)
+        # I tried to make an sql string out of this, but it's a lot slower actually...
+        constant_by_type(table, prefix: :Db, namespace: StemDatabase).where(column => string)
+      end
+
+      def stemify(entries)
+        entries.flat_map do |entry|
+          type = entry.type
+          args = case type
+                 when :noun      then hashify(entry, :nom, :stem, :inflectable_class, :sexus)
+                 when :persona   then hashify(entry, :nom, :stem, :inflectable_class, :sexus)
+                 when :place     then hashify(entry, :nom, :stem, :inflectable_class, :sexus)
+                 when :adjective then hashify(entry, :nom, :stem, :inflectable_class, :number_of_endings)
+                 when :ethnic    then hashify(entry, :stem, :inflectable_class)
+                 when :verb      then hashify(entry, :pr, :pf, :ppp, :inflectable_class, :pf_composition, :deponens, :dir_objs, :indir_objs)
+                 end
+
+          args ? StemBuilder.build(type, args, @type) : []
+        end
+      end
+
+      def hashify(entry, *args)
+        h = {}
+        args.each { |arg| h[arg] = entry.send(arg) }
+        h[:lemma_key] = entry.id
+        h
+      end
+
+      def normalized(restr_type)
+        case restr_type.to_sym
+        when :inflection_class then :inflectable_class
+        else restr_type
+        end
+      end
+    end
+  end
+end

data/lib/llt/db_handler/prometheus/db/database.yml

@@ -0,0 +1,8 @@
+adapter: postgresql
+encoding: unicode
+database: prometheus_stems
+pool: 20
+port: 5432
+username: prometheus
+password: admin
+host: localhost

data/lib/llt/db_handler/prometheus/db/models.rb

@@ -0,0 +1,111 @@
+require 'llt/db_handler/prometheus/db_to_lemma'
+
+module StemDatabase
+  class Db < ActiveRecord::Base
+    self.abstract_class = true
+    db = YAML::load(File.open(File.expand_path("../database.yml", __FILE__)))
+    establish_connection(db)
+
+    include LLT::DbHandler::Prometheus::DbToLemma
+
+    def type
+      self.class.name.match(/Db(.*)/)[1].downcase.to_sym
+    end
+  end
+
+  class DbAdjective < Db
+    attr_accessible :inflectable_class, :nom, :number_of_endings, :stem, :number
+    validates_presence_of :nom, :stem, :number_of_endings, :inflectable_class
+    validates :stem, uniqueness: { scope: %i{ nom number_of_endings inflectable_class number } }
+
+    def base_lemma
+      nom
+    end
+  end
+
+  class DbAdverb    < Db
+    attr_accessible :double, :word
+
+    validates_presence_of :word
+    validates :word, uniqueness: true
+
+    def base_lemma
+      word
+    end
+  end
+
+  class DbEthnic    < Db
+    attr_accessible :inflectable_class, :stem
+    validates_presence_of :stem, :inflectable_class
+    validates :stem, uniqueness: { scope: :inflectable_class }
+
+    def base_lemma
+      "#{stem}#{lemma_ending}"
+    end
+
+    private
+
+    def lemma_ending
+      case inflectable_class
+      when 1 then 'us'
+      when 3 then 'is'
+      end
+    end
+  end
+
+  class DbPersona   < Db
+    attr_accessible :defective, :inflectable_class, :nom, :sexus, :stem
+    validates_presence_of :stem, :inflectable_class
+    validates :stem, uniqueness: { scope: %i{ nom inflectable_class sexus } }
+
+    def base_lemma
+      nom
+    end
+  end
+
+  class DbPlace     < Db
+    attr_accessible :defective, :inflectable_class, :nom, :sexus, :stem
+    validates_presence_of :stem, :inflectable_class
+    validates :stem, uniqueness: { scope: %i{ nom inflectable_class sexus } }
+
+    def base_lemma
+      nom
+    end
+  end
+
+  class DbNoun      < Db
+    attr_accessible :defective, :inflectable_class, :nom, :sexus, :stem
+    validates_presence_of :stem, :inflectable_class
+    validates :stem, uniqueness: { scope: %i{ nom inflectable_class sexus } }
+
+    def base_lemma
+      nom
+    end
+  end
+
+  class DbVerb      < Db
+    attr_accessible :pr_stem, :pf_stem, :ppp, :inflectable_class, :dir_objs,
+                    :indir_objs, :deponens, :number
+    validates_presence_of :pr_stem, :inflectable_class
+    validates :pr_stem, uniqueness: { scope: %i{ pf_stem ppp deponens inflectable_class } }
+
+    def pr; pr_stem; end
+    def pf; pf_stem; end
+    def extension; tempus_sign; end
+
+    def base_lemma
+      "#{lemma_stem}#{lemma_ending}"
+    end
+
+    private
+
+    def lemma_stem
+      inflectable_class == 1 ? pr_stem.chop : pr_stem
+    end
+
+    def lemma_ending
+      ending = inflectable_class == 5 ? 'io' : 'o'
+      deponens ? (ending + 'r') : ending
+    end
+  end
+end

data/lib/llt/db_handler/prometheus/db_to_lemma.rb

@@ -0,0 +1,46 @@
+module LLT
+  module DbHandler
+    class Prometheus < CommonDb
+      module DbToLemma
+        # to be included by Db classes, the module
+        # is tightly coupled to them
+
+        def to_lemma(detailed = false)
+          if detailed
+            "#{base_lemma}##{number_attr}, #{category}#{str_helper(:inflectable_class, 'iclass')}#{str_helper(:sexus)}"
+          else
+            base_lemma
+          end
+        end
+
+        private
+
+        def category
+          # DbVerb to 'verb'
+          self.class.name[2..-1].downcase
+        end
+
+        def str_helper(meth, appearance = meth)
+          val = guarded(meth)
+          (val ? ", #{appearance}: #{val}" : '')
+        end
+
+        def base_lemma
+          raise NoMethodError.new("Has to be overwritten by class that includes the module DbToLemma")
+        end
+
+        def number_attr
+          guarded(:number, 1)
+        end
+
+        def guarded(meth, default_return = nil)
+          if respond_to?(meth)
+            send(meth)
+          else
+            default_return
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llt/db_handler/prometheus/stats.rb

@@ -0,0 +1,44 @@
+module LLT
+  module DbHandler
+    class Prometheus
+      class Stats
+        include Enumerable
+
+        CATEGORIES = %i{ noun adjective adverb verb persona ethnic place }
+        TABLES = CATEGORIES.map { |cat| cat.to_s.capitalize.prepend('Db').to_sym }
+
+        def count
+          @count ||= compute_count
+        end
+
+        def all_entries
+          @all_entries ||= flat_map(&:all)
+
+          if block_given?
+            @all_entries.map { |entry| yield(entry) }
+          else
+            @all_entries
+          end
+        end
+
+        def lemma_list(detailed = false)
+          all_entries.map { |entry| entry.to_lemma(detailed) }
+        end
+
+        private
+
+        def compute_count
+          map(&:count).inject(:+)
+        end
+
+        def each(&blk)
+          TABLES.map { |table| as_const(table) }.each(&blk)
+        end
+
+        def as_const(symbol)
+          StemDatabase.const_get(symbol)
+        end
+      end
+    end
+  end
+end

data/lib/llt/db_handler/stub.rb

@@ -0,0 +1,61 @@
+require 'llt/db_handler/common_db'
+
+module LLT
+  module DbHandler
+    class Stub < CommonDb
+      require 'llt/db_handler/stub/stub_entries'
+
+      @stems = {}
+
+      class << self
+        include Helpers::Normalizer
+
+        attr_reader :stems
+
+        def create_stem_stub(return_val, args)
+          args = normalize_args(args)
+          @stems[args] = return_val
+        end
+        alias :create :create_stem_stub
+
+        def setup
+          StubEntries.setup
+        end
+      end
+
+      def type
+        :stub
+      end
+
+      def look_up_stem(args)
+        super
+        stems.select do |stored_args|
+          if stored_args.merge(args_to_query) == stored_args
+            if restr = @args[:restrictions]
+              restr[:values].include?(stored_args[restr[:type]])
+            end
+          end
+        end.values
+      end
+
+      def direct_lookup(type, string)
+        args = dl_to_query(type, string)
+        stems.select do |stored|
+          stored.merge(args) == stored
+        end.values
+      end
+
+      def dl_to_query(type, string)
+        { type: type, word: string}
+      end
+
+      def args_to_query
+        {type: @args[:type], @args[:stem_type] => @args[:stem] }
+      end
+
+      def stems
+        self.class.stems
+      end
+    end
+  end
+end

data/lib/llt/db_handler/stub/stub_entries.rb

@@ -0,0 +1,87 @@
+require 'ostruct'
+
+class LLT::DbHandler::Stub::StubEntries
+  class << self
+    def setup(size = :medium)
+      db_stub.stems.clear
+
+      medium_setup
+      # not implemented yet
+      #case size
+      #when :big   then big_setup
+      #when :small then small_setup
+      #else medium_setup
+      #end
+    end
+
+    private
+
+    def small_setup
+    end
+
+    def medium_setup
+      wsr(type: :noun,      nom: "homo",      stem: "homin",      itype: 3, sexus: :m)
+      wsr(type: :noun,      nom: "vir",       stem: "vir",        itype: 2, sexus: :m)
+      wsr(type: :noun,      nom: "ratio",     stem: "ration",     itype: 3, sexus: :f)
+      wsr(type: :noun,      nom: "magnitudo", stem: "magnitudin", itype: 3, sexus: :f)
+      wsr(type: :noun,      nom: "libido",    stem: "libidin",    itype: 3, sexus: :f)
+      wsr(type: :noun,      nom: "nox",       stem: "noct",       itype: 3, sexus: :f)
+      wsr(type: :noun,      nom: "filius",    stem: "fili",       itype: 2, sexus: :m)
+      wsr(type: :noun,      nom: "servus",    stem: "serv",       itype: 2, sexus: :m)
+
+      wsr(type: :noun,      nom: "flumen",    stem: "flumin",     itype: 3, sexus: :n)
+      wsr(type: :noun,      nom: "arma",      stem: "arm",        itype: 2, sexus: :n) # this might actually be wrong?
+
+      wsr(type: :persona,   nom: "Plato",     stem: "Platon",     itype: 3)
+      wsr(type: :persona,   nom: "Solon",     stem: "Solon",      itype: 3)
+
+      wsr(type: :adjective, nom: "communis",  stem: "commun",     itype: 3, number_of_endings: 1)
+      wsr(type: :adjective, nom: "diligens",  stem: "diligent",   itype: 3, number_of_endings: 1)
+      wsr(type: :adjective, nom: "laetus",    stem: "laet",       itype: 1, number_of_endings: 3)
+      wsr(type: :adjective, nom: "ferus",     stem: "fer",        itype: 1, number_of_endings: 3)
+
+      wsr(type: :adjective, nom: "aestivus",  stem: "aestiv",     itype: 1, number_of_endings: 3)
+      wsr(type: :adjective, nom: "suavis",    stem: "suav",       itype: 3, number_of_endings: 2)
+
+
+      wsr(type: :ethnic, stem: "Haedu", inflection_class: 1)
+      wsr(type: :ethnic, stem: "Redon", inflection_class: 3)
+
+      wsr(type: :verb, pr: "ita",   pf: "itav",                 pf_composition: "v", itype: 1, dep: false, dir_objs: "", indir_objs: "")
+      wsr(type: :verb, pr: "cana",  pf: "canav", ppp: "canat",  pf_composition: "v", itype: 1, dep: false, dir_objs: "", indir_objs: "")
+      wsr(type: :verb, pr: "mone",  pf: "monu",  ppp: "monit",  pf_composition: "u", itype: 2, dep: false, dir_objs: "", indir_objs: "")
+      wsr(type: :verb, pr: "move",  pf: "movi",  ppp: "mot",    pf_composition: "ablaut", itype: 2, dep: false, dir_objs: "", indir_objs: "")
+      wsr(type: :verb, pr: "mitt",  pf: "mis",   ppp: "miss",   pf_composition: "s", itype: 3, dep: false, dir_objs: "", indir_objs: "")
+      wsr(type: :verb, pr: "viv",   pf: "vix",   ppp: "-",      pf_composition: "s", itype: 3, dep: false, dir_objs: "", indir_objs: "")
+      wsr(type: :verb, pr: "audi",  pf: "audiv", ppp: "audit",  pf_composition: "v", itype: 4, dep: false, dir_objs: "", indir_objs: "")
+      wsr(type: :verb, pr: "horta",              ppp: "hortat",                      itype: 1, dep: true , dir_objs: "", indir_objs: "")
+
+      dl(type: :adverb, word: "ita")
+      dl(type: :adverb, word: "iam")
+      dl(type: :adverb, word: "subito")
+    end
+
+    def big_setup
+    end
+
+    def db_stub
+      LLT::DbHandler::Stub
+    end
+
+    def factory(type, args)
+      LLT::StemBuilder.build(type, args, "stub")
+    end
+
+    # with_single_return
+    def wsr(args)
+      ret_val = factory(args[:type], args.reject { |k, _| k == :type })
+      db_stub.create(ret_val, args)
+    end
+
+    # direct_lookup
+    def dl(args)
+      ret_val = OpenStruct.new(word: args[:word])
+      db_stub.create(ret_val, args)
+    end
+  end
+end

data/lib/llt/db_handler/tasks.rb

@@ -0,0 +1,32 @@
+namespace :db do
+  namespace :prometheus do
+    DUMP_FILE = 'lib/llt/db_handler/prometheus/db/prometheus_stems.dump'
+
+    desc 'Opens a pry console with a prometheus instance preloaded as db'
+    task :console do
+      exec %{pry -e "require 'llt/db_handler/prometheus';
+                     db = LLT::DbHandler::Prometheus.new;
+                     puts 'A Prometheus instance is waiting for you in the variable db\!'; db"}
+    end
+
+    desc 'Creates the stem database'
+    task :create do
+      exec 'createdb -U prometheus -h localhost -T template0 prometheus_stems'
+    end
+
+    desc 'Opens the psql console'
+    task :db_console do
+      exec 'psql -U prometheus prometheus_stems'
+    end
+
+    desc "Dumps the stem databases' contents to a psql dump file"
+    task :dump do
+      exec "pg_dump -U prometheus -Fc prometheus_stems > #{DUMP_FILE}"
+    end
+
+    desc 'Loads the seed data - UNDUMPED CHANGES WILL BE LOST!'
+    task :seed do
+      exec "pg_restore --verbose --clean --no-acl --no-owner -h localhost -U prometheus -d prometheus_stems #{DUMP_FILE}"
+    end
+  end
+end

data/lib/llt/db_handler/version.rb

@@ -0,0 +1,5 @@
+module LLT
+  module DbHandler
+    VERSION = "0.0.1"
+  end
+end

data/llt-db_handler.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'llt/db_handler/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "llt-db_handler"
+  spec.version       = LLT::DbHandler::VERSION
+  spec.authors       = ["LFDM"]
+  spec.email         = ["1986gh@gmail.com"]
+  spec.description   = %q{LLT DB Handler}
+  spec.summary       = %q{LLT DB Handler}
+  spec.homepage      = ""
+  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 "pry"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "simplecov", "~> 0.7"
+  spec.add_development_dependency "yard"
+  spec.add_dependency 'activerecord', "~> 3.2"
+  spec.add_dependency "llt-core_extensions"
+  spec.add_dependency "llt-constants"
+  spec.add_dependency "llt-form_builder"
+  spec.add_dependency "llt-helpers"
+end

data/spec/lib/llt/db_handler/prometheus/db_to_lemma_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'llt/db_handler/prometheus/db_to_lemma'
+
+describe LLT::DbHandler::Prometheus::DbToLemma do
+  class DummyDbClass
+    include LLT::DbHandler::Prometheus::DbToLemma
+  end
+
+  let(:dummy) { DummyDbClass.new }
+
+  # private stuff, just to be safe
+  describe "#number_attr" do
+    it "returns the entries number attribute" do
+      dummy.stub(:number) { 2 }
+      dummy.send(:number_attr).should == 2
+    end
+
+    it "defaults to one when number attribute is not present" do
+      dummy.send(:number_attr).should == 1
+    end
+  end
+
+  describe "#base_lemma" do
+    it "raises an error when the including class doesn't overwrite this method" do
+      expect { dummy.send(:base_lemma) }.to raise_error NoMethodError, /overwritten/
+    end
+
+    it "returns whatever base_lemma returns when implemented by the including class" do
+      dummy.stub(:base_lemma) { 1 }
+      dummy.send(:base_lemma).should == 1
+    end
+  end
+
+  describe "#category" do
+    it "returns the category name" do
+      dummy.stub_chain(:class, :name).and_return('DbSomething')
+      dummy.send(:category).should == 'something'
+    end
+  end
+end

data/spec/lib/llt/db_handler/prometheus/stats_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe LLT::DbHandler::Prometheus::Stats do
+  let(:stats) { LLT::DbHandler::Prometheus::Stats.new }
+
+  describe "#count" do
+    it "returns the total number of db entries" do
+      stats.count.should be_kind_of Fixnum
+    end
+
+    it "returns the number 40000+ entries" do
+      # stupid to test a concrete count, but let it scream
+      # if we have strangly few entries
+      stats.count.should > 40000
+    end
+  end
+
+  describe "#all_entries", :slow do
+    it "returns an Array of all db objects" do
+      stats.all_entries.should be_kind_of Array
+    end
+
+    it "takes a block to be executed on each entry" do
+      mapped_entries = stats.all_entries { |entry| entry.kind_of?(Object)}
+      uniq_for_easier_test = mapped_entries.uniq
+      uniq_for_easier_test.should have(1).item
+      uniq_for_easier_test.first.should be_true
+    end
+  end
+
+  describe "#lemma_list", :slow do
+    let(:lemma_list_entry)  { stats.lemma_list.first}
+    let(:lemma_format) { '\p{L}[a-z]*' }
+
+    it "returns an Array of lemma strings" do
+      stats.lemma_list.count.should == stats.count
+    end
+
+    it "lemmas are represented with their base form" do
+      stats.lemma_list.first.should =~ /^#{lemma_format}$/
+    end
+
+    it "returns a more detailed lemma string with a truthy param" do
+      stats.lemma_list(true).first.should =~ /^#{lemma_format}#\d.+$/
+    end
+  end
+end

data/spec/lib/llt/db_handler/prometheus_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe LLT::DbHandler::Prometheus do
+  let(:db) { LLT::DbHandler::Prometheus.new }
+
+  describe "#type" do
+    it "returns :prometheus as its type" do
+      db.type.should == :prometheus
+    end
+  end
+
+  describe "#look_up_stem" do
+    let(:query)  { { type: :noun, stem: "ros", stem_type: :stem} }
+    let(:query2) { { type: :verb, stem: "ama", stem_type: :pr} }
+
+    let(:failing_query) { { type: :verb, stem: "ama", stem_type: :ppp} }
+
+    it "searches the db - with a noun" do
+      db.look_up_stem(query).should_not be_empty
+    end
+
+    it "searches the db - with a verb" do
+      db.look_up_stem(query2).should_not be_empty
+    end
+
+    it "returns an empty array when nothing is found" do
+      db.look_up_stem(failing_query).should be_empty
+    end
+
+    # bypassing the query in the two following specs, we're only interested in the
+    # conversion process
+
+    let(:fake_entry1) do
+      f = double(nom: "rosa", stem: "ros", inflectable_class: 1, sexus: "f", id: 2)
+      f.stub(:type) { :noun }
+      f
+    end
+
+    let(:fake_entry2) do
+      f = double(nom: "rosa", stem: "ros", inflectable_class: 2, sexus: "f", id: 1)
+      f.stub(:type) { :noun }
+      f
+    end
+
+    it "returns stem packs" do
+      db.stub(:query_db) { [fake_entry1] }
+
+      result = db.look_up_stem(query)
+      result.should have(1).item
+      result.first.should be_a LLT::Stem::NounPack
+    end
+
+    it "returns only valid entries if a restriction hash is passed" do
+      restrictions = { type: :inflection_class, values: [1] }
+      db.stub(:query_db) { [fake_entry1, fake_entry2] }
+
+      result = db.look_up_stem(query.merge(restrictions: restrictions))
+      result.should have(1).item
+      result.first.should be_a LLT::Stem::NounPack
+    end
+  end
+
+  describe "#direct_lookup" do
+    it "searches the db with a simplistic lookup, only a type and a string needed" do
+      db.direct_lookup(:adverb, "iam").should have(1).item
+    end
+  end
+
+  describe "#stats" do
+    it "returns a stats object" do
+      db.stats.should_not be_nil
+    end
+  end
+
+  %i{ all_entries count lemma_list }.each do |delegated_method|
+    describe "##{delegated_method}", :slow do
+      it "is delegated to the stats object" do
+        db.stats.should_receive(delegated_method)
+        db.send(delegated_method)
+      end
+    end
+  end
+end

data/spec/lib/llt/db_handler/stub_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'llt/db_handler/stub'
+
+describe LLT::DbHandler::Stub do
+  let(:db_stub) { LLT::DbHandler::Stub }
+
+  describe "#type" do
+    it "identifies the db_stub as stub" do
+      db_stub.new.type.should == :stub
+    end
+  end
+  describe ".create_stem_stub" do
+    it "creates a new stem stub" do
+      db_stub.stems.clear
+      db_stub.create_stem_stub("test", test: "val")
+      db_stub.stems.should have(1).item
+    end
+
+    it "has alias create" do
+      db_stub.stems.clear
+      db_stub.create("test", test: "val")
+      db_stub.stems.should have(1).item
+    end
+  end
+
+  describe "#look_up_stem" do
+    it "returns an array of db entries" do
+      db_stub.create_stem_stub("test", type: :noun, nom: "rosa", stem: "ros", inflection_class: 1)
+      result  = db_stub.new.look_up_stem(type: :noun, stem_type: :stem, stem: "ros", restrictions: { type: :inflection_class, values: [1] })
+      result2 = db_stub.new.look_up_stem(type: :noun, stem_type: :stem, stem: "ros", restrictions: { type: :inflection_class, values: [2] })
+      result.should have(1).item
+      result.first.should == "test"
+
+      result2.should be_empty
+    end
+  end
+
+  describe "#direct_lookup" do
+    it "returns an array of db entries" do
+      db_stub.create(:success, type: :adverb, word: "ita")
+      result = db_stub.new.direct_lookup(:adverb, "ita")
+      result.should have(1).item
+      result.first.should == :success
+    end
+  end
+
+  describe ".setup" do
+    it "creates stub entries as defined in stub_entries.rb" do
+      db_stub.stems.clear
+      db_stub.setup
+      db_stub.stems.should_not be_empty
+    end
+  end
+end

data/spec/lib/llt/db_handler_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe LLT::DbHandler do
+  describe ".use" do
+    it "returns a new LLT db handler instance by a given type" do
+      LLT::DbHandler.use(:prometheus).should be_an_instance_of LLT::DbHandler::Prometheus
+    end
+
+    it "raises an exception when the requested handler is unknown" do
+      expect { LLT::DbHandler.use(:undefined_handler) }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+require 'simplecov'
+require 'coveralls'
+
+Coveralls.wear!
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+
+SimpleCov.start do
+  add_filter '/spec/'
+end
+
+require 'llt/db_handler'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end

metadata

@@ -0,0 +1,230 @@
+--- !ruby/object:Gem::Specification
+name: llt-db_handler
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- LFDM
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: llt-core_extensions
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: llt-constants
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: llt-form_builder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: llt-helpers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: LLT DB Handler
+email:
+- 1986gh@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/llt/db_handler.rb
+- lib/llt/db_handler/common_db.rb
+- lib/llt/db_handler/prometheus.rb
+- lib/llt/db_handler/prometheus/db/database.yml
+- lib/llt/db_handler/prometheus/db/models.rb
+- lib/llt/db_handler/prometheus/db/prometheus_stems.dump
+- lib/llt/db_handler/prometheus/db_to_lemma.rb
+- lib/llt/db_handler/prometheus/stats.rb
+- lib/llt/db_handler/stub.rb
+- lib/llt/db_handler/stub/stub_entries.rb
+- lib/llt/db_handler/tasks.rb
+- lib/llt/db_handler/version.rb
+- llt-db_handler.gemspec
+- spec/lib/llt/db_handler/prometheus/db_to_lemma_spec.rb
+- spec/lib/llt/db_handler/prometheus/stats_spec.rb
+- spec/lib/llt/db_handler/prometheus_spec.rb
+- spec/lib/llt/db_handler/stub_spec.rb
+- spec/lib/llt/db_handler_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.5
+signing_key: 
+specification_version: 4
+summary: LLT DB Handler
+test_files:
+- spec/lib/llt/db_handler/prometheus/db_to_lemma_spec.rb
+- spec/lib/llt/db_handler/prometheus/stats_spec.rb
+- spec/lib/llt/db_handler/prometheus_spec.rb
+- spec/lib/llt/db_handler/stub_spec.rb
+- spec/lib/llt/db_handler_spec.rb
+- spec/spec_helper.rb
+has_rdoc: