fsorg 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c27599263e9d7099988d7e22a4bf25025b65f1cc1add20f9ffe0b8c83c2f38fd
-  data.tar.gz: 41a9c30f0d6c97eba90440fadb536ebbb3f1c27df23990ee7afb6582fb76816e
+  metadata.gz: 8de7035273a930e84018355538d364b68016be1d6dc015269e00867a6cb0b72b
+  data.tar.gz: 167a486eaa81c1315c9dab96cf5c1536277a871d40a20c3f8d5dded4d13e8e0f
 SHA512:
-  metadata.gz: 8732ef572aa0947e6169839e74dee898e2fbcf42dcfe6a01506a969f8754b942fed18874ec9dab0cb2777b9cae1b5ba61b1638737804bece0a0bb4e0a838607d
-  data.tar.gz: b9cd12b4acf2303ba5df9b122bea206712e749578c33c0b992ac2999be99f2025393106a4cd00b42119de0875f3d71e55cb1d31fc7a999f08410b7134fb0e80b
+  metadata.gz: eb062a7c0e9722ff75aee01f2703bd29b0caa54668c093bceca3e4b865940da4251c79d06b01e74456730332f586c541325033e33d1e12be5623a03fca2df9c8
+  data.tar.gz: 5cf687f4913525c92a17ba1c094e9b27fcdf2641fdf8aecbe35655c2b75d6b8b321b251fce5c72591b16a3f15b121dcf148872e5d64cd35568b9f1660e06c0c4

data/bin/fsorg

@@ -1,4 +1,33 @@
 #!/usr/bin/env ruby
+require "docopt"
+require "yaml"
 require "fsorg"
 
+args = Docopt.docopt <<-DOC
+    Usage:
+        fsorg [options] <filepath>
+        fsorg [options] <data> <filepath>
 
+    Options:
+        -h --help                 Show this screen.
+        -r --root=ROOT_DIRECTORY  Set the root directory.
+        -n --dry-run              Show what would be done, but don't do it.
+        -q --quiet                Don't show actions performed.
+        -v --verbose              Show details about actions performed.
+    
+    Actions performed:
+        Paths are shown relative to the root directory.
+        +                         Create a directory
+        $                         Run a command
+        >                         Write a file
+DOC
+
+filepath = Pathname.new args["<filepath>"]
+document = File.new(filepath).read.strip
+data_raw = args["<data>"] || "{}"
+data = YAML.load data_raw, symbolize_names: true
+root_directory = Pathname.new(args["--root"] || "")
+
+fsorg = Fsorg.new root_directory, data, document, Pathname.new(Dir.pwd).join(filepath)
+fsorg.preprocess
+fsorg.walk args["--dry-run"], args["--quiet"], args["--verbose"]

data/lib/fsorg.rb

@@ -1,10 +1,9 @@
-require "docopt"
 require "colorize"
 require "set"
 require "shellwords"
 require "yaml"
 
-PERMISSIONS_PATTERN = /[ugoa]*([-+=]([rwxXst]*|[ugo]))+|[-+=][0-7]+/
+PERMISSIONS_PATTERN = /[ugoa]*([-+=]([rwxXst]*|[ugo]))+|[-+=]?[0-7]+/
 
 def d(thing)
   p thing
@@ -21,10 +20,12 @@ class Fsorg
     @data = { :HERE => @root_directory.to_s }.merge data
     @document = document
     @current_line = 0
+    @current_depth = -1
+    @to_write = [] # [ { :path, :content, :permissions } ]
   end
 
-  def relative_to_root(path)
-    File.join(@root_directory, path)
+  def from_relative_to_root(path)
+    @root_directory / path
   end
 
   def depth_change(line)
@@ -38,35 +39,15 @@ class Fsorg
     change
   end
 
-  def self.from_command_line
-    args = Docopt.docopt <<-DOC
-      Usage:
-          fsorg [options] <filepath>
-          fsorg [options] <data> <filepath>
-
-      Options:
-          -h --help                 Show this screen.
-          -v --version              Show version.
-          -r --root=ROOT_DIRECTORY  Set the root directory.
-    DOC
-
-    filepath = Pathname.new args["<filepath>"]
-    document = File.new(filepath).read.strip
-    data_raw = args["<data>"] || "{}"
-    data = YAML.load data_raw, symbolize_names: true
-    root_directory = Pathname.new(args["--root"] || "")
-
-    return Fsorg.new root_directory, data, document, Pathname.new(Dir.pwd).join(filepath)
-  end
-
   def preprocess
     process_front_matter
+    strip_comments
     desugar
     process_includes
     # TODO process_see
     process_for
     process_if
-    turn_writes_into_runs
+    store_writes
     turn_puts_into_runs
     ask_missing_variables
     process_root
@@ -103,15 +84,40 @@ class Fsorg
 
   def desugar
     output = []
+    inside_write_directive_shorthand = false
     @document.lines(chomp: true).each_with_index do |line, index|
       @current_line = index + 1
-      if /^\}(\s*ELSE\s*\{)$/.match line
+      if inside_write_directive_shorthand
+        if line.strip == "]"
+          inside_write_directive_shorthand = false
+          output << "}"
+        else
+          output << line
+        end
+      elsif /^\}(\s*ELSE\s*\{)$/.match line.strip
         output << "}"
         output << $~[1]
+      elsif /^FILE\s+(?<filename>.+?)$/ =~ line.strip
+        output << "RUN touch #{filename.shellescape}"
       elsif /^(\s*[^{]+?\{)([^{]+?)\}$/.match line.strip
         output << $~[1]
         output << $~[2]
         output << "}"
+      elsif /^(?<filename>.+?)\s*(\s+\((?<permissions>#{PERMISSIONS_PATTERN.to_s})\))?\s*\[$/.match line.strip
+        output << "WRITE #{$~[:filename]} " + ($~[:permissions] ? "MODE #{$~[:permissions]}" : "") + " {"
+        inside_write_directive_shorthand = true
+      else
+        output << line
+      end
+    end
+    @document = output.join "\n"
+  end
+
+  def strip_comments
+    output = []
+    @document.lines(chomp: true).each_with_index do |line, index|
+      if /^(?<content>.*)#\s.*$/ =~ line
+        output << content
       else
         output << line
       end
@@ -139,35 +145,23 @@ class Fsorg
     @document = output.join "\n"
   end
 
-  def turn_writes_into_runs
+  def store_writes
     output = []
-    inside_write_directive = false
-    compact = nil
-    current_content = []
-    destination = nil
-    permissions = nil
+    current = {}
+    inside_write_directive = -> { !current.keys.empty? }
 
     @document.lines(chomp: true).each_with_index do |line, index|
       @current_line = index + 1
-      if inside_write_directive
-        if line.strip == (compact ? "]" : "}")
-          inside_write_directive = false
-          content = deindent(current_content.join("\n")).gsub "\n", '\n'
-          content = content.shellescape.gsub('\{\{', "{{").gsub('\}\}', "}}")
-          output << "RUN" + (destination.include?("/") ? "mkdir -p #{Pathname.new(destination.strip).parent.to_s.shellescape}" : "") + "echo -ne #{content} > #{destination.strip.shellescape}" + (permissions ? " && chmod #{permissions} #{destination.strip.shellescape}" : "")
+      if inside_write_directive.()
+        if line.strip == "}"
+          @to_write << current
+          current = {}
         else
-          current_content << line
+          current[:content] += line + "\n"
         end
-      elsif /^WRITE(\s+INTO)?\s+(?<destination>.+?)(?:\s+MODE\s+(?<permissions>.+?))?\s*\{$/ =~ line.strip
-        inside_write_directive = true
-        compact = false
-      elsif /^(?<destination>.+)(\s*\((?<permissions>#{PERMISSIONS_PATTERN})\))?\s*\[$/ =~ line.strip
-        # Shouldn't be needed, as =~ should assign to destination, but heh, it doesn't work for some reason ¯\_(ツ)_/¯
-        if destination.nil?
-          destination = $~[:destination]
-        end
-        inside_write_directive = true
-        compact = true
+      elsif /^WRITE(\s+INTO)?\s+(?<destination>.+?)(?:\s+MODE\s+(?<permissions>.+?))?\s*\{$/.match line.strip
+        current = $~.named_captures.transform_keys(&:to_sym)
+        current[:content] = ""
       else
         output << line
       end
@@ -181,8 +175,8 @@ class Fsorg
     @document.lines(chomp: true).each_with_index do |line, index|
       @current_line = index + 1
       if /^PUT\s+(?<source>.+?)(\s+AS\s+(?<destination>.+?))?(\s+MODE\s+(?<permissions>.+?))?$/.match(line.strip)
-        output << "RUN install -D \"$FSORG_ROOT/#{$~[:source]}\" #{($~[:destination] || $~[:source]).shellescape}" + (if $~[:permissions]
-          " -D #{$~[:permissions].shellescape}"
+        output << "RUN install -D \"$DOCUMENT_DIR/#{$~[:source]}\" #{($~[:destination] || $~[:source]).shellescape}" + (if $~[:permissions]
+          " -m #{$~[:permissions].shellescape}"
         else
           ""
         end)
@@ -298,7 +292,7 @@ class Fsorg
   end
 
   def ask_missing_variables
-    @document.scan /\{\{(?<variable>[^}]+?)\}\}/ do |variable|
+    (@document + @to_write.map { |f| f[:content] }.join(" ")).scan /\{\{(?<variable>[^}]+?)\}\}/ do |variable|
       unless @data.include? variable[0].to_sym
         @data[variable[0].to_sym] = :ask
       end
@@ -344,29 +338,117 @@ class Fsorg
     @data[:HERE]
   end
 
-  def walk
+  def execute_writes(dry_run, quiet)
+    @to_write.each do |future_file|
+      do_write future_file, dry_run, quiet
+    end
+  end
+
+  def walk(dry_run, quiet, verbose)
     current_path = [@root_directory]
     current_path_as_pathname = -> { current_path.reduce(Pathname.new "") { |path, fragment| path.join fragment } }
     @data[:HERE] = @root_directory
 
+    if verbose
+      puts "Data is #{@data.except :HERE}".light_black
+    end
+
     @document.lines(chomp: true).each_with_index do |line, index|
       @current_line = index + 1
-      
+      @current_depth = current_path.length - 1
+
       @data.each do |key, value|
         line = line.gsub "{{#{key}}}", value.to_s
       end
 
-      if /^RUN\s+(?<command>.+?)$/ =~ line.strip
-        puts "run ".colorize(:cyan) + command + " at ".colorize(:blue) + current_location.to_s.colorize(:blue)
+      if /^(?<leaf>.+?)\s+\{/ =~ line.strip
+        current_path << leaf
+        @data[:HERE] = current_path_as_pathname.()
+        if verbose
+          puts "currenly #{current_path.map { |fragment| fragment.to_s }.join " -> "}".light_black
+        end
+        do_mkpath current_location, dry_run, quiet
       elsif line.strip == "}"
         current_path.pop
-      elsif /^(?<leaf>.+?)\s+\{/ =~ line.strip
-        current_path << leaf
         @data[:HERE] = current_path_as_pathname.()
-        puts "mk  ".colorize(:cyan) + current_location.to_s
+        if verbose
+          puts "currenly #{current_path.map { |fragment| fragment.to_s }.join " -> "}".light_black
+        end
+      elsif /^RUN\s+(?<command>.+?)$/ =~ line.strip
+        environment = {
+          "FSORG_ROOT" => @root_directory.to_s,
+          "HERE" => @data[:HERE].relative_path_from(@root_directory).to_s,
+          "CWD" => Dir.pwd,
+          "DOCUMENT_DIR" => @document_path.parent.to_s,
+        }
+        do_run command, current_location, environment, dry_run, quiet, verbose
+      end
+    end
+
+    @current_depth = 0
+    # TODO do writes alongside other operations
+    puts ("Writing files " + "─" * 40).light_black
+    execute_writes dry_run, quiet
+  end
+
+  def do_mkpath(path, dry_run, quiet)
+    unless quiet
+      puts "#{"  " * @current_depth}+ ".cyan.bold + path.relative_path_from(@root_directory).to_s
+    end
+    unless dry_run
+      path.mkpath
+    end
+  end
+
+  def do_write(future_file, dry_run, quiet)
+    dest = from_relative_to_root future_file[:destination]
+    do_mkpath dest.parent, dry_run, quiet
+
+    unless quiet
+      puts "> ".cyan.bold + dest.relative_path_from(@root_directory).to_s + (future_file[:permissions] ? " mode #{future_file[:permissions]}".yellow : "")
+    end
+    unless dry_run
+      dest.write replace_data future_file[:content]
+      # Not using dest.chmod as the syntax for permissions is more than just integers,
+      # and matches in fact the exact syntax of chmod's argument, per the manpage, chmod(1) (line "Each MODE is of the form…")
+      `chmod #{future_file[:permissions]} #{dest}` if future_file[:permissions]
+    end
+  end
+
+  def replace_data(content)
+    content.gsub /\{\{(?<variable>[^}]+?)\}\}/ do |interpolation| 
+      variable = interpolation[2..-3]
+      @data[variable.to_sym] 
+    end
+  end
+
+  def do_run(command, inside, environment, dry_run, quiet, verbose)
+    indentation = "  " * @current_depth
+    unless quiet
+      puts "#{indentation}$ ".cyan.bold + command + (verbose ? " at #{inside.relative_path_from(@root_directory)}".light_blue + " with ".light_black + (format_environment_hash environment) : "")
+    end
+    unless dry_run
+      stdout, stdout_w = IO.pipe
+      stderr, stderr_w = IO.pipe
+
+      system environment, command, { :chdir => inside.to_s, :out => stdout_w, :err => stderr_w }
+      stdout_w.close
+      stderr_w.close
+
+      stdout.read.each_line(chomp: true) do |line|
+        puts "  " + indentation + line
+      end
+      stderr.read.each_line(chomp: true) do |line|
+        puts "  " + indentation + line.red
       end
     end
   end
+
+  def format_environment_hash(environment)
+    "{ ".light_black + (environment.map do |key, value|
+      "$#{key}".red + "=".light_black + "\"#{value}\"".green
+    end.join ", ".light_black) + " }".light_black
+  end
 end
 
 def deindent(text)
@@ -386,6 +468,14 @@ def deindent(text)
   end.join "\n"
 end
 
-fsorg = Fsorg.from_command_line
-fsorg.preprocess
-fsorg.walk
+def capture_output
+  old_stdout = $stdout
+  old_stderr = $stderr
+  $stdout = StringIO.new
+  $stderr = StringIO.new
+  yield
+  return $stdout.string, $stderr.string
+ensure
+  $stdout = old_stdout
+  $stderr = old_stderr
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fsorg
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Ewen Le Bihan