rubycut-babushka 0.10.6

data/lib/babushka/version_of.rb

@@ -0,0 +1,65 @@
+module Babushka
+  class VersionOf
+    module Helpers
+      module_function
+
+      def VersionOf first, *rest
+        # Convert the arguments into a VersionOf. If a single string argument is
+        # passed, try splitting it on space to separate name and version. Otherwise,
+        # pass the arguments as-is, splatting if required.
+        if rest.any?
+          Babushka::VersionOf.new(*[first].concat(rest))
+        elsif first.is_a?(String)
+          Babushka::VersionOf.new(*first.split(' ', 2))
+        elsif first.is_a?(Array)
+          Babushka::VersionOf.new(*first)
+        else
+          Babushka::VersionOf.new(first)
+        end
+      end
+    end
+
+    attr_accessor :name, :version
+
+    def initialize name, version = nil
+      @name = name.respond_to?(:name) ? name.name : name
+      @version = if version.nil?
+        name.version if name.respond_to?(:version)
+      elsif version.is_a? VersionStr
+        version
+      else
+        version.to_version
+      end
+    end
+
+    def == other
+      if other.is_a? VersionOf
+        name == other.name &&
+        version == other.version
+      else
+        to_s == other.to_s
+      end
+    end
+
+    def <=> other
+      raise ArgumentError, "You can't compare the versions of two different things (#{name}, #{other.name})." unless name == other.name
+      version <=> other.version
+    end
+
+    def matches? other
+      if other.is_a? VersionStr
+        version.nil? || other.send(version.operator, version)
+      else
+        matches? other.to_version
+      end
+    end
+
+    def to_s joinery = '-'
+      [name, version].compact * joinery
+    end
+
+    def inspect
+      "#<VersionOf #{name}#{", v#{version}" unless version.nil?}>"
+    end
+  end
+end

data/lib/babushka/version_str.rb

@@ -0,0 +1,57 @@
+module Babushka
+  class VersionStrError < StandardError; end
+  class InvalidVersionOperator < VersionStrError; end
+  class InvalidVersionStr < VersionStrError; end
+
+  class VersionStr
+    include Comparable
+    attr_reader :pieces, :operator, :version
+    GemVersionOperators = %w[= == != > < >= <= ~>].freeze
+
+    def <=> other
+      other = other.to_version unless other.is_a? VersionStr
+      max_length = [pieces.length, other.pieces.length].max
+      (0...max_length).to_a.pick {|index|
+        result = compare_pieces pieces[index], other.pieces[index]
+        result unless result == 0
+      } || 0
+    end
+
+    def initialize str
+      @operator, @version = str.strip.scan(/^([^\s\w\-\.]+)?\s*v?([\w\-\.]+)$/i).first
+
+      if !(@operator.nil? || GemVersionOperators.include?(@operator))
+        raise InvalidVersionOperator, "VersionStr.new('#{str}'): invalid operator '#{@operator}'."
+      elsif @version.nil?
+        raise InvalidVersionStr, "VersionStr.new('#{str}'): couldn't parse a version number."
+      else
+        @pieces = @version.strip.scan(/\d+|[a-zA-Z]+|\w+/).map {|piece|
+          piece[/^\d+$/] ? piece.to_i : piece
+        }
+        @operator = '==' if @operator.nil? || @operator == '='
+      end
+    end
+
+    def to_s
+      @operator == '==' ? @version : "#{@operator} #{@version}"
+    end
+
+    define_method "!=" do |other|
+      !(self == other)
+    end
+
+    define_method "~>" do |other|
+      (self >= other) && pieces.starts_with?(other.pieces[0..-2])
+    end
+
+    private
+
+    def compare_pieces this, that
+      if this.is_a?(String) ^ that.is_a?(String)
+        this.is_a?(String) ? -1 : 1
+      else
+        (this || 0) <=> (that || 0)
+      end
+    end
+  end
+end

data/lib/babushka/xml_string.rb

@@ -0,0 +1,28 @@
+module Babushka
+  class XMLString < String
+    # This extracts values from XML, like that found in .plist files. For example,
+    #
+    #   %Q{
+    #     <key>SVNPath</key>
+    #     <string>/trunk/src</string>
+    #     <key>SVNRevision</key>
+    #     <string>37609</string>
+    #   }.val_for('SVNRevision') #=> "37609"
+    #
+    # It doesn't work for arrays, and probably doesn't work for boolean values.
+    # Patches welcome :)
+    def val_for key
+      split(/<\/[^>]+>\n\s*<key>/m).select {|i|
+        i[/#{Regexp.escape(key)}<\/key>/]
+      }.map {|i|
+        i.scan(/<[^\/>]+>(.*)$/m)
+      }.flatten.first
+    end
+  end
+end
+
+class String
+  def xml_val_for key
+    Babushka::XMLString.new(self).val_for(key)
+  end
+end

data/lib/components.rb

@@ -0,0 +1,82 @@
+require 'singleton'
+
+module Babushka
+  ExternalComponents = %w[
+    fancypath/fancypath
+    inkan/inkan
+  ]
+
+  Components = %w[
+    core_patches/blank
+    core_patches/try
+    core_patches/array
+    core_patches/hash
+    core_patches/hashish
+    core_patches/integer
+    core_patches/io
+    core_patches/numeric
+    core_patches/bytes
+    core_patches/object
+    core_patches/string
+    core_patches/symbol
+    core_patches/uri
+    xml_string
+    helpers/log_helpers
+    helpers/shell_helpers
+    helpers/path_helpers
+    helpers/run_helpers
+    helpers/suggest_helpers
+    helpers/git_helpers
+    helpers/uri_helpers
+    popen
+    shell
+    git_repo
+    resource
+    prompt
+    lambda_chooser
+    ip
+    version_str
+    version_of
+    accepts_list_for
+    accepts_value_for
+    accepts_block_for
+    colorizer
+    levenshtein
+    cmdline/parser
+    cmdline/handler
+    cmdline/helpers
+    cmdline
+    base
+    renderable
+    system_definitions
+    system_profile
+    run_reporter
+    bug_reporter
+    pkg_helper
+    pkg_helpers/base_helper
+    pkg_helpers/apt_helper
+    pkg_helpers/yum_helper
+    pkg_helpers/brew_helper
+    pkg_helpers/gem_helper
+    pkg_helpers/macports_helper
+    pkg_helpers/src_helper
+    pkg_helpers/pip_helper
+    pkg_helpers/binpkgsrc_helper
+    pkg_helpers/binports_helper
+    pkg_helpers/npm_helper
+    pkg_helpers/pacman_helper
+    dsl
+    dep
+    dep_pool
+    task
+    source
+    source_pool
+    vars
+    parameter
+    dep_runner
+    dep_definer
+    dep_context
+    meta_dep
+    meta_dep_context
+  ]
+end

data/lib/fancypath/fancypath.rb

@@ -0,0 +1,200 @@
+require 'pathname'
+
+class Fancypath < Pathname
+  module Helpers
+    require 'etc'
+    def to_fancypath
+      Fancypath.new to_tilde_expanded_path
+    end
+    def to_expanded_fancypath
+      Fancypath.new File.expand_path(to_tilde_expanded_path)
+    end
+    def to_tilde_expanded_path
+      sub(/^\~\/|^\~$/) {|_| Etc.getpwuid(Process.euid).dir.end_with('/') }
+    end
+    alias :p :to_expanded_fancypath
+  end
+
+  # methods are chainable and do what you think they do
+
+  alias_method :to_str, :to_s unless method_defined? :to_str
+
+  alias_method :dir, :dirname
+  alias_method :directory, :dirname
+
+  alias_method :dir?, :directory?
+
+  alias_method :expand, :expand_path
+  alias_method :abs, :expand_path
+  alias_method :absolute, :expand_path
+
+  alias_method :exists?, :exist?
+  alias_method :rename_to, :rename
+
+  def == other
+    if other.is_a? String
+      to_s == other
+    else
+      super
+    end
+  end
+
+  def length
+    to_s.length
+  end
+
+  def join(path)
+    path_str = path.to_s
+    super(path_str[0..0] == '/' ? path_str[1..-1] : path_str).p
+  end
+
+  alias_method :/, :join
+
+  # This method returns true if the path is writable (i.e. and already
+  # exists), or if the current user would be able to create it (i.e. if
+  # its closest existing parent is writable).
+  def hypothetically_writable?
+    writable? || (!exists? && !root? && parent.hypothetically_writable?)
+  end
+
+  # make file
+  def touch
+    `touch '#{self}'`
+    self
+  end
+
+  def create_dir
+    mkpath unless exist?
+    self
+  end
+
+  alias_method :create, :create_dir
+
+  def copy(dest)
+    `cp -pPR '#{self}' '#{dest}'`
+    self
+  end
+
+  alias_method :cp, :copy
+
+  # file or dir
+  def remove
+    directory? ? rmtree : delete if exist?
+    self
+  end
+  alias_method :rm, :remove
+
+  def read
+    super.chomp if exists?
+  end
+
+  def readlink
+    if !symlink?
+      self
+    elsif
+      target = super
+      target.absolute? ? target : (dir / target)
+    end
+  end
+
+  def mkdir
+    `mkdir -p '#{self}'`
+    self
+  end
+
+  def glob expr = nil, flags = File::FNM_CASEFOLD, &block
+    Dir.glob((expr.nil? ? self : (self / expr)).to_s, flags, &block)
+  end
+
+  def write(contents, mode='wb')
+    dirname.create
+    open(mode) { |f| f.write contents }
+    self
+  end
+
+  def append(contents)
+    write(contents,'a+')
+    self
+  end
+
+  def move(dest)
+    self.rename(dest)
+    dest.p
+  end
+
+  def tail(bytes)
+    return self.read if self.size < bytes
+    open('r') do |f|
+      f.seek(-bytes, IO::SEEK_END)
+      f.read
+    end
+  end
+
+  alias_method :mv, :move
+
+  def set_extension(ext)
+    "#{without_extension}.#{ext}".p
+  end
+
+  alias_method :change_extension, :set_extension
+
+  def without_extension
+    to_s[/^ (.+?) (\. ([^\.]+))? $/x, 1].p
+  end
+
+  def has_extension?(ext)
+    !!(self.to_s =~ /\.#{ext}$/)
+  end
+
+  def parent
+    super.p
+  end
+
+  alias_method :all_children, :children
+
+  def children
+    super.reject { |c| c.basename.to_s =~ /^\./ }
+  end
+
+  # only takes sym atm
+  def select(*args)
+    return args.map { |arg| select(arg) }.flatten.uniq if args.size > 1
+
+    case arg = args.first
+    when Symbol
+      Dir["#{self}/*.#{arg}"].map { |p| self.class.new(p) }
+    when Regexp
+      children.select { |child| child.to_s =~ arg }
+    else
+      Dir["#{self}/#{arg}"].map { |p| self.class.new(p) }
+    end
+  end
+  
+  def empty?
+    directory? ? children.size == 0 : self.size == 0
+  end
+  
+  def owner
+    Etc.getpwuid(File.stat(to_s).uid).name
+  end
+
+  def group
+    Etc.getgrgid(File.stat(to_s).gid).name
+  end
+
+  def inspect
+    super.sub('Pathname','Fancypath')
+  end
+
+  def to_fancypath
+    self
+  end
+
+end
+
+class Pathname
+  include Fancypath::Helpers
+end
+class String
+  include Fancypath::Helpers
+end

data/lib/inkan/inkan.rb

@@ -0,0 +1,76 @@
+class Inkan
+  attr_accessor :credit, :comment, :comment_suffix
+  
+  def self.legitimate?(filename)
+    File.open(filename) do |file|
+      file_content = file.read
+      seal, content = if file_content[/\A#!/]
+        hashbang, seal, remaining_content = file_content.split("\n", 3)
+        [seal, "#{hashbang}\n#{remaining_content}"]
+      else
+        file_content.split("\n", 2)
+      end
+
+      !seal[/\s#{sha(content || '')}\s*$/].nil?
+    end
+  end
+  
+  def self.seal(file)
+    new(file).tap {|inkan| yield inkan }.seal
+  end
+  
+  def self.render
+    new(nil).tap {|inkan| yield inkan }.render
+  end
+  
+  def self.sha(content)
+    require 'digest/sha1'
+    Digest::SHA1.hexdigest(content)
+  end
+  
+  def initialize(file)
+    @file = file
+    
+    # Set Defaults
+    @credit         = 'Generated by Inkan'
+    @comment        = '#'
+    @comment_suffix = ''
+  end
+  
+  def print(string)
+    file_content << string
+  end
+  
+  def puts(string)
+    file_content << string << "\n"
+  end
+  
+  def seal
+    File.open(@file, 'w') do |f|
+      f.print render
+    end
+  end
+  
+  def render
+    if file_content[/\A#!/]
+      hashbang, remaining_content = file_content.split("\n", 2)
+      "#{hashbang}\n#{render_seal}\n#{remaining_content}"
+    else
+      "#{render_seal}\n#{file_content}"
+    end
+  end
+  
+  private
+  
+  def render_seal
+    "#{comment} #{credit}. #{sha} #{comment_suffix}"
+  end
+  
+  def sha
+    self.class.sha(file_content)
+  end
+  
+  def file_content
+    @file_content ||= ''
+  end
+end