rubycut-babushka 0.10.6

data/lib/babushka/cmdline/handler.rb

@@ -0,0 +1,41 @@
+require 'abbrev'
+
+module Babushka
+  module Cmdline
+
+    def handle name, description, &blk
+      Handler.add name, description, blk
+    end
+    module_function :handle
+
+    class Handler
+      def self.add name, description, opt_definer
+        Handler.new(name, description, opt_definer).tap {|handler|
+          (@handlers ||= []).push handler
+        }
+      end
+
+      def self.all
+        @handlers.reject {|h| h.name == 'global' }
+      end
+
+      def self.abbrev
+        all.map(&:name).abbrev
+      end
+
+      def self.for name
+        @handlers.detect {|h| h.name == name }
+      end
+
+      attr_reader :name, :description, :opt_definer, :handler
+
+      def initialize name, description, opt_definer
+        @name, @description, @opt_definer = name, description, (opt_definer || L{})
+      end
+
+      def run &handler
+        @handler = handler
+      end
+    end
+  end
+end

data/lib/babushka/cmdline/helpers.rb

@@ -0,0 +1,127 @@
+# coding: utf-8
+
+module Babushka
+  module Cmdline
+    module_function
+
+    def fail_with message
+      log message if message.is_a? String
+      exit 1
+    end
+
+    module Helpers
+      extend LogHelpers
+      module_function
+
+      def print_version opts = {}
+        if opts[:full]
+          log "Babushka v#{VERSION}, (c) 2011 Ben Hoskings <ben@hoskings.net>"
+        else
+          log VERSION
+        end
+      end
+
+      def print_usage
+        log "\nThe gist:"
+        log "  #{Base.program_name} <command> [options]"
+        log "\nAlso:"
+        log "  #{Base.program_name} help <command>  # Print command-specific usage info"
+        log "  #{Base.program_name} <dep name>      # A shortcut for 'babushka meet <dep name>'"
+        log "  #{Base.program_name} babushka        # Update babushka itself (what babushka.me/up does)"
+      end
+
+      def print_handlers
+        log "\nCommands:"
+        Handler.all.each {|handler|
+          log "  #{handler.name.ljust(10)} #{handler.description}"
+        }
+      end
+
+      def print_examples
+        log "\nExamples:"
+        log "  # Inspect the 'system' dep (and all its sub-deps) without touching the system.".colorize('grey')
+        log "  #{Base.program_name} system --dry-run"
+        log "\n"
+        log "  # Meet the 'fish' dep (i.e. install fish and all its dependencies).".colorize('grey')
+        log "  #{Base.program_name} fish"
+        log "\n"
+        log "  # Meet the 'user setup' dep, printing lots of debugging (including realtime".colorize('grey')
+        log "  # shell command output).".colorize('grey')
+        log "  #{Base.program_name} 'user setup' --debug"
+      end
+
+      def print_notes
+        log "\nCommands can be abbrev'ed, as long as they remain unique."
+        log "  e.g. '#{Base.program_name} l' is short for '#{Base.program_name} list'."
+      end
+
+      def search_results_for q
+        YAML.load(search_webservice_for(q).body).sort_by {|i|
+          -i[:runs_this_week]
+        }.map {|i|
+          [
+            i[:name],
+            i[:source_uri],
+            ((i[:runs_this_week] && i[:runs_this_week] > 0) ? "#{i[:runs_this_week]} this week" : "#{i[:total_runs]} ever"),
+            ((i[:runs_this_week] && i[:runs_this_week] > 0) ? "#{(i[:success_rate_this_week] * 100).round}%" : ((i[:total_runs] && i[:total_runs] > 0) ? "#{(i[:total_success_rate] * 100).round}%" : '')),
+            (i[:source_uri][github_autosource_regex] ? "#{Base.program_name} #{$1}:#{"'" if i[:name][/\s/]}#{i[:name]}#{"'" if i[:name][/\s/]}" : '✣')
+          ]
+        }
+      end
+
+      def print_search_results search_term, results
+        log "The webservice knows about #{results.length} dep#{'s' unless results.length == 1} that match#{'es' if results.length == 1} '#{search_term}':"
+        log ""
+        Logging.log_table(
+          ['Name', 'Source', 'Runs', ' ✓', 'Command'],
+          results
+        )
+        if (custom_sources = results.select {|r| r[1][github_autosource_regex].nil? }.length) > 0
+          log ""
+          log "✣  #{custom_sources == 1 ? 'This source has a custom URI' : 'These sources have custom URIs'}, so babushka can't discover #{custom_sources == 1 ? 'it' : 'them'} automatically."
+          log "   You can run #{custom_sources == 1 ? 'its' : 'their'} deps in the same way, though, once you add #{custom_sources == 1 ? 'it' : 'them'} manually:"
+          log "   $ #{Base.program_name} sources -a <alias> <uri>"
+          log "   $ #{Base.program_name} <alias>:<dep>"
+        end
+      end
+
+      def github_autosource_regex
+        /^git\:\/\/github\.com\/(.*)\/babushka-deps(\.git)?/
+      end
+
+      def search_webservice_for q
+        Net::HTTP.start('babushka.me') {|http|
+          http.get URI.escape("/deps/search.yaml/#{q}")
+        }
+      end
+
+      def generate_list_for to_list, filter_str
+        context = to_list == :deps ? Base.program_name : ':template =>'
+        match_str = filter_str.try(:downcase)
+        Base.sources.all_present.each {|source|
+          source.load!
+        }.map {|source|
+          [source, source.send(to_list).items]
+        }.map {|(source,items)|
+          if match_str.nil? || source.name.downcase[match_str]
+            [source, items]
+          else
+            [source, items.select {|item| item.name.downcase[match_str] }]
+          end
+        }.select {|(_,items)|
+          !items.empty?
+        }.sort_by {|(source,_)|
+          source.name
+        }.each {|(source,items)|
+          indent = (items.map {|item| "#{source.name}:#{item.name}".length }.max || 0) + 3
+          log ""
+          log "# #{source.name} (#{source.type})#{" - #{source.uri}" unless source.implicit?}"
+          log "# #{items.length} #{to_list.to_s.chomp(items.length == 1 ? 's' : '')}#{" matching '#{filter_str}'" unless filter_str.nil?}:"
+          items.each {|dep|
+            log "#{context} #{"'#{source.name}:#{dep.name}'".ljust(indent)}"
+          }
+        }
+      end
+    end
+  end
+end

data/lib/babushka/cmdline/parser.rb

@@ -0,0 +1,69 @@
+require 'optparse'
+
+module Babushka
+  module Cmdline
+    class Parser
+      include LogHelpers
+
+      attr_reader :verb, :argv, :opts
+
+      def self.for argv
+        if argv.empty? || (%w[-h --help] & argv).any?
+          new 'help', argv
+        elsif !Handler.abbrev.has_key?(argv.first.sub(/^--/, ''))
+          new 'meet', argv, :implicit_verb => true
+        else
+          new Handler.abbrev[argv.shift.sub(/^--/, '')], argv
+        end
+      end
+
+      def initialize verb, argv, parse_opts = {}
+        @verb, @argv, @opts, @implicit_verb = verb, argv, default_opts, parse_opts[:implicit_verb]
+        parse(&Handler.for('global').opt_definer)
+        parse(&Handler.for(verb).opt_definer)
+      end
+
+      def run
+        parser.parse! argv
+        Handler.for(verb).handler.call self
+      rescue OptionParser::ParseError => e
+        log_error "The #{e.args.first} option #{error_reason(e)}. #{hint}"
+      end
+
+      def print_usage
+        log parser.to_s.sub(/^Usage:.*$/, '')
+      end
+
+      def parse &blk
+        instance_eval(&blk)
+      end
+
+      private
+
+      def default_opts
+        {
+          :"[no_]color" => $stdout.tty?
+        }
+      end
+
+      def hint
+        "`babushka#{" #{verb}" unless @implicit_verb} --help` for more info."
+      end
+
+      def error_reason e
+        {
+          OptionParser::MissingArgument => "requires an argument"
+        }[e.class] || "isn't valid"
+      end
+
+      def opt *args, &block
+        opt_name = args.collapse(/^--/).first.gsub(/\s.*$/, '').gsub('-', '_').to_sym
+        parser.on(*args) {|arg| opts[opt_name] = arg }
+      end
+
+      def parser
+        @parser ||= OptionParser.new
+      end
+    end
+  end
+end

data/lib/babushka/colorizer.rb

@@ -0,0 +1,59 @@
+class String
+
+  private
+
+  class Colorizer
+    include Singleton
+
+    HomeOffset = 29
+    LightOffset = 60
+    BGOffset = 10
+    LightRegex = /^light_/
+    ColorRegex = /^(light_)?none|gr[ae]y|red|green|yellow|blue|pink|cyan|white$/
+    CtrlRegex = /^bold|underlined?|blink(ing)?|reversed?$/
+    ColorOffsets = {
+      'none' => 0,
+      'gray' => 61, 'grey' => 61,
+      'red' => 2,
+      'green' => 3,
+      'yellow' => 4,
+      'blue' => 5,
+      'pink' => 6,
+      'cyan' => 7,
+      'white' => 8
+    }
+    CtrlOffsets = {
+      'bold' => 1,
+      'underline' => 4, 'underlined' => 4,
+      'blink' => 5, 'blinking' => 5,
+      'reverse' => 7, 'reversed' => 7
+    }
+
+    def colorize text, description
+      return text if Babushka::Base.task.opts[:"[no_]color"] == false
+
+      terms = " #{description} ".gsub(' light ', ' light_').gsub(' on ', ' on_').strip.split(/\s+/)
+      bg = terms.detect {|i| /on_#{ColorRegex}/ =~ i }
+      fg = terms.detect {|i| ColorRegex =~ i }
+      ctrl = terms.detect {|i| CtrlRegex =~ i }
+
+      "\e[#{"0;#{fg_for(fg)};#{bg_for(bg) || ctrl_for(ctrl)}"}m#{text}\e[0m"
+    end
+
+    def fg_for name
+      light = name.gsub!(LightRegex, '') unless name.nil?
+      (ColorOffsets[name] || 0) + HomeOffset + (light ? LightOffset : 0)
+    end
+
+    def bg_for name
+      # There's a hole in the table on bg=none, so we use BGOffset to the left
+      offset = fg_for((name || '').sub(/^on_/, ''))
+      offset + BGOffset unless offset == HomeOffset
+    end
+
+    def ctrl_for name
+      CtrlOffsets[name] || HomeOffset
+    end
+  end
+
+end

data/lib/babushka/core_patches/array.rb

@@ -0,0 +1,171 @@
+class Array
+  # Returns true iff +other+ appears exactly at the start of +self+.
+  def starts_with? first, *rest
+    other = first.is_a?(Array) ? first : [first].concat(rest)
+    self[0, other.length] == other
+  end
+
+  # Returns true iff +other+ appears exactly at the end of +self+.
+  def ends_with? first, *rest
+    other = first.is_a?(Array) ? first : [first].concat(rest)
+    self[-other.length, other.length] == other
+  end
+
+  # Like #detect, but return the result of the block instead of the element.
+  def pick &block
+    value = nil
+    detect {|i| value = yield(i) }
+    value
+  end
+
+  # This is defined separately, and then aliased into place if required, so we
+  # can run specs against it no matter which ruby we're running against.
+  def local_group_by &block
+    inject({}) {|hsh,i|
+      (hsh[yield(i)] ||= []).push i
+      hsh
+    }
+  end
+  alias_method :group_by, :local_group_by unless [].respond_to?(:group_by)
+
+  # Return two arrays, the first being the portion of this array preceding the
+  # first element for which the block returs true, and the second being the
+  # remainder (or +nil+ if the block didn't return true for any elements).
+  def cut &block
+    if (cut_at = index {|i| yield i }).nil?
+      [self, nil]
+    else
+      [self[0...cut_at], self[cut_at..-1]]
+    end
+  end
+  # Return two arrays in the same manner as +cut+, but check for element
+  # equality against +value+ to find the point at which to cut the array.
+  def cut_at value
+    cut {|i| i == value }
+  end
+  # Return a new array containing every element from this array for which
+  # the block returns true.
+  def extract &block
+    dup.extract!(&block)
+  end
+  # Like +extract+, but remove the extracted values in-place before
+  # returning them.
+  def extract! &block
+    dup.inject [] do |extracted,i|
+      extracted << delete(i) if yield i
+      extracted
+    end
+  end
+  # Return a new array containing all the elements from this array that
+  # are neither +#nil?+ nor +#blank?+.
+  def squash
+    dup.squash!
+  end
+  # Like +squash+, but remove the +#nil?+ and +#blank?+ entries in-place.
+  def squash!
+    delete_if(&:blank?)
+  end
+
+  # Return a new array containing the elements that match +pattern+, with
+  # +pattern+ removed (or replaced via Array#sub, if +replacement+ is
+  # supplied).
+  #
+  # This is useful for selecting items from a list based on some label,
+  # removing the label at the same time. A good example is finding the current
+  # git branch. Given this repository:
+  #   $ git branch
+  #     master
+  #   * next
+  #     topic
+  # You can use +#collapse+ to retrieve the current branch like this:
+  #   shell('git branch').split("\n").collapse(/\* /) #=> ["next"]
+  def collapse pattern, replacement = ''
+    grep(pattern).map {|i| i.sub pattern, replacement }
+  end
+
+  # Return a new array by converting each element in this array to a VersionOf.
+  def versions
+    map {|i| Babushka::VersionOf::Helpers.VersionOf i }
+  end
+
+  # Return a string describing this array as an English list. The final two
+  # elements are separated with 'and', and all the other elements are separated
+  # with commas.
+  #
+  #   %w[John Paul Ringo George].to_list #=> "John, Paul, Ringo and George"
+  #
+  # A custom conjugation can be specified by passing +:conj+; if present, it
+  # will be used instead of 'and'.
+  #
+  #   %[rain hail shine].to_list(:conj => 'or') #=> "rain, hail or shine"
+  #
+  # To add an oxford comma before the conjugation, pass +:oxford => true+.
+  #
+  #   %w[hook line sinker].to_list(:oxford => true) #=> "hook, line, and sinker"
+  #
+  # If +:suffix+ is set, it will be appended along with the correct linking verb,
+  # i.e. 'is' for single-item lists and 'are' otherwise.
+  #
+  #   %w[coffee].to_list(:suffix => 'great') => "coffee is great"
+  #   %w[Cîroc Żubrówka].to_list(:suffix => 'vodkas') #=> "Cîroc and Żubrówka are vodkas"
+  #
+  # If +:limit+ is set, only the first +:limit+ items will be included in the
+  # output. If any elements were ommitted as a result, the suffix 'et al' will
+  # be appended to indicate there are missing elements.
+  #
+  #   %w[latte espresso ristretto].to_list(:suffix => 'coffees', :limit => 2) #=> "latte, espresso et al are coffees"
+  #
+  # If +:noun+ is set in addition to +:limit+, it will be used to describe the
+  # length of the list after 'et al' if any items were ommitted as a result of
+  # the +:limit+ setting.
+  #
+  #   %w[latte espresso ristretto].to_list(:limit => 2, :noun => 'coffees') #=> "latte, espresso et al - 3 coffees"
+  def to_list(opts = {})
+    items = map(&:to_s)
+    if opts[:limit].nil? || (length <= opts[:limit])
+      [
+        items[0..-2].squash.join(', '),
+        items.last
+      ].squash.join("#{',' if opts[:oxford]} #{opts[:conj] || 'and'} ")
+    else
+      items[0..(opts[:limit] - 1)].squash.join(', ') + ' et al' + (opts[:noun].nil? ? '' : " - #{length} #{opts[:noun]}")
+    end +
+    (opts[:suffix] ? " #{length > 1 ? 'are' : 'is'} #{opts[:suffix].strip}" : '')
+  end
+
+  # If the final element of the array is a +Hash+, it's removed from this array
+  # and returned. Otherwise, an empty hash is returned.
+  def extract_options!
+    last.is_a?(::Hash) ? pop : {}
+  end
+
+  # As above, without modifying the receiving object.
+  def extract_options
+    dup.extract_options!
+  end
+
+  # Return a new array containing the terms from this array that were
+  # determined to be 'similar to' +string+. A string is considered to
+  # be similar to another if its Levenshtein distance is less than
+  # either the string's length minus one, or one fifth is length plus
+  # two, whichever is less.
+  #
+  #     word length  1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  …
+  #   typos allowed  0  0  1  2  3  3  3  3  3   4   4   4   4   4   5  …
+  #
+  # This means that:
+  #   - a little over one fifth of strings longer than 4 characters can be misspelt;
+  #   - strings 3 or 4 characters long can have 1 or 2 misspelt characters respectively;
+  #   - strings 1 or 2 characters long must be spelt correctly.
+  def similar_to string
+    map {|term|
+      [term, Babushka::Levenshtein.distance(term, string)]
+    }.select {|(i, similarity)|
+      similarity <= [i.length - 2, (i.length / 5) + 2].min
+    }.sort_by {|(_, similarity)|
+      similarity
+    }.map {|(i, _)|
+      i
+    }
+  end
+end