berkshelf 3.0.0.beta7 → 3.0.0.beta8

data/.ruby-version

@@ -1 +0,0 @@
-2.0.0-p353

data/berkshelf-complete.sh

@@ -1,75 +0,0 @@
-#!/bin/bash
-#
-# Description
-#   Add tab completion for berkshelf
-#
-# Configuration:
-#   BERKSHELF_BERKSFILE (default is 'Berksfile')
-#
-# Notes:
-#   Must be added to your ~/.bashrc, ~/.zshrc, etc
-#
-# Author:
-#   Seth Vargo <sethvargo@gmail.com>
-#
-# License:
-#   Apache 2.0
-#
-
-_bundler() {
-  which bundle > /dev/null 2>&1 && [ -f "$(pwd)/Gemfile" ]
-}
-
-# Overwrite berks to use bundler if defined
-_berks() {
-  [ _bundler ] && bundle exec berks $@ || berks $@
-}
-
-_berkshelf_commands() {
-  local cachefile=~/.berkshelf/.commands
-  [ ! -f $cachefile ] && $(_berks help | grep berks | cut -d " " -f 4 > $cachefile)
-  cat $cachefile
-}
-
-_berkshelf_cookbooks() {
-  local file=${BERKSHELF_BERKSFILE:-Berksfile}
-  if [ -e $file ]; then
-    # strip all quotes from cookbook name and remove trailing comma, if any
-    grep -w '^cookbook' $file \
-      | awk '{ print $2 }' \
-      | sed 's/"//g' \
-      | sed "s/'//g" \
-      | sed 's/,$//'
-  fi
-}
-
-_local_cookbooks() {
-  [ -d cookbooks ] && ls -d cookbooks/*/ | cut -d "/" -f 2
-}
-
-_berkshelf() {
-  # local curr prev commands
-  COMPREPLY=()
-  curr="${COMP_WORDS[COMP_CWORD]}"
-  prev="${COMP_WORDS[COMP_CWORD-1]}"
-
-  # List of commands to complete
-  commands=`_berkshelf_commands`
-
-  case "${prev}" in
-    "open"|"outdated"|"show"|"update"|"upload")
-      local berkshelf_cookbooks=`_berkshelf_cookbooks`
-      local local_cookbooks=`_local_cookbooks`
-      local cookbooks=`echo $berkshelf_cookbooks $local_cookbooks | sort -n | uniq`
-      COMPREPLY=($(compgen -W "${cookbooks}" -- ${curr}))
-      return 0
-      ;;
-    *)
-      ;;
-  esac
-
-  COMPREPLY=($(compgen -W "${commands}" -- ${curr}))
-  return 0
-}
-
-complete -F _berkshelf berks

data/lib/berkshelf/formatters.rb

@@ -1,110 +0,0 @@
-module Berkshelf
-  module Formatters
-    class << self
-      @@formatters = Hash.new
-
-      # Access the formatters map that links string symbols to Formatter
-      # implementations
-      #
-      # @return [Hash]
-      def formatters
-        @@formatters
-      end
-
-      # @param [#to_sym] id
-      # @param [Constant] klass
-      #
-      # @raise [Berkshelf::InternalError] if an ID that has already been registered is attempted
-      #   to be registered again
-      #
-      # @return [Hash]
-      #   a hash of registered formatters
-      def register(id, klass)
-        unless id.respond_to?(:to_sym)
-          raise ArgumentError, "Invalid Formatter ID: must respond to #to_sym. You gave: #{id}"
-        end
-
-        id = id.to_sym
-        if self.formatters.has_key?(id)
-          raise Berkshelf::InternalError, "Formatter ID '#{id}' already registered"
-        end
-
-        self.formatters[id] = klass
-      end
-
-      # @param [#to_sym] id
-      #
-      # @return [~AbstractFormatter, nil]
-      def get(id)
-        unless id.respond_to?(:to_sym)
-          raise ArgumentError, "Invalid Formatter ID: must respond to #to_sym. You gave: #{id}"
-        end
-
-        self.formatters.fetch(id.to_sym, nil)
-      end
-      alias_method :[], :get
-    end
-
-    # @abstract Include and override {#install} {#use} {#upload}
-    #   {#msg} {#error} to implement.
-    #
-    #   Implement {#cleanup_hook} to run any steps required to run after the task is finished
-    module AbstractFormatter
-      module ClassMethods
-        # @param [Symbol] id
-        #
-        # @raise [Berkshelf::InternalError] if an ID that has already been registered is attempted
-        #   to be registered again
-        #
-        # @return [Hash]
-        #   a hash of registered formatters
-        def register_formatter(id)
-          Formatters.register(id, self)
-        end
-      end
-
-      class << self
-        def included(base)
-          base.send(:extend, ClassMethods)
-        end
-
-        private
-
-          def formatter_methods(*args)
-            args.each do |meth|
-              define_method(meth.to_sym) do |*args|
-                raise AbstractFunction, "##{meth} must be implemented on #{self.class}"
-              end unless respond_to?(meth.to_sym)
-            end
-          end
-      end
-
-      formatter_methods :error,
-                        :warn,
-                        :fetch,
-                        :install,
-                        :list,
-                        :msg,
-                        :outdated,
-                        :package,
-                        :skip,
-                        :show,
-                        :upload,
-                        :use,
-                        :vendor,
-                        :version
-
-      def cleanup_hook
-        # run after the task is finished
-      end
-
-      private
-
-        attr_reader :args
-    end
-  end
-end
-
-Dir["#{File.dirname(__FILE__)}/formatters/*.rb"].sort.each do |path|
-  require_relative "formatters/#{File.basename(path, '.rb')}"
-end

data/lib/berkshelf/formatters/human_readable.rb

@@ -1,142 +0,0 @@
-module Berkshelf
-  module Formatters
-    class HumanReadable
-      include AbstractFormatter
-
-      register_formatter :human
-
-      # Output the version of Berkshelf
-      def version
-        Berkshelf.ui.info Berkshelf::VERSION
-      end
-
-      # @param [Berkshelf::Dependency] dependency
-      def fetch(dependency)
-        Berkshelf.ui.info "Fetching '#{dependency.name}' from #{dependency.location}"
-      end
-
-      # Output a Cookbook installation message using {Berkshelf.ui}
-      #
-      # @param [Source] source
-      #   the source the dependency is being downloaded from
-      # @param [RemoteCookbook] cookbook
-      #   the cookbook to be downloaded
-      def install(source, cookbook)
-        message = "Installing #{cookbook.name} (#{cookbook.version})"
-
-        unless source.default?
-          message << " from #{source}"
-          message << " ([#{cookbook.location_type}] #{cookbook.location_path})"
-        end
-
-        Berkshelf.ui.info(message)
-      end
-
-      # Output a Cookbook use message using {Berkshelf.ui}
-      #
-      # @param [Dependency] dependency
-      def use(dependency)
-        message =  "Using #{dependency.name} (#{dependency.locked_version})"
-        message << " from #{dependency.location}" if dependency.location
-        Berkshelf.ui.info message
-      end
-
-      # Output a Cookbook upload message using {Berkshelf.ui}
-      #
-      # @param [Berkshelf::CachedCookbook] cookbook
-      # @param [Ridley::Connection] conn
-      def upload(cookbook, conn)
-        Berkshelf.ui.info "Uploading #{cookbook.cookbook_name} (#{cookbook.version}) to: '#{conn.server_url}'"
-      end
-
-      # Output a Cookbook skip message using {Berkshelf.ui}
-      #
-      # @param [Berkshelf::CachedCookbook] cookbook
-      # @param [Ridley::Connection] conn
-      def skip(cookbook, conn)
-        Berkshelf.ui.info "Skipping #{cookbook.cookbook_name} (#{cookbook.version}) (frozen)"
-      end
-
-      # Output a list of outdated cookbooks and the most recent version
-      # using {Berkshelf.ui}
-      #
-      # @param [Hash] hash
-      #   the list of outdated cookbooks in the format
-      #   { 'cookbook' => { 'api.berkshelf.com' => #<Cookbook> } }
-      def outdated(hash)
-        hash.keys.each do |name|
-          hash[name].each do |source, newest|
-            string = "  * #{newest.name} (#{newest.version})"
-            unless source == Berksfile::DEFAULT_API_URL
-              string << " [#{source}]"
-            end
-            Berkshelf.ui.info string
-          end
-        end
-      end
-
-      # Output a Cookbook package message using {Berkshelf.ui}
-      #
-      # @param [String] destination
-      def package(destination)
-        Berkshelf.ui.info "Cookbook(s) packaged to #{destination}"
-      end
-
-      # Output a list of cookbooks using {Berkshelf.ui}
-      #
-      # @param [Array<Dependency>] list
-      def list(dependencies)
-        Berkshelf.ui.info "Cookbooks installed by your Berksfile:"
-        dependencies.each do |dependency|
-          out =  "  * #{dependency}"
-          out << " from #{dependency.location}" if dependency.location
-          Berkshelf.ui.info(out)
-        end
-      end
-
-      # Output Cookbook info message using {Berkshelf.ui}
-      #
-      # @param [CachedCookbook] cookbook
-      def show(cookbook)
-        Berkshelf.ui.info(cookbook.pretty_print)
-      end
-
-      # Output Cookbook vendor info message using {Berkshelf.ui}
-      #
-      # @param [CachedCookbook] cookbook
-      # @param [String] destination
-      def vendor(cookbook, destination)
-        cookbook_destination = File.join(destination, cookbook.cookbook_name)
-        Berkshelf.ui.info "Vendoring #{cookbook.cookbook_name} (#{cookbook.version}) to #{cookbook_destination}"
-      end
-
-      # Output a generic message using {Berkshelf.ui}
-      #
-      # @param [String] message
-      def msg(message)
-        Berkshelf.ui.info message
-      end
-
-      # Output an error message using {Berkshelf.ui}
-      #
-      # @param [String] message
-      def error(message)
-        Berkshelf.ui.error message
-      end
-
-      # Output a warning message using {Berkshelf.ui}
-      #
-      # @param [String] message
-      def warn(message)
-        Berkshelf.ui.warn message
-      end
-
-      # Output a deprecation warning
-      #
-      # @param [String] message
-      def deprecation(message)
-        Berkshelf.ui.info "DEPRECATED: #{message}"
-      end
-    end
-  end
-end

data/lib/berkshelf/git.rb

@@ -1,204 +0,0 @@
-require 'uri'
-require 'buff/shell_out'
-
-module Berkshelf
-  class Git
-    GIT_REGEXP = URI.regexp(%w(http https ssh git+ssh git rsync))
-    SCP_REGEXP = /^(.+@)?[\w\d\.-]+:.*$/
-
-    HAS_QUOTE_RE = %r{\"}.freeze
-    HAS_SPACE_RE = %r{\s}.freeze
-
-    class << self
-      include Buff::ShellOut
-
-      # @overload git(commands)
-      #   Shellout to the Git executable on your system with the given commands.
-      #
-      #   @param [Array<String>]
-      #
-      #   @return [String]
-      #     the output of the execution of the Git command
-      def git(*command)
-        command.unshift(git_cmd)
-        command_str = command.map { |p| quote_cmd_arg(p) }.join(' ')
-        response    = shell_out(command_str)
-
-        unless response.success?
-          raise GitError.new(response.stderr.strip)
-        end
-
-        response.stdout.strip
-      end
-
-      # Clone a remote Git repository to disk
-      #
-      # @param [String] uri
-      #   a Git URI to clone
-      # @param [#to_s] destination
-      #   a local path on disk to clone to
-      #
-      # @return [String]
-      #   the destination the URI was cloned to
-      def clone(uri, destination = Dir.mktmpdir)
-        if File::ALT_SEPARATOR
-          destination = destination.to_s.gsub(File::SEPARATOR, File::ALT_SEPARATOR)
-        end
-
-        git('clone', uri, destination.to_s)
-
-        destination
-      end
-
-      # Checkout the given reference in the given repository
-      #
-      # @param [String] repo_path
-      #   path to a Git repo on disk
-      # @param [String] ref
-      #   reference to checkout
-      def checkout(repo_path, ref)
-        Dir.chdir repo_path do
-          git('checkout', '-qf', revision_from_ref(repo_path, ref))
-        end
-      end
-
-      # @param [String] repo_path
-      def rev_parse(repo_path)
-        Dir.chdir repo_path do
-          git('rev-parse', 'HEAD')
-        end
-      end
-
-      # Return the sha revision for the given reference in the given repository
-      #
-      # @param [String] repo_path
-      #   path to a Git repo on disk
-      # @param [String] ref
-      #   reference to show
-      #
-      # @return [String]
-      #   the sha revision for the given ref
-      #
-      # @raise [AmbiguousGitRef] if the ref could refer to more than one revision
-      def show_ref(repo_path, ref)
-        Dir.chdir repo_path do
-          lines = git('show-ref', ref).lines.to_a
-
-          raise AmbiguousGitRef, ref if lines.size > 1
-
-          lines.first.chomp.split(/\s/).first
-        end
-      end
-
-      # Return the sha revision for the given reference or revision in the given repository
-      #
-      # This method is useful when you have either a sha revision, tag, or branch and
-      # you'd like to end up with a sha revision.
-      #
-      # @param [String] repo_path
-      #   path to a Git repo on disk
-      # @param [String] ref
-      #   reference to show
-      #
-      # @return [String]
-      #   the sha revision for the given ref
-      #
-      # @raise [InvalidGitRef] if the ref could not be found
-      def revision_from_ref(repo_path, ref)
-        begin
-          show_ref(repo_path, ref)
-        rescue GitError
-          begin
-            git('rev-parse', ref)
-            ref
-          rescue GitError
-            raise InvalidGitRef, ref
-          end
-        end
-      end
-
-      # Return an absolute path to the Git executable on your system
-      #
-      # @return [String]
-      #   absolute path to git executable
-      #
-      # @raise [GitNotFound] if executable is not found in system path
-      def find_git
-        git_path = nil
-        ENV['PATH'].split(::File::PATH_SEPARATOR).each do |path|
-          git_path = detect_git_path(path)
-          break if git_path
-        end
-
-        unless git_path
-          raise GitNotFound
-        end
-
-        return git_path
-      end
-
-      # Determines if the given URI is a valid Git URI. A valid Git URI is a string
-      # containing the location of a Git repository by either the Git protocol,
-      # SSH protocol, or HTTPS protocol.
-      #
-      # @example Valid Git protocol URI
-      #   'git://github.com/reset/thor-foodcritic.git'
-      # @example Valid HTTPS URI
-      #   'https://github.com/reset/solve.git'
-      # @example Valid SSH protocol URI
-      #   'git@github.com:reset/solve.git'
-      #
-      # @param [String] uri
-      #
-      # @return [Boolean]
-      def validate_uri(uri)
-        unless uri.is_a?(String)
-          return false
-        end
-
-        unless uri.slice(GIT_REGEXP).nil?
-          return true
-        end
-
-        unless uri.slice(SCP_REGEXP).nil?
-          return true
-        end
-
-        false
-      end
-
-      # @raise [InvalidGitURI] if the given object is not a String containing a valid Git URI
-      #
-      # @see validate_uri
-      def validate_uri!(uri)
-        unless validate_uri(uri)
-          raise InvalidGitURI.new(uri)
-        end
-
-        true
-      end
-
-      private
-
-        def git_cmd
-          @git_cmd ||= find_git
-        end
-
-        def quote_cmd_arg(arg)
-          return arg if HAS_QUOTE_RE.match(arg)
-          return arg unless HAS_SPACE_RE.match(arg)
-          "\"#{arg}\""
-        end
-
-        def detect_git_path(base_dir)
-          %w(git git.exe git.cmd).each do |git_cmd|
-            potential_path = File.join(base_dir, git_cmd)
-            if File.executable?(potential_path)
-              return potential_path
-            end
-          end
-          nil
-        end
-    end
-  end
-end