ing 0.1.1

data/lib/ing/actions/file_manipulation.rb

@@ -0,0 +1,308 @@
+require 'erb'
+require 'open-uri'
+
+module Ing
+  module Files
+
+    # 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.
+    #
+    # ==== 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))
+
+      create_file destination, nil, config do
+        content = File.binread(source)
+        content = block.call(content) if block
+        content
+      end
+    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, &block)
+      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.
+    #
+    # ==== 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.
+    #
+    # ==== Examples
+    #
+    #   get "http://gist.github.com/103208", "doc/README"
+    #
+    #   get "http://gist.github.com/103208" do |content|
+    #     content.split("\n").first
+    #   end
+    #
+    def get(source, *args, &block)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      destination = args.first
+
+      source = File.expand_path(find_in_source_paths(source.to_s)) unless source =~ /^https?\:\/\//
+      render = open(source) {|input| input.binmode.read }
+
+      destination ||= if block_given?
+        block.arity == 1 ? block.call(render) : block.call
+      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(/\.tt$/, '')
+
+      source  = File.expand_path(find_in_source_paths(source.to_s))
+      context = instance_eval('binding')
+
+      create_file destination, nil, config do
+        content = ERB.new(::File.binread(source), nil, '-', '@output_buffer').result(context)
+        content = block.call(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/*", 0755
+    #
+    def chmod(path, mode, config={})
+      return if revoke?
+      path = File.expand_path(path, destination_root)
+      shell.say_status :chmod, relative_to_original_destination_root(path), config.fetch(:verbose, true)
+      FileUtils.chmod_R(mode, path) unless options[:pretend]
+    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, &block)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      config.merge!(:after => /\A/)
+      insert_into_file(path, *(args << config), &block)
+    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, &block)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      config.merge!(:before => /\z/)
+      insert_into_file(path, *(args << config), &block)
+    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, &block)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      config.merge!(:after => /class #{klass}\n|class #{klass} .*\n/)
+      insert_into_file(path, *(args << config), &block)
+    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.
+    #
+    # ==== 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 thor!"
+    #   end
+    #
+    def gsub_file(path, flag, *args, &block)
+      return if revoke?
+      config = args.last.is_a?(Hash) ? args.pop : {}
+
+      path = File.expand_path(path, destination_root)
+      shell.say_status :gsub, relative_to_original_destination_root(path), config.fetch(:verbose, true)
+
+      unless options[:pretend]
+        content = File.binread(path)
+        content.gsub!(flag, *args, &block)
+        File.open(path, 'wb') { |file| file.write(content) }
+      end
+    end
+
+    # Uncomment all lines matching a given regex.  It will leave the space
+    # which existed before the comment hash in tact but will remove any spacing
+    # between the comment hash and the beginning of the line.
+    #
+    # ==== 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, *args)
+      flag = flag.respond_to?(:source) ? flag.source : flag
+
+      gsub_file(path, /^(\s*)#\s*(.*#{flag})/, '\1\2', *args)
+    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, *args)
+      flag = flag.respond_to?(:source) ? flag.source : flag
+
+      gsub_file(path, /^(\s*)([^#|\n]*#{flag})/, '\1# \2', *args)
+    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 if revoke?
+      path  = File.expand_path(path, destination_root)
+
+      shell.say_status :remove, relative_to_original_destination_root(path), config.fetch(:verbose, true)
+      ::FileUtils.rm_rf(path) if !options[:pretend] && File.exists?(path)
+    end
+    alias :remove_dir :remove_file
+
+  private
+    attr_accessor :output_buffer
+    def concat(string)
+      @output_buffer.concat(string)
+    end
+
+    def capture(*args, &block)
+      with_output_buffer { block.call(*args) }
+    end
+
+    def with_output_buffer(buf = '') #:nodoc:
+      self.output_buffer, old_buffer = buf, output_buffer
+      yield
+      output_buffer
+    ensure
+      self.output_buffer = old_buffer
+    end
+  end
+end

data/lib/ing/actions/inject_into_file.rb

@@ -0,0 +1,109 @@
+require File.expand_path('empty_directory', File.dirname(__FILE__))
+
+module Ing
+  module Files
+
+    # 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 :thor", :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)
+      if block_given?
+        data, config = block, args.shift
+      else
+        data, config = args.shift, args.shift
+      end
+      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)
+      end
+
+      def invoke!
+        say_status :invoke
+
+        content = if @behavior == :after
+          '\0' + replacement
+        else
+          replacement + '\0'
+        end
+
+        replace!(/#{flag}/, content, config[:force])
+      end
+
+      def revoke!
+        say_status :revoke
+
+        regexp = if @behavior == :after
+          content = '\1\2'
+          /(#{flag})(.*)(#{Regexp.escape(replacement)})/m
+        else
+          content = '\2\3'
+          /(#{Regexp.escape(replacement)})(.*)(#{flag})/m
+        end
+
+        replace!(regexp, content, true)
+      end
+
+      protected
+
+        def say_status(behavior)
+          status = if behavior == :invoke
+            if flag == /\A/
+               :prepend
+            elsif flag == /\z/
+              :append
+            else
+              :insert
+            end
+          else
+            :subtract
+          end
+
+          super(status, config[:verbose])
+        end
+
+        # Adds the content to the file.
+        #
+        def replace!(regexp, string, force)
+          unless base.options[:pretend]
+            content = File.binread(destination)
+            if force || !content.include?(replacement)
+              content.gsub!(regexp, string)
+              File.open(destination, 'wb') { |file| file.write(content) }
+            end
+          end
+        end
+
+    end
+  end
+end

data/lib/ing/commands/boot.rb

@@ -0,0 +1,76 @@
+# Base class
+
+module Ing
+  module Commands
+    class Boot
+    
+      attr_accessor :options 
+      attr_writer :shell
+      
+      def shell
+        @shell ||= ::Ing.shell_class.new
+      end
+      
+      def initialize(options)
+        self.options = options
+        debug "#{__FILE__}:#{__LINE__} :: options #{options.inspect}"
+      end
+      
+      # Runs after options initialized but before any processing of arguments 
+      # or dispatching the command.
+      # Should be implemented in subclasses.
+      def before(*args)
+      end
+
+      # Configure the command prior to dispatch.
+      # Should be implemented in subclasses.
+      # If you want to keep this default behavior setting the shell, 
+      # call +super+ first.
+      def configure_command(cmd)
+        cmd.shell = self.shell if cmd.respond_to?(:"shell=")
+      end
+      
+      # Runs after dispatching the command.
+      # Should be implemented in subclasses.
+      def after
+      end
+      
+      # Main processing of arguments and dispatch from command line (+Ing.run+)
+      def call(*args)
+        before *args
+        ns         = Ing::Util.to_class_names(options[:namespace] || 'object')
+        classes    = Ing::Util.to_class_names(args.shift)
+        debug "#{__FILE__}:#{__LINE__} :: dispatch #{ns.inspect}, #{classes.inspect}, #{args.inspect}"
+        Dispatcher.new(ns, classes, *args).dispatch do |cmd|
+          configure_command cmd
+        end
+        after
+      end
+      
+      # Dispatch from +Ing.invoke+
+      def call_invoke(klass, meth, *args)
+        before *args
+        Dispatcher.invoke(klass, meth, *args) do |cmd|
+          configure_command cmd
+        end
+        after
+      end
+      
+      # Dispatch from +Ing.execute+
+      def call_execute(klass, meth, *args)
+        before *args
+        Dispatcher.execute(klass, meth, *args) do |cmd|
+          configure_command cmd
+        end
+        after
+      end
+      
+      # Internal debugging -- define a :debug option in subclass if you want this
+      def debug(*args)
+        shell.debug(*args) if options[:debug]
+      end
+
+    end
+
+  end
+end