freyia 0.5.0

data/lib/freyia/automations/file_manipulation.rb

@@ -0,0 +1,415 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module Freyia
+  module Automations
+    # Copies the file from the relative source to the relative destination. If
+    # the destination is not given it's assumed to be equal to the source.
+    #
+    # ==== Parameters
+    # source<String>:: the relative path to the source root.
+    # destination<String>:: the relative path to the destination root.
+    # config<Hash>:: give :verbose => false to not log the status, and
+    #                :mode => :preserve, to preserve the file mode from the source.
+    #
+    # ==== Examples
+    #
+    #   copy_file "README", "doc/README"
+    #
+    #   copy_file "doc/README"
+    #
+    def copy_file(source, *args, &block)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      destination = args.first || source
+      source = File.expand_path(find_in_source_paths(source.to_s))
+
+      resulting_destination = create_file destination, nil, config do
+        content = File.binread(source)
+        content = yield(content) if block
+        content
+      end
+      return unless config[:mode] == :preserve
+
+      mode = File.stat(source).mode
+      chmod(resulting_destination, mode, config)
+    end
+
+    # Links the file from the relative source to the relative destination. If
+    # the destination is not given it's assumed to be equal to the source.
+    #
+    # ==== Parameters
+    # source<String>:: the relative path to the source root.
+    # destination<String>:: the relative path to the destination root.
+    # config<Hash>:: give :verbose => false to not log the status.
+    #
+    # ==== Examples
+    #
+    #   link_file "README", "doc/README"
+    #
+    #   link_file "doc/README"
+    #
+    def link_file(source, *args)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      destination = args.first || source
+      source = File.expand_path(find_in_source_paths(source.to_s))
+
+      create_link destination, source, config
+    end
+
+    # Gets the content at the given address and places it at the given relative
+    # destination. If a block is given instead of destination, the content of
+    # the url is yielded and used as location.
+    #
+    # +get+ relies on open-uri, so passing application user input would provide
+    # a command injection attack vector.
+    #
+    # ==== Parameters
+    # source<String>:: the address of the given content.
+    # destination<String>:: the relative path to the destination root.
+    # config<Hash>:: give :verbose => false to not log the status, and
+    #                :http_headers => <Hash> to add headers to an http request.
+    #
+    # ==== Examples
+    #
+    #   get "http://gist.github.com/103208", "doc/README"
+    #
+    #   get "http://gist.github.com/103208", "doc/README", :http_headers => {"Content-Type" => "application/json"}
+    #
+    #   get "http://gist.github.com/103208" do |content|
+    #     content.split("\n").first
+    #   end
+    #
+    def get(source, *args, &block) # rubocop:todo Metrics
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      destination = args.first
+
+      render = if %r{^https?://}.match?(source)
+                 require "open-uri"
+                 URI.send(:open, source, config.fetch(:http_headers, {})) do |input|
+                   input.binmode.read
+                 end
+               else
+                 source = File.expand_path(find_in_source_paths(source.to_s))
+                 File.open(source) { |input| input.binmode.read }
+               end
+
+      destination ||= if block_given?
+                        block.arity == 1 ? yield(render) : yield
+                      else
+                        File.basename(source)
+                      end
+
+      create_file destination, render, config
+    end
+
+    # Gets an ERB template at the relative source, executes it and makes a copy
+    # at the relative destination. If the destination is not given it's assumed
+    # to be equal to the source removing .tt from the filename.
+    #
+    # ==== Parameters
+    # source<String>:: the relative path to the source root.
+    # destination<String>:: the relative path to the destination root.
+    # config<Hash>:: give :verbose => false to not log the status.
+    #
+    # ==== Examples
+    #
+    #   template "README", "doc/README"
+    #
+    #   template "doc/README"
+    #
+    def template(source, *args, &block)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      destination = args.first || source.sub(%r{#{TEMPLATE_EXTNAME}$}o, "")
+
+      source  = File.expand_path(find_in_source_paths(source.to_s))
+      context = config.delete(:context) || instance_eval("binding", __FILE__, __LINE__)
+
+      create_file destination, nil, config do
+        capturable_erb = CapturableERB.new(::File.binread(source), trim_mode: "-",
+                                                                   eoutvar: "@output_buffer")
+        content = capturable_erb.tap do |erb|
+          erb.filename = source
+        end.result(context)
+        content = yield(content) if block
+        content
+      end
+    end
+
+    # Changes the mode of the given file or directory.
+    #
+    # ==== Parameters
+    # mode<Integer>:: the file mode
+    # path<String>:: the name of the file to change mode
+    # config<Hash>:: give :verbose => false to not log the status.
+    #
+    # ==== Example
+    #
+    #   chmod "script/server", 0755
+    #
+    def chmod(path, mode, config = {})
+      path = File.expand_path(path, destination_root)
+      say_status :chmod, relative_to_original_destination_root(path), config.fetch(:verbose, true)
+      return if options[:pretend]
+
+      require "fileutils"
+      FileUtils.chmod_R(mode, path)
+    end
+
+    # Prepend text to a file. Since it depends on insert_into_file, it's reversible.
+    #
+    # ==== Parameters
+    # path<String>:: path of the file to be changed
+    # data<String>:: the data to prepend to the file, can be also given as a block.
+    # config<Hash>:: give :verbose => false to not log the status.
+    #
+    # ==== Example
+    #
+    #   prepend_to_file 'config/environments/test.rb', 'config.gem "rspec"'
+    #
+    #   prepend_to_file 'config/environments/test.rb' do
+    #     'config.gem "rspec"'
+    #   end
+    #
+    def prepend_to_file(path, *args, &)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      config[:after] = %r{\A}
+      insert_into_file(path, *(args << config), &)
+    end
+    alias_method :prepend_file, :prepend_to_file
+
+    # Append text to a file. Since it depends on insert_into_file, it's reversible.
+    #
+    # ==== Parameters
+    # path<String>:: path of the file to be changed
+    # data<String>:: the data to append to the file, can be also given as a block.
+    # config<Hash>:: give :verbose => false to not log the status.
+    #
+    # ==== Example
+    #
+    #   append_to_file 'config/environments/test.rb', 'config.gem "rspec"'
+    #
+    #   append_to_file 'config/environments/test.rb' do
+    #     'config.gem "rspec"'
+    #   end
+    #
+    def append_to_file(path, *args, &)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      config[:before] = %r{\z}
+      insert_into_file(path, *(args << config), &)
+    end
+    alias_method :append_file, :append_to_file
+
+    # Injects text right after the class definition. Since it depends on
+    # insert_into_file, it's reversible.
+    #
+    # ==== Parameters
+    # path<String>:: path of the file to be changed
+    # klass<String|Class>:: the class to be manipulated
+    # data<String>:: the data to append to the class, can be also given as a block.
+    # config<Hash>:: give :verbose => false to not log the status.
+    #
+    # ==== Examples
+    #
+    #   inject_into_class "app/controllers/application_controller.rb",
+    #                     "ApplicationController",
+    #                     "  filter_parameter :password\n"
+    #
+    #   inject_into_class "app/controllers/application_controller.rb", "ApplicationController" do
+    #     "  filter_parameter :password\n"
+    #   end
+    #
+    def inject_into_class(path, klass, *args, &)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      config[:after] = %r{class #{klass}\n|class #{klass} .*\n}
+      insert_into_file(path, *(args << config), &)
+    end
+
+    # Injects text right after the module definition. Since it depends on
+    # insert_into_file, it's reversible.
+    #
+    # ==== Parameters
+    # path<String>:: path of the file to be changed
+    # module_name<String|Class>:: the module to be manipulated
+    # data<String>:: the data to append to the class, can be also given as a block.
+    # config<Hash>:: give :verbose => false to not log the status.
+    #
+    # ==== Examples
+    #
+    #   inject_into_module "app/helpers/application_helper.rb",
+    #                      "ApplicationHelper",
+    #                      "  def help; 'help'; end\n"
+    #
+    #   inject_into_module "app/helpers/application_helper.rb", "ApplicationHelper" do
+    #     "  def help; 'help'; end\n"
+    #   end
+    #
+    def inject_into_module(path, module_name, *args, &)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      config[:after] = %r{module #{module_name}\n|module #{module_name} .*\n}
+      insert_into_file(path, *(args << config), &)
+    end
+
+    # Run a regular expression replacement on a file, raising an error if the
+    # contents of the file are not changed.
+    #
+    # ==== Parameters
+    # path<String>:: path of the file to be changed
+    # flag<Regexp|String>:: the regexp or string to be replaced
+    # replacement<String>:: the replacement, can be also given as a block
+    # config<Hash>:: give :verbose => false to not log the status, and
+    #                :force => true, to force the replacement regardless of runner behavior.
+    #
+    # ==== Example
+    #
+    #   gsub_file! 'app/controllers/application_controller.rb',
+    #              /#\s*(filter_parameter_logging :password)/, '\1'
+    #
+    #   gsub_file! 'README', /rake/, :green do |match|
+    #     match << " no more. Use freyia!"
+    #   end
+    #
+    def gsub_file!(path, flag, *args, &)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+
+      path = File.expand_path(path, destination_root)
+      say_status :gsub, relative_to_original_destination_root(path), config.fetch(:verbose, true)
+
+      actually_gsub_file(path, flag, args, true, &) unless options[:pretend]
+    end
+
+    # Run a regular expression replacement on a file.
+    #
+    # ==== Parameters
+    # path<String>:: path of the file to be changed
+    # flag<Regexp|String>:: the regexp or string to be replaced
+    # replacement<String>:: the replacement, can be also given as a block
+    # config<Hash>:: give :verbose => false to not log the status, and
+    #                :force => true, to force the replacement regardless of runner behavior.
+    #
+    # ==== Example
+    #
+    #   gsub_file 'app/controllers/application_controller.rb',
+    #             /#\s*(filter_parameter_logging :password)/, '\1'
+    #
+    #   gsub_file 'README', /rake/, :green do |match|
+    #     match << " no more. Use freyia!"
+    #   end
+    #
+    def gsub_file(path, flag, *args, &)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+
+      path = File.expand_path(path, destination_root)
+      say_status :gsub, relative_to_original_destination_root(path), config.fetch(:verbose, true)
+
+      actually_gsub_file(path, flag, args, false, &) unless options[:pretend]
+    end
+
+    # Uncomment all lines matching a given regex. Preserves indentation before
+    # the comment hash and removes the hash and any immediate following space.
+    #
+    # ==== Parameters
+    # path<String>:: path of the file to be changed
+    # flag<Regexp|String>:: the regexp or string used to decide which lines to uncomment
+    # config<Hash>:: give :verbose => false to not log the status.
+    #
+    # ==== Example
+    #
+    #   uncomment_lines 'config/initializers/session_store.rb', /active_record/
+    #
+    def uncomment_lines(path, flag, *)
+      flag = flag.source if flag.respond_to?(:source)
+
+      gsub_file(path, %r{^(\s*)#[[:blank:]]?(.*#{flag})}, '\1\2', *)
+    end
+
+    # Comment all lines matching a given regex.  It will leave the space
+    # which existed before the beginning of the line in tact and will insert
+    # a single space after the comment hash.
+    #
+    # ==== Parameters
+    # path<String>:: path of the file to be changed
+    # flag<Regexp|String>:: the regexp or string used to decide which lines to comment
+    # config<Hash>:: give :verbose => false to not log the status.
+    #
+    # ==== Example
+    #
+    #   comment_lines 'config/initializers/session_store.rb', /cookie_store/
+    #
+    def comment_lines(path, flag, *)
+      flag = flag.source if flag.respond_to?(:source)
+
+      gsub_file(path, %r{^(\s*)([^#\n]*#{flag})}, '\1# \2', *)
+    end
+
+    # Removes a file at the given location.
+    #
+    # ==== Parameters
+    # path<String>:: path of the file to be changed
+    # config<Hash>:: give :verbose => false to not log the status.
+    #
+    # ==== Example
+    #
+    #   remove_file 'README'
+    #   remove_file 'app/controllers/application_controller.rb'
+    #
+    def remove_file(path, config = {})
+      return unless behavior == :invoke
+
+      path = File.expand_path(path, destination_root)
+
+      say_status :remove, relative_to_original_destination_root(path), config.fetch(:verbose, true)
+      return unless !options[:pretend] && (File.exist?(path) || File.symlink?(path))
+
+      require "fileutils"
+      ::FileUtils.rm_rf(path)
+    end
+    alias_method :remove_dir, :remove_file
+
+    attr_accessor :output_buffer
+    private :output_buffer, :output_buffer=
+
+    private
+
+    def concat(string)
+      @output_buffer.concat(string)
+    end
+
+    def capture(*args)
+      with_output_buffer { yield(*args) }
+    end
+
+    def with_output_buffer(buf = +"") #:nodoc:
+      raise ArgumentError, "Buffer cannot be a frozen object" if buf.frozen?
+
+      old_buffer = output_buffer
+      self.output_buffer = buf
+      yield
+      output_buffer
+    ensure
+      self.output_buffer = old_buffer
+    end
+
+    def actually_gsub_file(path, flag, args, error_on_no_change, &)
+      content = File.binread(path)
+      success = content.gsub!(flag, *args, &)
+
+      if success.nil? && error_on_no_change
+        raise Freyia::Error, "The content of #{path} did not change"
+      end
+
+      File.binwrite(path, content)
+    end
+
+    # Freyia::Automations#capture depends on what kind of buffer is used in ERB.
+    # Thus CapturableERB fixes ERB to use String buffer.
+    class CapturableERB < ERB
+      def set_eoutvar(compiler, eoutvar = "_erbout")
+        compiler.put_cmd = "#{eoutvar}.concat"
+        compiler.insert_cmd = "#{eoutvar}.concat"
+        compiler.pre_cmd = ["#{eoutvar} = ''.dup"]
+        compiler.post_cmd = [eoutvar]
+      end
+    end
+  end
+end

data/lib/freyia/automations/inject_into_file.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require_relative "empty_directory"
+
+module Freyia
+  module Automations
+    WARNINGS = {
+      unchanged_no_flag: "File unchanged! Either the supplied flag value not found or the " \
+                         "content has already been inserted!",
+    }.freeze
+
+    # Injects the given content into a file, raising an error if the contents of
+    # the file are not changed. Different from gsub_file, this method is reversible.
+    #
+    # ==== Parameters
+    # destination<String>:: Relative path to the destination root
+    # data<String>:: Data to add to the file. Can be given as a block.
+    # config<Hash>:: give :verbose => false to not log the status and the flag
+    #                for injection (:after or :before) or :force => true for
+    #                insert two or more times the same content.
+    #
+    # ==== Examples
+    #
+    #   insert_into_file "config/environment.rb", "config.gem :freyia",
+    #                    after: "Rails::Initializer.run do |config|\n"
+    #
+    #   insert_into_file "config/environment.rb", after: "Rails::Initializer.run do |config|\n" do
+    #     gems = ask "Which gems would you like to add?"
+    #     gems.split(" ").map{ |gem| "  config.gem :#{gem}" }.join("\n")
+    #   end
+    #
+    def insert_into_file!(destination, *args, &block)
+      data = block_given? ? block : args.shift
+
+      config = args.shift || {}
+      config[:after] = %r{\z} unless config.key?(:before) || config.key?(:after)
+      config = config.merge({ error_on_no_change: true })
+
+      action InjectIntoFile.new(self, destination, data, config)
+    end
+    alias_method :inject_into_file!, :insert_into_file!
+
+    # Injects the given content into a file. Different from gsub_file, this
+    # method is reversible.
+    #
+    # ==== Parameters
+    # destination<String>:: Relative path to the destination root
+    # data<String>:: Data to add to the file. Can be given as a block.
+    # config<Hash>:: give :verbose => false to not log the status and the flag
+    #                for injection (:after or :before) or :force => true for
+    #                insert two or more times the same content.
+    #
+    # ==== Examples
+    #
+    #   insert_into_file "config/environment.rb", "config.gem :freyia",
+    #                    after: "Rails::Initializer.run do |config|\n"
+    #
+    #   insert_into_file "config/environment.rb", after: "Rails::Initializer.run do |config|\n" do
+    #     gems = ask "Which gems would you like to add?"
+    #     gems.split(" ").map{ |gem| "  config.gem :#{gem}" }.join("\n")
+    #   end
+    #
+    def insert_into_file(destination, *args, &block)
+      data = block_given? ? block : args.shift
+
+      config = args.shift || {}
+      config[:after] = %r{\z} unless config.key?(:before) || config.key?(:after)
+
+      action InjectIntoFile.new(self, destination, data, config)
+    end
+    alias_method :inject_into_file, :insert_into_file
+
+    class InjectIntoFile < EmptyDirectory #:nodoc:
+      attr_reader :replacement, :flag, :behavior
+
+      def initialize(base, destination, data, config)
+        super(base, destination, { verbose: true }.merge(config))
+
+        @behavior, @flag = if @config.key?(:after)
+                             [:after, @config.delete(:after)]
+                           else
+                             [:before, @config.delete(:before)]
+                           end
+
+        @replacement = data.is_a?(Proc) ? data.call : data
+        @flag = Regexp.escape(@flag) unless @flag.is_a?(Regexp)
+        @error_on_no_change = @config.fetch(:error_on_no_change, false)
+      end
+
+      def invoke! # rubocop:todo Metrics
+        content = if @behavior == :after
+                    "\\0#{replacement}"
+                  else
+                    "#{replacement}\\0"
+                  end
+
+        if exists?
+          if replace!(%r{#{flag}}, content, config[:force])
+            say_status(:invoke)
+          elsif @error_on_no_change
+            raise Freyia::Error, "The content of #{destination} did not change"
+          elsif replacement_present?
+            say_status(:unchanged, color: :blue)
+          else
+            say_status(:unchanged, warning: WARNINGS[:unchanged_no_flag], color: :red)
+          end
+        else
+          raise Freyia::Error, "The file #{destination} does not appear to exist" unless pretend?
+        end
+      end
+
+      def revoke!
+        say_status :revoke
+
+        regexp = if @behavior == :after
+                   content = '\1\2'
+                   %r{(#{flag})(.*)(#{Regexp.escape(replacement)})}m
+                 else
+                   content = '\2\3'
+                   %r{(#{Regexp.escape(replacement)})(.*)(#{flag})}m
+                 end
+
+        replace!(regexp, content, true)
+      end
+
+      protected
+
+      def say_status(behavior, warning: nil, color: nil) # rubocop:todo Metrics
+        status = if behavior == :invoke
+                   if flag == %r{\A}
+                     :prepend
+                   elsif flag == %r{\z}
+                     :append
+                   else
+                     :insert
+                   end
+                 elsif warning
+                   warning
+                 elsif behavior == :unchanged
+                   :unchanged
+                 else
+                   :subtract
+                 end
+
+        super(status, color || config[:verbose])
+      end
+
+      def content
+        @content ||= File.read(destination)
+      end
+
+      def replacement_present?
+        content.include?(replacement)
+      end
+
+      # Adds the content to the file.
+      #
+      def replace!(regexp, string, force)
+        return unless force || !replacement_present?
+
+        success = content.gsub!(regexp, string)
+
+        File.binwrite(destination, content) unless pretend?
+        success
+      end
+    end
+  end
+end