josevalim-thor 0.10.0

data/lib/thor/options.rb

@@ -0,0 +1,282 @@
+require 'thor/option'
+
+class Thor
+
+  # This is a modified version of Daniel Berger's Getopt::Long class, licensed
+  # under Ruby's license.
+  #
+  class Options
+    NUMERIC     = /(\d*\.\d+|\d+)/
+    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
+
+    attr_reader :arguments, :options, :trailing
+
+    # Takes an array of switches. Each array consists of up to three
+    # elements that indicate the name and type of switch. Returns a hash
+    # containing each switch name, minus the '-', as a key. The value
+    # for each key depends on the type of switch and/or the value provided
+    # by the user.
+    #
+    # The long switch _must_ be provided. The short switch defaults to the
+    # first letter of the short switch. The default type is :boolean.
+    #
+    # Example:
+    #
+    #   opts = Thor::Options.new(
+    #      "--debug" => true,
+    #      ["--verbose", "-v"] => true,
+    #      ["--level", "-l"] => :numeric
+    #   ).parse(args)
+    #
+    def initialize(switches={})
+      @arguments, @shorts, @options = [], {}, {}
+      @non_assigned_required, @non_assigned_arguments, @trailing = [], [], []
+
+      @switches = switches.values.inject({}) do |mem, option|
+        @non_assigned_required  << option if option.required?
+
+        if option.argument?
+          @non_assigned_arguments << option
+        elsif option.default
+          @options[option.human_name] = option.default
+        end
+
+        # If there are no shortcuts specified, generate one using the first character
+        shorts = option.aliases.dup
+        shorts << "-" + option.human_name[0,1] if shorts.empty? and option.human_name.length > 1
+        shorts.each { |short| @shorts[short.to_s] ||= option.switch_name }
+
+        mem[option.switch_name] = option
+        mem
+      end
+
+      remove_duplicated_shortcuts!
+    end
+
+    def parse(args)
+      @pile, @trailing = args, []
+
+      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)
+
+          next if option.nil? || option.argument?
+
+          check_requirement!(switch, option)
+          parse_option(switch, option, @options)
+        else
+          unless @non_assigned_arguments.empty?
+            argument = @non_assigned_arguments.shift
+            parse_option(argument.switch_name, argument, @options)
+            @arguments << @options.delete(argument.human_name)
+          else
+            @trailing << shift
+          end
+        end
+      end
+
+      assign_arguments_default_values!
+      check_validity!
+      @options
+    end
+
+    private
+
+      def peek
+        @pile.first
+      end
+
+      def shift
+        @pile.shift
+      end
+
+      def unshift(arg)
+        unless arg.kind_of?(Array)
+          @pile.unshift(arg)
+        else
+          @pile = arg + @pile
+        end
+      end
+
+      # Returns true if the current peek is a 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
+
+      # Check if the given argument matches with a switch.
+      #
+      def switch?(arg)
+        switch_option(arg) || @shorts.key?(arg)
+      end
+
+      # Returns the option object for the given switch.
+      #
+      def switch_option(arg)
+        if arg =~ /^--no-(\w+)$/
+          @switches[arg] || @switches["--#{$1}"]
+        else
+          @switches[arg]
+        end
+      end
+
+      # Check if the given argument is actually a shortcut.
+      #
+      def normalize_switch(arg)
+        @shorts.key?(arg) ? @shorts[arg] : arg
+      end
+
+      # Receives switch, option and the current values hash and assign the next
+      # value to it. At the end, remove the option from the array where non
+      # assigned requireds are kept.
+      #
+      def parse_option(switch, option, hash)
+        human_name = option.human_name
+
+        case option.type
+          when :default
+            hash[human_name] = peek.nil? || peek.to_s =~ /^-/ || shift
+          when :boolean
+            if !@switches.key?(switch) && switch =~ /^--no-(\w+)$/
+              hash[$1] = false
+            else
+              hash[human_name] = true
+            end
+          when :string
+            hash[human_name] = shift
+          when :numeric
+            hash[human_name] = parse_numeric(switch)
+          when :hash
+            hash[human_name] = parse_hash
+          when :array
+            hash[human_name] = parse_array
+        end
+
+        @non_assigned_required.delete(option)
+      end
+
+      # Runs through the argument array getting strings that contains ":" and
+      # mark it as a hash:
+      #
+      #   [ "name:string", "age:integer" ]
+      #
+      # Becomes:
+      #
+      #   { "name" => "string", "age" => "integer" }
+      #
+      def parse_hash
+        hash = {}
+
+        while peek && peek !~ /^\-/
+          key, value = shift.split(':')
+          hash[key] = value
+        end
+
+        hash
+      end
+
+      # Runs through the argument array getting all strings until no string is
+      # found or a switch is found.
+      #
+      #   ["a", "b", "c"]
+      #
+      # And returns it as an array:
+      #
+      #   ["a", "b", "c"]
+      #
+      def parse_array
+        array = []
+
+        while peek && peek !~ /^\-/
+          array << shift
+        end
+
+        array
+      end
+
+      # Check if the peel is numeric ofrmat and return a Float or Integer.
+      # Otherwise raises an error.
+      #
+      def parse_numeric(switch)
+        unless peek =~ NUMERIC && $& == peek
+          raise MalformattedArgumentError, "expected numeric value for '#{switch}'; got #{peek.inspect}"
+        end
+        $&.index('.') ? shift.to_f : shift.to_i
+      end
+
+      # Raises an error if the option requires an input but it's not present.
+      #
+      def check_requirement!(switch, option)
+        if option.input_required?
+          raise RequiredArgumentMissingError, "no value provided for argument '#{switch}'"  if peek.nil?
+          raise MalformattedArgumentError, "cannot pass switch '#{peek}' as an argument" if switch?(peek)
+        end
+      end
+
+      # Raises an error if @required array is not empty after parsing.
+      #
+      def check_validity!
+        unless @non_assigned_required.empty?
+          switch_names = @non_assigned_required.map{ |o| o.switch_name }.join(', ')
+          raise RequiredArgumentMissingError, "no value provided for required arguments '#{switch_names}'" 
+        end
+      end
+
+      # Assign default values to the argument hash.
+      #
+      def assign_arguments_default_values!
+        @non_assigned_arguments.each do |option|
+          @arguments << option.default
+        end
+      end
+
+      # Remove shortcuts that happen to coincide with any of the main switches
+      #
+      def remove_duplicated_shortcuts!
+        @shorts.keys.each do |short|
+          @shorts.delete(short) if @switches.key?(short)
+        end
+      end
+
+  end
+end

data/lib/thor/runner.rb

@@ -0,0 +1,296 @@
+require 'fileutils'
+require 'open-uri'
+require 'yaml'
+require 'digest/md5'
+require 'pathname'
+
+class Thor::Runner < Thor
+  map "-T" => :list, "-i" => :install, "-u" => :update
+
+  # 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.namespace_to_thor_class(meth)
+      klass.start(["-h", task].compact, :shell => self.shell) # send mapping -h because it works with Thor::Group too
+    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.namespace_to_thor_class(meth)
+    args.unshift(task) if task
+    klass.start(args, :shell => self.shell)
+  end
+
+  desc "install NAME", "Install a Thor file into your system tasks, optionally named for future updates"
+  method_options :as => :optional, :relative => :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
+
+    return false if no?("Do you wish to continue [y/N]?")
+
+    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_contents(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 "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)
+
+    klasses = Thor::Base.subclasses
+    klasses -= [Thor, Thor::Runner] unless options["internal"]
+
+    display_klasses(true, klasses)
+  end
+
+  desc "list [SEARCH]",
+       "List the available thor tasks (--substring means SEARCH anywhere in the namespace)"
+  method_options :substring => :boolean, :group => :optional, :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_name == group) && k.namespace =~ search
+    end
+
+    display_klasses(false, klasses)
+  end
+
+  private
+
+    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
+
+    # 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)
+      # Deal with deprecated thor when :namespaces: is available as constants
+      save_yaml(thor_yaml) if Thor::Util.convert_constants_to_namespaces(thor_yaml)
+
+      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]}") }
+      files
+    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, klasses=Thor.subclasses)
+      klasses -= [Thor, Thor::Runner] unless with_modules
+      raise Error, "No Thor tasks available" if klasses.empty?
+
+      if with_modules && !thor_yaml.empty?
+        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
+
+      unless klasses.empty?
+        klasses.each { |k| display_tasks(k) }
+      else
+        say "\033[1;34mNo Thor tasks available\033[0m"
+      end
+    end
+
+    # Display tasks from the given Thor class.
+    #
+    def display_tasks(klass)
+      unless klass.tasks.empty?
+        base = klass.namespace
+
+        if base == "default"
+          say "\033[1;35m#{base}\033[0m"
+        else
+          say "\033[1;34m#{base}\033[0m"
+        end
+        say "-" * base.length
+
+        klass.help(shell, :short => true, :namespace => true)
+        say
+      end
+    end
+end