brut 0.0.1

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

@@ -0,0 +1,279 @@
+require "sequel"
+require "uri"
+require "date"
+require "brut/cli"
+
+class Brut::CLI::Apps::DB < Brut::CLI::App
+  description "Manage your database in development, test, and production"
+
+  class Seed < Brut::CLI::Command
+    description "Load seed data into the database"
+    requires_project_env default: "development"
+
+    def handle_bootstrap_exception(ex)
+      case ex
+      when Sequel::DatabaseConnectionError
+        err.puts "Database needs to be created"
+        stop_execution
+      when Sequel::DatabaseError
+        if ex.cause.kind_of?(PG::UndefinedTable)
+          err.puts "Migrations need to be run"
+          stop_execution
+        else
+          super
+        end
+      else
+        super
+      end
+    end
+
+    def execute
+      seeds_dir = Brut.container.db_seeds_dir
+      Dir["#{seeds_dir}/*.rb"].each do |file|
+        require file
+      end
+      seed_data = Brut::Backend::SeedData.new
+      seed_data.setup!
+      seed_data.load_seeds!
+      0
+    rescue Sequel::UniqueConstraintViolation => ex
+      out.puts "Seed data may have already been loaded: #{ex}"
+    end
+  end
+
+  class Rebuild < Brut::CLI::Command
+    description "Drop, re-create, and run migrations, effecitvely rebuilding the entire database"
+    opts.on("--[no-]seeds","Load seed data after applying migrations")
+
+    requires_project_env default: "development"
+
+    def handle_bootstrap_exception(ex)
+      case ex
+      when Sequel::DatabaseConnectionError
+        continue_execution
+      when Sequel::DatabaseError
+        if ex.cause.kind_of?(PG::UndefinedTable)
+          continue_execution
+        else
+          super
+        end
+      else
+        super
+      end
+    end
+
+    def execute
+      result = delegate_to_commands(Drop, Create, Migrate)
+      if result.ok? && options.seeds?
+        result = delegate_to_command(Seed)
+      end
+      result
+    end
+  end
+
+  class Create < Brut::CLI::Command
+    description "Create the database if it does not exist"
+    requires_project_env default: "development"
+
+    def handle_bootstrap_exception(ex)
+      case ex
+      when Sequel::DatabaseConnectionError
+        uri_no_database = URI(Brut.container.database_url.to_s)
+        database_name = uri_no_database.path.gsub(/^\//,"")
+        uri_no_database.path = ""
+        begin
+          connection = Sequel.connect(uri_no_database.to_s)
+          out.puts "#{database_name} does not exit. Creating..."
+          connection.run("CREATE DATABASE \"#{database_name}\"")
+          connection.disconnect
+        rescue => ex
+          err.puts ex.message
+        end
+        stop_execution
+      when Sequel::DatabaseError
+        if ex.cause.kind_of?(PG::UndefinedTable)
+          out.puts "Migrations need to be run"
+          continue_execution
+        else
+          super
+        end
+      else
+        super
+      end
+    end
+    def execute
+      connection = Sequel.connect(Brut.container.database_url)
+      out.puts "Database already exists"
+      connection.disconnect
+      0
+    rescue => ex
+      handle_bootstrap_exception(ex)
+    end
+  end
+
+  class Drop < Brut::CLI::Command
+    description "Drop the database if it exists"
+    requires_project_env default: "development"
+
+    def handle_bootstrap_exception(ex)
+      case ex
+      when Sequel::DatabaseConnectionError
+        out.puts "Database does not exist"
+        stop_execution
+      when Sequel::DatabaseError
+        if ex.cause.kind_of?(PG::UndefinedTable)
+          continue_execution
+        else
+          super
+        end
+      else
+        super
+      end
+    end
+
+    def execute
+      uri_no_database = URI(Brut.container.database_url.to_s)
+      database_name = uri_no_database.path.gsub(/^\//,"")
+      uri_no_database.path = ""
+      out.puts "Database exists. Dropping..."
+      begin
+        Brut.container.sequel_db_handle.disconnect
+      rescue Sequel::DatabaseConnectionError
+      end
+      connection = Sequel.connect(uri_no_database.to_s)
+      connection.run("DROP DATABASE IF EXISTS \"#{database_name}\"")
+      connection.disconnect
+      0
+    rescue => ex
+      handle_bootstrap_exception(ex)
+    end
+  end
+
+  class Migrate < Brut::CLI::Command
+    description "Apply any outstanding migrations to the database"
+    requires_project_env default: "development"
+
+    def handle_bootstrap_exception(ex)
+      case ex
+      when Sequel::DatabaseConnectionError
+        err.puts "Database does not exist. Create it first"
+        stop_execution
+      when Sequel::DatabaseError
+        if ex.cause.kind_of?(PG::UndefinedTable)
+          # ignoring - we are running migrations which will address this
+          continue_execution
+        else
+          super
+        end
+      else
+        super
+      end
+    end
+
+    def execute
+      Sequel.extension :migration
+      Brut.container.sequel_db_handle.extension :brut_migrations
+      migrations_dir = Brut.container.migrations_dir
+      if !migrations_dir.exist?
+        err.puts "#{migrations_dir} doesn't exist"
+        return
+      end
+      Brut.container.sequel_db_handle.extension :pg_array
+
+      logger = Logger.new(STDOUT)
+      logger.level = ENV["LOG_LEVEL"]
+      indent = ""
+      logger.formatter = proc { |severity,time,progname,message|
+        formatted = "#{indent} - #{message}\n"
+        if message =~ /^Begin applying/
+          indent = "   "
+        elsif message =~ /^Finished applying/
+          indent = ""
+          formatted = "#{indent} - #{message}\n"
+        end
+        formatted
+      }
+      Brut.container.sequel_db_handle.logger = logger
+      Sequel::Migrator.run(Brut.container.sequel_db_handle,migrations_dir)
+      out.puts "Migrations applied"
+    end
+  end
+
+  class NewMigration < Brut::CLI::Command
+    description "Create a new migration file"
+    args "migration_name"
+
+    def before_execute
+      ENV["RACK_ENV"] = "development"
+    end
+
+    def execute
+      if @args.length == 0
+        return abort_execution("You must provide a name for the migration")
+      end
+      migrations_dir = Brut.container.migrations_dir
+      name = @args.join(" ").gsub(/[^\w\d\-]/,"-")
+      date = DateTime.now.strftime("%Y%m%d%H%M%S")
+      file_name = migrations_dir / "#{date}_#{name}.rb"
+      File.open(file_name,"w") do |file|
+        file.puts "Sequel.migration do"
+        file.puts "  up do"
+        file.puts "  end"
+        file.puts "end"
+      end
+      relative_path = file_name.relative_path_from(Brut.container.project_root)
+      out.puts "Migration created:\n    #{relative_path}"
+    end
+  end
+
+  class Status < Brut::CLI::Command
+    description "Check the status of the database and migrations"
+    requires_project_env default: "development"
+
+    def handle_bootstrap_exception(ex)
+      case ex
+      when Sequel::DatabaseConnectionError
+        uri_no_database = URI(Brut.container.database_url.to_s)
+        database_name = uri_no_database.path.gsub(/^\//,"")
+        uri_no_database.path = ""
+        begin
+          connection = Sequel.connect(uri_no_database.to_s)
+          out.puts "Database Server is Up"
+          out.puts "Database #{database_name} does not exist"
+        rescue => ex
+          err.puts ex.message
+        end
+        stop_execution
+      when Sequel::DatabaseError
+        if ex.cause.kind_of?(PG::UndefinedTable)
+          err.puts "Migrations need to be run"
+          continue_execution
+        else
+          super
+        end
+      end
+    end
+
+    def execute
+      database_name = URI(Brut.container.database_url).path
+      connection = Brut.container.sequel_db_handle
+      out.puts "Database Server is Up"
+      out.puts "Database #{database_name} exists"
+      migrations_run = if connection.table_exists?("schema_migrations")
+                         connection["select filename from schema_migrations order by filename"].all.map { |_| _[:filename] }
+                       else
+                         []
+                       end
+      migration_files = Dir[Brut.container.migrations_dir / "*.rb"].map { |file|
+        filename = Pathname(file).basename.to_s
+      }
+      max_length = migration_files.map(&:length).max
+      printf_string = "%-#{max_length}s - %s\n"
+      migration_files.each do |filename|
+        applied = migrations_run.include?(filename)
+        printf(printf_string,filename,applied ? "✅ APPLIED" : "❌ NOT APPLIED")
+      end
+      0
+    end
+  end
+end

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

@@ -0,0 +1,256 @@
+require "brut/cli"
+
+class Brut::CLI::Apps::Scaffold < Brut::CLI::App
+  description "Create scaffolds of various files to help develop more quckly"
+  opts.on("--overwrite", "If set, any files that exists already will be overwritten by new scaffolds")
+  opts.on("--dry-run", "If set, no files are changed. You will see output of what would happen without this flag")
+
+  def before_execute
+    ENV["RACK_ENV"] = "development"
+  end
+
+  class Test < Brut::CLI::Command
+    description "Create a test for a given file in the app"
+    args "source_file_paths..."
+    def execute
+      if args.empty?
+        err.puts "'test' requires one or more files to scaffold a test for"
+        return 1
+      end
+      files_to_test_files = args.map { |arg|
+        Pathname(arg).expand_path
+      }.map { |pathname|
+        relative = pathname.relative_path_from(Brut.container.app_src_dir)
+        test_file = Brut.container.app_specs_dir / relative.dirname / "#{relative.basename(relative.extname)}.spec.rb"
+        [ pathname, test_file ]
+      }.to_h
+
+      non_existent_sources  = files_to_test_files.keys.select   { |pathname| !pathname.exist? }
+      existent_destinations = files_to_test_files.values.select { |pathname| pathname.exist? }
+
+      if non_existent_sources.any?
+        relative_paths = non_existent_sources.map { |pathname| pathname.relative_path_from(Brut.container.project_root) }
+        err.puts "Not all input files exist:"
+        relative_paths.each do |file|
+          err.puts file
+        end
+        return 1
+      end
+
+      if existent_destinations.any? && !global_options.overwrite?
+        relative_paths = existent_destinations.map { |pathname| pathname.relative_path_from(Brut.container.project_root) }
+        err.puts "Some files to be generated already exist. Set --overwrite to overwrite them:"
+        relative_paths.each do |file|
+          err.puts file
+        end
+        return 1
+      end
+
+      files_to_test_files.each do |source,destination|
+        result = Prism.parse_file(source.to_s)
+        if !result
+          raise "For some reason Prism did not parse #{source.to_s}"
+        end
+        classes = find_classes(result.value).map { |(module_nodes,class_node)|
+          (module_nodes.map(&:constant_path).map(&:full_name).map(&:to_s) + [class_node.constant_path.full_name.to_s]).compact.join("::")
+        }
+
+
+        out.puts "#{destination} will contain tests for:\n#{classes.join("\n")}\n\n"
+
+        code = ["require \"spec_helper\"\n"] + classes.map { |class_name|
+          %{RSpec.describe #{class_name} do
+  it "should have tests" do
+    expect(false).to eq(true)
+  end
+end}
+        }
+
+        if global_options.dry_run?
+          puts code
+        else
+          FileUtils.mkdir_p destination.dirname
+          File.open(destination,"w") do |file|
+            file.puts code
+          end
+        end
+      end
+
+      0
+    end
+
+  private
+
+    def find_classes(ast,current_modules = [])
+      classes = []
+      if ast.nil?
+        return classes
+      end
+      new_module = nil
+      if ast.kind_of?(Prism::ClassNode)
+        classes << [ current_modules, ast ]
+        new_module = ast
+      elsif ast.kind_of?(Prism::ModuleNode)
+        new_module = ast
+      end
+      ast.child_nodes.each do |child|
+        new_current_modules = current_modules + [ new_module ]
+        result = find_classes(child, new_current_modules.compact)
+        classes = classes + result
+      end
+      classes
+    end
+
+  end
+  class Component < Brut::CLI::Command
+    description "Create a new component, template, and associated test"
+    opts.on("--page","If set, this component is for a specific page and won't go with the other components")
+    args "ComponentName"
+    def execute
+      if args.length != 1
+        raise "component requires exactly one argument, got #{args.length}"
+      end
+      class_name = RichString.new(args[0])
+      if class_name.to_s !~ /Component$/
+        class_name = RichString.new(class_name.to_s + "Component")
+      end
+
+      relative_path = class_name.underscorized
+
+      components_src_dir   = Brut.container.components_src_dir
+      components_specs_dir = Brut.container.components_specs_dir
+
+      if options.page?
+        components_src_dir   = Brut.container.pages_src_dir
+        components_specs_dir = Brut.container.pages_specs_dir
+        if class_name.to_s !~ /::/
+          raise "component #{class_name} cannot be a page component - it must be an inner class of an existing page"
+        else
+          existing_page = RichString.new(class_name.to_s.split(/::/)[0..-2].join("::")).underscorized.to_s + ".rb"
+
+          if !(components_src_dir / existing_page).exist?
+            raise "#{class_name} was set as a page component, however we cannot find the page it belongs in.  File #{existing_page} does not exist and should contain that page"
+          end
+        end
+      end
+
+      source_path      = Pathname( (components_src_dir / relative_path).to_s + ".rb" )
+      html_source_path = Pathname( (components_src_dir / relative_path).to_s + ".html.erb" )
+      spec_path        = Pathname( (components_specs_dir / relative_path).to_s + ".spec.rb" )
+
+      exists = [
+        source_path,
+        html_source_path,
+        spec_path,
+      ].select(&:exist?)
+
+      if exists.any? && !global_options.overwrite?
+        exists.each do |path|
+          err.puts "'#{path.relative_path_from(Brut.container.project_root)}' exists already"
+        end
+        err.puts "Re-run with --overwrite to overwrite these files"
+        return 1
+      end
+
+      if global_options.dry_run?
+        puts "FileUtils.mkdir_p #{source_path.dirname}"
+        puts "FileUtils.mkdir_p #{html_source_path.dirname}"
+        puts "FileUtils.mkdir_p #{spec_path.dirname}"
+      else
+        FileUtils.mkdir_p source_path.dirname
+        FileUtils.mkdir_p html_source_path.dirname
+        FileUtils.mkdir_p spec_path.dirname
+
+        File.open(source_path,"w") do |file|
+          file.puts %{class #{class_name} < AppComponent
+  def initialize
+  end
+end}
+        end
+        File.open(html_source_path,"w") do |file|
+          file.puts "<h1>#{class_name} is ready!</h1>"
+        end
+        File.open(spec_path,"w") do |file|
+          file.puts %{require "spec_helper"
+
+RSpec.describe #{class_name} do
+  it "should have tests" do
+    expect(true).to eq(false)
+  end
+end}
+        end
+      end
+      out.puts "Component source is in        #{source_path.relative_path_from(Brut.container.project_root)}"
+      out.puts "Component HTML template is in #{html_source_path.relative_path_from(Brut.container.project_root)}"
+      out.puts "Component test is in          #{spec_path.relative_path_from(Brut.container.project_root)}"
+      0
+    end
+  end
+  class CustomElementTest < Brut::CLI::Command
+    description "Create a test for a custom element in your app"
+    args "path_to_js_files..."
+    def execute
+      if args.empty?
+        err.puts "'custom-element-test' requires one or more files to scaffold a test for"
+        return 1
+      end
+
+      if args.any? { |file| Pathname(file).extname != ".js" }
+        err.puts "'custom-element-test' must be given only .js files"
+        return 1
+      end
+
+      files_to_create = args.map { |arg|
+        path = Pathname(arg).expand_path
+        relative_path = path.relative_path_from(Brut.container.js_src_dir)
+        relative_path_as_spec = relative_path.dirname / (relative_path.basename(relative_path.extname).to_s + ".spec.js")
+        spec_path = Brut.container.js_specs_dir / relative_path_as_spec
+        [ path, spec_path ]
+      }
+
+      existing_files = files_to_create.select { |_,spec|
+        spec.exist?
+      }
+
+      if existing_files.any? && !global_options.overwrite?
+        relative_paths = existing_files.map { |_,pathname| pathname.relative_path_from(Brut.container.project_root) }
+        err.puts "Some files to be generated already exist. Set --overwrite to overwrite them:"
+        relative_paths.each do |file|
+          err.puts file
+        end
+        return 1
+      end
+
+      files_to_create.each do |source_file, spec_file|
+        source_class = source_file.basename(source_file.extname)
+        tag_name = File.read(source_file).split(/\n/).map { |line|
+          if line =~ /static\s+tagName\s*=\s*\"([^"]+)\"/
+            "<#{$1}>"
+          else
+            nil
+          end
+        }.compact.first
+        description = tag_name || source_class
+        code =  %{import { withHTML } from "brut-js/testing/index.js"
+
+describe("#{description}", () => {
+  withHTML(`
+  #{ tag_name ? "#{tag_name}" : "<!-- HTML here -->" }
+  #{ tag_name ? "#{tag_name.gsub(/^</,'</')}" : "" }
+  `).test("description here", ({document,window,assert}) => {
+    assert.fail("test goes here")
+  })
+})}
+        if global_options.dry_run?
+          out.puts "Would generate this code:\n\n#{code}"
+        else
+          File.open(spec_file, "w") do |file|
+            file.puts code
+          end
+        end
+      end
+
+      0
+    end
+  end
+end