rubycut-babushka 0.10.6

data/lib/babushka/helpers/suggest_helpers.rb

@@ -0,0 +1,16 @@
+module Babushka
+  module SuggestHelpers
+    def suggest_value_for typo, choices
+      if (possible_matches = choices.similar_to typo.to_s).empty?
+        nil # nothing to suggest
+      elsif possible_matches.length == 1
+        Prompt.confirm "#{"Did you mean".colorize('grey')} '#{possible_matches.first}'#{"?".colorize('grey')}" do
+          possible_matches.first
+        end or false
+      else
+        log "Similar: #{possible_matches.map {|d| "'#{d}'" }.join(', ')}"
+        Prompt.get_value("Did you mean any of those".colorize('grey'), :default => possible_matches.first)
+      end
+    end
+  end
+end

data/lib/babushka/helpers/uri_helpers.rb

@@ -0,0 +1,36 @@
+module Babushka
+  module UriHelpers
+
+    def setup_source_uris
+      parse_uris
+      requires_when_unmet(@uris.map(&:scheme).uniq & %w[ git ])
+    end
+
+    def parse_uris
+      @uris = source.map(&uri_processor(:escape)).map(&uri_processor(:parse))
+      @extra_uris = extra_source.map(&uri_processor(:escape)).map(&uri_processor(:parse)) if respond_to?(:extra_source)
+    end
+
+    def uri_processor(method_name)
+      L{|uri| URI.send(method_name, uri.respond_to?(:call) ? uri.call : uri.to_s) }
+    end
+
+    def process_sources &block
+      @extra_uris.each {|uri| handle_source uri } unless @extra_uris.nil?
+      @uris.all? {|uri| handle_source uri, &block } unless @uris.nil?
+    end
+
+    def handle_source uri, &block
+      uri = uri_processor(:parse).call(uri) unless uri.is_a?(URI)
+      case uri.scheme
+      when 'git'
+        git uri, &block
+      when 'http', 'https', 'ftp', nil # We let `curl` work out the protocol if it's nil.
+        Resource.extract uri, &block
+      else
+        log_error "Babushka can't handle #{uri.scheme}:// URLs yet. But it can if you write a patch! :)"
+      end
+    end
+
+  end
+end

data/lib/babushka/ip.rb

@@ -0,0 +1,160 @@
+module Babushka
+  class IP
+    attr_reader :bytes
+
+    def initialize input
+      @bytes = sanitize input
+    end
+
+    def to_s
+      bytes.join '.'
+    end
+
+    def == other
+      bytes == other.bytes
+    end
+
+    # Returns whether this IP should be considered a valid one for a client to be using.
+    def valid?
+      [:public, :private, :loopback].include? describe
+    end
+
+    def next
+      offset_by(1)
+    end
+
+    def prev
+      offset_by(-1)
+    end
+
+    private
+
+    def sanitize input
+      if input.is_a? IP
+        input.bytes.dup
+      elsif input.is_a? Array
+        input.select {|i| (0..255).include? i }
+      else
+        parse_and_sanitize input do |str,val|
+          val if ((1..255) === val) || (val == 0 && str == '0')
+        end
+      end
+    end
+
+    def parse_and_sanitize input, &block
+      parts = input.strip.split('.')
+      parts.zip(
+        parts.map(&:to_i)
+      ).map {|(str,val)|
+        yield str, val
+      }.compact
+    end
+
+    def offset_by offset
+      IP.new bytes.reverse.inject([offset]) {|acc,byte|
+        carry, next_byte = (byte + acc.pop).divmod(256)
+        acc.push next_byte
+        acc.push carry
+      }[0...4].reverse.join('.')
+    end
+
+    # Returns a symbol describing the class of IP address +self+ represents, if any.
+    #
+    # Examples:
+    #
+    #     "Hello world!".valid_ip?   #=> false
+    #     "192.168.".valid_ip?       #=> false
+    #     "127.0.0.1".valid_ip?      #=> :loopback
+    #     "172.24.137.6".valid_ip?   #=> :private
+    #     "169.254.1.142".valid_ip?  #=> :self_assigned
+    #     "72.9.108.122".valid_ip?   #=> :public
+    def describe
+      if bytes.length != 4
+        false
+      elsif bytes.starts_with? 0 # Source hosts on "this" network
+        :reserved
+      elsif bytes.starts_with? 127 # Loopback network; RFC1700
+        :loopback
+      elsif bytes.starts_with? 10 # Class-A private; RFC1918
+        :private
+      elsif bytes.starts_with?(172) && ((16..31) === bytes[1]) # Class-B private; RFC1918
+        :private
+      elsif bytes.starts_with? 169, 254 # Link-local range; RFC3330/3927
+        [0, 255].include?(bytes[2]) ? :reserved : :self_assigned
+      elsif bytes.starts_with? 192, 0, 2 # TEST-NET - used as example.com IP
+        :reserved
+      elsif bytes.starts_with? 192, 88, 99 # 6-to-4 relay anycast; RFC3068
+        :reserved
+      elsif bytes.starts_with? 192, 168 # Class-C private; RFC1918
+        :private
+      elsif bytes.starts_with? 198, 18 # Benchmarking; RFC2544
+        :reserved
+      else
+        :public
+      end
+    end
+  end
+
+  class IPRange < IP
+    def valid?
+      !bytes.empty?
+    end
+
+    def padded_bytes
+      bytes.concat(['x'] * (4 - bytes.length))
+    end
+
+    def ip_for address_part
+      IP.new padded_bytes.zip(
+        IPTail.new(address_part).padded_bytes
+      ).map {|(network, address)|
+        [network, address, 0].detect {|i| i != 'x' }
+      }
+    end
+
+    def first
+      ip_for 'x.0.0.1'
+    end
+
+    def last
+      ip_for 'x.255.255.255'
+    end
+
+    def subnet
+      padded_bytes.map {|byte|
+        byte == 'x' ? '0' : '255'
+      }.join('.')
+    end
+
+    def broadcast
+      padded_bytes.map {|byte|
+        byte == 'x' ? '255' : byte
+      }.join('.')
+    end
+
+    private
+    def sanitize input
+      if /^\d+(\.\d+)*(\.x)+$/ !~ input
+        []
+      else
+        parse_and_sanitize input.gsub(/x(\.x)*$/, 'x') do |str,val|
+          if ((1..255) === val) || (val == 0 && str == '0')
+            val
+          elsif str == 'x'
+            str
+          end
+        end
+      end
+    end
+  end
+
+  class IPTail < IPRange
+    def padded_bytes
+      (['x'] * (4 - bytes.length)).concat bytes
+    end
+    private
+    def sanitize input
+      super(input.split('.').reverse.join('.')).reverse
+    end
+  end
+end

data/lib/babushka/lambda_chooser.rb

@@ -0,0 +1,40 @@
+module Babushka
+  class LambdaChooser
+
+    attr_reader :owner
+
+    def var(name, opts = {}) owner.var(name, opts) end
+
+    def initialize owner, *possible_choices, &block
+      raise ArgumentError, "You can't use :otherwise as a choice name, because it's reserved." if possible_choices.include?(:otherwise)
+      @owner = owner
+      @possible_choices = possible_choices.push(:otherwise)
+      @block = block
+      @results = {}
+    end
+
+    def choose choices, method_name = nil
+      self.class.send :alias_method, (method_name || :on), :process_choice
+      block_result = instance_eval(&@block)
+      @results.empty? ? block_result : [*choices].push(:otherwise).pick {|c| @results[c] }
+    end
+
+    def otherwise first = nil, *rest, &block
+      process_choice :otherwise, first, *rest, &block
+    end
+
+    def process_choice choice, first = nil, *rest, &block
+      raise "You can supply values or a block, but not both." if first && block
+      raise "The choice '#{choice}' isn't valid." unless @possible_choices.include?(choice)
+
+      @results[choice] = if block
+        block
+      elsif first.is_a? Hash
+        first
+      else
+        [*first].concat(rest)
+      end
+    end
+
+  end
+end

data/lib/babushka/levenshtein.rb

@@ -0,0 +1,125 @@
+# This code is licensed under the MIT license with permission
+# from the author. The license follows.
+#
+# Copyright (c) 2008-2009 Paul Battley (pbattley@gmail.com)
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module Babushka
+# The Levenshtein distance is a metric for measuring the amount
+# of difference between two sequences (i.e., the so called edit
+# distance). The Levenshtein distance between two sequences is
+# given by the minimum number of operations needed to transform
+# one sequence into the other, where an operation is an
+# insertion, deletion, or substitution of a single element.
+#
+# More information about the Levenshtein distance algorithm:
+# http://en.wikipedia.org/wiki/Levenshtein_distance .
+
+module Levenshtein
+  VERSION	= "0.2.0"
+
+  # Returns the Levenshtein distance as a number between 0.0 and
+  # 1.0. It's basically the Levenshtein distance divided by the
+  # length of the longest sequence.
+
+  def self.normalized_distance(s1, s2, threshold=nil)
+    s1, s2	= s2, s1	if s1.length > s2.length	# s1 is the short one; s2 is the long one.
+
+    if s2.length == 0
+      0.0	# Since s1.length < s2.length, s1 must be empty as well.
+    else
+      if threshold
+        if d = self.distance(s1, s2, (threshold*s2.length+1).to_i)
+          d.to_f/s2.length
+        else
+          nil
+        end
+      else
+        self.distance(s1, s2).to_f/s2.length
+      end
+    end
+  end
+
+  # Returns the Levenshtein distance between two sequences.
+  #
+  # The two sequences can be two strings, two arrays, or two other
+  # objects. Strings, arrays and arrays of strings are handled with
+  # optimized (very fast) C code. All other sequences are handled
+  # with generic (fast) C code.
+  #
+  # The sequences should respond to :length and :[] and all objects
+  # in the sequences (as returned by []) should response to :==.
+
+  def self.distance(s1, s2, threshold=nil)
+    s1, s2	= s2, s1	if s1.length > s2.length	# s1 is the short one; s2 is the long one.
+
+    # Handle some basic circumstances.
+
+    return 0		if s1 == s2
+    return s2.length	if s1.length == 0
+
+    if threshold
+      return nil	if (s2.length-s1.length) >= threshold
+
+      a1, a2	= nil, nil
+      a1, a2	= s1, s2			if s1.respond_to?(:-) and s2.respond_to?(:-)
+      a1, a2	= s1.scan(/./), s2.scan(/./)	if s1.respond_to?(:scan) and s2.respond_to?(:scan)
+
+      if a1 and a2
+        return nil	if (a1-a2).length >= threshold
+        return nil	if (a2-a1).length >= threshold
+      end
+    end
+
+    distance_fast_or_slow(s1, s2, threshold)
+  end
+
+  def self.distance_fast_or_slow(s1, s2, threshold)	# :nodoc:
+    if respond_to?(:levenshtein_distance_fast)
+      levenshtein_distance_fast(s1, s2, threshold)	# Implemented in C.
+    else
+      levenshtein_distance_slow(s1, s2, threshold)	# Implemented in Ruby.
+    end
+  end
+
+  def self.levenshtein_distance_slow(s1, s2, threshold)	# :nodoc:
+    row	= (0..s1.length).to_a
+
+    1.upto(s2.length) do |y|
+      prow	= row
+      row	= [y]
+
+      1.upto(s1.length) do |x|
+        row[x]	= [prow[x]+1, row[x-1]+1, prow[x-1]+(s1[x-1]==s2[y-1] ? 0 : 1)].min
+      end
+
+      # Stop analysing this sequence as soon as the best possible
+      # result for this sequence is bigger than the best result so far.
+      # (The minimum value in the next row will be equal to or greater
+      # than the minimum value in this row.)
+
+      return nil	if threshold and row.min >= threshold
+    end
+
+    row[-1]
+  end
+end
+end

data/lib/babushka/meta_dep.rb

@@ -0,0 +1,65 @@
+module Babushka
+  class MetaDep
+    include LogHelpers
+
+    INVALID_NAMES = %w[base]
+
+    VALID_NAME_START_CHARS = /[a-z]/
+    VALID_NAME_CHARS = /#{VALID_NAME_START_CHARS}[a-z0-9_]*/
+    VALID_NAME_START = /^#{VALID_NAME_START_CHARS}/
+    VALID_NAME = /\A#{VALID_NAME_CHARS}\z/m
+
+    TEMPLATE_NAME_MATCH = /\A.+\.(#{VALID_NAME_CHARS})\z/m
+
+    def self.for supplied_name, source, opts, &block
+      name = supplied_name.to_s.downcase
+
+      if name.empty?
+        raise ArgumentError, "You can't define a template with a blank name."
+      elsif INVALID_NAMES.include? name
+        raise ArgumentError, "You can't use '#{name}' for a template name, because it's reserved."
+      elsif name[VALID_NAME_START].nil?
+        raise ArgumentError, "You can't use '#{name}' for a template name - it must start with a letter."
+      elsif name[VALID_NAME].nil?
+        raise ArgumentError, "You can't use '#{name}' for a template name - it can only contain [a-z0-9_]."
+      elsif Base.sources.current_load_source.templates.for(name)
+        raise ArgumentError, "A template called '#{name}' has already been defined."
+      else
+        new name, source, opts, &block
+      end
+    end
+
+    attr_reader :name, :source, :opts, :context_class
+
+    def desc; context_class.desc end
+
+    def initialize name, source, opts, &block
+      @name, @source, @opts, @block = name, source, opts, block
+      debug "Defining #{source.name}:#{name} template"
+      @context_class = build_context block
+      source.templates.register self
+    end
+
+    # Returns this template's name, including the source name as a prefix if
+    # this template is in a cloneable source.
+    #
+    # A cloneable source is one that babushka knows how to automatically
+    # update; i.e. a source that babushka could have installed itself.
+    #
+    # In effect, a cloneable source is one whose deps you prefix when you run
+    # them, so this method returns the template's name in the same form as you
+    # would refer to it when using it from another source.
+    def contextual_name
+      source.cloneable? ? "#{source.name}:#{name}" : name
+    end
+
+    def build_context block
+      Class.new(MetaDepContext, &block).tap {|context|
+        shadow = self
+        context.metaclass.send :define_method, :source_template do
+          shadow
+        end
+      }
+    end
+  end
+end