brut 0.0.1

data/lib/brut/cli/apps/test.rb

@@ -0,0 +1,200 @@
+require "shellwords"
+require "brut/cli"
+
+class Brut::CLI::Apps::Test < Brut::CLI::App
+  description "Run and audit tests of the app"
+  default_command :run
+
+  def before_execute
+    ENV["RACK_ENV"] = "test"
+  end
+
+  class Run < Brut::CLI::Command
+    description "Run non-e2e tests"
+    opts.on("--[no-]rebuild", "If true, test database is rebuilt before tests are run (default false)")
+    opts.on("--[no-]rebuild-after", "If true, test database is rebuilt after tests are run (default false)")
+    opts.on("--seed SEED", "Set the random seed to allow duplicating a test run")
+    args "specs_to_run..."
+
+    def rspec_command
+      parts = [
+        "bin/rspec",
+        "-I", Brut.container.app_specs_dir,
+        "-I", Brut.container.app_src_dir,
+        "-I lib/", # not needed when Brut is gemified
+        rspec_cli_args,
+        "-P \"**/*.spec.rb\"",
+      ]
+      if options.seed
+        parts << "--seed #{options.seed}"
+      end
+      parts.join(" ")
+    end
+
+    def rspec_cli_args = "--tag ~e2e"
+
+    def rebuild_by_default?       = false
+    def rebuild_after_by_default? = false
+
+    def execute
+      Brut.container.sequel_db_handle.disconnect
+      if options.rebuild?(default: rebuild_by_default?)
+        out.puts "Rebuilding test database schema"
+        system! "bin/db rebuild --env=test"
+      end
+      if args.empty?
+        out.puts "Running all tests"
+        system! "#{rspec_command} #{Brut.container.app_specs_dir}/"
+      else
+        test_args = args.map { |_|
+          '"' + Shellwords.escape(_) + '"'
+        }.join(" ")
+        system! "#{rspec_command} #{test_args}"
+      end
+      if options.rebuild_after?(default: rebuild_after_by_default?)
+        out.puts "Re-Rebuilding test database schema"
+        system! "bin/db rebuild --env=test"
+      end
+      0
+    end
+  end
+  class E2e < Run
+    description "Run e2e tests"
+    opts.on("--[no-]rebuild", "If true, test database is rebuilt before tests are run (default true)")
+    opts.on("--[no-]rebuild-after", "If true, test database is rebuilt after tests are run (default true)")
+    opts.on("--seed SEED", "Set the random seed to allow duplicating a test run")
+    args "specs_to_run..."
+
+    def rspec_cli_args = "--tag e2e"
+    def rebuild_by_default?       = true
+    def rebuild_after_by_default? = true
+  end
+  class JS < Brut::CLI::Command
+    description "Run JavaScript unit tests"
+    opts.on("--[no-]build-assets","Build all assets before running the tests")
+    def execute
+      if options.build_assets?
+        system!({ "RACK_ENV" => "test" }, "bin/build-assets")
+      end
+      system!({ "NODE_DISABLE_COLORS" => "1" },"npx mocha #{Brut.container.js_specs_dir} --no-color --extension 'spec.js' --recursive")
+      0
+    end
+  end
+  class Audit < Brut::CLI::Command
+    description "Audits all of the app's classes to see if test files exist"
+
+    opts.on("--ignore PATH[,PATH]","Ignore any files in these paths, relative to app root",Array)
+    opts.on("--type TYPE","Only audit this type of file")
+    opts.on("--show-scaffold","If set, shows the command to scaffold the missing tests")
+
+    def execute
+      app_files = Dir["#{Brut.container.app_src_dir}/**/*"].select { |file|
+        if file.start_with?(Brut.container.app_specs_dir.to_s)
+          false
+        elsif Pathname(file).extname != ".rb"
+          false
+        else
+          true
+        end
+      }
+      audit = app_files.map { |file|
+        Pathname(file)
+      }.select { |pathname|
+        relative_to_root = pathname.relative_path_from(Brut.container.project_root)
+        if options.ignore(default: []).include?(relative_to_root.to_s)
+          false
+        else
+          true
+        end
+      }.map { |pathname|
+        relative = pathname.relative_path_from(Brut.container.app_src_dir)
+        test_file = Brut.container.project_root / "specs" / relative.dirname / "#{relative.basename(relative.extname)}.spec.rb"
+        hash = {
+          source_file: pathname.relative_path_from(Brut.container.project_root),
+          test_file: test_file,
+          test_expected: true,
+        }
+        if pathname.fnmatch?( (Brut.container.components_src_dir / "**").to_s )
+          if pathname.basename.to_s == "app_component.rb"
+            hash[:type] = :infrastructure
+            hash[:test_expected] = false
+          else
+            hash[:type] = :component
+          end
+        elsif pathname.fnmatch?( (Brut.container.forms_src_dir / "**").to_s )
+          if pathname.basename.to_s == "app_form.rb"
+            hash[:type] = :infrastructure
+          else
+            hash[:type] = :form
+          end
+          hash[:test_expected] = false
+        elsif pathname.fnmatch?( (Brut.container.handlers_src_dir / "**").to_s )
+          if pathname.basename.to_s == "app_handler.rb"
+            hash[:type] = :infrastructure
+            hash[:test_expected] = false
+          else
+            hash[:type] = :handler
+          end
+        elsif pathname.fnmatch?( (Brut.container.pages_src_dir / "**").to_s )
+          if pathname.basename.to_s == "app_page.rb"
+            hash[:type] = :infrastructure
+            hash[:test_expected] = false
+          else
+            hash[:type] = :page
+          end
+        elsif pathname.fnmatch?( (Brut.container.back_end_src_dir / "**").to_s )
+          type = pathname.parent.basename.to_s
+          if pathname.basename.to_s == "app_#{type}.rb" ||
+             type == "back_end" ||
+             type == "seed" ||
+             type == "migrations" ||
+             pathname.basename.to_s == "app_data_model.rb" ||
+             pathname.basename.to_s == "db.rb"
+
+            hash[:type] = :infrastructure
+            hash[:test_expected] = false
+          else
+            hash[:type] = type.to_sym
+          end
+        else
+          hash[:type] = :other
+          hash[:test_expected] = false
+        end
+        hash
+      }.compact
+
+      files_missing = []
+      printed_header = false
+      audit.each do |file_audit|
+        if !file_audit[:test_file].exist?
+          if options.audit_type.nil? || file_audit[:type] == options.audit_type
+            if file_audit[:test_expected]
+              files_missing << file_audit[:source_file]
+              if !printed_header
+                out.puts "These files are missing tests:"
+                out.puts ""
+                printed_header = true
+              end
+              out.puts "#{file_audit[:type].to_s.ljust(15)} - #{file_audit[:source_file]}"
+            end
+          end
+        end
+      end
+      if files_missing.empty?
+        out.puts "All tests exists!"
+        0
+      else
+        if options.show_scaffold?
+          out.puts
+          files_missing_args = files_missing.map { |file|
+            '             "' + Shellwords.escape(file.to_s) + '"'
+          }.join(" \\\n")
+
+          out.puts "Run this command to generate empty tests:\n\nbin/scaffold test \\\n#{files_missing_args}"
+        end
+        1
+      end
+    end
+  end
+end
+

data/lib/brut/cli/command.rb

@@ -0,0 +1,130 @@
+require "optparse"
+class Brut::CLI::Command
+  include Brut::CLI::ExecutionResults
+  include Brut::I18n::ForCLI
+
+  def self.description(new_description=nil)
+    if new_description.nil?
+      return @description.to_s
+    else
+      @description = new_description
+    end
+  end
+  def self.detailed_description(new_description=nil)
+    if new_description.nil?
+      if @detailed_description.nil?
+        return @detailed_description
+      end
+      return @detailed_description.to_s
+    else
+      @detailed_description = new_description
+    end
+  end
+  def self.args(new_args=nil)
+    if new_args.nil?
+      return @args.to_s
+    else
+      @args = new_args
+    end
+  end
+  def self.command_name = RichString.new(self.name.split(/::/).last).underscorized
+  def self.name_matches?(string)
+    self.command_name == string || self.command_name.to_s.gsub(/_/,"-") == string
+  end
+  def self.opts
+    self.option_parser
+  end
+  def self.option_parser
+    @option_parser ||= OptionParser.new do |opts|
+      opts.banner = "%{app} %{global_options} #{command_name} %{command_options} %{args}"
+    end
+  end
+
+  def self.requires_project_env(default: "development")
+    default_message = if default.nil?
+                        ""
+                      else
+                        " (default '#{default}')"
+                      end
+    opts.on("--env=ENVIRONMENT","Project environment#{default_message}")
+    @default_env = default
+    @requires_project_env = true
+  end
+
+  def self.default_env           = @default_env
+  def self.requires_project_env? = @requires_project_env
+
+  def initialize(command_options:,global_options:, args:,out:,err:,executor:)
+    @command_options = command_options
+    @global_options  = global_options
+    @args            = args
+    @out             = out
+    @err             = err
+    @executor        = executor
+    if self.class.default_env
+      @command_options.set_default(:env,self.class.default_env)
+    end
+  end
+
+  def system!(*args) = @executor.system!(*args)
+
+  def delegate_to_commands(*command_klasses)
+    result = nil
+    command_klasses.each do |command_klass|
+      result = delegate_to_command(command_klass)
+      if !result.ok?
+        err.puts "#{command_klass.command_name} failed"
+        return result
+      end
+    end
+    result
+  end
+
+  def delegate_to_command(command_klass)
+    command = command_klass.new(command_options: options, global_options:, args:, out:, err:, executor: @executor)
+    as_execution_result(command.execute)
+  end
+
+  def execute
+    raise Brut::Framework::Errors::AbstractMethod
+  end
+
+  def before_execute
+  end
+
+  def set_env_if_needed
+    if self.class.requires_project_env?
+      ENV["RACK_ENV"] = options.env
+    end
+  end
+
+  def handle_bootstrap_exception(ex)
+    raise ex
+  end
+
+  def bootstrap!(project_root:, configure_only:)
+    require "bundler"
+    Bundler.require(:default, ENV["RACK_ENV"].to_sym)
+    if configure_only
+      require "#{project_root}/app/pre_boot"
+      Brut::Framework.new(app: ::App.new)
+    else
+      require "#{project_root}/app/boot"
+    end
+    continue_execution
+  end
+
+private
+
+  def options        = @command_options
+  def global_options = @global_options
+  def args           = @args
+  def out            = @out
+  def err            = @err
+
+  def puts(...)
+    warn("Your CLI apps should use out and err to produce terminal output, not puts", uplevel: 1)
+    Kernel.puts(...)
+  end
+
+end

data/lib/brut/cli/error.rb

@@ -0,0 +1,12 @@
+# Marker that means an expected error happens and
+# we don't need to show the stack trace
+class Brut::CLI::Error < StandardError
+end
+class Brut::CLI::SystemExecError < Brut::CLI::Error
+  attr_reader :command,:exit_status
+  def initialize(command,exit_status)
+    super("#{command} failed - exited #{exit_status}")
+    @command = command
+    @exit_status = exit_status
+  end
+end

data/lib/brut/cli/execution_results.rb

@@ -0,0 +1,81 @@
+module Brut
+  module CLI
+    module ExecutionResults
+      class Result
+        attr_reader :message
+        def initialize(exit_status:,message:nil)
+          @exit_status = exit_status
+          @message = message
+        end
+
+        # Returns true if execution internal to the command should stop
+        def stop?       = @exit_status != 0
+        # Returns true if the execution of the command succeeded or didn't error
+        def ok?         = @exit_status == 0
+        # Returns the exit status to use for the CLI
+        def to_i        = @exit_status
+        def show_usage? = false
+      end
+
+      # Stop execution, even though nothing is wrong
+      class Stop < Result
+        def initialize
+          super(exit_status: 0)
+        end
+        def stop? = true
+      end
+
+      class ShowCLIUsage < Stop
+        attr_reader :command_klass
+        def initialize(command_klass:)
+          super()
+          @command_klass = command_klass
+        end
+        def show_usage? = true
+      end
+
+      # Continue execution
+      class Continue < Result
+        def initialize
+          super(exit_status: 0)
+        end
+      end
+
+      # Abort execution immediately
+      class Abort < Result
+        def initialize(exit_status:1,message:nil)
+          if exit_status == 0
+            raise ArgumentError,"Do not use Abort for a zero exit status"
+          end
+          super(exit_status:,message:)
+        end
+      end
+      class CLIUsageError < Abort
+        def initialize(message:)
+          super(message:,exit_status:65)
+        end
+        def show_usage? = true
+      end
+
+      def stop_execution                         = Stop.new
+      def continue_execution                     = Continue.new
+      def abort_execution(message,exit_status:1) = Abort.new(message:,exit_status:)
+      def cli_usage_error(message)               = CLIUsageError.new(message:)
+      def show_cli_usage(command_klass=nil)      = ShowCLIUsage.new(command_klass:)
+
+      def as_execution_result(exit_status_or_execution_result)
+        if exit_status_or_execution_result.kind_of?(Numeric) || exit_status_or_execution_result.nil?
+          Result.new(exit_status: exit_status_or_execution_result.to_i)
+        elsif exit_status_or_execution_result == true
+          Result.new(exit_status: 0)
+        elsif exit_status_or_execution_result == false
+          Abort.new
+        elsif exit_status_or_execution_result.kind_of?(Result)
+          exit_status_or_execution_result
+        else
+          raise ArgumentError,"Your method returned a #{exit_status_or_execution_result.class} when it should return an exit status or one of the methods from ExecutionResults"
+        end
+      end
+    end
+  end
+end

data/lib/brut/cli/executor.rb

@@ -0,0 +1,37 @@
+require "open3"
+class Brut::CLI::Executor
+  def initialize(out:,err:)
+    @out = out
+    @err = err
+  end
+  def system!(*args)
+    @out.puts "Executing #{args}"
+    wait_thread = Open3.popen3(*args) do |_stdin,stdout,stderr,wait_thread|
+      o = stdout.read_nonblock(10, exception: false)
+      e = stderr.read_nonblock(10, exception: false)
+      while o || e
+        if o
+          if o != :wait_readable
+            @out.print o
+            @out.flush
+          end
+          o = stdout.read_nonblock(10, exception: false)
+        end
+        if e
+          if e != :wait_readable
+            @err.print e
+            @err.flush
+          end
+          e = stderr.read_nonblock(10, exception: false)
+        end
+      end
+      wait_thread
+    end
+    if wait_thread.value.success?
+      @out.puts "#{args} succeeded"
+    else
+      raise Brut::CLI::SystemExecError.new(*args,wait_thread.value.exitstatus)
+    end
+    true
+  end
+end

data/lib/brut/cli/options.rb

@@ -0,0 +1,46 @@
+# Convienience module to put into Hash to allow options
+# parsed to be a bit more accessible
+class Brut::CLI::Options
+  def initialize(parsed_options)
+    @parsed_options = parsed_options
+    @defaults = {}
+  end
+
+  def to_h = @parsed_options
+
+  def [](key) = @parsed_options[key]
+  def key?(key) = @parsed_options.key?(key)
+  def set_default(sym,default_value)
+    @defaults[sym] = default_value
+  end
+
+  def method_missing(sym,*args,&block)
+    boolean = false
+    if sym.to_s =~ /\?$/
+      sym = sym.to_s[0..-2].to_sym
+      boolean = true
+    end
+
+    sym_underscore = sym.to_s.gsub(/\-/,"_").to_sym
+    sym_dash       = sym.to_s.gsub(/_/,"-").to_sym
+
+    value = if self.key?(sym_underscore)
+              self[sym_underscore]
+            elsif self.key?(sym_dash)
+              self[sym_dash]
+            elsif args[0].kind_of?(Hash) && args[0].key?(:default)
+              return args[0][:default]
+            elsif @defaults.key?(sym_underscore)
+              @defaults[sym_underscore]
+            elsif @defaults.key?(sym_dash)
+              @defaults[sym_dash]
+            else
+              nil
+            end
+    if boolean
+      !!value
+    else
+      value
+    end
+  end
+end

data/lib/brut/cli/output.rb

@@ -0,0 +1,30 @@
+class Brut::CLI::Output
+  def initialize(io:, prefix:)
+    @io          = io
+    @prefix      = prefix
+    @sync_status = @io.sync
+  end
+
+  def puts_no_prefix(*objects)
+    @io.puts(*objects)
+  end
+
+  def puts(*objects)
+    if objects.empty?
+      objects << ""
+    end
+    objects.each do |object|
+      @io.puts(@prefix + object.to_s)
+    end
+    nil
+  end
+
+  def print(*objects)
+    @io.print(*objects)
+  end
+
+  def flush
+    @io.flush
+    self
+  end
+end

data/lib/brut/cli.rb

@@ -0,0 +1,24 @@
+module Brut
+  module CLI
+
+    def self.app(app_klass, project_root:)
+      Brut::CLI::AppRunner.new(app_klass:,project_root:).run!
+    end
+    autoload(:App, "brut/cli/app")
+    autoload(:Command, "brut/cli/command")
+    autoload(:Error, "brut/cli/error")
+    autoload(:SystemExecError, "brut/cli/error")
+    autoload(:ExecutionResults, "brut/cli/execution_results")
+    autoload(:Options, "brut/cli/options")
+    autoload(:Output, "brut/cli/output")
+    autoload(:Executor, "brut/cli/executor")
+    autoload(:AppRunner, "brut/cli/app_runner")
+    module Apps
+      autoload(:DB,"brut/cli/apps/db")
+      autoload(:DB,"brut/cli/apps/test")
+      autoload(:DB,"brut/cli/apps/build_assets")
+      autoload(:DB,"brut/cli/apps/scaffold")
+    end
+  end
+end
+require_relative "i18n"

data/lib/brut/factory_bot.rb

@@ -0,0 +1,20 @@
+# Because FactoryBot 6.4.6 has a bug where it is not properly
+# requiring active support, active supporot must be required first,
+# then factory bot.  When 6.4.7 is released, this can be removed. See Gemfile
+require "active_support"
+require "factory_bot"
+require "faker"
+
+class Brut::FactoryBot
+  def setup!
+    Faker::Config.locale = :en
+    FactoryBot.definition_file_paths = [
+      Brut.container.app_specs_dir / "factories"
+    ]
+    FactoryBot.define do
+      to_create { |instance| instance.save }
+    end
+    FactoryBot.find_definitions
+
+  end
+end

data/lib/brut/framework/app.rb

@@ -0,0 +1,55 @@
+# An "App" in Brut paralance is the collection of source code and configure that is needed to operate
+# a website. This includes everything needed to serve HTTP requests, but also includes ancillary
+# tasks and any related files required for the app to exist and function.
+class Brut::Framework::App
+
+  # An identifier for this app that can be used as a hostname
+  def id = raise "Subclass must implement"
+
+  # An identifier for the app's 'organization' that can be used as a hostname.
+  # This isn't relevant in all contexts, but is useful for deploys or other
+  # actions where an app needs to exist inside some organizational context.
+  def organization = id
+
+  def self.routes(&block)
+    @routes_blocks ||= []
+    if block.nil?
+      @routes_blocks
+    else
+      @routes_blocks << block
+    end
+  end
+  def self.middleware(middleware=nil,*args,&block)
+    @middlewares ||= []
+    if middleware.nil? && args.empty? && block.nil?
+      @middlewares
+    else
+      @middlewares << [ middleware, args, block ]
+    end
+  end
+  def self.before(klass_name=nil)
+    @before ||= []
+    if klass_name.nil?
+      @before
+    else
+      @before << klass_name
+    end
+  end
+  def self.after(klass_name=nil)
+    @after ||= []
+    if klass_name.nil?
+      @after
+    else
+      @after << klass_name
+    end
+  end
+
+  # Override this to set up any runtime connections or execute other pre-flight
+  # code required *after* Brut has been set up and started.  You can rely on the
+  # database being available. Any attempts to override configuration values
+  # may not succeed.  This is called after the framework has booted, but before
+  # your apps routes are set up.
+  def boot!
+  end
+
+end