brut 0.4.0 → 0.8.0

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