ing 0.1.1

data/ing.rb

@@ -0,0 +1,102 @@
+# Usage:
+# ing rspec:convert    which is equivalent to
+# ing rspec:convert files './{test,spec}/**/*.rb' --convert-dir 'converted'
+#
+module Rspec
+
+  class Convert
+    
+    GSUBS = \
+    [ 
+      [ /^(\s*)(.+)\.should\s+be_true/          , '\1assert \2'            ],
+      [ /^(\s*)(.+)\.should\s+be_false/         , '\1refute \2'            ],
+      [ /^(\s*)(.+)\.should\s*==\s*(.+)$/       , '\1assert_equal \3, \2'  ],
+      [ /^(\s*)(.+)\.should_not\s*==\s*(.+)$/   , '\1refute_equal \3, \2'  ],
+      [ /^(\s*)(.+)\.should\s*=~\s*(.+)$/       , '\1assert_match(\3, \2)' ],
+      [ /^(\s*)(.+)\.should_not\s*=~\s*(.+)$/   , '\1refute_match(\3, \2)' ],
+      [ /^(\s*)(.+)\.should\s+be_(.+)$/         , '\1assert \2.\3?'        ],
+      [ /^(\s*)(.+)\.should_not\s+be_(.+)$/     , '\1refute \2.\3?'        ],
+      [ /expect\s+\{(.+)\}\.to\s+raise_error\s*\((.*)\)\s*\Z/m, 
+        'assert_raises(\2) {\1}'                                      ],
+      [ /\{(.+)\}\.should raise_error\s*\((.*)\)\s*\Z/m,
+        'assert_raises(\2) {\1}'                                        ],
+    # these next aren't quite right because they need to wrap the next 
+    # lines as a lambda. Thus the FIXME notes.
+      [ /\.should_receive\(([^\)]+)\)\.and_return\((.+)\)/,  
+        '.stub(\1, \2) do |s|  # FIXME'                                 ],
+      [ /.stub\!\(([\w:]+)\)\.and_return\((.+)\)/,
+        '.stub(\1, \2) do |s|  # FIXME'                                 ]
+      
+    ]
+    
+    def self.specify_options(expect)
+      expect.banner "Convert rspec 'should/not' matchers to minitest 'assert/refute'"
+      expect.text "It's not magic, you still need to hand edit your test files after running this"
+      expect.text "\nUsage:"
+      expect.text "  ing rspec:convert    # which is equivalent to"
+      expect.text "  ing rspec:convert files './{test,spec}/**/*.rb' --convert-dir 'converted'"
+      expect.text "\nOptions:"
+      expect.opt :pattern, "Directory glob pattern for test files",
+                 :type => :string, :default => './{test,spec}/**/*.rb'
+      expect.opt :convert_dir, "Subdirectory to save converted files",
+                 :type => :string, :default => 'converted'
+    end
+    
+    include Ing::Files
+    
+    attr_accessor :shell, :options, :destination_root, :source_root
+    
+    def destination_root; @destination_root ||= Dir.pwd; end
+    def source_root;      @source_root ||= File.dirname(__FILE__); end
+    
+    def input_files
+      @input_files ||= Dir[ File.expand_path(options[:pattern], source_root) ]
+    end
+    
+    def converted_files
+      input_files.map {|f|
+        File.join( File.dirname(f), options[:convert_dir], File.basename(f) )
+      }
+    end
+    
+    def conversion_map
+      input_files.zip(converted_files)
+    end
+    
+    def initialize(options)
+      self.options = options
+    end
+    
+    def call(pattern=nil)
+      options[:pattern] = pattern || options[:pattern]
+      shell.say "Processing #{input_files.length} input files: #{options[:pattern]}" if verbose?
+      conversion_map.each do |input_f, output_f|
+        new_lines = convert_lines(input_f)
+        create_file output_f, new_lines.join
+      end
+    end
+    alias :files :call
+    
+    private
+    
+    def convert_lines(fname)
+      count = 0; accum = []
+      File.open(fname) do |f|
+        f.each_line do |line|
+          new_line = GSUBS.inject(line) do |str, (rx, replace)|
+            str = str.gsub(rx, replace)
+          end
+          count += 1 if line != new_line
+          accum << new_line
+        end
+      end
+      shell.say_status(:convert, 
+                       "#{relative_to_original_destination_root(fname)}: " +
+                         "#{count} changes", 
+                       :green) if verbose?
+      accum
+    end
+        
+  end
+  
+end

data/lib/ing.rb

@@ -0,0 +1,78 @@
+['ing/version',
+ 'ing/lib_trollop',
+ 'ing/trollop/parser',
+ 'ing/util',
+ 'ing/dispatcher',
+ 'ing/shell',
+ 'ing/files',
+ 'ing/commands/boot',
+ 'ing/commands/implicit',
+ 'ing/commands/list',
+ 'ing/commands/help',
+ 'ing/commands/generate'
+].each do |f| 
+  require_relative f
+end
+
+module Ing
+  extend self
+  
+  Error = Class.new(StandardError)
+  FileNotFoundError = Class.new(Error)
+  
+  attr_writer :shell_class
+
+  def shell_class
+    @shell_class ||= Shell::Basic
+  end
+      
+  def implicit_booter
+    ["Implicit"]
+  end
+  
+  # Dispatch command line to boot class (if specified, or Implicit otherwise), 
+  # which in turn dispatches the command after parsing args. 
+  #
+  # Note boot dispatch happens within +Ing::Commands+ namespace.
+  #
+  def run(argv=ARGV)
+    booter = extract_boot_class!(argv) || implicit_booter
+    run_boot booter, "call", *argv
+  end
+  
+  # Dispatch to the command via +Ing::Boot#call_invoke+
+  # Use this when you want to invoke a command from another command, but only
+  # if it hasn't been run yet. For example,
+  #
+  #   invoke Some::Task, :some_instance_method, some_argument, :some_option => true
+  #
+  # You can skip the method and it will assume +#call+ :
+  #
+  #   invoke Some::Task, :some_option => true
+  def invoke(klass, *args)
+    run_boot implicit_booter, "call_invoke", klass, *args
+  end
+  
+  # Dispatch to the command via +Ing::Boot#call_execute+
+  # Use this when you want to execute a command from another command, and you
+  # don't care if it has been run yet or not. See equivalent examples for 
+  # +invoke+.
+  #
+  def execute(klass, *args)
+    run_boot implicit_booter, "call_execute", klass, *args
+  end
+  
+  private
+  
+  def run_boot(booter, *args)
+    Dispatcher.new(["Ing","Commands"], booter, *args).dispatch
+  end
+  
+  def extract_boot_class!(args)
+    c = Util.to_class_names(args.first)
+    if (Commands.const_defined?(c.first, false) rescue nil)
+      args.shift; c
+    end
+  end
+
+end

data/lib/ing/actions/create_file.rb

@@ -0,0 +1,105 @@
+require File.expand_path('empty_directory', File.dirname(__FILE__))
+
+module Ing
+  module Files
+
+    # 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/apache.conf", "your apache config"
+    #
+    def create_file(destination, *args, &block)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      data = args.first
+      action CreateFile.new(self, destination, block || data.to_s, config)
+    end
+    alias :add_file :create_file
+
+    # CreateFile 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/ing/actions/create_link.rb

@@ -0,0 +1,57 @@
+require File.expand_path('create_file', File.dirname(__FILE__))
+
+module Ing
+  module Files
+
+    # Create a new file relative to the destination root from the given source.
+    #
+    # ==== Parameters
+    # destination<String>:: the relative path to the destination root.
+    # source<String|NilClass>:: the relative path to the source root.
+    # config<Hash>:: give :verbose => false to not log the status.
+    #   :: give :symbolic => false for hard link.
+    #
+    # ==== Examples
+    #
+    #   create_link "config/apache.conf", "/etc/apache.conf"
+    #
+    def create_link(destination, *args, &block)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      source = args.first
+      action CreateLink.new(self, destination, source, config)
+    end
+    alias :add_link :create_link
+
+    # CreateLink is a subset of CreateFile, which instead of taking a block of
+    # data, just takes a source string from the user.
+    #
+    class CreateLink < CreateFile #:nodoc:
+      attr_reader :data
+
+      # 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.identical?(render, destination)
+      end
+
+      def invoke!
+        invoke_with_conflict_check do
+          FileUtils.mkdir_p(File.dirname(destination))
+          # Create a symlink by default
+          config[:symbolic] = true if config[:symbolic].nil?
+          File.unlink(destination) if exists?
+          if config[:symbolic]
+            File.symlink(render, destination)
+          else
+            File.link(render, destination)
+          end
+        end
+        given_destination
+      end
+
+    end
+  end
+end

data/lib/ing/actions/directory.rb

@@ -0,0 +1,98 @@
+require File.expand_path('empty_directory', File.dirname(__FILE__))
+
+module Ing
+  module Files
+    # 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. If any file name is wrapped within % signs, the text within
+    # the % signs will be executed as a method and replaced with the returned
+    # value. 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` method returns the value "blog"):
+    #
+    #   doc/
+    #     components/
+    #     README
+    #     rdoc.rb
+    #     blog.rb
+    #
+    # <b>Encoded path note:</b> Since Thor internals use Object#respond_to? to check if it can
+    # expand %something%, this `something` should be a public method in the class calling
+    # #directory. If a method is private, Thor stack raises PrivateMethodEncodedError.
+    #
+    # ==== 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, *args, &block)
+      config = args.last.is_a?(Hash) ? args.pop : {}
+      destination = args.first || source
+      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 = Util.escape_globs(source)
+          lookup = config[:recursive] ? File.join(lookup, '**') : lookup
+          lookup = File.join(lookup, '{*,.[a-z]*}')
+
+          Dir[lookup].sort.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/ing/actions/empty_directory.rb

@@ -0,0 +1,155 @@
+module Ing
+  module Files
+
+    # 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.current_destination)
+            @relative_destination = base.relative_to_original_destination_root(@destination)
+          end
+        end
+
+        # Filenames in the encoded form are converted. If you have a file:
+        #
+        #   %file_name%.rb
+        #
+        # It calls #file_name from the base and replaces %-string with the
+        # return value (should be String) of #file_name:
+        #
+        #   user.rb
+        #
+        # The method referenced by %-string SHOULD be public. Otherwise you
+        # get the exception with the corresponding error message.
+        #
+        def convert_encoded_instructions(filename)
+          filename.gsub(/%(.*?)%/) do |initial_string|
+            call_public_method($1.strip) or initial_string
+          end
+        end
+
+#TODO: base.public_send(sym) rescue nil      instead?
+
+        # Calls `base`'s public method `sym`.
+        # Returns:: result of `base.sym` or `nil` if `sym` wasn't found in
+        #  `base`
+        # Raises::  NoMethodError if `sym` references
+        #  a private method.
+        def call_public_method(sym)
+          if base.respond_to?(sym)
+            base.send(sym)
+          elsif base.respond_to?(sym, true)
+            raise NoMethodError,
+              "Method #{base.class}##{sym} should be public, not private"
+          else
+            nil
+          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