mkbrut 0.1.0

data/lib/mkbrut/ops/insert_code_in_method.rb

@@ -0,0 +1,58 @@
+class MKBrut::Ops::InsertCodeInMethod < MKBrut::Ops::PrismParsingOp
+  def initialize(file:, class_name:, method_name:, code:, where: :end)
+    @file        = file
+    @class_name  = class_name
+    @method_name = method_name.to_sym
+    @code        = code
+    @where       = where
+  end
+
+  def call
+    method_node = find_method(class_name: @class_name, method_name: @method_name)
+
+    insertion_point = if @where == :start
+                        insertion_point_for_code_at_start_of_method(method_node: method_node)
+                      else
+                        insertion_point_for_code_at_end_of_method(method_node: method_node)
+                      end
+    indented_code = indent_code_for_method(method_node: method_node)
+
+    new_source = @source.dup.insert(insertion_point, indented_code)
+    File.write(@file, new_source)
+  end
+
+private
+
+  def indent_code_for_method(method_node:)
+
+    method_start_line = method_node.location.start_line
+    spaces_before_def = @source.lines[method_start_line - 1][/^\s*/] || ""
+    spaces_for_code_in_method = spaces_before_def + "  "
+
+    post_indent = if @where == :start
+                    "\n#{spaces_before_def}"
+                  else
+                    ""
+                  end
+
+
+    "\n" + 
+      @code.split(/\n/).map { |line|
+        spaces_for_code_in_method + line
+      }.join("\n") + post_indent
+  end
+
+  def insertion_point_for_code_at_end_of_method(method_node:)
+    line_number_of_method_end = method_node.location.end_line - 1
+    length_of_method_end      = @source.lines[line_number_of_method_end].length
+
+    method_node.location.end_offset - length_of_method_end
+  end
+
+  def insertion_point_for_code_at_start_of_method(method_node:)
+    line_number_of_method_start = method_node.location.start_line - 1
+    length_of_method_start      = @source.lines[line_number_of_method_start].length
+
+    method_node.location.start_offset + length_of_method_start
+  end
+end

data/lib/mkbrut/ops/insert_route.rb

@@ -0,0 +1,52 @@
+class MKBrut::Ops::InsertRoute < MKBrut::Ops::PrismParsingOp
+  def initialize(project_root:, code:)
+    @file = project_root / "app" / "src" / "app.rb"
+    @code = code
+  end
+
+  def call
+    if dry_run?
+      puts "Would insert route:\n#{@code}\ninto #{@file}"
+      return
+    end
+    app_class_node = find_class(class_name: "App")
+
+    routes_block = find_routes_block(app_class_node)
+
+    if !routes_block
+      raise "'App' in '#{@file}' did not have a routes block, so we cannot insert a new route"
+    end
+
+    end_offset = routes_block.block.location.end_offset
+    indented_line = "  #{@code}\n  "
+    new_source = @source.dup.insert(end_offset - 3, indented_line)
+
+    File.open(@file, "w") do |file|
+      file.puts new_source
+    end
+  end
+
+  def find_routes_block(class_node)
+    statements = case class_node.body 
+                 when Prism::StatementsNode
+                   class_node.body.body
+                 when nil
+                   []
+                 else
+                   [class_node.body]
+                 end
+
+    statements.detect do |statement|
+      if statement.is_a?(Prism::CallNode)
+        if statement.name == :routes
+          statement.block
+        else
+          false
+        end
+      else
+        false
+      end
+    end
+  end
+end
+

data/lib/mkbrut/ops/mkdir.rb

@@ -0,0 +1,13 @@
+require "fileutils"
+
+class MKBrut::Ops::Mkdir < MKBrut::Ops::BaseOp
+  def initialize(path)
+    @path = path
+  end
+
+  def call
+    FileUtils.mkdir_p(@path, **fileutils_args)
+  end
+
+  def to_s = "Make Dir '#{@path}'"
+end

data/lib/mkbrut/ops/prism_parsing_op.rb

@@ -0,0 +1,70 @@
+require "prism"
+class MKBrut::Ops::PrismParsingOp < MKBrut::Ops::BaseOp
+  def initialize(file:)
+    @file = file
+  end
+
+  class ClassNotInSource < StandardError
+    def initialize(file:, class_name:)
+      super("Could not find the class '#{class_name}' inside '#{file}'")
+    end
+  end
+
+  class MethodNotInClass < StandardError
+    def initialize(file:, class_name:, method_name:)
+      super("Could not find the method '#{method_name}' in class '#{class_name}' inside '#{file}'")
+    end
+  end
+
+  class SourceNotParseable < StandardError
+    def initialize(tree_errors:, file:)
+      error_message = tree_errors.map { |error|
+        "#{error.message} (line #{error.location.start_line}, column #{error.location.start_column})"
+      }.join(", ")
+      super("Failed to parse file '#{file}': #{error_message}")
+    end
+  end
+
+private
+
+  def parse_file!
+    source = File.read(@file)
+    tree = Prism.parse(source)
+
+    if !tree.success?
+      raise SourceNotParseable.new(tree_errors: tree.errors, file: @file)
+    end
+    @tree = tree
+    @source = source
+  end
+
+  def find_class(class_name:, assumed_body: true)
+    if !@tree
+      parse_file!
+    end
+    class_node = @tree.value.statements.body.detect { |node|
+      node.is_a?(Prism::ClassNode) && node.constant_path.slice == class_name
+    }
+
+    if !class_node
+      raise ClassNotInSource.new(file: @file, class_name: class_name)
+    end
+
+    if !class_node.body.respond_to?(:body) && assumed_body
+      raise "The class '#{class_name}' in '#{file}' does not have any methods"
+    end
+    class_node
+  end
+
+  def find_method(class_name:, method_name:)
+    class_node = find_class(class_name:)
+    method_node = class_node.body.body.detect { |node|
+      node.is_a?(Prism::DefNode) && node.name == @method_name
+    }
+
+    if !method_node
+      raise MethodNotInClass.new(file: @file, class_name: class_name, method_name: @method_name)
+    end
+    method_node
+  end
+end

data/lib/mkbrut/ops/render_template.rb

@@ -0,0 +1,26 @@
+require "erb"
+class MKBrut::Ops::RenderTemplate < MKBrut::Ops::BaseOp
+
+  def initialize(source, destination_root:, erb_binding:)
+    @erb              = source
+    @destination_file = destination_root / @erb.basename.sub_ext("")
+    @erb_binding      = erb_binding
+  end
+
+  def call
+    if dry_run?
+      puts "Render '#{@destination_file}'"
+      return
+    end
+    template = File.read(@erb)
+    File.open(@destination_file, "w") do |file|
+      file.puts ERB.new(
+        template,
+        trim_mode: "-"
+      ).result(
+        @erb_binding.instance_eval { binding }
+      )
+    end
+  end
+  def to_s = "ERB '#{@erb}' to '#{@destination_file}'"
+end

data/lib/mkbrut/ops/skip_file.rb

@@ -0,0 +1,10 @@
+class MKBrut::Ops::SkipFile
+  def initialize(source)
+    @source = source
+  end
+
+  def call
+  end
+
+  def to_s = "Skip #{@source}"
+end

data/lib/mkbrut/ops.rb

@@ -0,0 +1,16 @@
+module MKBrut
+  module Ops
+    autoload :BaseOp, "mkbrut/ops/base_op"
+    autoload :Mkdir, "mkbrut/ops/mkdir"
+    autoload :CopyFile, "mkbrut/ops/copy_file"
+    autoload :RenderTemplate, "mkbrut/ops/render_template"
+    autoload :SkipFile, "mkbrut/ops/skip_file"
+    autoload :InsertRoute, "mkbrut/ops/insert_route"
+    autoload :InsertCodeInMethod, "mkbrut/ops/insert_code_in_method"
+    autoload :AppendToFile, "mkbrut/ops/append_to_file"
+    autoload :PrismParsingOp, "mkbrut/ops/prism_parsing_op"
+    autoload :AddI18nMessage, "mkbrut/ops/add_i18n_message"
+    autoload :AddCSSImport, "mkbrut/ops/add_css_import"
+    autoload :AddMethod, "mkbrut/ops/add_method"
+  end
+end

data/lib/mkbrut/organization.rb

@@ -0,0 +1,5 @@
+class MKBrut::Organization < MKBrut::InternetIdentifier
+  def initialize(value)
+    super(:organization, value)
+  end
+end

data/lib/mkbrut/prefix.rb

@@ -0,0 +1,26 @@
+module MKBrut
+  class Prefix
+    def self.from_app_id(app_id)
+      app_id = app_id.to_s
+      prefix = if app_id =~ /^[^-]+[a-z]-[a-z]/
+                 app_id.split("-")[0..1].map { it[0] }.join("")
+               else
+                 app_id[0..1]
+               end
+      self.new(prefix)
+    end
+
+    def initialize(identifier)
+      @identifier = identifier.to_s
+      if @identifier.length != 2
+        raise InvalidIdentifier, "prefix '#{@identifier}' must be 2 characters"
+      end
+      if @identifier !~ /^[a-z]+$/
+        raise InvalidIdentifier, "prefix must be only lower case ASCII letters"
+      end
+    end
+
+    def to_s = @identifier
+    alias to_str to_s
+  end
+end

data/lib/mkbrut/prefixed_io.rb

@@ -0,0 +1,16 @@
+require "delegate"
+class PrefixedIO < Delegator
+  def initialize(io, prefix)
+    @io     = io
+    @prefix = "[ #{prefix} ] "
+  end
+
+  def __getobj__ = @io
+
+  def puts(*args)
+    args.each do |arg|
+      @io.puts(@prefix + arg.to_s)
+    end
+  end
+
+end

data/lib/mkbrut/segments/bare_bones.rb

@@ -0,0 +1,184 @@
+# The bare bones configuration on top of a blank Brut app.
+class MKBrut::Segments::BareBones < MKBrut::Base
+
+  def self.friendly_name = "Bare bones framing"
+
+  def initialize(app_options:, current_dir:, templates_dir:)
+    @project_root  = current_dir / app_options.app_name
+    @templates_dir = templates_dir / "segments" / "BareBones"
+    @erb_binding   = ErbBindingDelegate.new(app_options)
+  end
+
+  def add!
+
+    operations = copy_files(@templates_dir, @project_root) + 
+                 other_operations(@project_root)
+
+    operations.each do |operation|
+      operation.call
+    end
+
+  end
+
+  def other_operations(project_root)
+    [
+      MKBrut::Ops::InsertRoute.new(
+        project_root: @project_root,
+        code: %{path "/trigger_exception", method: :get}
+      ),
+      MKBrut::Ops::InsertCodeInMethod.new(
+        file: @project_root / "app" / "src" / "app.rb",
+        class_name: "App",
+        method_name: "initialize",
+        code: %{
+Brut.container.store(
+  "trigger_exception_key",
+  String,
+  "String used to prevent anyone from triggering exceptions in TriggerExceptionHandler"
+) do
+  ENV.fetch("TRIGGER_EXCEPTION_KEY")
+end},
+      ),
+      InsertCustomElement.new(
+        project_root: @project_root,
+        element_class_name: "Example",
+      ),
+      MKBrut::Ops::InsertCodeInMethod.new(
+        file: @project_root / "app" / "src" / "front_end" / "pages" / "home_page.rb",
+        class_name: "HomePage",
+        method_name: "page_template",
+        code: %{
+#{ @erb_binding.prefix }_example(
+  transform: "upper",
+  class: [ "ff-sans",
+           "lh-title",
+           "tracked",
+           "f-5",
+           "f-6-ns",
+           "bg-green-100",
+           "red-900",
+           "tc",
+           "pa-3",
+           "mt-3",
+           "db",
+  ]
+) do
+  "We Like the Web"
+end
+}
+      ),
+      InsertEndToEndTestCode.new(
+        file: @project_root / "specs" / "e2e" / "home_page.spec.rb",
+        code: %{
+    example = page.locator("#{ @erb_binding.prefix }-example")
+    # The #{ @erb_binding.prefix }-example custom element will transform
+    # the text it contains.  Since this is an end-to-end test
+    # the element should've done its thing and given us 
+    # upper-case text.
+    expect(example).to have_text("WE LIKE THE WEB") }
+      ),
+      MKBrut::Ops::AppendToFile.new(
+        file: @project_root / ".env.development",
+        content: %{
+# Key used to allow triggering an exception. This is required to prevent
+# just anyone from triggering one.
+TRIGGER_EXCEPTION_KEY=dev-trigger-exception
+}
+      ),
+      MKBrut::Ops::AppendToFile.new(
+        file: @project_root / ".env.test",
+        content: "TRIGGER_EXCEPTION_KEY=test-trigger-exception"
+      ),
+
+    ]
+  end
+  class InsertCustomElement < MKBrut::Ops::BaseOp
+    def initialize(project_root:, element_class_name:)
+      @file               = project_root / "app" / "src" / "front_end" / "js" / "index.js"
+      @element_class_name = element_class_name
+    end
+    def call
+      if dry_run?
+        puts "Would insert custom element '#{@element_class_name}' into #{@file}"
+        return
+      end
+      inserted = false
+      new_source = []
+      File.read(@file).split("\n").each do  |line|
+        regexp = /^document\.addEventListener\(\"DOMContentLoaded\"/
+        if line.match?(regexp)
+          new_source << %{import #{@element_class_name} from "./#{@element_class_name}"}
+          new_source << line
+          new_source << %{  #{@element_class_name}.define()}
+          inserted = true
+        else
+          new_source << line
+        end
+      end
+      if !inserted
+        raise "Could not find a place to insert code in '#{@file}'. Trying to find a line that matches this regular expression:\n\n#{regexp.inspect}"
+      end
+      File.open(@file, "w") do |file|
+        file.puts new_source.join("\n")
+      end
+    end
+  end
+
+  class InsertEndToEndTestCode < MKBrut::Ops::PrismParsingOp
+    def initialize(file:, code:)
+      @file = file
+      @code = code
+    end
+    def call
+      if dry_run?
+        puts "Would insert end-to-end test code into #{@file}:\n\n#{@code}\n"
+        return
+      end
+      parse_file!
+
+      found_describe = false
+      first_it_block = nil
+
+      @tree.value.statements.body.each do |top|
+        if top.is_a?(Prism::CallNode) &&
+           top.name == :describe      &&
+           top.block
+          found_describe = true
+
+          statements = top.block.body
+          if statements.respond_to?(:body)
+            statements.body.each do |statement|
+              if statement.is_a?(Prism::CallNode) &&
+                 statement.name == :it            &&
+                 statement.block
+
+                first_it_block = statement
+                break
+
+              end
+            end
+          end
+        end
+      end
+      if !first_it_block
+        if found_describe
+        raise "Could not find an 'it' block inside the first 'describe' in '#{@file}'"
+        else
+        raise "Could not find a 'describe' block in '#{@file}'"
+        end
+      end
+
+      insertion_point = first_it_block.block.location.end_offset - 3
+
+      block_line = @source.lines[first_it_block.location.start_line - 1]
+      describe_indent = block_line[/^\s*/] 
+      it_indent = describe_indent + "  "
+
+      new_source = @source.dup.insert(insertion_point, "\n#{it_indent}#{@code}\n#{describe_indent}")
+      File.open(@file, "w") do |file|
+        file.puts new_source
+      end
+    end
+  end
+
+end

data/lib/mkbrut/segments/demo.rb

@@ -0,0 +1,117 @@
+# Additional classes and configuration for a new Brut
+# app that provides a more demonstration of the features.
+class MKBrut::Segments::Demo < MKBrut::Base
+
+  def self.friendly_name = "Demo features and files"
+
+  def initialize(app_options:, current_dir:, templates_dir:)
+    @project_root  = current_dir / app_options.app_name
+    @templates_dir = templates_dir / "segments" / "Demo"
+    @erb_binding   = ErbBindingDelegate.new(app_options)
+  end
+
+  def add!
+    operations = copy_files(@templates_dir, @project_root) + 
+                 other_operations(@project_root)
+
+    operations.each do |operation|
+      operation.call
+    end
+  end
+
+private
+
+  def other_operations(project_root)
+    [
+      MKBrut::Ops::AddI18nMessage.new(
+        project_root: project_root,
+        hash: {
+          en: {
+            cv: {
+              be: {
+                not_enough_words: "%{field} does not have enough words",
+                already_posted: "You've already posted a message. Thanks for that!",
+              },
+            },
+            pages: {
+              "NewGuestbookMessagePage": {
+                title: "New guestbook message page",
+              },
+              "GuestbookPage": {
+                title: "Guestbook page",
+              },
+            },
+            guestbook_not_saved: "Your guestbook message was not saved",
+            guestbook_saved: "Thanks for writing!",
+          },
+        }
+      ),
+      MKBrut::Ops::InsertRoute.new(
+        project_root: project_root,
+        code: %{page "/guestbook"},
+      ),
+      MKBrut::Ops::InsertRoute.new(
+        project_root: project_root,
+        code: %{form "/guestbook_message"},
+      ),
+      MKBrut::Ops::InsertRoute.new(
+        project_root: project_root,
+        code: %{page "/new_guestbook_message"},
+      ),
+      MKBrut::Ops::InsertCodeInMethod.new(
+        file: project_root / "app" / "src" / "back_end" / "data_models" / "seed" / "seed_data.rb",
+        class_name: "SeedData",
+        method_name: "seed!",
+        code: %{
+10.times do
+  create(:guestbook_message, created_at: Date.today - rand(1..100))
+end
+}
+      ),
+      MKBrut::Ops::AddCSSImport.new(
+        project_root: project_root,
+        import: "constraint-violations.css"
+      ),
+      MKBrut::Ops::InsertCodeInMethod.new(
+        file: project_root / "app" / "src" / "front_end" / "pages"/ "home_page.rb",
+        class_name: "HomePage",
+        method_name: "page_template",
+        where: :start,
+        code: %{
+div(class: "w-50 mh-auto mt-4") do
+  a(href: NewGuestbookMessagePage.routing,
+    class: "db f-3 ff-sans blue-400 fw-bold tc"
+  ) do
+    "Sign The Guestbook!"
+  end
+end
+}
+      ),
+      MKBrut::Ops::AddMethod.new(
+        file: project_root / "app" / "src" / "front_end" / "support" / "app_session.rb",
+        class_name: "AppSession",
+        code: %{def signed_guestbook? = !!self.guestbook_message},
+      ),
+      MKBrut::Ops::AddMethod.new(
+        file: project_root / "app" / "src" / "front_end" / "support" / "app_session.rb",
+        class_name: "AppSession",
+        code: %{
+def guestbook_message
+  DB::GuestbookMessage.find(
+    external_id: self[:guestbook_message_external_id]
+  )
+end
+}
+      ),
+      MKBrut::Ops::AddMethod.new(
+        file: project_root / "app" / "src" / "front_end" / "support" / "app_session.rb",
+        class_name: "AppSession",
+        code: %{
+def signed_guestbook(guestbook_message)
+  self[:guestbook_message_external_id] = guestbook_message.external_id
+end
+}
+      ),
+    ]
+  end
+end

data/lib/mkbrut/segments/sidekiq.rb

@@ -0,0 +1,3 @@
+# Adds Sidekiq to a Brut app
+class MKBrut::Segments::Sidekiq
+end

data/lib/mkbrut/segments.rb

@@ -0,0 +1,7 @@
+module MKBrut
+  module Segments
+    autoload :BareBones, "mkbrut/segments/bare_bones"
+    autoload :Demo, "mkbrut/segments/demo"
+    autoload :Sidekiq, "mkbrut/segments/demo"
+  end
+end

data/lib/mkbrut/version.rb

@@ -0,0 +1,3 @@
+module MKBrut
+  VERSION = "0.1.0"
+end

data/lib/mkbrut/versions.rb

@@ -0,0 +1,16 @@
+require "pathname"
+require "json"
+
+class MKBrut::Versions
+  def initialize
+    @brut_version = Gem.loaded_specs["brut"].version.to_s
+    package_json_file = Pathname(Gem::Specification.find_by_name("mkbrut").gem_dir) / "package.json"
+    package_json = JSON.parse(File.read(package_json_file))
+    @brut_js_version = package_json["devDependencies"]["brut-js"]
+    @brut_css_version = package_json["devDependencies"]["brut-css"]
+  end
+
+  def brut_version_specifier     = "~> #{@brut_version}"
+  def brut_css_version_specifier = @brut_css_version
+  def brut_js_version_specifier  = @brut_js_version
+end

data/lib/mkbrut.rb

@@ -0,0 +1,17 @@
+module MKBrut
+  autoload :App, "mkbrut/app"
+  autoload :AppId, "mkbrut/app_id"
+  autoload :AppName, "mkbrut/app_name"
+  autoload :AppOptions, "mkbrut/app_options"
+  autoload :Base, "mkbrut/base"
+  autoload :CLI, "mkbrut/cli"
+  autoload :ErbBindingDelegate, "mkbrut/erb_binding_delegate"
+  autoload :InternetIdentifier, "mkbrut/internet_identifier"
+  autoload :InvalidIdentifier, "mkbrut/invalid_identifier"
+  autoload :Ops, "mkbrut/ops"
+  autoload :Organization, "mkbrut/organization"
+  autoload :Prefix, "mkbrut/prefix"
+  autoload :Segments, "mkbrut/segments"
+  autoload :Versions, "mkbrut/versions"
+  autoload :PrefixedIO, "mkbrut/prefixed_io"
+end