angry_mob 0.1.0

data/vendor/thor/lib/thor/parser/options.rb

@@ -0,0 +1,169 @@
+class Thor
+  # This is a modified version of Daniel Berger's Getopt::Long class, licensed
+  # under Ruby's license.
+  #
+  class Options < Arguments #:nodoc:
+    LONG_RE     = /^(--\w+(?:-\w+)*)$/
+    SHORT_RE    = /^(-[a-z])$/i
+    EQ_RE       = /^(--\w+(?:-\w+)*|-[a-z])=(.*)$/i
+    SHORT_SQ_RE = /^-([a-z]{2,})$/i # Allow either -x -v or -xv style for single char args
+    SHORT_NUM   = /^(-[a-z])#{NUMERIC}$/i
+
+    # Receives a hash and makes it switches.
+    def self.to_switches(options)
+      options.map do |key, value|
+        case value
+          when true
+            "--#{key}"
+          when Array
+            "--#{key} #{value.map{ |v| v.inspect }.join(' ')}"
+          when Hash
+            "--#{key} #{value.map{ |k,v| "#{k}:#{v}" }.join(' ')}"
+          when nil, false
+            ""
+          else
+            "--#{key} #{value.inspect}"
+        end
+      end.join(" ")
+    end
+
+    # Takes a hash of Thor::Option and a hash with defaults.
+    def initialize(hash_options={}, defaults={})
+      options = hash_options.values
+      super(options)
+
+      # Add defaults
+      defaults.each do |key, value|
+        @assigns[key.to_s] = value
+        @non_assigned_required.delete(hash_options[key])
+      end
+
+      @shorts, @switches, @unknown = {}, {}, []
+
+      options.each do |option|
+        @switches[option.switch_name] = option
+
+        option.aliases.each do |short|
+          @shorts[short.to_s] ||= option.switch_name
+        end
+      end
+    end
+
+    def parse(args)
+      @pile = args.dup
+
+      while peek
+        if current_is_switch?
+          case shift
+            when SHORT_SQ_RE
+              unshift($1.split('').map { |f| "-#{f}" })
+              next
+            when EQ_RE, SHORT_NUM
+              unshift($2)
+              switch = $1
+            when LONG_RE, SHORT_RE
+              switch = $1
+          end
+
+          switch = normalize_switch(switch)
+          option = switch_option(switch)
+          @assigns[option.human_name] = parse_peek(switch, option)
+        elsif current_is_switch_formatted?
+          @unknown << shift
+        else
+          shift
+        end
+      end
+
+      check_requirement!
+
+      assigns = Thor::CoreExt::HashWithIndifferentAccess.new(@assigns)
+      assigns.freeze
+      assigns
+    end
+
+    def check_unknown!
+      raise UnknownArgumentError, "Unknown switches '#{@unknown.join(', ')}'" unless @unknown.empty?
+    end
+
+    protected
+
+      # Returns true if the current value in peek is a registered switch.
+      #
+      def current_is_switch?
+        case peek
+          when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM
+            switch?($1)
+          when SHORT_SQ_RE
+            $1.split('').any? { |f| switch?("-#{f}") }
+        end
+      end
+
+      def switch_formatted?(arg)
+        case arg
+        when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM, SHORT_SQ_RE
+          true
+        else
+          false
+        end
+      end
+
+      def current_is_switch_formatted?
+        switch_formatted? peek
+      end
+
+      def switch?(arg)
+        switch_option(arg) || @shorts.key?(arg)
+      end
+
+      def switch_option(arg)
+        if match = no_or_skip?(arg)
+          @switches[arg] || @switches["--#{match}"]
+        else
+          @switches[arg]
+        end
+      end
+
+      def no_or_skip?(arg)
+        arg =~ /^--(no|skip)-([-\w]+)$/
+        $2
+      end
+
+      # Check if the given argument is actually a shortcut.
+      #
+      def normalize_switch(arg)
+        @shorts.key?(arg) ? @shorts[arg] : arg
+      end
+
+      # Parse boolean values which can be given as --foo=true, --foo or --no-foo.
+      #
+      def parse_boolean(switch)
+        if current_is_value?
+          ["true", "TRUE", "t", "T", true].include?(shift)
+        else
+          @switches.key?(switch) || !no_or_skip?(switch)
+        end
+      end
+
+      # Parse the value at the peek analyzing if it requires an input or not.
+      #
+      def parse_peek(switch, option)
+        if current_is_switch_formatted? || last?
+          if option.boolean?
+            # No problem for boolean types
+          elsif no_or_skip?(switch)
+            return nil # User set value to nil
+          elsif option.string? && !option.required?
+            # Return the default if there is one, else the human name
+            return option.default || option.human_name
+          else
+            raise MalformattedArgumentError, "No value provided for option '#{switch}'"
+          end
+        end
+
+        @non_assigned_required.delete(option)
+        send(:"parse_#{option.type}", switch)
+      end
+
+  end
+end

data/vendor/thor/lib/thor/rake_compat.rb

@@ -0,0 +1,66 @@
+require 'rake'
+
+class Thor
+  # Adds a compatibility layer to your Thor classes which allows you to use
+  # rake package tasks. For example, to use rspec rake tasks, one can do:
+  #
+  #   require 'thor/rake_compat'
+  #
+  #   class Default < Thor
+  #     include Thor::RakeCompat
+  #
+  #     Spec::Rake::SpecTask.new(:spec) do |t|
+  #       t.spec_opts = ['--options', "spec/spec.opts"]
+  #       t.spec_files = FileList['spec/**/*_spec.rb']
+  #     end
+  #   end
+  #
+  module RakeCompat
+    def self.rake_classes
+      @rake_classes ||= []
+    end
+
+    def self.included(base)
+      # Hack. Make rakefile point to invoker, so rdoc task is generated properly.
+      rakefile = File.basename(caller[0].match(/(.*):\d+/)[1])
+      Rake.application.instance_variable_set(:@rakefile, rakefile)
+      self.rake_classes << base
+    end
+  end
+end
+
+class Object #:nodoc:
+  alias :rake_task :task
+  alias :rake_namespace :namespace
+
+  def task(*args, &block)
+    task = rake_task(*args, &block)
+
+    if klass = Thor::RakeCompat.rake_classes.last
+      non_namespaced_name = task.name.split(':').last
+
+      description = non_namespaced_name
+      description << task.arg_names.map{ |n| n.to_s.upcase }.join(' ')
+      description.strip!
+
+      klass.desc description, task.comment || non_namespaced_name
+      klass.send :define_method, non_namespaced_name do |*args|
+        Rake::Task[task.name.to_sym].invoke(*args)
+      end
+    end
+
+    task
+  end
+
+  def namespace(name, &block)
+    if klass = Thor::RakeCompat.rake_classes.last
+      const_name = Thor::Util.camel_case(name.to_s).to_sym
+      klass.const_set(const_name, Class.new(Thor))
+      new_klass = klass.const_get(const_name)
+      Thor::RakeCompat.rake_classes << new_klass
+    end
+
+    rake_namespace(name, &block)
+    Thor::RakeCompat.rake_classes.pop
+  end
+end

data/vendor/thor/lib/thor/runner.rb

@@ -0,0 +1,314 @@
+require 'thor'
+require 'thor/group'
+require 'thor/core_ext/file_binary_read'
+
+require 'fileutils'
+require 'open-uri'
+require 'yaml'
+require 'digest/md5'
+require 'pathname'
+
+class Thor::Runner < Thor #:nodoc:
+  map "-T" => :list, "-i" => :install, "-u" => :update, "-v" => :version
+
+  # Override Thor#help so it can give information about any class and any method.
+  #
+  def help(meth=nil)
+    if meth && !self.respond_to?(meth)
+      initialize_thorfiles(meth)
+      klass, task = Thor::Util.find_class_and_task_by_namespace(meth)
+      klass.start(["-h", task].compact, :shell => self.shell)
+    else
+      super
+    end
+  end
+
+  # If a task is not found on Thor::Runner, method missing is invoked and
+  # Thor::Runner is then responsable for finding the task in all classes.
+  #
+  def method_missing(meth, *args)
+    meth = meth.to_s
+    initialize_thorfiles(meth)
+    klass, task = Thor::Util.find_class_and_task_by_namespace(meth)
+    args.unshift(task) if task
+    klass.start(args, :shell => self.shell)
+  end
+
+  desc "install NAME", "Install an optionally named Thor file into your system tasks"
+  method_options :as => :string, :relative => :boolean, :force => :boolean
+  def install(name)
+    initialize_thorfiles
+
+    # If a directory name is provided as the argument, look for a 'main.thor' 
+    # task in said directory.
+    begin
+      if File.directory?(File.expand_path(name))
+        base, package = File.join(name, "main.thor"), :directory
+        contents      = open(base).read
+      else
+        base, package = name, :file
+        contents      = open(name).read
+      end
+    rescue OpenURI::HTTPError
+      raise Error, "Error opening URI '#{name}'"
+    rescue Errno::ENOENT
+      raise Error, "Error opening file '#{name}'"
+    end
+
+    say "Your Thorfile contains:"
+    say contents
+
+    unless options["force"]
+      return false if no?("Do you wish to continue [y/N]?")
+    end
+
+    as = options["as"] || begin
+      first_line = contents.split("\n")[0]
+      (match = first_line.match(/\s*#\s*module:\s*([^\n]*)/)) ? match[1].strip : nil
+    end
+
+    unless as
+      basename = File.basename(name)
+      as = ask("Please specify a name for #{name} in the system repository [#{basename}]:")
+      as = basename if as.empty?
+    end
+
+    location = if options[:relative] || name =~ /^http:\/\//
+      name
+    else
+      File.expand_path(name)
+    end
+
+    thor_yaml[as] = {
+      :filename   => Digest::MD5.hexdigest(name + as),
+      :location   => location,
+      :namespaces => Thor::Util.namespaces_in_content(contents, base)
+    }
+
+    save_yaml(thor_yaml)
+    say "Storing thor file in your system repository"
+    destination = File.join(thor_root, thor_yaml[as][:filename])
+
+    if package == :file
+      File.open(destination, "w") { |f| f.puts contents }
+    else
+      FileUtils.cp_r(name, destination)
+    end
+
+    thor_yaml[as][:filename] # Indicate success
+  end
+
+  desc "version", "Show Thor version"
+  def version
+    require 'thor/version'
+    say "Thor #{Thor::VERSION}"
+  end
+
+  desc "uninstall NAME", "Uninstall a named Thor module"
+  def uninstall(name)
+    raise Error, "Can't find module '#{name}'" unless thor_yaml[name]
+    say "Uninstalling #{name}."
+    FileUtils.rm_rf(File.join(thor_root, "#{thor_yaml[name][:filename]}"))
+
+    thor_yaml.delete(name)
+    save_yaml(thor_yaml)
+
+    puts "Done."
+  end
+
+  desc "update NAME", "Update a Thor file from its original location"
+  def update(name)
+    raise Error, "Can't find module '#{name}'" if !thor_yaml[name] || !thor_yaml[name][:location]
+
+    say "Updating '#{name}' from #{thor_yaml[name][:location]}"
+
+    old_filename = thor_yaml[name][:filename]
+    self.options = self.options.merge("as" => name)
+    filename     = install(thor_yaml[name][:location])
+
+    unless filename == old_filename
+      File.delete(File.join(thor_root, old_filename))
+    end
+  end
+
+  desc "installed", "List the installed Thor modules and tasks"
+  method_options :internal => :boolean
+  def installed
+    initialize_thorfiles(nil, true)
+    display_klasses(true, options["internal"])
+  end
+
+  desc "list [SEARCH]", "List the available thor tasks (--substring means .*SEARCH)"
+  method_options :substring => :boolean, :group => :string, :all => :boolean
+  def list(search="")
+    initialize_thorfiles
+
+    search = ".*#{search}" if options["substring"]
+    search = /^#{search}.*/i
+    group  = options[:group] || "standard"
+
+    klasses = Thor::Base.subclasses.select do |k|
+      (options[:all] || k.group == group) && k.namespace =~ search
+    end
+
+    display_klasses(false, false, klasses)
+  end
+
+  private
+
+    def self.banner(task)
+      "thor " + task.formatted_usage(self, false)
+    end
+
+    def thor_root
+      Thor::Util.thor_root
+    end
+
+    def thor_yaml
+      @thor_yaml ||= begin
+        yaml_file = File.join(thor_root, "thor.yml")
+        yaml = YAML.load_file(yaml_file) if File.exists?(yaml_file)
+        yaml || {}
+      end
+    end
+
+    # Save the yaml file. If none exists in thor root, creates one.
+    #
+    def save_yaml(yaml)
+      yaml_file = File.join(thor_root, "thor.yml")
+
+      unless File.exists?(yaml_file)
+        FileUtils.mkdir_p(thor_root)
+        yaml_file = File.join(thor_root, "thor.yml")
+        FileUtils.touch(yaml_file)
+      end
+
+      File.open(yaml_file, "w") { |f| f.puts yaml.to_yaml }
+    end
+
+    def self.exit_on_failure?
+      true
+    end
+
+    # Load the thorfiles. If relevant_to is supplied, looks for specific files
+    # in the thor_root instead of loading them all.
+    #
+    # By default, it also traverses the current path until find Thor files, as
+    # described in thorfiles. This look up can be skipped by suppliying
+    # skip_lookup true.
+    #
+    def initialize_thorfiles(relevant_to=nil, skip_lookup=false)
+      thorfiles(relevant_to, skip_lookup).each do |f|
+        Thor::Util.load_thorfile(f) unless Thor::Base.subclass_files.keys.include?(File.expand_path(f))
+      end
+    end
+
+    # Finds Thorfiles by traversing from your current directory down to the root
+    # directory of your system. If at any time we find a Thor file, we stop.
+    #
+    # We also ensure that system-wide Thorfiles are loaded first, so local
+    # Thorfiles can override them.
+    #
+    # ==== Example
+    #
+    # If we start at /Users/wycats/dev/thor ...
+    #
+    # 1. /Users/wycats/dev/thor
+    # 2. /Users/wycats/dev
+    # 3. /Users/wycats <-- we find a Thorfile here, so we stop
+    #
+    # Suppose we start at c:\Documents and Settings\james\dev\thor ...
+    #
+    # 1. c:\Documents and Settings\james\dev\thor
+    # 2. c:\Documents and Settings\james\dev
+    # 3. c:\Documents and Settings\james
+    # 4. c:\Documents and Settings
+    # 5. c:\ <-- no Thorfiles found!
+    #
+    def thorfiles(relevant_to=nil, skip_lookup=false)
+      thorfiles = []
+
+      unless skip_lookup
+        Pathname.pwd.ascend do |path|
+          thorfiles = Thor::Util.globs_for(path).map { |g| Dir[g] }.flatten
+          break unless thorfiles.empty?
+        end
+      end
+
+      files  = (relevant_to ? thorfiles_relevant_to(relevant_to) : Thor::Util.thor_root_glob)
+      files += thorfiles
+      files -= ["#{thor_root}/thor.yml"]
+
+      files.map! do |file|
+        File.directory?(file) ? File.join(file, "main.thor") : file
+      end
+    end
+
+    # Load thorfiles relevant to the given method. If you provide "foo:bar" it
+    # will load all thor files in the thor.yaml that has "foo" e "foo:bar"
+    # namespaces registered.
+    #
+    def thorfiles_relevant_to(meth)
+      lookup = [ meth, meth.split(":")[0...-1].join(":") ]
+
+      files = thor_yaml.select do |k, v|
+        v[:namespaces] && !(v[:namespaces] & lookup).empty?
+      end
+
+      files.map { |k, v| File.join(thor_root, "#{v[:filename]}") }
+    end
+
+    # Display information about the given klasses. If with_module is given,
+    # it shows a table with information extracted from the yaml file.
+    #
+    def display_klasses(with_modules=false, show_internal=false, klasses=Thor::Base.subclasses)
+      klasses -= [Thor, Thor::Runner, Thor::Group] unless show_internal
+
+      raise Error, "No Thor tasks available" if klasses.empty?
+      show_modules if with_modules && !thor_yaml.empty?
+
+      # Remove subclasses
+      klasses.dup.each do |klass|
+        klasses -= Thor::Util.thor_classes_in(klass)
+      end
+
+      list = Hash.new { |h,k| h[k] = [] }
+      groups = klasses.select { |k| k.ancestors.include?(Thor::Group) }
+
+      # Get classes which inherit from Thor
+      (klasses - groups).each { |k| list[k.namespace] += k.printable_tasks(false) }
+
+      # Get classes which inherit from Thor::Base
+      groups.map! { |k| k.printable_tasks(false).first }
+      list["root"] = groups
+
+      # Order namespaces with default coming first
+      list = list.sort{ |a,b| a[0].sub(/^default/, '') <=> b[0].sub(/^default/, '') }
+      list.each { |n, tasks| display_tasks(n, tasks) unless tasks.empty? }
+    end
+
+    def display_tasks(namespace, list) #:nodoc:
+      list.sort!{ |a,b| a[0] <=> b[0] }
+
+      say shell.set_color(namespace, :blue, true)
+      say "-" * namespace.size
+
+      print_table(list, :truncate => true)
+      say
+    end
+
+    def show_modules #:nodoc:
+      info  = []
+      labels = ["Modules", "Namespaces"]
+
+      info << labels
+      info << [ "-" * labels[0].size, "-" * labels[1].size ]
+
+      thor_yaml.each do |name, hash|
+        info << [ name, hash[:namespaces].join(", ") ]
+      end
+
+      print_table info
+      say ""
+    end
+end