module Thor::Actions

def self.included(base) #:nodoc:
  base.extend ClassMethods
end

def _cleanup_options_and_set(options, key) #:nodoc:
  case options
    when Array
      %w(--force -f --skip -s).each { |i| options.delete(i) }
      options << "--#{key}"
    when Hash
      [:force, :skip, "force", "skip"].each { |i| options.delete(i) }
      options.merge!(key => true)
  end
end

def _shared_configuration #:nodoc:
  super.merge!(:destination_root => self.destination_root)
end

def action(instance) #:nodoc:
  if behavior == :revoke
    instance.revoke!
  else
    instance.invoke!
  end
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

def apply(path, config={})
  verbose = config.fetch(:verbose, true)
  path    = find_in_source_paths(path) unless path =~ /^http\:\/\//
  say_status :apply, path, verbose
  shell.padding += 1 if verbose
  if URI(path).is_a?(URI::HTTP)
    contents = open(path, "Accept" => "application/x-thor-template") {|io| io.read }
  else
    contents = open(path) {|io| io.read }
  end
  instance_eval(contents, path)
  shell.padding -= 1 if verbose
end

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

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

def create_file(destination, data=nil, config={}, &block)
  action CreateFile.new(self, destination, block || data.to_s, config)
end

def destination_root
  @destination_stack.last
end

def destination_root=(root)
  @destination_stack ||= []
  @destination_stack[0] = File.expand_path(root || '')
end

def directory(source, destination=nil, config={}, &block)
  action Directory.new(self, source, destination || source, config, &block)
end

def empty_directory(destination, config={})
  action EmptyDirectory.new(self, destination, config)
end

def find_in_source_paths(file)
  relative_root = relative_to_original_destination_root(destination_root, false)
  source_paths.each do |source|
    source_file = File.expand_path(file, File.join(source, relative_root))
    return source_file if File.exists?(source_file)
  end
  if source_paths.empty?
    raise Error, "You don't have any source path defined for class #{self.class.name}. To fix this, " <<
                 "you can define a source_root in your class."
  else
    raise Error, "Could not find #{file.inspect} in source paths: \n#{source_paths.join("\n")}"
  end
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

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

def in_root
  inside(@destination_stack.first) { yield }
end

def initialize(args=[], options={}, config={})
  self.behavior = case config[:behavior].to_s
    when "force", "skip"
      _cleanup_options_and_set(options, config[:behavior])
      :invoke
    when "revoke"
      :revoke
    else
      :invoke
  end
  super
  self.destination_root = config[:destination_root]
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

def inject_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

def inside(dir='', config={}, &block)
  verbose = config.fetch(:verbose, false)
  say_status :inside, dir, verbose
  shell.padding += 1 if verbose
  @destination_stack.push File.expand_path(dir, destination_root)
  FileUtils.mkdir_p(destination_root) unless File.exist?(destination_root)
  FileUtils.cd(destination_root) { block.arity == 1 ? yield(destination_root) : yield }
  @destination_stack.pop
  shell.padding -= 1 if verbose
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

def relative_to_original_destination_root(path, remove_dot=true)
  path = path.gsub(@destination_stack[0], '.')
  remove_dot ? (path[2..-1] || '') : path
end

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

def run(command, config={})
  return unless behavior == :invoke
  destination = relative_to_original_destination_root(destination_root, false)
  desc = "#{command} from #{destination.inspect}"
  if config[:with]
    desc = "#{File.basename(config[:with].to_s)} #{desc}"
    command = "#{config[:with]} #{command}"
  end
  say_status :run, desc, config.fetch(:verbose, true)
  `#{command}` unless options[:pretend]
end

def run_ruby_script(command, config={})
  return unless behavior == :invoke
  run command, config.merge(:with => Thor::Util.ruby_command)
end

def source_paths
  @source_paths ||= self.class.source_paths_for_search
end

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

def thor(task, *args)
  config  = args.last.is_a?(Hash) ? args.pop : {}
  verbose = config.key?(:verbose) ? config.delete(:verbose) : true
  pretend = config.key?(:pretend) ? config.delete(:pretend) : false
  args.unshift task
  args.push Thor::Options.to_switches(config)
  command = args.join(' ').strip
  run command, :with => :thor, :verbose => verbose, :pretend => pretend
end