brut 0.5.0 → 0.9.0

data/mkbrut/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/mkbrut/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/mkbrut/lib/mkbrut/ops/append_to_file.rb

@@ -0,0 +1,20 @@
+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
+
+    contents = File.read(@file)
+    File.open(@file, "w") do |file|
+      file.puts contents
+      file.puts "\n"
+      file.puts @content
+    end
+  end
+end

data/mkbrut/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/mkbrut/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

data/mkbrut/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/mkbrut/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/mkbrut/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/mkbrut/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/mkbrut/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/mkbrut/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/mkbrut/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/mkbrut/lib/mkbrut/organization.rb

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

data/mkbrut/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/mkbrut/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/mkbrut/lib/mkbrut/segments/bare_bones.rb

@@ -0,0 +1,185 @@
+# 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: [ "pos-fixed",
+           "bottom-0",
+           "left-0",
+           "w-100",
+           "ff-sans",
+           "lh-title",
+           "tracked",
+           "f-5",
+           "f-6-ns",
+           "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