rodbot 0.1.0

data/lib/rodbot/async.rb

@@ -0,0 +1,45 @@
+# frozen-string-literal: true
+
+require 'sucker_punch'
+
+module Rodbot
+  module Async
+    extend self
+
+    SuckerPunch.logger = Rodbot::Log.logger('async')
+
+    # Perform code asynchronously
+    #
+    # In order not to interfere with tests, the code is performed synchronously
+    # in case the current env is "test"!
+    #
+    # @example with block
+    #   Environment.async do
+    #     some_heavy_number_crunching
+    #   end
+    #
+    # @example with proc
+    #   Environment.async(-> { some_heavy_number_crunching })
+    #
+    # @param proc [Proc] either pass a proc to perform...
+    # @yield ...or yield the code to perform (ignored if a proc is given)
+    def perform(&block)
+      if Rodbot.env.test?
+        block.call
+      else
+        Job.perform_async(block)
+      end
+    end
+
+    class Job
+      include SuckerPunch::Job
+
+      # Generic job which simply calls a proc
+      #
+      # @param proc [Proc] proc to call
+      def perform(proc)
+        proc.call
+      end
+    end
+  end
+end

data/lib/rodbot/cli/command.rb

@@ -0,0 +1,25 @@
+# frozen-string-literal: true
+
+module Rodbot
+  class CLI
+    class Command < Dry::CLI::Command
+      option :backtrace, type: :boolean, default: false, desc: "Dump backtrace on errors"
+
+      def call(backtrace:, **args)
+        rescued_call(**args)
+      rescue => error
+        error(error.message) do
+          raise error if backtrace
+        end
+      end
+
+      private
+
+      def error(message)
+        STDERR.puts "ERROR: command failed: #{message}"
+        yield if block_given?
+        exit 1
+      end
+    end
+  end
+end

data/lib/rodbot/cli/commands/console.rb

@@ -0,0 +1,23 @@
+# frozen-string-literal: true
+
+using Rodbot::Refinements
+
+module Rodbot
+  class CLI
+    module Commands
+      class Console < Rodbot::CLI::Command
+        desc 'Start the Rodbot console'
+
+        def rescued_call(**)
+          Rodbot.boot
+          Rodbot::SERVICES.each { "rodbot/services/#{_1}".constantize }
+          require 'irb'
+          IRB.setup nil
+          IRB.conf[:MAIN_CONTEXT] = IRB::Irb.new.context
+          require 'irb/ext/multi-irb'
+          IRB.irb nil, Rodbot
+        end
+      end
+    end
+  end
+end

data/lib/rodbot/cli/commands/credentials.rb

@@ -0,0 +1,19 @@
+# frozen-string-literal: true
+
+module Rodbot
+  class CLI
+    module Commands
+      class Credentials < Rodbot::CLI::Command
+        desc 'Edit the credentials for ENVIRONMENT'
+        argument :environment, values: Rodbot::Env::ENVS, desc: 'Which environment to edit', required: true
+        example [
+          'development'
+        ]
+
+        def rescued_call(environment:, **)
+          Rodbot.credentials.edit! environment
+        end
+      end
+    end
+  end
+end

data/lib/rodbot/cli/commands/deploy.rb

@@ -0,0 +1,20 @@
+# frozen-string-literal: true
+
+module Rodbot
+  class CLI
+    module Commands
+      class Deploy < Rodbot::CLI::Command
+        desc 'Print the deploy configuration'
+        argument :hosting, values: Rodbot::HOSTINGS, required: true, desc: 'Which hosting to use'
+        option :split, type: :boolean, default: false, desc: "Whether to split into individual services"
+
+        def rescued_call(hosting:, split:, **)
+          dir = [hosting, ('split' if split)].compact.join('-')
+          Rodbot::Generator
+            .new(Rodbot.env.gem.join('lib', 'templates', 'deploy', dir))
+            .display
+        end
+      end
+    end
+  end
+end

data/lib/rodbot/cli/commands/new.rb

@@ -0,0 +1,21 @@
+# frozen-string-literal: true
+
+module Rodbot
+  class CLI
+    module Commands
+      class New < Rodbot::CLI::Command
+        desc 'Create a new Rodbot scaffold in PATH'
+        argument :path, required: true, desc: 'Root directory of the new bot'
+        example [
+          'my_awesome_bot'
+        ]
+
+        def rescued_call(path:, **)
+          Rodbot::Generator
+            .new(Rodbot.env.gem.join('lib', 'templates', 'new'))
+            .write(Pathname(path))
+        end
+      end
+    end
+  end
+end

data/lib/rodbot/cli/commands/simulator.rb

@@ -0,0 +1,17 @@
+# frozen-string-literal: true
+
+module Rodbot
+  class CLI
+    module Commands
+      class Simulator < Rodbot::CLI::Command
+        desc 'Launch the chat simulator'
+        option :sender, default: 'simulator', desc: "Sender to mimick"
+        option :raw, type: :boolean, default: false, desc: "Whether to display raw Markdown"
+
+        def rescued_call(sender:, raw:, **)
+          Rodbot::Simulator.new(sender, raw: raw).run
+        end
+      end
+    end
+  end
+end

data/lib/rodbot/cli/commands/start.rb

@@ -0,0 +1,26 @@
+# frozen-string-literal: true
+
+module Rodbot
+  class CLI
+    module Commands
+      class Start < Rodbot::CLI::Command
+        desc 'Start Rodbot or parts of it'
+        argument :service, values: Rodbot::SERVICES, desc: 'Which service to start or all by default'
+        argument :extension, desc: 'Which service extension to start or all by default (only if SERVICE is relay)'
+        option :daemonize, type: :boolean, desc: "Whether to daemonize and supervise processes, default: true (all services) or false (one service)"
+        option :debugger, type: :boolean, default: false, desc: "Whether to load the debugger"
+
+        def rescued_call(service: nil, extension: nil, daemonize: false, debugger: false, **)
+          require 'debug' if debugger
+          daemonize = true unless service
+          Rodbot::Services.new.then do |services|
+            (service ? [service] : Rodbot::SERVICES).each do |service|
+              services.register(service, extension: extension)
+            end
+            services.run(daemonize: daemonize)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rodbot/cli/commands/stop.rb

@@ -0,0 +1,15 @@
+# frozen-string-literal: true
+
+module Rodbot
+  class CLI
+    module Commands
+      class Stop < Rodbot::CLI::Command
+        desc 'Stop Rodbot'
+
+        def rescued_call(**)
+          Rodbot::Services.new.interrupt
+        end
+      end
+    end
+  end
+end

data/lib/rodbot/cli/commands/version.rb

@@ -0,0 +1,15 @@
+# frozen-string-literal: true
+
+module Rodbot
+  class CLI
+    module Commands
+      class Version < Rodbot::CLI::Command
+        desc "Print version"
+
+        def rescued_call(**)
+          puts Rodbot::VERSION
+        end
+      end
+    end
+  end
+end

data/lib/rodbot/cli/commands.rb

@@ -0,0 +1,18 @@
+# frozen-string-literal: true
+
+module Rodbot
+  class CLI
+    module Commands
+      extend Dry::CLI::Registry
+
+      register 'credentials', Credentials, aliases: %w(cred)
+      register 'deploy', Deploy
+      register 'new', New
+      register 'simulator', Simulator, aliases: %w(sim)
+      register 'start', Start, aliases: %w(up)
+      register 'stop', Stop, aliases: %w(down)
+      register 'console', Console, aliases: %w(c)
+      register 'version', Version, aliases: %w(-v --version)
+    end
+  end
+end

data/lib/rodbot/cli.rb

@@ -0,0 +1,9 @@
+# frozen-string-literal: true
+
+require 'dry/cli'
+
+module Rodbot
+  class CLI < Dry::CLI
+  end
+end
+

data/lib/rodbot/config.rb

@@ -0,0 +1,157 @@
+# frozen-string-literal: true
+
+module Rodbot
+
+  # Simple yet flexible configuration module
+  #
+  # The configuration is defined in Ruby as follows:
+  #
+  #   name 'Bot'
+  #   country 'Sweden'
+  #   country nil
+  #   log do
+  #     level 3
+  #   end
+  #   plugin :matrix do
+  #     version 1
+  #     ssl true
+  #   end
+  #   plugin :slack do
+  #     version 2
+  #   end
+  #
+  # Within Rodbot, you should use the +Rodbot.config+ shortcut to access the
+  # configuration.
+  #
+  #   file = File.new('config/rodbot.rb')
+  #   rc = Rodbot::Config.new(file.read)
+  #   rc.config(:name)        # => 'Bot'
+  #   rc.config(:country)     # => nil
+  #   rc.config(:undefined)   # => nil
+  #   rc.config(:log)         # => { level: 3 }
+  #   rc.config(:plugin, :matrix, :version)
+  #   # => 1
+  #   rc.config(:plugin, :matrix)
+  #   # => { version: 1, ssl: true }
+  #   rc.config(:plugin)
+  #   # => { matrix: { version: 1, ssl: true }, slack: { version: 2 } }
+  #   rc.config
+  #   # => { name: 'Bot', country: nil, plugin: { matrix: { version: 1, ssl: true }, slack: { version: 2 } } }
+  #
+  # There are two types configuration items:
+  #
+  # 1. Object values without block like +name 'Bot'+:<br>The config key +:name+
+  #    gets the object +'Bot'+ assigned. Subsequent assignments with the same
+  #    config key overwrite previous assignments.
+  # 2. Unspecified value with a block like +log do+:<br>The config key +:log+ is
+  #    assigned a hash defined by the block. Subsequent assignments with the
+  #    same config key are merged into the hash.
+  # 3. Object values with a block like +plugin :matrix do+:<br>The config key
+  #    +:plugin+ is assigned an empty hash which is then populated with the
+  #    object `:matrix` (usually a Symbol) as key and the subtree defined by the
+  #    block. Subsequent assignments with the same config key add more keys to
+  #    this hash.
+  #
+  # Please note: You can force a config key to always be treated as if it had
+  # a block (type 3) by adding it to the +KEYS_WITH_IMPLICIT_BLOCK+ array.
+  #
+  # Defaults set by the +DEFAULTS+ constant are read first and therefore may be
+  # overwritten or extend as mentioned above.
+  class Config
+
+    # Keys which are always treated as if they had a block even if they don't
+    KEYS_WITH_IMPLICIT_BLOCK = %i(plugin).freeze
+
+    # Default configuration
+    DEFAULTS = <<~END
+      name 'Rodbot'
+      port 7200
+      timezone 'Etc/UTC'
+      db 'hash'
+      app do
+        threads Rodbot.env.development? ? (1..1) : (2..4)
+      end
+      log do
+        to STDOUT
+        level Rodbot.env.development? ? Logger::INFO : Logger::ERROR
+      end
+    END
+
+    # Read configuration from file
+    #
+    # @param source [String] config source e.g. read from +config/rodbot.rb+
+    # @param defaults [Boolean] whether to load the defaults or not
+    # @return [self]
+    def initialize(source, defaults: true)
+      @config = Reader.new.eval_strings((DEFAULTS if defaults), source).to_h
+    end
+
+    # Get config values and subtrees
+    #
+    # @note Use the +Rodbot.config+ shortcut to access this method!
+    #
+    # @param keys [Array] key path to config subtree or value
+    # @return [Object] config subtree or value
+    def config(*keys)
+      return @config if keys.none?
+      value = @config.dig(*keys)
+      if value.instance_of?(Array) && value.count == 1
+        value.first
+      else
+        value
+      end
+    end
+
+    class Reader
+      def initialize
+        @hash = {}
+      end
+
+      # Eval configuration from strings
+      #
+      # @param strings [String, nil] one or more strings to evaluate
+      # @return [self]
+      def eval_strings(*strings)
+        instance_eval(strings.compact.join("\n"))
+        self
+      end
+
+      # Eval configuration from block
+      #
+      # @yield block to evaluate
+      # @return [self]
+      def eval_block(&block)
+        instance_eval(&block) if block
+        self
+      end
+
+      # Set an config value
+      #
+      # @param key [Symbol] config key
+      # @param value [Object, nil] config value
+      # @yield optional block containing nested config
+      # @return [self]
+      def method_missing(key, value=nil, *, &block)
+        case
+        when block && value.nil?
+          @hash[key] ||= {}
+          @hash[key].merge! self.class.new.eval_block(&block).to_h
+        when block || KEYS_WITH_IMPLICIT_BLOCK.include?(key)
+          @hash[key] ||= {}
+          @hash[key][value] = self.class.new.eval_block(&block).to_h
+        else
+          @hash[key] = value
+        end
+        self
+      end
+
+      # Config hash
+      #
+      # @return [Hash]
+      def to_h
+        @hash
+      end
+
+    end
+  end
+end

data/lib/rodbot/constants.rb

@@ -0,0 +1,13 @@
+# frozen-string-literal: true
+
+module Rodbot
+  module Constants
+
+    # Service types
+    SERVICES = %i(app relay schedule).freeze
+
+    # Hosting types
+    HOSTINGS = %i(procfile docker render).freeze
+
+  end
+end

data/lib/rodbot/db/hash.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Rodbot
+  class Db
+
+    # Database adapter for Hash
+    #
+    # @example Enable in config/rodbot.rb
+    #   db 'hash'
+    #
+    # This database is for development and testing only, it is not thread-safe
+    # and therefore should not be used in production.
+    module Hash
+      PRUNE_THRESHOLD = 100
+
+      def set(*key, expires_in: nil, &block)
+        prune
+        block.call((get(*key) unless block.arity.zero?)).tap do |value|
+          db[key.join(':')] = [
+            serialize(value),
+            (epoch + expires_in if expires_in)
+          ]
+        end
+      end
+
+      def get(*key)
+        value, expires_at = db[skey(*key)]
+        deserialize(value) if value && (!expires_at || epoch < expires_at)
+      end
+
+      def delete(*key)
+        value, expires_at = db.delete(skey(*key))
+        deserialize(value) if value && (!expires_at || epoch < expires_at)
+      end
+
+      def scan(*key)
+        re = /\A#{skey(*key).sub(/\*\z/, '')}/
+        db.keys.select { _1.match? re }
+      end
+
+      def flush
+        @db = {}
+        self
+      end
+
+      private
+
+      def db
+        @db ||= {}
+      end
+
+      def skey(*key)
+        key.join(':')
+      end
+
+      def epoch
+        Time.now.to_f
+      end
+
+      def prune
+        @counter ||= 0
+        if (@counter += 1) > PRUNE_THRESHOLD
+          cached_epoch = epoch
+          db.delete_if { _2.last < cached_epoch }
+          @counter = 1
+        end
+      end
+    end
+
+  end
+end

data/lib/rodbot/db/redis.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Rodbot
+  class Db
+
+    # Database adapter for Redis
+    #
+    # All keys are implicitly nested inside the "rodbot:..." namespace to allow
+    # using one and the same Redis db for more than just Rodbot.
+    #
+    # @example Enable in config/rodbot.rb
+    #   db 'redis://localhost:6379/10'
+    module Redis
+      include Rodbot::Memoize
+
+      def self.extended(*)
+        require 'redis'
+      end
+
+      def set(*key, expires_in: nil, &block)
+        block.call((get(*key) unless block.arity.zero?)).tap do |value|
+          db.set(skey(*key), serialize(value), ex: expires_in)
+        end
+      end
+
+      def get(*key)
+        deserialize(db.get(skey(*key)))
+      end
+
+      def delete(*key)
+        get(*key).tap do
+          db.del(skey(*key))
+        end
+      end
+
+      def scan(*key)
+        cursor, result = 0, []
+        loop do
+          cursor, keys = db.scan(cursor, match: skey(*key))
+          result.append(*keys)
+          break result if cursor == '0'
+        end.map { _1[7..] }
+      end
+
+      def flush
+        db.flushdb
+        self
+      end
+
+      private
+
+      memoize def db
+        ::Redis.new(url: url)
+      end
+
+      def skey(*key)
+        key.prepend('rodbot').join(':')
+      end
+    end
+  end
+end

data/lib/rodbot/db.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'json'
+
+using Rodbot::Refinements
+
+module Rodbot
+
+  # Uniform key/value database interface for various backends
+  #
+  # Keys can be namespaced using the colon as separator:
+  #
+  # * 'color' - color key without namespace
+  # * 'bike:color' - color key within the bike namespace
+  # * 'vehicle:bike:color' - color key within... you get the idea
+  #
+  # Furthermore, keys can be entered either as colon separated keys or as
+  # list of symbols. The following are therefore equivalent:
+  #
+  #   Rodbot.db.get('vehicle:bike:color')
+  #   Rodbot.db.get(:vehicle, :bike, :color)
+  #
+  # Same goes for the star wildcard which is only allowed last:
+  #
+  #   Rodbot.db.scan('vehicle:*')
+  #   Rodbot.db.scan(:vehicle, :*)
+  #
+  # The interface is simple and straightforward:
+  #
+  # @example Set a value
+  #   Rodbot.db.set(:name) { 'John' }
+  #
+  # @example Set a value which expires after 30 seconds
+  #   Rodbot.db.set(:name, expires_in: 30) { 'John' }
+  #
+  # @example Replace an existing value
+  #   Rodbot.db.set(:name) { 'John' }
+  #   Rodbot.db.set(:name) { 'Bob' }   # replaces John with Bob
+  #
+  # @example Update an existing value
+  #   Rodbot.db.set(:name) { 'John' }
+  #   Rodbot.db.set(:name) { |n| "#{n} Doe" }   # replaces John with John Doe
+  #
+  # @example Get a value
+  #   Rodbot.db.set(:name) { 'John' }
+  #   Rodbot.db.get(:name)   # => 'John'
+  #
+  # @example Delete a value
+  #   Rodbot.db.set(:name) { 'John' }
+  #   Rodbot.db.delete(:name)   # => 'John'
+  #   Rodbot.db.get(:name)      # => nil
+  #
+  # @example Scan for keys
+  #   Rodbot.db.set(:first_name) { 'John' }
+  #   Rodbot.db.set(:last_name) { 'Doe' }
+  #   Rodbot.db.scan(:*)   # => [:first_name, :last_name]
+  #
+  # @example Delete all keys
+  #   Rodbot.db.flush
+  #
+  # Please note that {JSON} is used to serialize which has an influence on
+  # what you get back after deserialization:
+  #
+  # * Primitive types such as String, Integer or TrueClass are preserved.
+  # * Any other object is converted to String, incuding...
+  # * Symbol values are converted to String
+  # * Symbol elements in an array are converted to String
+  # * Symbol values in a hash are converted to String
+  #
+  # However, hash keys are always converted to Symbol - mainly because Rubyland
+  # favours Symbol keys over String keys for visual reasons.
+  class Db
+    attr_reader :url
+
+    # @param url [String] connection URL of the backend
+    def initialize(url)
+      @url = url
+      extend "rodbot/db/#{url.split('://').first}".constantize
+    end
+
+    private
+
+    def serialize(object)
+      object.to_json
+    end
+
+    def deserialize(string)
+      JSON.parse(string, symbolize_names: true) if string
+    end
+  end
+end