slimer 0.1.1

data/exe/slimer

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "slimer"

data/lib/slimer.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require_relative "slimer/version"
+
+require_relative "slimer/database"
+require_relative "slimer/group_configurator"
+
+require "logger"
+
+# @abstract
+module Slimer
+  class Error < StandardError; end
+
+  DEFAULT_GROUP = "general"
+  DEFAULT_DATABASE_URL = "sqlite://./slimer.db"
+  DEFAULT_SIDEKIQ_QUEUE = "slimer"
+
+  DEFAULTS = {
+    groups: Set.new([DEFAULT_GROUP]),
+    database_url: DEFAULT_DATABASE_URL,
+    sidekiq_queue: DEFAULT_SIDEKIQ_QUEUE
+  }.freeze
+
+  def self.options
+    @options ||= DEFAULTS.dup
+  end
+
+  def self.options=(opts)
+    @options = DEFAULTS.merge(opts)
+  end
+
+  def self.db
+    database_url_from_env = ENV.delete("SLIMER_DATABASE_URL") || ENV.delete("DATABASE_URL")
+
+    if database_url_from_env
+      @options[:database_url] = database_url_from_env
+      return @db = Database.connection(
+        options[:database_url] || DEFAULT_DATABASE_URL
+      )
+    end
+
+    @db ||= Database.connection(
+      options[:database_url] || DEFAULT_DATABASE_URL
+    )
+  end
+
+  def self.groups(new_groups = nil)
+    self.groups = new_groups if new_groups
+    options[:groups]
+  end
+
+  def self.groups=(new_groups = Set.new(options[:groups].dup))
+    @options[:groups] = Set.new(new_groups.map(&:to_s))
+  end
+
+  def self.group(new_group, &block)
+    options[:groups] += GroupConfigurator.group(new_group, &block).all
+  end
+
+  def self.database_url(db_url = nil)
+    self.database_url = db_url if db_url
+    options[:database_url]
+  end
+
+  def self.database_url=(db_url)
+    @options[:database_url] = db_url
+  end
+
+  def self.sidekiq_queue(new_queue = nil)
+    self.sidekiq_queue = new_queue if new_queue
+    options[:sidekiq_queue]
+  end
+
+  def self.sidekiq_queue=(new_queue)
+    @options[:sidekiq_queue] = new_queue
+  end
+
+  def self.configure
+    yield self
+  end
+
+  def self.configure_sidekiq_client(&block)
+    Sidekiq.configure_client(&block)
+  end
+
+  def self.configure_sidekiq_server(&block)
+    Sidekiq.configure_server(&block)
+  end
+
+  def self.logger
+    @logger ||= Logger.new($stdout, level: Logger::INFO)
+  end
+
+  def self.logger=(logger)
+    if logger.nil?
+      self.logger.level = Logger::FATAL
+      return self.logger
+    end
+
+    @logger = logger
+  end
+
+  def self.reset!
+    @options = DEFAULTS.dup
+    truncate_tables!
+    @db = nil
+  end
+
+  def self.truncate_tables!
+    Slimer::ApiKey.truncate if defined? Slimer::ApiKey
+    Slimer::Substance.truncate if defined? Slimer::Substance
+  end
+end
+
+# These all depend on Slimer.options to exist, so we'll load hem after our
+# initial module is setup.
+require_relative "slimer/workers"

data/lib/slimer/api_key.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Slimer
+  # A Sequel::Model wrapper around the api_keys table
+  class ApiKey < Sequel::Model
+    def self.generate(name)
+      new_token = loop do
+        generated_token = SecureRandom.urlsafe_base64
+        break generated_token unless token_exists?(generated_token)
+      end
+
+      create name: name, token: new_token
+    end
+
+    def self.token_exists?(token)
+      ApiKey.where(token: token).count.positive?
+    end
+  end
+end

data/lib/slimer/database.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "json"
+require "sequel/core"
+require "sequel/model"
+require "sequel/plugins/serialization"
+
+module Slimer
+  # @abstract Wraps Sequel.connect to easily interface with the Slimer database
+  class Database
+    attr_reader :url
+
+    REQUIRED_TABLES = %i[api_keys substances].freeze
+
+    def initialize(url)
+      @url = url
+      add_supported_extensions
+      resolve_missing_tables!
+      connection.loggers << Slimer.logger if connection.loggers.empty?
+    end
+
+    def self.connection(url)
+      db = new(url)
+      # Sequel::Model requires a connection before you can subclass.  Now that
+      # we have a connection, require the models.
+      connection = db.connection
+      db.load_models
+      connection
+    end
+
+    def connection
+      @connection ||= Sequel.connect(url)
+    end
+    alias connect connection
+
+    def resolve_missing_tables!
+      return if migrated?
+
+      create!
+    end
+
+    def create!
+      create_substances unless connection.table_exists?(:substances)
+      create_api_keys unless connection.table_exists?(:api_keys)
+    end
+
+    def migrated?
+      REQUIRED_TABLES.all? { |t| connection.table_exists?(t) }
+    end
+
+    def load_models
+      require_relative "api_key" unless defined?(Slimer::ApiKey)
+      require_relative "substance" unless defined?(Slimer::Substance)
+    end
+
+    private
+
+    def add_supported_extensions
+      return if connection.database_type != :postgres
+
+      connection.extension :pg_json
+      Sequel.extension :pg_json_ops
+    end
+
+    def create_substances
+      return create_substances_for_postgres if connection.database_type == :postgres
+
+      connection.create_table(:substances, ignore_index_errors: true) do
+        primary_key :id
+        String :uid
+        String :group, default: Slimer::DEFAULT_GROUP
+        String :payload, text: true
+        String :metadata, text: true
+        full_text_index :payload
+        full_text_index :metadata
+      end
+    end
+
+    def create_substances_for_postgres
+      connection.create_table(:substances, ignore_index_errors: true) do
+        String :uid
+        String :group, default: Slimer::DEFAULT_GROUP
+        JSONB :payload
+        JSONB :metadata
+        index :payload, type: :gin
+        index :metadata, type: :gin
+      end
+    end
+
+    def create_api_keys
+      connection.create_table(:api_keys, ignore_index_errors: true) do
+        primary_key :id
+        String :name
+        String :token
+      end
+    end
+  end
+end

data/lib/slimer/group_configurator.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# A simple utility class to parse nested groups
+class GroupConfigurator
+  attr_reader :groups
+
+  alias all groups
+
+  # Creates a flat set of groups from a string or block
+  #
+  # @examples
+  #
+  # GroupConfigurator.group("ruby/rails") => #<Set: {[ "ruby", "ruby/rails" ]} >
+  # GroupConfigurator.group(:ruby) do |config|
+  #   config.group :rails
+  # end => #<Set: {[ "ruby", "ruby/rails" ]} >
+  def self.group(new_groups, &block)
+    new.group(new_groups, &block)
+  end
+
+  # Creates a flat set of groups from a string or block
+  #
+  # @examples
+  #
+  # GroupConfigurator.group("ruby/rails") => #<Set: {[ "ruby", "ruby/rails" ]} >
+  # GroupConfigurator.group(:ruby) do |config|
+  #   config.group :rails
+  # end => #<Set: {[ "ruby", "ruby/rails" ]} >
+  def group(new_group)
+    @groups ||= Set.new
+    return group(group_from_string(new_group)) if new_group.to_s.include?("/")
+
+    group_with_level = [@level, new_group].compact.join("/")
+    @groups << group_with_level
+    return self unless block_given?
+
+    @level = group_with_level
+
+    yield(self)
+    self
+  end
+
+  private
+
+  # Extracts nested groups from a string and sets new level as parent group
+  #   e.g. group_from_string("ruby/rails")
+  def group_from_string(new_group)
+    new_groups = new_group.split("/")
+    @groups << new_groups[0]
+    @level = new_groups.shift
+    new_groups
+  end
+end

data/lib/slimer/substance.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Slimer
+  # A data object Slimer consumes
+  class Substance < Sequel::Model
+    plugin :serialization
+    serialize_attributes :json, :payload
+    serialize_attributes :json, :metadata
+
+    def self.consume(payload, options = {})
+      metadata = options.delete(:metadata)
+      group = options.delete(:group) || Slimer::DEFAULT_GROUP
+
+      Slimer::Workers::IngestSubstance.perform_async(
+        payload,
+        group,
+        metadata
+      )
+    end
+  end
+end

data/lib/slimer/tasks.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "rake"
+
+# Initialize the DB
+Slimer.db
+Dir.glob("#{__dir__}/tasks/*.rake") do |rake_file|
+  load rake_file
+end

data/lib/slimer/tasks/api_keys.rake

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+namespace :slimer do
+  namespace :api_keys do
+    desc "Generate a Slimer API key"
+    task :generate do
+      name = loop do
+        puts "Enter a name for this API key: "
+        new_name = $stdin.gets.chomp
+        break new_name unless new_name.to_s.empty?
+
+        puts "You must enter a name for this API key."
+      end
+
+      puts "Your new Slimer API key for \"#{name}\": #{Slimer::ApiKey.generate(name).token}"
+    end
+  end
+end

data/lib/slimer/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Slimer
+  VERSION = "0.1.1"
+end

data/lib/slimer/web.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "slimer"
+require "slimer/web/helpers"
+
+require "slimer/web/router"
+require "slimer/web/action"
+require "slimer/web/application"
+require "slimer/web/csfr_protection"
+
+require "rack/builder"
+require "rack/content_length"
+require "rack/session/cookie"
+
+# Slimer
+module Slimer
+  # The Slimer web application on Rack
+  # Borrowed from Slidekiq:
+  # https://github.com/mperham/sidekiq/blob/master/lib/sidekiq/web.rb
+  class Web
+    class << self
+      def settings
+        self
+      end
+
+      def middlewares
+        @middlewares ||= []
+      end
+
+      def enable(*opts)
+        opts.each { |key| set(key, true) }
+      end
+
+      def disable(*opts)
+        opts.each { |key| set(key, false) }
+      end
+
+      # Helper for the Sinatra syntax: Slimer::Web.set(:session_secret, Rails.application.secrets...)
+      def set(attribute, value)
+        send(:"#{attribute}=", value)
+      end
+
+      attr_accessor :app_url, :session_secret, :sessions
+    end
+
+    # rubocop:disable Lint/MissingSuper
+    def self.inherited(child)
+      child.app_url = app_url
+      child.session_secret = session_secret
+      child.redis_pool = redis_pool
+      child.sessions = sessions
+    end
+    # rubocop:enable Lint/MissingSuper
+
+    def settings
+      self.class.settings
+    end
+
+    def use(*middleware_args, &block)
+      middlewares << [middleware_args, block]
+    end
+
+    def middlewares
+      @middlewares ||= Web.middlewares.dup
+    end
+
+    def call(env)
+      app.call(env)
+    end
+
+    def self.call(env)
+      @app ||= new
+      @app.call(env)
+    end
+
+    def app
+      @app ||= build
+    end
+
+    def enable(*opts)
+      opts.each { |key| set(key, true) }
+    end
+
+    def disable(*opts)
+      opts.each { |key| set(key, false) }
+    end
+
+    def set(attribute, value)
+      send(:"#{attribute}=", value)
+    end
+
+    # Default values
+    set :sessions, true
+
+    attr_writer :sessions
+
+    def sessions
+      unless instance_variable_defined?("@sessions")
+        @sessions = self.class.sessions
+        @sessions = @sessions.to_hash.dup if @sessions.respond_to?(:to_hash)
+      end
+
+      @sessions
+    end
+
+    def self.register(extension)
+      extension.registered(WebApplication)
+    end
+
+    private
+
+    def using?(middleware)
+      middlewares.any? do |(m, _)|
+        m.is_a?(Array) && (m[0] == middleware || m[0].is_a?(middleware))
+      end
+    end
+
+    def build_sessions
+      middlewares = self.middlewares
+
+      s = sessions
+
+      # turn on CSRF protection if sessions are enabled and this is not the test env
+      middlewares.unshift [[CsrfProtection], nil] if s && !using?(CsrfProtection) && ENV["RACK_ENV"] != "test"
+
+      configure_cookie_middleware if s && !using?(::Rack::Session::Cookie)
+      middlewares.unshift [[::Rack::ContentLength], nil] unless using? ::Rack::ContentLength
+    end
+
+    def configure_cookie_middleware
+      unless (secret = Web.session_secret)
+        require "securerandom"
+        secret = SecureRandom.hex(64)
+      end
+
+      options = { secret: secret }
+      options = options.merge(sessions.to_hash) if sessions.respond_to? :to_hash
+
+      middlewares.unshift [[::Rack::Session::Cookie, options], nil]
+    end
+
+    def build
+      build_sessions
+
+      middlewares = self.middlewares
+      klass = self.class
+
+      ::Rack::Builder.new do
+        middlewares.each { |middleware, block| use(*middleware, &block) }
+
+        run WebApplication.new(klass)
+      end
+    end
+  end
+
+  Slimer::WebApplication.helpers WebHelpers
+end