carat 1.9.9.pre1

data/lib/carat/friendly_errors.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+require "cgi"
+require "carat/vendored_thor"
+
+module Carat
+  def self.with_friendly_errors
+    yield
+  rescue Carat::CaratError => e
+    Carat.ui.error e.message, :wrap => true
+    Carat.ui.trace e
+    exit e.status_code
+  rescue Thor::AmbiguousTaskError => e
+    Carat.ui.error e.message
+    exit 15
+  rescue Thor::UndefinedTaskError => e
+    Carat.ui.error e.message
+    exit 15
+  rescue Thor::Error => e
+    Carat.ui.error e.message
+    exit 1
+  rescue LoadError => e
+    raise e unless e.message =~ /cannot load such file -- openssl|openssl.so|libcrypto.so/
+    Carat.ui.error "\nCould not load OpenSSL."
+    Carat.ui.warn <<-WARN, :wrap => true
+      You must recompile Ruby with OpenSSL support or change the sources in your \
+      Gemfile from 'https' to 'http'. Instructions for compiling with OpenSSL \
+      using RVM are available at http://rvm.io/packages/openssl.
+    WARN
+    Carat.ui.trace e
+    exit 1
+  rescue Interrupt => e
+    Carat.ui.error "\nQuitting..."
+    Carat.ui.trace e
+    exit 1
+  rescue SystemExit => e
+    exit e.status
+  rescue Exception => e
+    request_issue_report_for(e)
+    exit 1
+  end
+
+  def self.request_issue_report_for(e)
+    Carat.ui.info <<-EOS.gsub(/^ {6}/, '')
+      #{'--- ERROR REPORT TEMPLATE -------------------------------------------------------'}
+      - What did you do?
+
+        I ran the command `#{$PROGRAM_NAME} #{ARGV.join(' ')}`
+
+      - What did you expect to happen?
+
+        I expected Carat to...
+
+      - What happened instead?
+
+        Instead, what actually happened was...
+
+
+      Error details
+
+          #{e.class}: #{e.message}
+            #{e.backtrace.join("\n            ")}
+
+      #{Carat::Env.new.report(:print_gemfile => false).gsub(/\n/, "\n      ").strip}
+      #{'--- TEMPLATE END ----------------------------------------------------------------'}
+
+    EOS
+
+    Carat.ui.error "Unfortunately, an unexpected error occurred, and Carat cannot continue."
+
+    Carat.ui.warn <<-EOS.gsub(/^ {6}/, '')
+
+      First, try this link to see if there are any existing issue reports for this error:
+      #{issues_url(e)}
+
+      If there aren't any reports for this error yet, please create copy and paste the report template above into a new issue. Don't forget to anonymize any private data! The new issue form is located at:
+      https://github.com/caratrb/carat/issues/new
+    EOS
+  end
+
+  def self.issues_url(exception)
+    'https://github.com/caratrb/carat/search?q=' \
+    "#{CGI.escape(exception.message.lines.first.chomp)}&type=Issues"
+  end
+
+end

data/lib/carat/gem_helper.rb

@@ -0,0 +1,180 @@
+require 'carat/vendored_thor' unless defined?(Thor)
+require 'carat'
+
+module Carat
+  class GemHelper
+    include Rake::DSL if defined? Rake::DSL
+
+    class << self
+      # set when install'd.
+      attr_accessor :instance
+
+      def install_tasks(opts = {})
+        new(opts[:dir], opts[:name]).install
+      end
+
+      def gemspec(&block)
+        gemspec = instance.gemspec
+        block.call(gemspec) if block
+        gemspec
+      end
+    end
+
+    attr_reader :spec_path, :base, :gemspec
+
+    def initialize(base = nil, name = nil)
+      Carat.ui = UI::Shell.new
+      @base = (base ||= SharedHelpers.pwd)
+      gemspecs = name ? [File.join(base, "#{name}.gemspec")] : Dir[File.join(base, "{,*}.gemspec")]
+      raise "Unable to determine name from existing gemspec. Use :name => 'gemname' in #install_tasks to manually set it." unless gemspecs.size == 1
+      @spec_path = gemspecs.first
+      @gemspec = Carat.load_gemspec(@spec_path)
+    end
+
+    def install
+      built_gem_path = nil
+
+      desc "Build #{name}-#{version}.gem into the pkg directory."
+      task 'build' do
+        built_gem_path = build_gem
+      end
+
+      desc "Build and install #{name}-#{version}.gem into system gems."
+      task 'install' => 'build' do
+        install_gem(built_gem_path)
+      end
+
+      desc "Build and install #{name}-#{version}.gem into system gems without network access."
+      task 'install:local' => 'build' do
+        install_gem(built_gem_path, :local)
+      end
+
+      desc "Create tag #{version_tag} and build and push #{name}-#{version}.gem to Rubygems\n" \
+           "To prevent publishing in Rubygems use `gem_push=no rake release`"
+      task 'release' => ['build', 'release:guard_clean',
+                         'release:source_control_push', 'release:rubygem_push'] do
+      end
+
+      task 'release:guard_clean' do
+        guard_clean
+      end
+
+      task 'release:source_control_push' do
+        tag_version { git_push } unless already_tagged?
+      end
+
+      task 'release:rubygem_push' do
+        rubygem_push(built_gem_path) if gem_push?
+      end
+
+      GemHelper.instance = self
+    end
+
+    def build_gem
+      file_name = nil
+      sh("gem build -V '#{spec_path}'") { |out, code|
+        file_name = File.basename(built_gem_path)
+        FileUtils.mkdir_p(File.join(base, 'pkg'))
+        FileUtils.mv(built_gem_path, 'pkg')
+        Carat.ui.confirm "#{name} #{version} built to pkg/#{file_name}."
+      }
+      File.join(base, 'pkg', file_name)
+    end
+
+    def install_gem(built_gem_path = nil, local = false)
+      built_gem_path ||= build_gem
+      out, _ = sh_with_code("gem install '#{built_gem_path}'#{' --local' if local}")
+      raise "Couldn't install gem, run `gem install #{built_gem_path}' for more detailed output" unless out[/Successfully installed/]
+      Carat.ui.confirm "#{name} (#{version}) installed."
+    end
+
+    protected
+    def rubygem_push(path)
+      if Pathname.new("~/.gem/credentials").expand_path.exist?
+        sh("gem push '#{path}'")
+        Carat.ui.confirm "Pushed #{name} #{version} to rubygems.org."
+      else
+        raise "Your rubygems.org credentials aren't set. Run `gem push` to set them."
+      end
+    end
+
+    def built_gem_path
+      Dir[File.join(base, "#{name}-*.gem")].sort_by{|f| File.mtime(f)}.last
+    end
+
+    def git_push
+      perform_git_push
+      perform_git_push ' --tags'
+      Carat.ui.confirm "Pushed git commits and tags."
+    end
+
+    def perform_git_push(options = '')
+      cmd = "git push #{options}"
+      out, code = sh_with_code(cmd)
+      raise "Couldn't git push. `#{cmd}' failed with the following output:\n\n#{out}\n" unless code == 0
+    end
+
+    def already_tagged?
+      if sh('git tag').split(/\n/).include?(version_tag)
+        Carat.ui.confirm "Tag #{version_tag} has already been created."
+        true
+      end
+    end
+
+    def guard_clean
+      clean? && committed? or raise("There are files that need to be committed first.")
+    end
+
+    def clean?
+      sh_with_code("git diff --exit-code")[1] == 0
+    end
+
+    def committed?
+      sh_with_code("git diff-index --quiet --cached HEAD")[1] == 0
+    end
+
+    def tag_version
+      sh "git tag -a -m \"Version #{version}\" #{version_tag}"
+      Carat.ui.confirm "Tagged #{version_tag}."
+      yield if block_given?
+    rescue
+      Carat.ui.error "Untagging #{version_tag} due to error."
+      sh_with_code "git tag -d #{version_tag}"
+      raise
+    end
+
+    def version
+      gemspec.version
+    end
+
+    def version_tag
+      "v#{version}"
+    end
+
+    def name
+      gemspec.name
+    end
+
+    def sh(cmd, &block)
+      out, code = sh_with_code(cmd, &block)
+      code == 0 ? out : raise(out.empty? ? "Running `#{cmd}' failed. Run this command directly for more detailed output." : out)
+    end
+
+    def sh_with_code(cmd, &block)
+      cmd << " 2>&1"
+      outbuf = ''
+      Carat.ui.debug(cmd)
+      SharedHelpers.chdir(base) {
+        outbuf = `#{cmd}`
+        if $? == 0
+          block.call(outbuf) if block
+        end
+      }
+      [outbuf, $?]
+    end
+
+    def gem_push?
+      ! %w{n no nil false off 0}.include?(ENV['gem_push'].to_s.downcase)
+    end
+  end
+end

data/lib/carat/gem_helpers.rb

@@ -0,0 +1,26 @@
+module Carat
+  module GemHelpers
+
+    GENERIC_CACHE = {}
+    GENERICS = [
+      [Gem::Platform.new('java'), Gem::Platform.new('java')],
+      [Gem::Platform.new('mswin32'), Gem::Platform.new('mswin32')],
+      [Gem::Platform.new('mswin64'), Gem::Platform.new('mswin64')],
+      [Gem::Platform.new('universal-mingw32'), Gem::Platform.new('universal-mingw32')],
+      [Gem::Platform.new('x64-mingw32'), Gem::Platform.new('x64-mingw32')],
+      [Gem::Platform.new('x86_64-mingw32'), Gem::Platform.new('x64-mingw32')],
+      [Gem::Platform.new('mingw32'), Gem::Platform.new('x86-mingw32')]
+    ]
+
+    def generic(p)
+      return p if p == Gem::Platform::RUBY
+
+      GENERIC_CACHE[p] ||= begin
+        _, found = GENERICS.find do |match, _generic|
+          p.os == match.os && (!match.cpu || p.cpu == match.cpu)
+        end
+        found || Gem::Platform::RUBY
+      end
+    end
+  end
+end

data/lib/carat/gem_installer.rb

@@ -0,0 +1,9 @@
+require 'rubygems/installer'
+
+module Carat
+  class GemInstaller < Gem::Installer
+    def check_executable_overwrite(filename)
+      # Carat needs to install gems regardless of binstub overwriting
+    end
+  end
+end

data/lib/carat/gem_path_manipulation.rb

@@ -0,0 +1,8 @@
+module Carat
+  def self.preserve_gem_path
+    original_gem_path = ENV["_ORIGINAL_GEM_PATH"]
+    gem_path          = ENV["GEM_PATH"]
+    ENV["_ORIGINAL_GEM_PATH"] = gem_path          if original_gem_path.nil? || original_gem_path == ""
+    ENV["GEM_PATH"]           = original_gem_path if gem_path.nil? || gem_path == ""
+  end
+end

data/lib/carat/gem_tasks.rb

@@ -0,0 +1,2 @@
+require 'carat/gem_helper'
+Carat::GemHelper.install_tasks

data/lib/carat/graph.rb

@@ -0,0 +1,169 @@
+require 'set'
+module Carat
+  class Graph
+    GRAPH_NAME = :Gemfile
+
+    def initialize(env, output_file, show_version = false, show_requirements = false, output_format = "png", without = [])
+      @env               = env
+      @output_file       = output_file
+      @show_version      = show_version
+      @show_requirements = show_requirements
+      @output_format     = output_format
+      @without_groups    = without.map(&:to_sym)
+
+      @groups            = []
+      @relations         = Hash.new {|h, k| h[k] = Set.new}
+      @node_options      = {}
+      @edge_options      = {}
+
+      _patching_gem_dependency_class
+      _populate_relations
+    end
+
+    attr_reader :groups, :relations, :node_options, :edge_options, :output_file, :output_format
+
+    def viz
+      GraphVizClient.new(self).run
+    end
+
+    private
+
+    def _populate_relations
+      parent_dependencies = _groups.values.to_set.flatten
+      while true
+        if parent_dependencies.empty?
+          break
+        else
+          tmp = Set.new
+          parent_dependencies.each do |dependency|
+            child_dependencies = dependency.to_spec.runtime_dependencies.to_set
+            @relations[dependency.name] += child_dependencies.map(&:name).to_set
+            tmp += child_dependencies
+
+            @node_options[dependency.name] = _make_label(dependency, :node)
+            child_dependencies.each do |c_dependency|
+              @edge_options["#{dependency.name}_#{c_dependency.name}"] = _make_label(c_dependency, :edge)
+            end
+          end
+          parent_dependencies = tmp
+        end
+      end
+    end
+
+    def _groups
+      relations = Hash.new {|h, k| h[k] = Set.new}
+      @env.current_dependencies.each do |dependency|
+        dependency.groups.each do |group|
+          next if @without_groups.include?(group)
+
+          relations[group.to_s].add(dependency)
+          @relations[group.to_s].add(dependency.name)
+
+          @node_options[group.to_s] ||= _make_label(group, :node)
+          @edge_options["#{group}_#{dependency.name}"] = _make_label(dependency, :edge)
+        end
+      end
+      @groups = relations.keys
+      relations
+    end
+
+    def _make_label(symbol_or_string_or_dependency, element_type)
+      case element_type.to_sym
+      when :node
+        if symbol_or_string_or_dependency.is_a?(Gem::Dependency)
+          label = symbol_or_string_or_dependency.name.dup
+          label << "\n#{symbol_or_string_or_dependency.to_spec.version.to_s}" if @show_version
+        else
+          label = symbol_or_string_or_dependency.to_s
+        end
+      when :edge
+        label = nil
+        if symbol_or_string_or_dependency.respond_to?(:requirements_list) && @show_requirements
+          tmp = symbol_or_string_or_dependency.requirements_list.join(", ")
+          label = tmp if tmp != ">= 0"
+        end
+      else
+        raise ArgumentError, "2nd argument is invalid"
+      end
+      label.nil? ? {} : { :label => label }
+    end
+
+    def _patching_gem_dependency_class
+      # method borrow from rubygems/dependency.rb
+      # redefinition of matching_specs will also redefine to_spec and to_specs
+      Gem::Dependency.class_eval do
+        def matching_specs platform_only = false
+          matches = Carat.load.specs.select { |spec|
+            self.name == spec.name and
+              requirement.satisfied_by? spec.version
+          }
+
+          if platform_only
+            matches.reject! { |spec|
+              not Gem::Platform.match spec.platform
+            }
+          end
+
+          matches = matches.sort_by { |s| s.sort_obj } # HACK: shouldn't be needed
+        end
+      end
+    end
+
+    class GraphVizClient
+      def initialize(graph_instance)
+        @graph_name    = graph_instance.class::GRAPH_NAME
+        @groups        = graph_instance.groups
+        @relations     = graph_instance.relations
+        @node_options  = graph_instance.node_options
+        @edge_options  = graph_instance.edge_options
+        @output_file   = graph_instance.output_file
+        @output_format = graph_instance.output_format
+      end
+
+      def g
+        @g ||= ::GraphViz.digraph(@graph_name, {:concentrate => true, :normalize => true, :nodesep => 0.55}) do |g|
+          g.edge[:weight]   = 2
+          g.edge[:fontname] = g.node[:fontname] = 'Arial, Helvetica, SansSerif'
+          g.edge[:fontsize] = 12
+        end
+      end
+
+      def run
+        @groups.each do |group|
+          g.add_nodes(
+            group,
+            {:style     => 'filled',
+             :fillcolor => '#B9B9D5',
+             :shape     => "box3d",
+             :fontsize  => 16}.merge(@node_options[group])
+          )
+        end
+
+        @relations.each do |parent, children|
+          children.each do |child|
+            if @groups.include?(parent)
+              g.add_nodes(child, {:style => 'filled', :fillcolor => '#B9B9D5'}.merge(@node_options[child]))
+              g.add_edges(parent, child, {:constraint => false}.merge(@edge_options["#{parent}_#{child}"]))
+            else
+              g.add_nodes(child, @node_options[child])
+              g.add_edges(parent, child, @edge_options["#{parent}_#{child}"])
+            end
+          end
+        end
+
+        if @output_format.to_s == "debug"
+          $stdout.puts g.output :none => String
+          Carat.ui.info "debugging carat viz..."
+        else
+          begin
+            g.output @output_format.to_sym => "#{@output_file}.#{@output_format}"
+            Carat.ui.info "#{@output_file}.#{@output_format}"
+          rescue ArgumentError => e
+            $stderr.puts "Unsupported output format. See Ruby-Graphviz/lib/graphviz/constants.rb"
+            raise e
+          end
+        end
+      end
+    end
+  end
+end