mkbrut 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8d93e08e9f662468dd47a79c11c2afa36144905bfdf52e8fe54d209f99940557
+  data.tar.gz: 5911070cfefab0d42f46d19c5676bdce3f6bc0c63d386adab09d1995778f274c
+SHA512:
+  metadata.gz: efae7e39b7ebe46371308cd83098d26a0ac12c637e76988b37ccc43c4271b58d74a1575f52ee451e821a3b410b2dad268807bafac5d7797aa99d6a4c63705e88
+  data.tar.gz: 8ec79d1512d8552e72e86534f72cd9750c3fc236a3224a98b195b062f1fffa90ad56eaafd5f2d0b3a6aa877296dfe6674a212fb76bbd125a43ab1d475e81df1d

data/README.md

@@ -0,0 +1,51 @@
+# mkbrut - Create a new Brut App
+
+`mkbrut` is how you go from zero to having a Brut app where you can start working.
+
+## Installation
+
+TBD
+
+## Usage
+
+```
+mkbrut my-new-app
+```
+
+This will create a new Brut app, including a development environment.  The app will
+have some demo features to show you around the framework.
+
+To get a bare bones new app, use `--no-demo`:
+
+```
+mkbrut my-new-app --no-demo
+```
+
+You can also customize some aspects of your app once start to have an opinion about
+it:
+
+
+```
+mkbrut --app-id=new-app \
+       --organization=cyberdyne \
+       --prefix=ap \
+       my-new-app
+```
+
+* `--app-id` The identifier for your app, suitable for use as a hostname or other internet-safe identifier.
+* `--organization` This is your organization name you might use on GitHub, DockerHub, or WhateverHub.
+* `--prefix` The two-character prefix for all external IDs of your database tables that opt into external IDs as well as any autonomous custom elements you might make
+
+## Developing
+
+`mkbrut` has a Docker-based dev environment:
+
+1. Install Docker
+2. `dx/build`
+3. `dx/start`
+4. Open a new terminal:
+   1. `dx/exec bash`
+   2. You are now inside a running Docker container:
+      1. `bin/setup`
+      2. `bundle exec exe/mkbrut -h`
+

data/exe/mkbrut

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "mkbrut"
+
+exit MKBrut::CLI.new(args: ARGV).run

data/lib/mkbrut/app.rb

@@ -0,0 +1,67 @@
+require "fileutils"
+require "erb"
+require "ostruct"
+
+module MKBrut
+  class App
+    def initialize(current_dir:, app_options:, out:, err:)
+      @out = out
+      @app_options = app_options
+
+      @out.puts "Creating app with these options:\n"
+      @out.puts "App name:      #{app_options.app_name}"
+      @out.puts "App ID:        #{app_options.app_id}"
+      @out.puts "Prefix:        #{app_options.prefix}"
+      @out.puts "Organization:  #{app_options.organization}"
+      @out.puts "Include demo?  #{app_options.demo}\n"
+
+      if app_options.dry_run?
+        @out.puts "Dry Run"
+        MKBrut::Ops::BaseOp.dry_run = true
+      end
+
+      templates_dir = Pathname(
+        Gem::Specification.find_by_name("mkbrut").gem_dir
+      ) / "templates"
+
+      @base = MKBrut::Base.new(
+        app_options:,
+        current_dir:,
+        templates_dir:
+      )
+      @segments = [
+        MKBrut::Segments::BareBones.new(
+          app_options:,
+          current_dir:,
+          templates_dir:,
+        )
+      ]
+      if app_options.demo?
+        @segments << MKBrut::Segments::Demo.new(
+          app_options:,
+          current_dir:,
+          templates_dir:
+        )
+      end
+    end
+
+    def create!
+      @out.puts "Creating Base app"
+      @base.create!
+      @segments.each do |segment|
+        @out.puts "Creating segment: #{segment.class.friendly_name}"
+        segment.add!
+      end
+      @out.puts "#{@app_options.app_name} was created\n\n"
+      @out.puts "Time to get building:"
+      @out.puts "1. cd #{@app_options.app_name}"
+      @out.puts "2. dx/build"
+      @out.puts "3. dx/start"
+      @out.puts "4. [ in another terminal ] dx/exec bash"
+      @out.puts "5. [ inside the Docker container ] bin/setup"
+      @out.puts "6. [ inside the Docker container ] bin/dev"
+      @out.puts "7. Visit http://localhost:6502 in your browser"
+      @out.puts "8. [ inside the Docker container ] bin/setup help # to see more commands"
+    end
+  end
+end

data/lib/mkbrut/app_id.rb

@@ -0,0 +1,8 @@
+class MKBrut::AppId < MKBrut::InternetIdentifier
+  def self.from_app_name(app_name)
+    self.new(app_name.to_s.gsub(/[^a-zA-Z0-9\-]/, "-").downcase)
+  end
+  def initialize(value)
+    super(:app_id, value)
+  end
+end

data/lib/mkbrut/app_name.rb

@@ -0,0 +1,29 @@
+module MKBrut
+  class AppName
+    def initialize(value)
+      identifier = value.to_s
+      if identifier.empty?
+        raise MKBrut::InvalidIdentifier, "app-name is required"
+      end
+
+      if identifier.length > 63
+        raise MKBrut::InvalidIdentifier, "app-name cannot be longer than 63 characters"
+      end
+
+      if identifier.start_with?("-") || identifier.end_with?("-")
+        raise MKBrut::InvalidIdentifier, "app-name cannot start or end with a hyphen"
+      end
+
+      if identifier.match?(/[^a-zA-Z\-_]/)
+        raise MKBrut::InvalidIdentifier, "app-name can only contain letters, hyphens, and underscores"
+      end
+      if identifier.match?(/__/) || identifier.match?(/--/)
+        raise MKBrut::InvalidIdentifier, "app-name can not have repeating underscores or hyphens"
+      end
+      @identifier = identifier.to_s.gsub(/_/,"-")
+    end
+
+    def to_s = @identifier
+    alias to_str to_s
+  end
+end

data/lib/mkbrut/app_options.rb

@@ -0,0 +1,29 @@
+class MKBrut::AppOptions
+  attr_reader :app_name, :app_id, :prefix, :organization, :demo, :versions
+
+  def initialize(
+    app_name:,
+    app_id: nil,
+    prefix: nil,
+    dry_run: nil,
+    organization: nil,
+    demo: false,
+    versions: nil,
+    **ignore
+  )
+    if app_name.nil?
+      raise ArgumentError, "app_name is required"
+    end
+
+    @app_name     =   app_name
+    @app_id       =   app_id       || MKBrut::AppId.from_app_name(@app_name)
+    @prefix       =   prefix       || MKBrut::Prefix.from_app_id(@app_id)
+    @organization =   organization || @app_id
+    @dry_run      = !!dry_run
+    @demo         = !!demo
+    @versions     =   versions
+  end
+
+  def dry_run? = @dry_run
+  def demo?    = @demo
+end

data/lib/mkbrut/base.rb

@@ -0,0 +1,57 @@
+require "pathname"
+require "securerandom"
+# Constructs the base of any Brut app.
+class MKBrut::Base
+  include MKBrut
+
+  class ErbBinding < MKBrut::ErbBindingDelegate
+    def session_secret = SecureRandom.hex(64)
+  end
+
+  def initialize(app_options:, current_dir:, templates_dir:)
+    @project_root  = current_dir / app_options.app_name
+    @templates_dir = templates_dir / "Base"
+    @erb_binding   = ErbBinding.new(app_options)
+  end
+
+  def create!
+    if @project_root.exist?
+      raise "Project root #{@project_root} already exists"
+    end
+    operations = [ Ops::Mkdir.new(@project_root) ]           + 
+                   copy_files(@templates_dir, @project_root)
+
+    operations.each do |operation|
+      operation.call
+    end
+  end
+
+private
+
+  def filenames_to_always_skip = [ "README.md", "mkicons.sh" ]
+
+  def copy_files(source_dir, destination_root)
+    operations = []
+    Dir.glob("#{source_dir}/*", flags: File::FNM_DOTMATCH).each do |template_file|
+      template_file = Pathname(template_file)
+      if [ ".", ".." ].include?(template_file.basename.to_s)
+        next
+      end
+      if template_file.directory?
+        operations << Ops::Mkdir.new(destination_root / template_file.basename)
+        operations += copy_files(template_file, destination_root / template_file.basename)
+      elsif template_file.extname == ".erb"
+        operations << Ops::RenderTemplate.new(
+          template_file,
+          destination_root:,
+          erb_binding: @erb_binding
+        )
+      elsif filenames_to_always_skip.include?(template_file.basename.to_s)
+        operations << Ops::SkipFile.new(template_file)
+      else
+        operations << Ops::CopyFile.new(template_file, destination_root:)
+      end
+    end
+    operations
+  end
+end

data/lib/mkbrut/cli.rb

@@ -0,0 +1,91 @@
+require "optparse"
+require "pathname"
+
+module MKBrut
+  class CLI
+    def initialize(args:, out: $stdout, err: $stderr)
+      @args    = args
+      @out     = out
+      @err     = err
+    end
+
+    def run
+
+      app_options = parse_options(@args, MKBrut::Versions.new)
+      new_app = MKBrut::App.new(
+        current_dir: Pathname.pwd.expand_path,
+        app_options:,
+        out: PrefixedIO.new(@out, "mkbrut"),
+        err: @err
+      )
+      new_app.create!
+      0
+    rescue => e
+      @err.puts "Error: #{e.message}"
+      if ENV["BRUT_CLI_RAISE_ON_ERROR"] == "true"
+        raise
+      end
+      1
+    end
+
+    def show_help
+      @out.puts @option_parser
+      @out.puts
+      @out.puts "ARGUMENTS"
+      @out.puts
+      @out.puts "    app-name - name for your app, which will be the folder where your app's files are created"
+      @out.puts
+      @out.puts "ENVIRONMENT VARIABLES"
+      @out.puts
+      @out.puts "  BRUT_CLI_RAISE_ON_ERROR - if set to 'true', any error will raise an exception instead of printing to stderr"
+      @out.puts
+
+    end
+
+  private
+
+
+    def parse_options(args, versions)
+      options = {}
+      @option_parser = OptionParser.new do |opts|
+        opts.accept(MKBrut::Prefix) do |prefix|
+          MKBrut::Prefix.new(prefix)
+        end
+        opts.accept(MKBrut::AppId) do |prefix|
+          MKBrut::AppId.new(prefix)
+        end
+        opts.accept(MKBrut::Organization) do |prefix|
+          MKBrut::Organization.new(prefix)
+        end
+        opts.banner = "Usage: mkbrut [options] app-name\n\n    Creates a new Brut-powered app\n\nOPTIONS\n\n"
+
+        opts.on("-a", "--app-id=ID", MKBrut::AppId,
+                "App identifier, which must be able to be used as a hostname or other Internet identifier. Derived from your app name, if omitted")
+
+        opts.on("-o", "--organization=ORG",MKBrut::Organization,
+                "Organization name, e.g. what you'd use for GitHub. Defaults to the app-id value")
+
+        opts.on("-e", "--prefix=PREFIX", MKBrut::Prefix,
+                "Two-character prefix for external IDs and autonomous custom elements. Derived from your app-id, if omitted.")
+
+        opts.on("--dry-run", "Only show what would happen, don't actually do anything")
+        opts.on("--[no-]demo", "Include, or not, additional files that demonstrate Brut's features (default is true for now")
+        opts.on("-h", "--help", "Show this help message") do
+          show_help
+          exit
+        end
+      end
+
+      @option_parser.parse!(args, into: options)
+      if !options.key?(:demo)
+        options[:demo] = true
+      end
+
+      options[:app_name] = MKBrut::AppName.new(args.first)
+      options[:app_id] = options[:'app-id']
+      options[:dry_run] = !!options[:'dry-run']
+      MKBrut::AppOptions.new(**options.merge(versions:))
+    end
+
+  end
+end 

data/lib/mkbrut/erb_binding_delegate.rb

@@ -0,0 +1,20 @@
+# This exists because ERB can't working with a SimpleDelegator or
+# Delegate.
+class MKBrut::ErbBindingDelegate
+  def initialize(app_options)
+    @app_options = app_options
+  end
+
+  # Not using Delegate because it won't work with ERB binding
+  def method_missing(syn,*args,&block)
+    if args.empty? && @app_options.respond_to?(syn)
+      @app_options.send(syn)
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(syn,include_all)
+    @app_options.respond_to?(syn)
+  end
+end

data/lib/mkbrut/internet_identifier.rb

@@ -0,0 +1,32 @@
+module MKBrut
+  class InternetIdentifier
+    def initialize(name, value)
+      @name = name
+      @identifier = value.to_s
+      validate_identifier
+    end
+
+    def to_s = @identifier
+    alias to_str to_s
+
+  private
+
+    def validate_identifier
+      if @identifier.empty?
+        raise MKBrut::InvalidIdentifier, "#{@name} cannot be empty"
+      end
+
+      if @identifier.length > 63
+        raise MKBrut::InvalidIdentifier, "#{@name} cannot be longer than 63 characters"
+      end
+
+      if @identifier.start_with?("-") || @identifier.end_with?("-")
+        raise MKBrut::InvalidIdentifier, "#{@name} cannot start or end with a hyphen"
+      end
+
+      if @identifier.match?(/[^a-zA-Z0-9-]/)
+        raise MKBrut::InvalidIdentifier, "#{@name} can only contain letters, numbers, and hyphens"
+      end
+    end
+  end 
+end

data/lib/mkbrut/invalid_identifier.rb

@@ -0,0 +1,4 @@
+module MKBrut
+  class InvalidIdentifier < ArgumentError
+  end
+end

data/lib/mkbrut/ops/add_css_import.rb

@@ -0,0 +1,42 @@
+class MKBrut::Ops::AddCSSImport < MKBrut::Ops::BaseOp
+  def initialize(project_root:, import:)
+    @file   = project_root / "app" / "src" / "front_end" / "css" / "index.css"
+    @import = import
+  end
+
+  def call
+    if dry_run?
+      puts "Would add import '#{@import}'; to '#{@file}'"
+      return
+    end
+
+    contents = File.read(@file).split(/\n/)
+
+    inserted_import          = false
+    previous_line_was_import = false
+    new_contents = []
+    contents.each do |line|
+      if line =~ /^\s*@import\s+["']/
+        previous_line_was_import = true
+        new_contents << line
+      else
+        if previous_line_was_import && !inserted_import
+          new_contents << "@import '#{@import}';"
+          inserted_import = true
+        end
+        previous_line_was_import = false
+        new_contents << line
+      end
+    end
+    if !inserted_import && previous_line_was_import
+      new_contents << "@import \"#{@import}\";"
+      inserted_import = true
+    end
+    if !inserted_import
+      raise "Did not find any other @imports in '#{@file}' - was expecting at least one to exist"
+    end
+    File.open(@file, "w") do |file|
+      file.puts new_contents.join("\n")
+    end
+  end
+end

data/lib/mkbrut/ops/add_i18n_message.rb

@@ -0,0 +1,74 @@
+class MKBrut::Ops::AddI18nMessage < MKBrut::Ops::PrismParsingOp
+  def initialize(project_root:, hash:)
+    @file = project_root / "app" / "config" / "i18n" / "en" / "2_app.rb"
+    @hash = hash
+  end
+
+  def call
+    if dry_run?
+      puts "Would merge:\n#{@hash}\ninto #{@file}"
+      return
+    end
+    parse_file!
+
+    hash_node = @tree.value.statements.body.detect { it.is_a?(Prism::HashNode) }
+    if !hash_node
+      raise "'#{@file}' did not have a hash node, so we cannot insert a new i18n message"
+    end
+
+    # eval the source to get a real hash of the contents
+    start_offset  = hash_node.location.start_offset
+    end_offset    = hash_node.location.end_offset
+    original_code = @source[start_offset...end_offset]
+    original_hash = eval(original_code, binding, @file.to_s)
+
+    new_hash = deep_merge(original_hash,@hash)
+
+    formatted_hash = format_hash(new_hash)
+
+    new_source = @source.dup
+    new_source[start_offset...end_offset] = formatted_hash
+
+    File.open(@file, "w") do |file|
+      file.puts new_source
+    end
+  end
+
+private
+
+  def deep_merge(a, b)
+    a.merge(b) do |_key, old_val, new_val|
+      if old_val.is_a?(Hash) && new_val.is_a?(Hash) 
+        deep_merge(old_val, new_val)
+      else
+        new_val
+      end
+    end
+  end
+
+  # NASTY, but not currently sure a better what do it.
+  def format_hash(hash, trailing_comma = "", indent = "")
+    string = "{\n"
+    hash.each do |key, value|
+      key_code = if key.kind_of?(Symbol)
+                   if key =~ /^[A-Za-z_][A-Za-z0-9_]*$/
+                     "#{key}:"
+                   else
+                     "'#{key}':"
+                   end
+      else
+        "#{key} =>"
+      end
+      value_code = case value
+                   when String
+                     then "\"#{value}\",\n"
+                   when Hash
+                     format_hash(value, ",", indent + "  ")
+                   end
+      string << "#{indent}  #{key_code} #{value_code}"
+    end
+    string << "#{indent}}#{trailing_comma}\n"
+    string
+  end
+end
+

data/lib/mkbrut/ops/add_method.rb

@@ -0,0 +1,48 @@
+class MKBrut::Ops::AddMethod < MKBrut::Ops::PrismParsingOp
+  def initialize(file:, class_name:, code:)
+    @file        = file
+    @class_name  = class_name
+    @code        = code.gsub(/^\n\s*$/,"").gsub(/\n$/,"")
+  end
+
+  def call
+    if dry_run?
+      puts "Would add method:\n#{@code}\nto #{@class_name} in '#{@file}'"
+      return
+    end
+    class_node = find_class(class_name: @class_name, assumed_body: false)
+
+    insert_offset = nil
+    class_body_nodes = case class_node.body
+                       when Prism::StatementsNode
+                         class_node.body.body
+                       when nil
+                         []
+                       else
+                         [class_node.body]
+                       end
+                          
+    class_body_nodes.each do |node|
+      if node.is_a?(Prism::CallNode) && node.name == "private"
+        insert_offset = node.location.start_offset
+        break
+      end
+    end
+
+    if insert_offset.nil?
+      # Use the final end of the class
+      insert_offset = class_node.location.end_offset - 3
+    end
+
+    class_start_line = class_node.location.start_line
+    class_indent = @source.lines[class_start_line - 1][/^\s*/] || ""
+    method_indent = class_indent + "  "
+
+    indented_method_code = @code.lines.map { |line| method_indent + line }.join
+    insert_text = "\n" + indented_method_code + "\n"
+
+    updated_source = @source.dup.insert(insert_offset, insert_text)
+    File.write(@file, updated_source)
+    updated_source
+  end
+end

data/lib/mkbrut/ops/append_to_file.rb

@@ -0,0 +1,17 @@
+class MKBrut::Ops::AppendToFile < MKBrut::Ops::BaseOp
+  def initialize(file:, content:)
+    @file    = file
+    @content = content
+  end
+
+  def call
+    if dry_run?
+      puts "Would append to #{@file}:\n#{@content}\n"
+      return
+    end
+
+    File.open(@file, "a") do |file|
+      file.puts @content
+    end
+  end
+end

data/lib/mkbrut/ops/base_op.rb

@@ -0,0 +1,21 @@
+class MKBrut::Ops::BaseOp
+  @dry_run = false
+
+  def self.dry_run=(value)
+    MKBrut::Ops::BaseOp.instance_variable_set(:@dry_run, value)
+  end
+
+  def self.dry_run? = !!MKBrut::Ops::BaseOp.instance_variable_get(:@dry_run)
+  def dry_run? = self.class.dry_run?
+
+  def call = raise "Subclass must implement"
+
+  def self.fileutils_args
+    if self.dry_run?
+      { noop: true, verbose: true }
+    else
+      {}
+    end
+  end
+  def fileutils_args = self.class.fileutils_args
+end

data/lib/mkbrut/ops/copy_file.rb

@@ -0,0 +1,12 @@
+require "fileutils"
+
+class MKBrut::Ops::CopyFile < MKBrut::Ops::BaseOp
+  def initialize(source, destination_root:)
+    @source           = source
+    @destination_root = destination_root
+  end
+  def call
+    FileUtils.cp(@source, @destination_root / @source.basename, **fileutils_args)
+  end
+  def to_s = "Copy '#{@source}' to '#{@destination_root}'"
+end