amqp-daemon-kit 0.1.8.1

data/lib/daemon_kit/vendor/thor-0.13.6/lib/thor/actions/create_file.rb

@@ -0,0 +1,103 @@
+require 'thor/actions/empty_directory'
+
+class Thor
+  module Actions
+
+    # Create a new file relative to the destination root with the given data,
+    # which is the return value of a block or a data string.
+    #
+    # ==== Parameters
+    # destination<String>:: the relative path to the destination root.
+    # data<String|NilClass>:: the data to append to the file.
+    # config<Hash>:: give :verbose => false to not log the status.
+    #
+    # ==== Examples
+    #
+    #   create_file "lib/fun_party.rb" do
+    #     hostname = ask("What is the virtual hostname I should use?")
+    #     "vhost.name = #{hostname}"
+    #   end
+    #
+    #   create_file "config/apach.conf", "your apache config"
+    #
+    def create_file(destination, data=nil, config={}, &block)
+      action CreateFile.new(self, destination, block || data.to_s, config)
+    end
+    alias :add_file :create_file
+
+    # AddFile is a subset of Template, which instead of rendering a file with
+    # ERB, it gets the content from the user.
+    #
+    class CreateFile < EmptyDirectory #:nodoc:
+      attr_reader :data
+
+      def initialize(base, destination, data, config={})
+        @data = data
+        super(base, destination, config)
+      end
+
+      # Checks if the content of the file at the destination is identical to the rendered result.
+      #
+      # ==== Returns
+      # Boolean:: true if it is identical, false otherwise.
+      #
+      def identical?
+        exists? && File.binread(destination) == render
+      end
+
+      # Holds the content to be added to the file.
+      #
+      def render
+        @render ||= if data.is_a?(Proc)
+          data.call
+        else
+          data
+        end
+      end
+
+      def invoke!
+        invoke_with_conflict_check do
+          FileUtils.mkdir_p(File.dirname(destination))
+          File.open(destination, 'wb') { |f| f.write render }
+        end
+        given_destination
+      end
+
+      protected
+
+        # Now on conflict we check if the file is identical or not.
+        #
+        def on_conflict_behavior(&block)
+          if identical?
+            say_status :identical, :blue
+          else
+            options = base.options.merge(config)
+            force_or_skip_or_conflict(options[:force], options[:skip], &block)
+          end
+        end
+
+        # If force is true, run the action, otherwise check if it's not being
+        # skipped. If both are false, show the file_collision menu, if the menu
+        # returns true, force it, otherwise skip.
+        #
+        def force_or_skip_or_conflict(force, skip, &block)
+          if force
+            say_status :force, :yellow
+            block.call unless pretend?
+          elsif skip
+            say_status :skip, :yellow
+          else
+            say_status :conflict, :red
+            force_or_skip_or_conflict(force_on_collision?, true, &block)
+          end
+        end
+
+        # Shows the file collision menu to the user and gets the result.
+        #
+        def force_on_collision?
+          base.shell.file_collision(destination){ render }
+        end
+
+    end
+  end
+end

data/lib/daemon_kit/vendor/thor-0.13.6/lib/thor/actions/directory.rb

@@ -0,0 +1,91 @@
+require 'thor/actions/empty_directory'
+
+class Thor
+  module Actions
+
+    # Copies recursively the files from source directory to root directory.
+    # If any of the files finishes with .tt, it's considered to be a template
+    # and is placed in the destination without the extension .tt. If any
+    # empty directory is found, it's copied and all .empty_directory files are
+    # ignored. Remember that file paths can also be encoded, let's suppose a doc
+    # directory with the following files:
+    #
+    #   doc/
+    #     components/.empty_directory
+    #     README
+    #     rdoc.rb.tt
+    #     %app_name%.rb
+    #
+    # When invoked as:
+    #
+    #   directory "doc"
+    #
+    # It will create a doc directory in the destination with the following
+    # files (assuming that the app_name is "blog"):
+    #
+    #   doc/
+    #     components/
+    #     README
+    #     rdoc.rb
+    #     blog.rb
+    #
+    # ==== 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.
+    #                If :recursive => false, does not look for paths recursively.
+    #
+    # ==== Examples
+    #
+    #   directory "doc"
+    #   directory "doc", "docs", :recursive => false
+    #
+    def directory(source, destination=nil, config={}, &block)
+      action Directory.new(self, source, destination || source, config, &block)
+    end
+
+    class Directory < EmptyDirectory #:nodoc:
+      attr_reader :source
+
+      def initialize(base, source, destination=nil, config={}, &block)
+        @source = File.expand_path(base.find_in_source_paths(source.to_s))
+        @block  = block
+        super(base, destination, { :recursive => true }.merge(config))
+      end
+
+      def invoke!
+        base.empty_directory given_destination, config
+        execute!
+      end
+
+      def revoke!
+        execute!
+      end
+
+      protected
+
+        def execute!
+          lookup = config[:recursive] ? File.join(source, '**') : source
+          lookup = File.join(lookup, '{*,.[a-z]*}')
+
+          Dir[lookup].each do |file_source|
+            next if File.directory?(file_source)
+            file_destination = File.join(given_destination, file_source.gsub(source, '.'))
+            file_destination.gsub!('/./', '/')
+
+            case file_source
+              when /\.empty_directory$/
+                dirname = File.dirname(file_destination).gsub(/\/\.$/, '')
+                next if dirname == given_destination
+                base.empty_directory(dirname, config)
+              when /\.tt$/
+                destination = base.template(file_source, file_destination[0..-4], config, &@block)
+              else
+                destination = base.copy_file(file_source, file_destination, config, &@block)
+            end
+          end
+        end
+
+    end
+  end
+end

data/lib/daemon_kit/vendor/thor-0.13.6/lib/thor/actions/empty_directory.rb

@@ -0,0 +1,134 @@
+class Thor
+  module Actions
+
+    # Creates an empty directory.
+    #
+    # ==== Parameters
+    # destination<String>:: the relative path to the destination root.
+    # config<Hash>:: give :verbose => false to not log the status.
+    #
+    # ==== Examples
+    #
+    #   empty_directory "doc"
+    #
+    def empty_directory(destination, config={})
+      action EmptyDirectory.new(self, destination, config)
+    end
+
+    # Class which holds create directory logic. This is the base class for
+    # other actions like create_file and directory.
+    #
+    # This implementation is based in Templater actions, created by Jonas Nicklas
+    # and Michael S. Klishin under MIT LICENSE.
+    #
+    class EmptyDirectory #:nodoc:
+      attr_reader :base, :destination, :given_destination, :relative_destination, :config
+
+      # Initializes given the source and destination.
+      #
+      # ==== Parameters
+      # base<Thor::Base>:: A Thor::Base instance
+      # source<String>:: Relative path to the source of this file
+      # destination<String>:: Relative path to the destination of this file
+      # config<Hash>:: give :verbose => false to not log the status.
+      #
+      def initialize(base, destination, config={})
+        @base, @config   = base, { :verbose => true }.merge(config)
+        self.destination = destination
+      end
+
+      # Checks if the destination file already exists.
+      #
+      # ==== Returns
+      # Boolean:: true if the file exists, false otherwise.
+      #
+      def exists?
+        ::File.exists?(destination)
+      end
+
+      def invoke!
+        invoke_with_conflict_check do
+          ::FileUtils.mkdir_p(destination)
+        end
+      end
+
+      def revoke!
+        say_status :remove, :red
+        ::FileUtils.rm_rf(destination) if !pretend? && exists?
+        given_destination
+      end
+
+      protected
+
+        # Shortcut for pretend.
+        #
+        def pretend?
+          base.options[:pretend]
+        end
+
+        # Sets the absolute destination value from a relative destination value.
+        # It also stores the given and relative destination. Let's suppose our
+        # script is being executed on "dest", it sets the destination root to
+        # "dest". The destination, given_destination and relative_destination
+        # are related in the following way:
+        #
+        #   inside "bar" do
+        #     empty_directory "baz"
+        #   end
+        #
+        #   destination          #=> dest/bar/baz
+        #   relative_destination #=> bar/baz
+        #   given_destination    #=> baz
+        #
+        def destination=(destination)
+          if destination
+            @given_destination = convert_encoded_instructions(destination.to_s)
+            @destination = ::File.expand_path(@given_destination, base.destination_root)
+            @relative_destination = base.relative_to_original_destination_root(@destination)
+          end
+        end
+
+        # Filenames in the encoded form are converted. If you have a file:
+        #
+        #   %class_name%.rb
+        #
+        # It gets the class name from the base and replace it:
+        #
+        #   user.rb
+        #
+        def convert_encoded_instructions(filename)
+          filename.gsub(/%(.*?)%/) do |string|
+            instruction = $1.strip
+            base.respond_to?(instruction) ? base.send(instruction) : string
+          end
+        end
+
+        # Receives a hash of options and just execute the block if some
+        # conditions are met.
+        #
+        def invoke_with_conflict_check(&block)
+          if exists?
+            on_conflict_behavior(&block)
+          else
+            say_status :create, :green
+            block.call unless pretend?
+          end
+
+          destination
+        end
+
+        # What to do when the destination file already exists.
+        #
+        def on_conflict_behavior(&block)
+          say_status :exist, :blue
+        end
+
+        # Shortcut to say_status shell method.
+        #
+        def say_status(status, color)
+          base.shell.say_status status, relative_destination, color if config[:verbose]
+        end
+
+    end
+  end
+end

data/lib/daemon_kit/vendor/thor-0.13.6/lib/thor/actions/file_manipulation.rb

@@ -0,0 +1,223 @@
+require 'erb'
+require 'open-uri'
+
+class Thor
+  module Actions
+
+    # 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, destination=nil, config={}, &block)
+      destination ||= 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
+
+    # 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, destination=nil, config={}, &block)
+      source = File.expand_path(find_in_source_paths(source.to_s)) unless source =~ /^http\:\/\//
+      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, destination=nil, config={}, &block)
+      destination ||= source
+      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, '-').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 unless behavior == :invoke
+      path = File.expand_path(path, destination_root)
+      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 inject_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_file 'config/environments/test.rb', 'config.gem "rspec"'
+    #
+    #   prepend_file 'config/environments/test.rb' do
+    #     'config.gem "rspec"'
+    #   end
+    #
+    def prepend_file(path, *args, &block)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      config.merge!(:after => /\A/)
+      inject_into_file(path, *(args << config), &block)
+    end
+
+    # Append text to a file. Since it depends on inject_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_file 'config/environments/test.rb', 'config.gem "rspec"'
+    #
+    #   append_file 'config/environments/test.rb' do
+    #     'config.gem "rspec"'
+    #   end
+    #
+    def append_file(path, *args, &block)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      config.merge!(:before => /\z/)
+      inject_into_file(path, *(args << config), &block)
+    end
+
+    # Injects text right after the class definition. Since it depends on
+    # inject_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", "  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/)
+      inject_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 unless behavior == :invoke
+      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)
+
+      unless options[:pretend]
+        content = File.binread(path)
+        content.gsub!(flag, *args, &block)
+        File.open(path, 'wb') { |file| file.write(content) }
+      end
+    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)
+      ::FileUtils.rm_rf(path) if !options[:pretend] && File.exists?(path)
+    end
+    alias :remove_dir :remove_file
+
+  end
+end