angry_mob 0.1.0

data/vendor/thor/lib/thor/util.rb

@@ -0,0 +1,224 @@
+require 'rbconfig'
+
+class Thor
+  module Sandbox #:nodoc:
+  end
+
+  # This module holds several utilities:
+  #
+  # 1) Methods to convert thor namespaces to constants and vice-versa.
+  #
+  #   Thor::Utils.namespace_from_thor_class(Foo::Bar::Baz) #=> "foo:bar:baz"
+  #
+  # 2) Loading thor files and sandboxing:
+  #
+  #   Thor::Utils.load_thorfile("~/.thor/foo")
+  #
+  module Util
+
+    # Receives a namespace and search for it in the Thor::Base subclasses.
+    #
+    # ==== Parameters
+    # namespace<String>:: The namespace to search for.
+    #
+    def self.find_by_namespace(namespace)
+      namespace = "default#{namespace}" if namespace.empty? || namespace =~ /^:/
+      Thor::Base.subclasses.find { |klass| klass.namespace == namespace }
+    end
+
+    # Receives a constant and converts it to a Thor namespace. Since Thor tasks
+    # can be added to a sandbox, this method is also responsable for removing
+    # the sandbox namespace.
+    #
+    # This method should not be used in general because it's used to deal with
+    # older versions of Thor. On current versions, if you need to get the
+    # namespace from a class, just call namespace on it.
+    #
+    # ==== Parameters
+    # constant<Object>:: The constant to be converted to the thor path.
+    #
+    # ==== Returns
+    # String:: If we receive Foo::Bar::Baz it returns "foo:bar:baz"
+    #
+    def self.namespace_from_thor_class(constant)
+      constant = constant.to_s.gsub(/^Thor::Sandbox::/, "")
+      constant = snake_case(constant).squeeze(":")
+      constant
+    end
+
+    # Given the contents, evaluate it inside the sandbox and returns the
+    # namespaces defined in the sandbox.
+    #
+    # ==== Parameters
+    # contents<String>
+    #
+    # ==== Returns
+    # Array[Object]
+    #
+    def self.namespaces_in_content(contents, file=__FILE__)
+      old_constants = Thor::Base.subclasses.dup
+      Thor::Base.subclasses.clear
+
+      load_thorfile(file, contents)
+
+      new_constants = Thor::Base.subclasses.dup
+      Thor::Base.subclasses.replace(old_constants)
+
+      new_constants.map!{ |c| c.namespace }
+      new_constants.compact!
+      new_constants
+    end
+
+    # Returns the thor classes declared inside the given class.
+    #
+    def self.thor_classes_in(klass)
+      stringfied_constants = klass.constants.map { |c| c.to_s }
+      Thor::Base.subclasses.select do |subclass|
+        next unless subclass.name
+        stringfied_constants.include?(subclass.name.gsub("#{klass.name}::", ''))
+      end
+    end
+
+    # Receives a string and convert it to snake case. SnakeCase returns snake_case.
+    #
+    # ==== Parameters
+    # String
+    #
+    # ==== Returns
+    # String
+    #
+    def self.snake_case(str)
+      return str.downcase if str =~ /^[A-Z_]+$/
+      str.gsub(/\B[A-Z]/, '_\&').squeeze('_') =~ /_*(.*)/
+      return $+.downcase
+    end
+
+    # Receives a string and convert it to camel case. camel_case returns CamelCase.
+    #
+    # ==== Parameters
+    # String
+    #
+    # ==== Returns
+    # String
+    #
+    def self.camel_case(str)
+      return str if str !~ /_/ && str =~ /[A-Z]+.*/
+      str.split('_').map { |i| i.capitalize }.join
+    end
+
+    # Receives a namespace and tries to retrieve a Thor or Thor::Group class
+    # from it. It first searches for a class using the all the given namespace,
+    # if it's not found, removes the highest entry and searches for the class
+    # again. If found, returns the highest entry as the class name.
+    #
+    # ==== Examples
+    #
+    #   class Foo::Bar < Thor
+    #     def baz
+    #     end
+    #   end
+    #
+    #   class Baz::Foo < Thor::Group
+    #   end
+    #
+    #   Thor::Util.namespace_to_thor_class("foo:bar")     #=> Foo::Bar, nil # will invoke default task
+    #   Thor::Util.namespace_to_thor_class("baz:foo")     #=> Baz::Foo, nil
+    #   Thor::Util.namespace_to_thor_class("foo:bar:baz") #=> Foo::Bar, "baz"
+    #
+    # ==== Parameters
+    # namespace<String>
+    #
+    def self.find_class_and_task_by_namespace(namespace, fallback = true)
+      if namespace.include?(?:) # look for a namespaced task
+        pieces = namespace.split(":")
+        task   = pieces.pop
+        klass  = Thor::Util.find_by_namespace(pieces.join(":"))
+      end
+      unless klass # look for a Thor::Group with the right name
+        klass, task = Thor::Util.find_by_namespace(namespace), nil
+      end
+      if !klass && fallback # try a task in the default namespace
+        task = namespace
+        klass = Thor::Util.find_by_namespace('')
+      end
+      return klass, task
+    end
+
+    # Receives a path and load the thor file in the path. The file is evaluated
+    # inside the sandbox to avoid namespacing conflicts.
+    #
+    def self.load_thorfile(path, content=nil)
+      content ||= File.binread(path)
+
+      begin
+        Thor::Sandbox.class_eval(content, path)
+      rescue Exception => e
+        $stderr.puts "WARNING: unable to load thorfile #{path.inspect}: #{e.message}"
+      end
+    end
+
+    def self.user_home
+      @@user_home ||= if ENV["HOME"]
+        ENV["HOME"]
+      elsif ENV["USERPROFILE"]
+        ENV["USERPROFILE"]
+      elsif ENV["HOMEDRIVE"] && ENV["HOMEPATH"]
+        File.join(ENV["HOMEDRIVE"], ENV["HOMEPATH"])
+      elsif ENV["APPDATA"]
+        ENV["APPDATA"]
+      else
+        begin
+          File.expand_path("~")
+        rescue
+          if File::ALT_SEPARATOR
+            "C:/"
+          else
+            "/"
+          end
+        end
+      end
+    end
+
+    # Returns the root where thor files are located, dependending on the OS.
+    #
+    def self.thor_root
+      File.join(user_home, ".thor").gsub(/\\/, '/')
+    end
+
+    # Returns the files in the thor root. On Windows thor_root will be something
+    # like this:
+    #
+    #   C:\Documents and Settings\james\.thor
+    #
+    # If we don't #gsub the \ character, Dir.glob will fail.
+    #
+    def self.thor_root_glob
+      files = Dir["#{thor_root}/*"]
+
+      files.map! do |file|
+        File.directory?(file) ? File.join(file, "main.thor") : file
+      end
+    end
+
+    # Where to look for Thor files.
+    #
+    def self.globs_for(path)
+      ["#{path}/Thorfile", "#{path}/*.thor", "#{path}/tasks/*.thor", "#{path}/lib/tasks/*.thor"]
+    end
+
+    # Return the path to the ruby interpreter taking into account multiple
+    # installations and windows extensions.
+    #
+    def self.ruby_command
+      @ruby_command ||= begin
+        ruby = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+        ruby << Config::CONFIG['EXEEXT']
+
+        # escape string in case path to ruby executable contain spaces.
+        ruby.sub!(/.*\s.*/m, '"\&"')
+        ruby
+      end
+    end
+
+  end
+end

data/vendor/thor/lib/thor/version.rb

@@ -0,0 +1,3 @@
+class Thor
+  VERSION = "0.13.4".freeze
+end

data/vendor/thor/spec/actions/create_file_spec.rb

@@ -0,0 +1,170 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'thor/actions'
+
+describe Thor::Actions::CreateFile do
+  before(:each) do
+    ::FileUtils.rm_rf(destination_root)
+  end
+
+  def create_file(destination=nil, config={}, options={})
+    @base = MyCounter.new([1,2], options, { :destination_root => destination_root })
+    @base.stub!(:file_name).and_return('rdoc')
+
+    @action = Thor::Actions::CreateFile.new(@base, destination, "CONFIGURATION",
+                                            { :verbose => !@silence }.merge(config))
+  end
+
+  def invoke!
+    capture(:stdout){ @action.invoke! }
+  end
+
+  def revoke!
+    capture(:stdout){ @action.revoke! }
+  end
+
+  def silence!
+    @silence = true
+  end
+
+  describe "#invoke!" do
+    it "creates a file" do
+      create_file("doc/config.rb")
+      invoke!
+      File.exists?(File.join(destination_root, "doc/config.rb")).must be_true
+    end
+
+    it "does not create a file if pretending" do
+      create_file("doc/config.rb", {}, :pretend => true)
+      invoke!
+      File.exists?(File.join(destination_root, "doc/config.rb")).must be_false
+    end
+
+    it "shows created status to the user" do
+      create_file("doc/config.rb")
+      invoke!.must == "      create  doc/config.rb\n"
+    end
+
+    it "does not show any information if log status is false" do
+      silence!
+      create_file("doc/config.rb")
+      invoke!.must be_empty
+    end
+
+    it "returns the given destination" do
+      capture(:stdout) do
+        create_file("doc/config.rb").invoke!.must == "doc/config.rb"
+      end
+    end
+
+    it "converts encoded instructions" do
+      create_file("doc/%file_name%.rb.tt")
+      invoke!
+      File.exists?(File.join(destination_root, "doc/rdoc.rb.tt")).must be_true
+    end
+
+    describe "when file exists" do
+      before(:each) do
+        create_file("doc/config.rb")
+        invoke!
+      end
+
+      describe "and is identical" do
+        it "shows identical status" do
+          create_file("doc/config.rb")
+          invoke!
+          invoke!.must == "   identical  doc/config.rb\n"
+        end
+      end
+
+      describe "and is not identical" do
+        before(:each) do
+          File.open(File.join(destination_root, 'doc/config.rb'), 'w'){ |f| f.write("FOO = 3") }
+        end
+
+        it "shows forced status to the user if force is given" do
+          create_file("doc/config.rb", {}, :force => true).must_not be_identical
+          invoke!.must == "       force  doc/config.rb\n"
+        end
+
+        it "shows skipped status to the user if skip is given" do
+          create_file("doc/config.rb", {}, :skip => true).must_not be_identical
+          invoke!.must == "        skip  doc/config.rb\n"
+        end
+
+        it "shows forced status to the user if force is configured" do
+          create_file("doc/config.rb", :force => true).must_not be_identical
+          invoke!.must == "       force  doc/config.rb\n"
+        end
+
+        it "shows skipped status to the user if skip is configured" do
+          create_file("doc/config.rb", :skip => true).must_not be_identical
+          invoke!.must == "        skip  doc/config.rb\n"
+        end
+
+        it "shows conflict status to ther user" do
+          create_file("doc/config.rb").must_not be_identical
+          $stdin.should_receive(:gets).and_return('s')
+          file = File.join(destination_root, 'doc/config.rb')
+
+          content = invoke!
+          content.must =~ /conflict  doc\/config\.rb/
+          content.must =~ /Overwrite #{file}\? \(enter "h" for help\) \[Ynaqdh\]/
+          content.must =~ /skip  doc\/config\.rb/
+        end
+
+        it "creates the file if the file collision menu returns true" do
+          create_file("doc/config.rb")
+          $stdin.should_receive(:gets).and_return('y')
+          invoke!.must =~ /force  doc\/config\.rb/
+        end
+
+        it "skips the file if the file collision menu returns false" do
+          create_file("doc/config.rb")
+          $stdin.should_receive(:gets).and_return('n')
+          invoke!.must =~ /skip  doc\/config\.rb/
+        end
+
+        it "executes the block given to show file content" do
+          create_file("doc/config.rb")
+          $stdin.should_receive(:gets).and_return('d')
+          $stdin.should_receive(:gets).and_return('n')
+          @base.shell.should_receive(:system).with(/diff -u/)
+          invoke!
+        end
+      end
+    end
+  end
+
+  describe "#revoke!" do
+    it "removes the destination file" do
+      create_file("doc/config.rb")
+      invoke!
+      revoke!
+      File.exists?(@action.destination).must be_false
+    end
+
+    it "does not raise an error if the file does not exist" do
+      create_file("doc/config.rb")
+      revoke!
+      File.exists?(@action.destination).must be_false
+    end
+  end
+
+  describe "#exists?" do
+    it "returns true if the destination file exists" do
+      create_file("doc/config.rb")
+      @action.exists?.must be_false
+      invoke!
+      @action.exists?.must be_true
+    end
+  end
+
+  describe "#identical?" do
+    it "returns true if the destination file and is identical" do
+      create_file("doc/config.rb")
+      @action.identical?.must be_false
+      invoke!
+      @action.identical?.must be_true
+    end
+  end
+end

data/vendor/thor/spec/actions/directory_spec.rb

@@ -0,0 +1,131 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'thor/actions'
+
+describe Thor::Actions::Directory do
+  before(:each) do
+    ::FileUtils.rm_rf(destination_root)
+    invoker.stub!(:file_name).and_return("rdoc")
+  end
+
+  def invoker
+    @invoker ||= WhinyGenerator.new([1,2], {}, { :destination_root => destination_root })
+  end
+
+  def revoker
+    @revoker ||= WhinyGenerator.new([1,2], {}, { :destination_root => destination_root, :behavior => :revoke })
+  end
+
+  def invoke!(*args, &block)
+    capture(:stdout){ invoker.directory(*args, &block) }
+  end
+
+  def revoke!(*args, &block)
+    capture(:stdout){ revoker.directory(*args, &block) }
+  end
+
+  def exists_and_identical?(source_path, destination_path)
+    %w(config.rb README).each do |file|
+      source      = File.join(source_root, source_path, file)
+      destination = File.join(destination_root, destination_path, file)
+
+      File.exists?(destination).must be_true
+      FileUtils.identical?(source, destination).must be_true
+    end
+  end
+
+  describe "#invoke!" do
+    it "raises an error if the source does not exist" do
+      lambda {
+        invoke! "unknown"
+      }.must raise_error(Thor::Error, /Could not find "unknown" in source paths/)
+    end
+
+    it "copies the whole directory recursively to the default destination" do
+      invoke! "doc"
+      exists_and_identical?("doc", "doc")
+    end
+
+    it "copies the whole directory recursively to the specified destination" do
+      invoke! "doc", "docs"
+      exists_and_identical?("doc", "docs")
+    end
+
+    it "copies only the first level files if recursive" do
+      invoke! ".", "tasks", :recursive => false
+
+      file = File.join(destination_root, "tasks", "group.thor")
+      File.exists?(file).must be_true
+
+      file = File.join(destination_root, "tasks", "doc")
+      File.exists?(file).must be_false
+
+      file = File.join(destination_root, "tasks", "doc", "README")
+      File.exists?(file).must be_false
+    end
+
+    it "copies files from the source relative to the current path" do
+      invoker.inside "doc" do
+        invoke! "."
+      end
+      exists_and_identical?("doc", "doc")
+    end
+
+    it "copies and evaluates templates" do
+      invoke! "doc", "docs"
+      file = File.join(destination_root, "docs", "rdoc.rb")
+      File.exists?(file).must be_true
+      File.read(file).must == "FOO = FOO\n"
+    end
+
+    it "copies directories" do
+      invoke! "doc", "docs"
+      file = File.join(destination_root, "docs", "components")
+      File.exists?(file).must be_true
+      File.directory?(file).must be_true
+    end
+
+    it "does not copy .empty_diretories files" do
+      invoke! "doc", "docs"
+      file = File.join(destination_root, "docs", "components", ".empty_directory")
+      File.exists?(file).must be_false
+    end
+
+    it "copies directories even if they are empty" do
+      invoke! "doc/components", "docs/components"
+      file = File.join(destination_root, "docs", "components")
+      File.exists?(file).must be_true
+    end
+
+    it "does not copy empty directories twice" do
+      content = invoke!("doc/components", "docs/components")
+      content.must_not =~ /exist/
+    end
+
+    it "logs status" do
+      content = invoke!("doc")
+      content.must =~ /create  doc\/README/
+      content.must =~ /create  doc\/config\.rb/
+      content.must =~ /create  doc\/rdoc\.rb/
+      content.must =~ /create  doc\/components/
+    end
+
+    it "yields a block" do
+      checked = false
+      invoke!("doc") do |content|
+        checked ||= !!(content =~ /FOO/)
+      end
+      checked.must be_true
+    end
+  end
+
+  describe "#revoke!" do
+    it "removes the destination file" do
+      invoke! "doc"
+      revoke! "doc"
+
+      File.exists?(File.join(destination_root, "doc", "README")).must be_false
+      File.exists?(File.join(destination_root, "doc", "config.rb")).must be_false
+      File.exists?(File.join(destination_root, "doc", "components")).must be_false
+    end
+  end
+end