charyf 0.1.1

data/lib/charyf/utils/generators.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require 'thor/group'
+
+require_relative 'command/behavior'
+
+
+module Charyf
+  module Generators
+    include Charyf::Command::Behavior
+
+    REMOVED_GENERATORS = %w(app cli_app intents)
+
+
+    DEFAULT_ALIASES = {}
+
+    DEFAULT_OPTIONS = {
+        charyf: {
+            intents: true
+        }
+    }
+
+    class << self
+
+      def aliases #:nodoc:
+        @aliases ||= DEFAULT_ALIASES.dup
+      end
+
+      def options #:nodoc:
+        @options ||= DEFAULT_OPTIONS.dup
+      end
+
+      # Returns an array of generator namespaces that are hidden.
+      # Generator namespaces may be hidden for a variety of reasons.
+      def hidden_namespaces
+        @hidden_namespaces ||= []
+      end
+
+      def hide_namespaces(*namespaces)
+        hidden_namespaces.concat(namespaces)
+      end
+
+      alias hide_namespace hide_namespaces
+
+      # Show help message with available generators.
+      def help(command = "generate")
+        puts "Usage: charyf #{command} GENERATOR [args] [options]"
+        puts
+        puts "General options:"
+        puts "  -h, [--help]     # Print generator's options and usage"
+        puts "  -p, [--pretend]  # Run but do not make any changes"
+        puts "  -f, [--force]    # Overwrite files that already exist"
+        puts "  -s, [--skip]     # Skip files that already exist"
+        puts "  -q, [--quiet]    # Suppress status output"
+        puts
+        puts "Please choose a generator below."
+        puts
+
+        print_generators
+      end
+
+      # Receives a namespace, arguments and the behavior to invoke the generator.
+      # It's used as the default entry point for generate, destroy and update
+      # commands.
+      def invoke(namespace, args = ARGV, config = {})
+        names = namespace.to_s.split(":")
+        if klass = find_by_namespace(names.pop, names.any? && names.join(":"))
+          args << "--help" if args.empty? && klass.arguments.any?(&:required?)
+          klass.start(args, config)
+        else
+          options     = sorted_groups.flat_map(&:last)
+          suggestions = options.sort_by { |suggested| levenshtein_distance(namespace.to_s, suggested) }.first(3)
+          suggestions.map! { |s| "'#{s}'" }
+          msg =  "Could not find generator '#{namespace}'. ".dup
+
+          if suggestions.any?
+            msg << "Maybe you meant #{ suggestions[0...-1].join(', ')} or #{suggestions[-1]}\n"
+            msg << "Run `charyf generate --help` for more options."
+          end
+
+          puts msg
+        end
+      end
+
+      def configure!(config) #:nodoc:
+        options.deep_merge! config.options, union_arrays: true
+        hide_namespaces(*config.hidden_namespaces)
+      end
+
+      def print_generators
+        sorted_groups.each { |b, n| print_list(b, n) }
+      end
+
+      def sorted_groups
+        namespaces = public_namespaces
+        namespaces.sort!
+
+        groups = Hash.new { |h, k| h[k] = [] }
+        namespaces.each do |namespace|
+          base = namespace.split(":").first
+          groups[base] << namespace
+        end
+
+        charyf = groups.delete("charyf") || []
+        charyf.map! { |n| n.sub(/^charyf:/, "") }
+        REMOVED_GENERATORS.map { |name| charyf.delete(name) }
+
+        hidden_namespaces.each { |n| groups.delete(n.to_s) }
+
+        [[ "charyf", charyf ]] + groups.sort.to_a
+      end
+
+      def public_namespaces
+        subclasses.map(&:namespace)
+      end
+
+      # Charyf finds namespaces similar to Thor, it only adds one rule:
+      #
+      #   find_by_namespace :foo, :charyf, :bar
+      #
+      # Will search for the following generators:
+      #
+      #   "charyf:foo", "foo:bar", "foo"
+      #
+      # Notice that "charyf:generators:bar" could be loaded as well, what
+      # Charyf looks for is the first and last parts of the namespace.
+      def find_by_namespace(name, base = nil, context = nil) #:nodoc:
+        lookups = []
+        lookups << "#{base}:#{name}"    if base
+        lookups << "#{name}:#{context}" if context
+
+        unless base || context
+          unless name.to_s.include?(?:)
+            lookups << "#{name}:#{name}"
+            lookups << "charyf:#{name}"
+          end
+          lookups << "#{name}"
+        end
+
+        namespaces = Hash[subclasses.map { |klass| [klass.namespace, klass] }]
+        lookups.each do |namespace|
+
+          klass = namespaces[namespace]
+          return klass if klass
+        end
+
+        invoke_fallbacks_for(name, base) || invoke_fallbacks_for(context, name)
+      end
+
+      # Hold configured generators fallbacks. If a plugin developer wants a
+      # generator group to fallback to another group in case of missing generators,
+      # they can add a fallback.
+      #
+      # For example, shoulda is considered a test_framework and is an extension
+      # of test_unit. However, most part of shoulda generators are similar to
+      # test_unit ones.
+      #
+      # Shoulda then can tell generators to search for test_unit generators when
+      # some of them are not available by adding a fallback:
+      #
+      #   Charyf::Generators.fallbacks[:shoulda] = :test_unit
+      def fallbacks
+        @fallbacks ||= {}
+      end
+
+      private
+
+      # Try fallbacks for the given base.
+      def invoke_fallbacks_for(name, base)
+        return nil unless base && fallbacks[base.to_sym]
+        invoked_fallbacks = []
+
+        Array(fallbacks[base.to_sym]).each do |fallback|
+          next if invoked_fallbacks.include?(fallback)
+          invoked_fallbacks << fallback
+
+          klass = find_by_namespace(name, fallback)
+          return klass if klass
+        end
+
+        nil
+      end
+
+    end # End of self
+
+  end
+end

data/lib/charyf/utils/initializable.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'tsort'
+
+module Charyf
+  module Initializable
+    def self.included(base) #:nodoc:
+      base.extend ClassMethods
+    end
+
+    class Initializer
+      attr_reader :name, :block
+
+      def initialize(name, context, options, &block)
+        options[:group] ||= :default
+        @name, @context, @options, @block = name, context, options, block
+      end
+
+      def before
+        @options[:before]
+      end
+
+      def after
+        @options[:after]
+      end
+
+      def belongs_to?(group)
+        @options[:group] == group || @options[:group] == :all
+      end
+
+      def run(*args)
+        @context.instance_exec(*args, &block)
+      end
+
+      def bind(context)
+        return self if @context
+        Initializer.new(@name, context, @options, &block)
+      end
+
+      def context_class
+        @context.class
+      end
+    end
+
+    class Collection < Array
+      include TSort
+
+      alias :tsort_each_node :each
+      def tsort_each_child(initializer, &block)
+        select { |i| i.before == initializer.name || i.name == initializer.after }.each(&block)
+      end
+
+      def +(other)
+        Collection.new(to_a + other.to_a)
+      end
+    end
+
+    def run_initializers(group = :default, *args)
+      return if instance_variable_defined?(:@ran)
+      initializers.tsort_each do |initializer|
+        initializer.run(*args) if initializer.belongs_to?(group)
+      end
+      @ran = true
+    end
+
+    def initializers
+      @initializers ||= self.class.initializers_for(self)
+    end
+
+    module ClassMethods
+      def initializers
+        @initializers ||= Collection.new
+      end
+
+      def initializers_chain
+        initializers = Collection.new
+        ancestors.reverse_each do |klass|
+          next unless klass.respond_to?(:initializers)
+          initializers = initializers + klass.initializers
+        end
+        initializers
+      end
+
+      def initializers_for(binding)
+        Collection.new(initializers_chain.map { |i| i.bind(binding) })
+      end
+
+      def initializer(name, opts = {}, &blk)
+        raise ArgumentError, 'A block must be passed when defining an initializer' unless blk
+        opts[:after] ||= initializers.last.name unless initializers.empty? || initializers.find { |i| i.name == opts[:before] }
+        initializers << Initializer.new(name, nil, opts, &blk)
+      end
+    end
+  end
+end

data/lib/charyf/utils/logger.rb

@@ -0,0 +1,26 @@
+require 'logger'
+require 'colorize'
+
+module Charyf
+  class Logger < ::Logger
+
+    def initialize(logdev, shift_age = 0, shift_size = 1048576)
+      super
+
+      self.datetime_format = '%Y-%m-%d %H:%M:%S'
+
+      self.formatter = proc do |severity, datetime, progname, msg|
+        "#{datetime} [#{severity}]: #{msg}\n"
+      end
+    end
+
+    def flow_request(msg)
+      info(msg.green)
+    end
+
+    def flow_response(msg)
+      info(msg.blue)
+    end
+
+  end
+end

data/lib/charyf/utils/machine.rb

@@ -0,0 +1,129 @@
+module Charyf
+  module Utils
+    class Machine
+
+      DefaultExists = Class.new(ArgumentError)
+      NotInState = Class.new(ArgumentError)
+      InvalidDefinition = Class.new(LoadError)
+      InvalidEvent = Class.new(ArgumentError)
+
+      class << self
+
+        # Sig does not handle blocks
+        def state(name, default: false, final: false, action: nil, &block)
+          if default
+            raise DefaultExists.new if @_default_state
+            @_default_state = name
+          end
+
+
+          _states[name] = {
+              action: action || name,
+              final: final
+          }
+
+          if block
+            @_state = name
+            block.call
+            @_state = nil
+          end
+        end
+
+        def on(event, go: nil, &block)
+          raise NotInState.new unless @_state
+
+          _events(@_state)[event] =
+              {
+                  go: go,
+                  callback: block
+              }
+        end
+
+        def _default_state
+          @_default_state
+        end
+
+        # def _final_states
+        #   @_final_states ||= [:_terminated]
+        # end
+
+        def _states
+          @_states ||= {
+              _terminated: {
+                  action: :_terminated,
+                  final: true
+              }
+          }
+        end
+
+        def _events(state)
+          @_events ||= Hash.new
+          @_events[state] ||= Hash.new
+        end
+
+        def build
+          _states.each do |state_name, state|
+            events = _events(state_name)
+            raise InvalidDefinition.new("No transitions from state #{state_name}") if events.empty? && !state[:final]
+
+            _events(state_name).each do |event, details|
+              raise InvalidDefinition.new("Transition '#{event}' to undefined state '#{details[:go]}'") unless _states.include?(details[:go])
+            end
+          end
+
+          raise InvalidDefinition.new('No final states defined.') unless _states.values.any? { |state| state[:final] }
+        end
+
+      end # End of class
+
+      attr_reader :state
+
+      def initialize(state = nil)
+        @state ||= self.class._default_state
+      end
+
+      def trigger!(event, payload = nil)
+        raise InvalidEvent.new("No transition defined for event '#{event}' from state '#{@state}'") unless trigger?(event)
+        change(event, payload)
+      end
+
+      def trigger(event, payload = nil)
+        trigger?(event) && change(event, payload)
+      end
+
+      def trigger?(event)
+        self.class._events(@state).include?(event)
+      end
+
+      def terminate
+        @state = :_terminated
+      end
+
+      def final?
+        self.class._states[@state][:final]
+      end
+
+      def state?(state)
+        @state == state
+      end
+
+      def events
+        self.class._events(@state).keys
+      end
+
+      private
+
+      def change(event, payload)
+        transition = self.class._events(@state)[event]
+
+        @state = transition[:go]
+        #TODO machine
+        callback = transition[:callback]
+        callback.call(payload) if callback
+
+        @state
+      end
+
+    end
+  end
+end

data/lib/charyf/utils/parser/en_parser.rb

@@ -0,0 +1,97 @@
+require_relative 'parser'
+
+module Charyf
+  module Utils
+    module Parser
+      # noinspection RubyLiteralArrayInspection,RubyQuotedStringsInspection
+      # English string normalization
+      class English < Base
+
+        strategy_name :en
+
+        CONTRACTION = ["ain't", "aren't", "can't", "could've", "couldn't",
+                       "didn't", "doesn't", "don't", "gonna", "gotta",
+                       "hadn't", "hasn't", "haven't", "he'd", "he'll", "he's",
+                       "how'd", "how'll", "how's", "I'd", "I'll", "I'm",
+                       "I've", "isn't", "it'd", "it'll", "it's", "mightn't",
+                       "might've", "mustn't", "must've", "needn't", "oughtn't",
+                       "shan't", "she'd", "she'll", "she's", "shouldn't",
+                       "should've", "somebody's", "someone'd", "someone'll",
+                       "someone's", "that'll", "that's", "that'd", "there'd",
+                       "there're", "there's", "they'd", "they'll", "they're",
+                       "they've", "wasn't", "we'd", "we'll", "we're", "we've",
+                       "weren't", "what'd", "what'll", "what're", "what's",
+                       "whats",
+                       "what've", "when's", "when'd", "where'd", "where's",
+                       "where've", "who'd", "who'd've", "who'll", "who're",
+                       "who's", "who've", "why'd", "why're", "why's", "won't",
+                       "won't've", "would've", "wouldn't", "wouldn't've",
+                       "y'all", "ya'll", "you'd", "you'd've", "you'll",
+                       "y'aint", "y'ain't", "you're", "you've"].map(&:downcase).freeze
+
+        EXPANSION = ["is not", "are not", "can not", "could have",
+                     "could not", "did not", "does not", "do not",
+                     "going to", "got to", "had not", "has not",
+                     "have not", "he would", "he will", "he is", "how did",
+                     "how will", "how is", "I would", "I will", "I am",
+                     "I have", "is not", "it would", "it will", "it is",
+                     "might not", "might have", "must not", "must have",
+                     "need not", "ought not", "shall not", "she would",
+                     "she will", "she is", "should not", "should have",
+                     "somebody is", "someone would", "someone will",
+                     "someone is", "that will", "that is", "that would",
+                     "there would", "there are", "there is", "they would",
+                     "they will", "they are", "they have", "was not",
+                     "we would", "we will", "we are", "we have",
+                     "were not", "what did", "what will", "what are",
+                     "what is",
+                     "what is", "what have", "when is", "when did",
+                     "where did", "where is", "where have", "who would",
+                     "who would have", "who will", "who are", "who is",
+                     "who have", "why did", "why are", "why is",
+                     "will not", "will not have", "would have",
+                     "would not", "would not have", "you all", "you all",
+                     "you would", "you would have", "you will",
+                     "you are not", "you are not", "you are", "you have"].map(&:downcase).freeze
+
+        TEXT_NUMBERS = ["zero", "one", "two", "three", "four", "five", "six",
+                       "seven", "eight", "nine", "ten", "eleven", "twelve",
+                       "thirteen", "fourteen", "fifteen", "sixteen",
+                       "seventeen", "eighteen", "nineteen", "twenty"].map(&:downcase).freeze
+
+        ARTICLES = ["the", "a", "an"].map(&:downcase).freeze
+
+        def self.normalize(text, remove_articles: true)
+          words = text.split
+
+          normalized = ''
+
+          words.each do |word|
+            next if word.empty?
+            next if remove_articles && ARTICLES.include?(word.downcase)
+
+            # Expand common contractions, e.g. "isn't" -> "is not"
+            if CONTRACTION.include?(word.downcase)
+              capitalize = false
+              if word[0] == word[0].upcase
+                capitalize = true
+              end
+              word = EXPANSION[CONTRACTION.index(word.downcase)]
+
+              word.capitalize! if capitalize
+            end
+
+            if TEXT_NUMBERS.include?(word.downcase)
+              word = TEXT_NUMBERS.index(word.downcase)
+            end
+
+            normalized += " " + word
+          end
+
+          normalized.strip
+        end
+
+      end
+    end
+  end
+end

data/lib/charyf/utils/parser/parser.rb

@@ -0,0 +1,37 @@
+require_relative '../../support/string'
+require_relative '../strategy'
+
+module Charyf
+  module Utils
+    module Parser
+      class Base
+
+        include Charyf::Strategy
+        def self.base
+          Base
+        end
+
+        # TODO sig
+        def self.normalize(text, remove_articles: true)
+          raise Charyf::Utils::NotImplemented.new
+        end
+
+      end # End of base
+
+      def self.known
+        Base.known
+      end
+
+      def self.list
+        Base.list
+      end
+
+      # TODO sig
+      def self.get(language)
+        # TODO implement
+        Charyf::Utils::Parser::English
+        list[language]
+      end
+    end
+  end
+end

data/lib/charyf/utils/ruby_version_check.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+if RUBY_VERSION < "2.2.2" && RUBY_ENGINE == "ruby"
+  desc = defined?(RUBY_DESCRIPTION) ? RUBY_DESCRIPTION : "ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE})"
+  abort <<-end_message
+
+    Charyf [Alpha] requires Ruby 2.2.2 or newer.
+
+    You're running
+      #{desc}
+
+    Please upgrade to Ruby 2.2.2 or newer to continue.
+
+  end_message
+end

data/lib/charyf/utils/storage/provider.rb

@@ -0,0 +1,44 @@
+require_relative '../strategy'
+
+module Charyf
+  module Utils
+    module StorageProvider
+      class Base
+
+        include Charyf::Strategy
+        def self.base
+          Base
+        end
+
+        sig_self [['Module', 'String']], ['Charyf::Utils::StorageProvider::Base'],
+        def self.get_for(klass)
+          raise Charyf::Utils::NotImplemented.new
+        end
+
+        sig [nil], [nil],
+        def get(key)
+          raise Charyf::Utils::NotImplemented.new
+        end
+
+        sig [nil, nil], [nil],
+        def store(key, value)
+          raise Charyf::Utils::NotImplemented.new
+        end
+
+        sig [nil], [nil],
+        def remove(key)
+          raise Charyf::Utils::NotImplemented.new
+        end
+
+      end # End of Base
+
+      def self.known
+        Base.known
+      end
+
+      def self.list
+        Base.list
+      end
+    end
+  end
+end

data/lib/charyf/utils/strategy.rb

@@ -0,0 +1,44 @@
+module Charyf
+  module Strategy
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def inherited(subclass)
+        base._subclasses << subclass
+      end
+
+      def strategy_name(name = nil)
+        if name
+          @_strategy_name = name
+          base._aliases[name] = self
+        end
+
+        @_strategy_name
+      end
+
+      def _subclasses
+        @_subclasses ||= []
+      end
+
+      def _aliases
+        @_aliases ||= Hash.new
+      end
+
+      def known
+        base._subclasses
+      end
+
+      def list
+        base._aliases
+      end
+
+      def base
+        raise Charyf::Utils::NotImplemented.new("No base class found for #{self}")
+      end
+    end
+
+  end
+end