gemmyrb 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: '0597ccc5d58c800b09db4032d7f3b4c9417a200c'
-  data.tar.gz: d8cf7ba24fd1e4b423d2a8bdc2accd984b441d21
+  metadata.gz: f80e87943a486ead9bdcd3ede570b7cb164a0b46
+  data.tar.gz: b5cb77bda55be569a5769c382abf3eae6ab61b92
 SHA512:
-  metadata.gz: 61bd6b8d5e1ecb3735cf5da9b664aa0de07006402d386c86492c8b1ff763119895fce69758fcb04fc86cdd6b10a9e47ec805eb797ff420f21554cebf92966930
-  data.tar.gz: 0ce7ac19a0e282bd31f2644d032d5f334c89192af8a8f0f2765137066d1fb60f90f2de371e02fd1795bca328c69993c3b2b7e3639cb90d4fa7b4950c273993bc
+  metadata.gz: 53374471f968c7fbcd89050b98775b48bb3d1d0e9beca86920427605b5c826542939d4fecb2ede9f5201fa94ae4660c57fb96a65a38eda096f798a72eb3ad07f
+  data.tar.gz: f1f5c63c5e7169bef3313dd590de806740755e21320a9385dd03b506734a818e1c2dcd8b881b912839a097992176e827a3cc0fa7d30f1f0e1cc4adb701dec395

data/README.md

@@ -26,4 +26,4 @@ documents:
 
 Specifically, look at the constants defined on Gemmy::Patches. There is one
 module for each of the core classes being patched. Each individual method
-is also contained in its own module (for the sake of, well, modularity)
+is also contained in its own module (for the sake of, well, modularity).

data/lib/gemmy.rb

@@ -1,9 +1,13 @@
+require 'awesome_print'
 require 'thor'
 require 'colored'
 require 'active_support/all'
 require 'pry'
 require 'colored'
 require 'corefines'
+require 'sentence_interpreter'
+require 'engtagger'
+require 'odyssey'
 
 # Container class for all the functionality.
 #
@@ -28,24 +32,28 @@ class Gemmy
     parts = string.split("/")
     raise ArgumentError unless parts.length == 3
     core_class, context, method_name = parts
-    context_classname = if context.eql?("i")
-      "InstanceMethods"
-    elsif context.eql?("c")
-      "ClassMethods"
-    else
-      raise ArgumentError
-    end
+    context_classname = context.eql?("i") ? "InstanceMethods" : "ClassMethods"
     Gemmy::Patches.const_get("#{core_class.capitalize}Patch")
                   .const_get(context_classname)
                   .const_get method_name.camelcase
   end
 
-  # There are two main usages:
-  #   - namespaced (using refinements and explicit include/extend calls)
-  #   - global
-  #
-  # This is the method handling the global case
-  #
+  def self.patches(*args)
+    Gemmy::Patches.class_refinements *args
+  end
+
+  # Get a constant,
+  # lookup on Gemmy::Constants
+  # it gsubs '/' to '::'
+  # and if the given constant names are lowercase,
+  # then it camelcases them.
+  def self.const(const_name_abbrev)
+    const_name = const_name_abbrev.split("/").map do |x|
+      x.chars.all? { |char| char.in? 'a'.upto('z') } ? x.camelcase : x
+    end.join("::")
+    Gemmy::Constants.const_get const_name
+  end
+
   def self.load_globally
     core_patches = Patches.core_patches.map do |core_klass_name, patch_klass|
       core_klass = core_klass_name.to_s.constantize
@@ -72,10 +80,10 @@ class Gemmy
   end
 end
 
-# Load files in order of their "/" count
-# to preserve constant hierarchies
-#
 Gem.find_files("gemmy/**/*.rb").sort_by do |x|
   x.split("/").length
 end.each &method(:require)
 
+# Alias for less typing
+class Gmy < Gemmy
+end

data/lib/gemmy/coffee.rb

@@ -0,0 +1,33 @@
+Gemmy::Coffee = <<-COFFEE
+
+#!/usr/bin/env coffee
+puts = console.log
+
+# Gemmy.init reads from argv and starts command
+Gemmy =
+  validCommands: (key) ->
+    {
+      'pos': this.partOfSpeech
+    }[key]
+
+  init: ->
+    [cmd, args...] = process.argv.slice -2
+    component = this.validCommands(cmd)
+    unless component
+      throw('missing or invalid argv command')
+    component.run(args...).then component.callback
+
+# Part of speech detector
+pos = Gemmy.partOfSpeech = {}
+pos.run = (sentence) ->
+  WordPos = require 'wordpos'
+  wordpos = new WordPos(profile: true)
+  new Promise (resolve, reject) ->
+    wordpos.getPOS sentence, resolve
+pos.callback = (result) ->
+  puts JSON.stringify result
+
+Gemmy.init()
+
+COFFEE
+

data/lib/gemmy/components/cache.rb

@@ -0,0 +1,49 @@
+class Gemmy::Components::Cache < Hash
+
+  using Gemmy.patch("hash/i/persisted")
+  using Gemmy.patch("hash/i/bury")
+  using Gemmy.patch("object/i/home")
+
+  CachePath = ENV["GEMMY_CACHE_PATH"] || "#{home}/gemmy/caches"
+
+  unless Dir.exists?(CachePath)
+    `mkdir -p #{CachePath}`
+  end
+
+  def initialize(db_name)
+    @db = {}.persisted "#{CachePath}/#{db_name}.yaml"
+    @memory = @db.get(:data)
+  end
+
+  def get_or_set(*keys, &blk)
+    result = get(*keys)
+    if result.blank?
+      result = blk.call
+      set(*keys, result)
+    end
+    result
+  end
+
+  def keys
+    @db.data.keys
+  end
+
+  def get(*keys, source: :db)
+    if source == :memory
+      @memory.dig *keys
+    elsif source == :db
+      @db.dig *keys
+    else
+      raise ArgumentError
+    end
+  end
+
+  def set(*keys, val)
+    @db.set(*keys, val)
+  end
+
+  def clear
+    # forwards it to PersistedHash
+    @db.clear
+  end
+end

data/lib/gemmy/components/nlp.rb

@@ -0,0 +1,179 @@
+module Gemmy::Components::Nlp
+
+  Gemmy::Patches.class_refinements.each { |r| using r }
+
+
+  def parse_sentence sentence
+    setup_lexicons
+    log_sentence sentence
+    begin
+      SentenceInterpreter.interpret sentence
+    rescue NounBeforeVerbError
+      []
+    end
+  end
+
+  def setup_lexicons
+    return if @lexicon_set_up
+    Object.send :remove_const, "VerbLexicon"
+    Object.send :remove_const, "NounLexicon"
+    Object.send(:const_set,"VerbLexicon", Gemmy::Components::Cache.new(
+      "verb_lexicon"
+    ))
+    Object.send(:const_set,"NounLexicon", Gemmy::Components::Cache.new(
+      "noun_lexicon"
+    ))
+    @lexicon_set_up = true
+  end
+
+  # Uses the Ruby EngTagger tool to find parts of speech
+  # of a sentence
+  #
+  # Returns a hash with :verbs and :nouns keys (vals are arrays)
+  #
+  def tag_sentence sentence
+    @tagger ||= EngTagger.new
+    res = @tagger.add_tags(sentence).ergo do |tagged|
+      nouns = @tagger.get_nouns(tagged)&.keys || []
+      verbs = @tagger.get_verbs(tagged)&.keys || []
+      [nouns, verbs]
+    end
+  end
+
+  # Adds words in sentence to application database
+  # The part of speech is identified by the DB Name
+  # Each entry is a word => proc mapping.
+  #
+  # Noun procs are passed all vn_phrases for the sentence
+  # (these are constructed by parse_sentence)
+  #
+  # The Verb procs are passed the evaluated results of the Noun procs
+  # in its Verb-Noun phrase (as sequential arguments)
+  #
+  # For example, if the phrase is "live well and flourish"
+  # Then (assuming the
+  #
+  # Although EngTagger extracts POS for the words in a sentence,
+  # these classifications are context-dependent.
+  #
+  # For this reason, words are also looked up using WordPos.
+  # Only umambiguous words are added to the grammar.
+  #
+  def log_sentence sentence
+    sentence_cache.get_or_set(sentence) do
+      engtagger_lookup(sentence).map do |word, pos|
+        finalize_pos(word, pos)
+      end
+    end
+  end
+
+  # Compare WordPos and Engtagger results and save to proc if found
+  # only prioritize Engtagger if WordPos is missing
+  def finalize_pos word, pos
+    final_pos = word_pos_cache.get_or_set(word) do
+      doublecheck = wordpos_lookup(word)
+      if ['noun', 'verb'].none? &doublecheck.m(:include?)
+        finalize_engtagger_pos(pos)
+      else
+        finalize_wordpos_pos(pos)
+      end
+    end
+    save_proc(final_pos, word)
+    { word: word, pos: [final_pos] }
+  end
+
+  def finalize_engtagger_pos(pos)
+    # If the WordPos definition isn't found, then there's no ambiguity
+    if pos.include?("noun")
+      "noun"
+    elsif pos.include?("verb")
+      "verb"
+    else
+      "unknown"
+    end
+  end
+
+  def finalize_wordpos_pos(pos)
+    # WordPos returns ambiguous results.
+    # Only unambiguous words are selected.
+    # I.e. a noun|verb isn't saved.
+    # It must be solely noun or verb.
+    if pos.include?("noun") && !pos.include?("verb")
+      "noun"
+    elsif pos.include?("verb") && !pos.include?("noun")
+      "verb"
+    else
+      "unknown"
+    end
+  end
+
+  def save_proc(final_pos, word)
+    if final_pos.include?("noun")
+      save_noun_proc(word)
+    elsif final_pos.include?("verb")
+      save_verb_proc word
+    end
+  end
+
+  def save_noun_proc word
+    NounLexicon.set word.to_sym, default_noun_proc_string(word)
+  end
+
+  def save_verb_proc word
+    VerbLexicon.set word.to_sym, default_verb_proc_string(word)
+  end
+
+  def default_noun_proc_string(word)
+    <<-Ruby.strip_heredoc
+      ->(vn_phrases){ "#{word}" }
+    Ruby
+  end
+
+  def default_verb_proc_string(word)
+    <<-Ruby.strip_heredoc
+      ->(*nouns){ "#{word} \#{nouns.join " "}" }
+    Ruby
+  end
+
+  # This uses EngTagger to analyze a sentence
+  # The results will not be ambiguous; in this method's results,
+  # a given word with either be 'verb', 'noun', or 'unknown'.
+  def engtagger_lookup sentence
+    nouns, verbs = tag_sentence(sentence)
+    sentence.words.graph do |word|
+      pos = case word
+      when ->(w){ verbs.include? w }
+        "verb"
+      when ->(w){ nouns.include? w }
+        "noun"
+      else
+        "unknown"
+      end
+      [word, [pos]]
+    end
+  end
+
+  # Engtagger evaluates POS in the context of a sentence
+  # So from that perspective, only entire sentences can be cached
+  def sentence_cache
+    @sentence_cache ||= Gemmy::Components::Cache.new "sentence_pos"
+  end
+
+  # This cache reduces the call rate of the WordPos shell util
+  # by caching the POS for individual words.
+  def word_pos_cache
+    @pos_cache ||= Gemmy::Components::Cache.new("word_pos")
+  end
+
+  def wordpos_lookup(word)
+    default_result = ['unknown']
+    result = []
+    word = word.strip.gsub(/[^a-zA-z]/, '')
+    return default_result if word.empty?
+    pos_response = JSON.parse `coffee -e "#{Gemmy::Coffee}" pos #{word}`
+    result << "verb" unless pos_response["verbs"].empty?
+    result << "noun" unless pos_response["nouns"].empty?
+    result.empty? ? default_result : result
+  end
+
+end

data/lib/gemmy/components/word_speaker.rb

@@ -0,0 +1,7 @@
+module Gemmy::Components::WordSpeaker
+  Gemmy.patches.each { |x| using x }
+  def speak_sentence(sentence)
+    byebug
+    false
+  end
+end

data/lib/gemmy/constants.rb

@@ -0,0 +1,14 @@
+module Gemmy::Constants
+  HUNDRED =
+  10 ** 2
+  THOUSAND =
+  10 ** 3
+  MILLION =
+  10 ** 6
+  BILLION =
+  10 ** 9
+  TRILLION =
+  10 ** 12
+  QUADRILLION =
+  10 ** 15
+end

data/lib/gemmy/patches/array_patch.rb

@@ -28,6 +28,57 @@ module Gemmy::Patches::ArrayPatch
 
   module InstanceMethods
 
+    module Reject
+      # make it an alias for reject(&:blank?) if no block given
+      def reject(&blk)
+        blk ? super : reject(&:blank?)
+      end
+    end
+
+    module Cut
+      # another alias for compact
+      def cut
+        compact
+      end
+    end
+
+
+    module MethodMissing
+      # Tries to forward methods to enumerator
+      def method_missing(fn, &blk)
+        enum = to_enum
+        if enum.respond_to?(fn)
+          blk ? enum.send(fn, &blk) : enum.send(fn)
+        else
+          super
+        end
+      end
+    end
+
+    module RunCommands
+      # Part of the Nlp API
+      # Example:
+      #    include Gemmy::Components::Nlp
+      #    parse_sentence("A sentence").run_commands
+      #
+      # Under the hood, parse_sentence is creating procs in the db
+      # These are evaluated here
+      #
+      def run_commands
+        _eval_noun = Gemmy.patch("string/i/eval_noun")
+                          .method(:_eval_noun)
+        return self.flat_map do |cmds|
+          cmds&.map do |cmd|
+            eval(VerbLexicon.get cmd[:verb].to_sym).call(*(
+              cmd[:nouns]&.map do |noun|
+                _eval_noun.call(noun, self)
+              end
+            ).to_a.compact)
+          end
+        end.compact
+      end
+    end
+
     module Exclude
       # facets
       # the opposite of include
@@ -197,6 +248,8 @@ module Gemmy::Patches::ArrayPatch
       alias rangify arrange
     end
 
+
+
     module AnyNot
       # checks if any of the results of an array do not respond truthily
       # to a block

data/lib/gemmy/patches/enumerator_patch.rb

@@ -2,6 +2,34 @@ module Gemmy::Patches::EnumeratorPatch
   module ClassMethods
   end
   module InstanceMethods
+
+    # Facets
+    # Similar to map by (array => hash)
+    # but values are not wrapped in arrays
+    # iteration return val is [key, val]
+    module Graph
+      def graph(&yld)
+        if yld
+          h = {}
+          each do |*kv|
+            r = yld[*kv]
+            case r
+            when Hash
+              nk, nv = *r.to_a[0]
+            when Range
+              nk, nv = r.first, r.last
+            else
+              nk, nv = *r
+            end
+            h[nk] = nv
+          end
+          h
+        else
+          Enumerator.new(self,:graph)
+        end
+      end
+    end
+
     module MapBy
       using CF::Enumerable::MapBy
       # maps to hash
@@ -19,5 +47,16 @@ module Gemmy::Patches::EnumeratorPatch
         clone.map_to klass
       end
     end
+
+    module Frequencies
+      # taken from powerpack
+      # maps each element in the enum to it's num occurrances
+      def frequencies
+        each_with_object(Hash.new(0)) { |e, a| a[e] += 1 }
+      end
+    end
+
+
+
   end
 end

data/lib/gemmy/patches/hash_patch.rb

@@ -205,10 +205,9 @@ module Gemmy::Patches::HashPatch
     #
     module Bury
       def bury *args
-        Gemmy::Patches::HashPatch::InstanceMethods::Bury._bury(self, *args)
+        Gemmy.patch("hash/i/bury")._bury self, *args
       end
       # The bury method, taking the input hash as a parameter
-      # Used by the Hash#bury instance method
       def self._bury(caller_hash, *args)
         if args.count < 2
           raise ArgumentError.new("2 or more arguments required")
@@ -266,17 +265,22 @@ module Gemmy::Patches::HashPatch
     module Persisted
       def persisted(path)
         require 'yaml/store'
-        autovivified = Gemmy::Patches::HashPatch::InstanceMethods::Autovivified.method(:_autovivified)
+        autovivified = Gemmy.patch("hash/i/autovivified")\
+                            .method(:_autovivified)
         autovivified.call(self).tap do |hash|
           hash.instance_exec do
-            @db = YAML::Store.new path
-            @db.transaction do
-              @db[:data] = autovivified.call({})
+            @store = YAML::Store.new path
+            @store.transaction do
+              @store[:data] ||= autovivified.call({})
+              @store[:data].each { |k,v| self[k] = v.deep_dup }
             end
           end
           hash.extend Gemmy::Patches::HashPatch::PersistedHash
         end
       end
+      def db
+        @store
+      end
     end
 
   end # end instance methods
@@ -284,17 +288,25 @@ module Gemmy::Patches::HashPatch
   # Helper methods for the persistence patch
   #
   module PersistedHash
-    def get(*keys, disk: false)
-      disk ? @db.transaction { @db[:data].dig(*keys) } : dig(*keys)
+    def get(*keys, disk: true)
+      disk ? @store.transaction { @store[:data].dig(*keys) } : dig(*keys)
     end
     def set(*keys, val)
       bury = Gemmy::Patches::HashPatch::InstanceMethods::Bury.method(:_bury)
       bury.call(self, *keys, val)
-      @db.transaction do
-        bury.call(@db[:data], *(keys + [val]))
+      @store.transaction do
+        bury.call(@store[:data], *(keys + [val]))
       end
       val
     end
+    def data
+      @store.transaction { @store[:data] }
+    end
+    def clear
+      autovivified = Gemmy.patch("hash/i/autovivified")\
+                          .method(:_autovivified)
+      @store.transaction { @store[:data] = autovivified.call({}) }
+    end
   end
 
 end

data/lib/gemmy/patches/integer_patch.rb

@@ -27,6 +27,43 @@ module Gemmy::Patches::IntegerPatch
 
   module InstanceMethods
 
+    module Hundred
+      # from powerpack
+      def hundred
+        self * Gemmy.const("HUNDRED")
+      end
+    end
+    module Thousand
+      # from powerpack
+      def thousand
+        self * Gemmy.const("THOUSAND")
+      end
+    end
+    module Million
+      # from powerpack
+      def million
+        self * Gemmy.const("MILLION")
+      end
+    end
+    module Billion
+      # from powerpack
+      def billion
+        self * Gemmy.const("BILLION")
+      end
+    end
+    module Trillion
+      # from powerpack
+      def trillion
+        self * Gemmy.const("TRILLION")
+      end
+    end
+    module Quadrillion
+      # from powerpack
+      def quadrillion
+        self * Gemmy.const("QUADRILLION")
+      end
+    end
+
     module Factorial
       # facets
       def factorial

data/lib/gemmy/patches/object_patch.rb

@@ -14,7 +14,48 @@ module Gemmy::Patches::ObjectPatch
 
   module InstanceMethods
 
-    module Iteself
+    module Home
+      # the $HOME dir, aka ~
+      def home
+        `echo $HOME`.chomp
+      end
+    end
+
+    module ObjectState
+      # class StateExample
+      #   attr_reader :a, :b
+      #   def initialize(a,b)
+      #     @a, @b = a, b
+      #   end
+      # end
+
+      # obj = StateExample.new(1,2)
+      # obj.a  #=> 1
+      # obj.b  #=> 2
+
+      # obj.object_state  #=> {:a=>1, :b=>2}
+
+      # obj.object_state(:a=>3, :b=>4)
+      # obj.a  #=> 3
+      # obj.b  #=> 4
+      def object_state(data=nil)
+        if data
+          instance_variables.each do |iv|
+            name = iv.to_s.sub(/^[@]/, '').to_sym
+            instance_variable_set(iv, data[name])
+          end
+        else
+          data = {}
+          instance_variables.each do |iv|
+            name = iv.to_s.sub(/^[@]/, '').to_sym
+            data[name] = instance_variable_get(iv)
+          end
+          data
+        end
+      end
+    end
+
+    module Itself
       # facets
       def itself
         def itself

data/lib/gemmy/patches/string_patch.rb

@@ -7,6 +7,53 @@ module Gemmy::Patches::StringPatch
 
   module InstanceMethods
 
+    module NlpSanitize
+      def nlp_sanitize
+        Gemmy.patch("string/i/alpha")
+          ._alpha(self)
+          .downcase
+          .strip
+          .chomp
+      end
+    end
+
+    module Alpha
+      def self._alpha(string, bang: false, strip_whitespace: false)
+        fn = bang ? :gsub! : :gsub
+        regex = /[^a-zA-Z#{'\s' unless strip_whitespace}]/
+        string.send fn, regex, ''
+      end
+      def alpha!(opts={})
+        Gemmy.patch("string/i/alpha")._alpha(
+          self,
+          opts.merge(bang: true)
+        )
+      end
+      # Gsub non-alphabetical characters
+      def alpha(opts={})
+        Gemmy.patch("string/i/alpha")._alpha(
+          self,
+          opts
+        )
+      end
+    end
+
+    module TempfilePath
+      # Creates a tempfile containing a string and returns its path
+      def tempfile_path
+        Tempfile.new.tap { |t| t.write(self); t.close }.path
+      end
+    end
+
+    module EvalNoun
+      def eval_noun(commands=[])
+        Gemmy.patches("string/i/eval_noun")._eval_noun self, commands
+      end
+      def self._eval_noun(noun, commands=[])
+        eval(NounLexicon.get(noun.to_sym)).call(commands)
+      end
+    end
+
     module Words
       # facets
       def words

data/lib/gemmy/tests.rb

@@ -10,6 +10,7 @@ module Gemmy::Tests
 
   def self.run_test_class(klass)
     klass.run
+    # Unless a test raises an error, it's been run
     puts "#{klass} passed".green
   end
 

data/lib/gemmy/version.rb

@@ -1,3 +1,3 @@
 class Gemmy
-  VERSION = '0.0.5'
+  VERSION = '0.0.6'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gemmyrb
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - max pleaner
@@ -100,6 +100,76 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.9.0
+- !ruby/object:Gem::Dependency
+  name: sentence_interpreter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.7.0
+- !ruby/object:Gem::Dependency
+  name: engtagger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.10.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.10.1
+- !ruby/object:Gem::Dependency
+  name: odyssey
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
 description: ''
 email: maxpleaner@gmail.com
 executables:
@@ -111,8 +181,13 @@ files:
 - bin/gemmy
 - lib/gemmy.rb
 - lib/gemmy/cli.rb
+- lib/gemmy/coffee.rb
 - lib/gemmy/components.rb
+- lib/gemmy/components/cache.rb
 - lib/gemmy/components/dynamic_steps.rb
+- lib/gemmy/components/nlp.rb
+- lib/gemmy/components/word_speaker.rb
+- lib/gemmy/constants.rb
 - lib/gemmy/patches.rb
 - lib/gemmy/patches/array_patch.rb
 - lib/gemmy/patches/class_patch.rb