boxcar 0.10005.1

data/lib/vagrant/util/template_renderer.rb

@@ -0,0 +1,83 @@
+require 'ostruct'
+require 'erubis'
+
+module Vagrant
+  module Util
+    # This class is used to render the ERB templates in the
+    # `GEM_ROOT/templates` directory.
+    class TemplateRenderer < OpenStruct
+      class << self
+        # Render a given template and return the result. This method optionally
+        # takes a block which will be passed the renderer prior to rendering, which
+        # allows the caller to set any view variables within the renderer itself.
+        #
+        # @return [String] Rendered template
+        def render(*args)
+          render_with(:render, *args)
+        end
+
+        # Render a given string and return the result. This method optionally
+        # takes a block which will be passed the renderer prior to rendering, which
+        # allows the caller to set any view variables within the renderer itself.
+        #
+        # @param [String] template The template data string.
+        # @return [String] Rendered template
+        def render_string(*args)
+          render_with(:render_string, *args)
+        end
+
+        # Method used internally to DRY out the other renderers. This method
+        # creates and sets up the renderer before calling a specified method on it.
+        def render_with(method, template, data={})
+          renderer = new(template, data)
+          yield renderer if block_given?
+          renderer.send(method.to_sym)
+        end
+      end
+
+      def initialize(template, data = {})
+        super()
+
+        data[:template] = template
+        data.each do |key, value|
+          send("#{key}=", value)
+        end
+      end
+
+      # Renders the template using the class intance as the binding. Because the
+      # renderer inherits from `OpenStruct`, additional view variables can be
+      # added like normal accessors.
+      #
+      # @return [String]
+      def render
+        # TODO: Seems like a pretty dirty way to do this. Perhaps refactor this
+        old_template = template
+        result = nil
+        File.open(full_template_path, 'r') do |f|
+          self.template = f.read
+          result = render_string
+        end
+
+        result
+      ensure
+        self.template = old_template
+      end
+
+      # Renders a template, handling the template as a string, but otherwise
+      # acting the same way as {#render}.
+      #
+      # @return [String]
+      def render_string
+        Erubis::Eruby.new(template, :trim => true).result(binding)
+      end
+
+      # Returns the full path to the template, taking into accoun the gem directory
+      # and adding the `.erb` extension to the end.
+      #
+      # @return [String]
+      def full_template_path
+        Vagrant.source_root.join('templates', "#{template}.erb").to_s.squeeze("/")
+      end
+    end
+  end
+end

data/lib/vagrant/version.rb

@@ -0,0 +1,7 @@
+module Vagrant
+  # This will always be up to date with the current version of Vagrant,
+  # since it is used to generate the gemspec and is also the source of
+  # the version for `vagrant -v`
+  Version = File.read(File.expand_path('../../../VERSION',  __FILE__)).strip
+  VERSION = Version
+end

data/lib/vagrant/vm.rb

@@ -0,0 +1,195 @@
+require 'log4r'
+
+module Vagrant
+  class VM
+    include Vagrant::Util
+
+    attr_reader :uuid
+    attr_reader :env
+    attr_reader :name
+    attr_reader :vm
+    attr_reader :box
+    attr_reader :config
+    attr_reader :driver
+
+    def initialize(name, env, config, opts=nil)
+      @logger = Log4r::Logger.new("vagrant::vm")
+
+      @name   = name
+      @vm     = nil
+      @env    = env
+      @config = config
+      @box    = env.boxes.find(config.vm.box)
+
+      opts ||= {}
+      if opts[:base]
+        # The name is the ID we use.
+        @uuid = name
+      else
+        # Load the UUID if its saved.
+        active = env.local_data[:active] || {}
+        @uuid = active[@name.to_s]
+      end
+
+      # Reload ourselves to get the state
+      reload!
+
+      # Load the associated guest.
+      load_guest!
+      @loaded_guest_distro = false
+    end
+
+    # Loads the guest associated with the VM. The guest class is
+    # responsible for OS-specific functionality. More information
+    # can be found by reading the documentation on {Vagrant::Guest::Base}.
+    #
+    # **This method should never be called manually.**
+    def load_guest!(guest=nil)
+      guest ||= config.vm.guest
+      @logger.info("Loading guest: #{guest}")
+
+      if guest.is_a?(Class)
+        raise Errors::VMGuestError, :_key => :invalid_class, :guest => guest.to_s if !(guest <= Guest::Base)
+        @guest = guest.new(self)
+      elsif guest.is_a?(Symbol)
+        guest_klass = Vagrant.guests.get(guest)
+        raise Errors::VMGuestError, :_key => :unknown_type, :guest => guest.to_s if !guest_klass
+        @guest = guest_klass.new(self)
+      else
+        raise Errors::VMGuestError, :unspecified
+      end
+    end
+
+    # Returns a channel object to communicate with the virtual
+    # machine.
+    def channel
+      @channel ||= Communication::SSH.new(self)
+    end
+
+    # Returns the guest for this VM, loading the distro of the system if
+    # we can.
+    def guest
+      if !@loaded_guest_distro && state == :running
+        # Load the guest distro for the first time
+        result = @guest.distro_dispatch
+        load_guest!(result)
+        @loaded_guest_distro = true
+      end
+
+      @guest
+    end
+
+    # Access the {Vagrant::SSH} object associated with this VM, which
+    # is used to get SSH credentials with the virtual machine.
+    def ssh
+      @ssh ||= SSH.new(self)
+    end
+
+    # Returns the state of the VM as a symbol.
+    #
+    # @return [Symbol]
+    def state
+      return :not_created if !@uuid
+      state = @driver.read_state
+      return :not_created if !state
+      return state
+    end
+
+    # Returns a boolean true if the VM has been created, otherwise
+    # returns false.
+    #
+    # @return [Boolean]
+    def created?
+      state != :not_created
+    end
+
+    # Sets the currently active VM for this VM. If the VM is a valid,
+    # created virtual machine, then it will also update the local data
+    # to persist the VM. Otherwise, it will remove itself from the
+    # local data (if it exists).
+    def uuid=(value)
+      env.local_data[:active] ||= {}
+      if value
+        env.local_data[:active][name.to_s] = value
+      else
+        env.local_data[:active].delete(name.to_s)
+      end
+
+      # Commit the local data so that the next time vagrant is initialized,
+      # it realizes the VM exists
+      env.local_data.commit
+
+      # Store the uuid and reload the instance
+      @uuid = value
+      reload!
+    end
+
+    def reload!
+      begin
+        @driver = Driver::VirtualBox.new(@uuid)
+      rescue Driver::VirtualBox::VMNotFound
+        # Clear the UUID since this VM doesn't exist.
+        @uuid = nil
+
+        # Reset the driver. This shouldn't raise a VMNotFound since we won't
+        # feed it a UUID.
+        @driver = Driver::VirtualBox.new
+      end
+    end
+
+    def package(options=nil)
+      run_action(:package, { "validate" => false }.merge(options || {}))
+    end
+
+    def up(options=nil)
+      run_action(:up, options)
+    end
+
+    def start(options=nil)
+      return if state == :running
+      return resume if state == :saved
+
+      run_action(:start, options)
+    end
+
+    def halt(options=nil)
+      run_action(:halt, options)
+    end
+
+    def reload(options=nil)
+      run_action(:reload, options)
+    end
+
+    def provision
+      run_action(:provision)
+    end
+
+    def destroy
+      run_action(:destroy)
+    end
+
+    def suspend
+      run_action(:suspend)
+    end
+
+    def resume
+      run_action(:resume)
+    end
+
+    def ui
+      return @_ui if defined?(@_ui)
+      @_ui = @env.ui.dup
+      @_ui.resource = @name
+      @_ui
+    end
+
+    def run_action(name, options=nil)
+      options = {
+        :vm => self,
+        :ui => ui
+      }.merge(options || {})
+
+      env.action_runner.run(name, options)
+    end
+  end
+end

data/libexec/build

@@ -0,0 +1,30 @@
+#!/bin/bash
+
+#/ NAME
+#/     build-gem -- upload the latest (timestamp) rubygem to rubygems.org
+#/
+#/ SYNOPSIS
+#/     build gem -n gem_name
+
+# figure out the project root under which bin, lib live
+shome="$(cd -P -- "$(dirname -- "$BASH_SOURCE")/.." && pwd -P)"
+
+# load a jason bourne library
+source "$shome/bin/_treadstone"
+
+# define command line options:
+DEFINE_string 'name' "$(basename "$shome")" 'name of gem' 'n'
+
+# entry point
+function main {
+  local pth_gemspec="$shome/$FLAGS_name.gemspec"
+  if [[ ! -e "$pth_gemspec" ]]; then
+    logger_fatal "could not find gemspec $pth_gemspec"
+    exit 1
+  fi
+
+  cd "$shome"
+  gem build "$pth_gemspec"
+}
+
+require sub "$BASH_SOURCE" "$@"

data/libexec/build-gem

@@ -0,0 +1,30 @@
+#!/bin/bash
+
+#/ NAME
+#/     build-gem -- upload the latest (timestamp) rubygem to rubygems.org
+#/
+#/ SYNOPSIS
+#/     build gem -n gem_name
+
+# figure out the project root under which bin, lib live
+shome="$(cd -P -- "$(dirname -- "$BASH_SOURCE")/.." && pwd -P)"
+
+# load a jason bourne library
+source "$shome/bin/_treadstone"
+
+# define command line options:
+DEFINE_string 'name' "$(basename "$shome")" 'name of gem' 'n'
+
+# entry point
+function main {
+  local pth_gemspec="$shome/$FLAGS_name.gemspec"
+  if [[ ! -e "$pth_gemspec" ]]; then
+    logger_fatal "could not find gemspec $pth_gemspec"
+    exit 1
+  fi
+
+  cd "$shome"
+  gem build "$pth_gemspec"
+}
+
+require sub "$BASH_SOURCE" "$@"

data/libexec/bump

@@ -0,0 +1,32 @@
+#!/bin/bash
+
+#/ NAME
+#/     bump -- increments a semver in a file or in git tags
+#/
+#/ SYNOPSIS
+#/     bump [major|minor|patch]
+#/     bump 1.2.3
+#/     bump
+#/       without arguments is equivalent to 'bump patch'
+
+# figure out the project root under which bin, lib live
+shome="$(cd -P -- "$(dirname -- "$BASH_SOURCE")/.." && pwd -P)"
+
+# load a jason bourne library
+source "$shome/bin/_treadstone"
+
+# parse the command-line
+DEFINE_boolean 'dirty' "$FLAGS_FALSE" 'force bumping in unclean work area' 'f'
+
+# entry point
+function main {
+  require 'bump'
+
+  if [[ "$#" = 0 ]]; then
+    set -- patch
+  fi
+
+  bump_version "$FLAGS_dirty" "$@"
+}
+
+require sub "$BASH_SOURCE" "$@"

data/libexec/edit-gem

@@ -0,0 +1,81 @@
+#!/bin/bash
+
+#/ NAME
+#/     edit-gem -- set environment to hint to Gemfile to use a local gemspec
+#/
+#/ SYNOPSIS
+#/     edit gem <name> [location]
+#/     edit gem -r <names>
+#/     edit gem -R
+
+# figure out the project root under which bin, lib live
+shome="$(cd -P -- "$(dirname -- "$BASH_SOURCE")/.." && pwd -P)"
+
+# load a jason bourne library
+source "$shome/bin/_treadstone"
+
+# define command line options:
+DEFINE_boolean "update" "$FLAGS_FALSE" "finish editing a local gem and updates project" "u"
+DEFINE_boolean "reset" "$FLAGS_FALSE" "reset gem to remote" "r"
+DEFINE_boolean "resetall" "$FLAGS_FALSE" "reset all gems to remote" "R"
+
+# entry point
+function main {
+  if [[ "$FLAGS_resetall" = "$FLAGS_TRUE" ]]; then
+    set +f
+    rm -f $shome/.local/*
+    set -f
+    bundle --local --quiet && bundle check > /dev/null
+    git diff --no-ext-diff Gemfile.lock vendor/cache
+  elif [[ "$FLAGS_reset" = "$FLAGS_TRUE" ]]; then
+    local nm_gem
+    for nm_gem in "$@"; do
+      rm -f "$shome/.local/$nm_gem"
+    done
+
+    bundle --local --quiet && bundle check > /dev/null
+
+    git diff --no-ext-diff Gemfile.lock vendor/cache
+  elif [[ "$FLAGS_update" = "$FLAGS_TRUE" ]]; then
+    local nm_gem
+    for nm_gem in "$@"; do
+      echo -n > "$shome/.local/$nm_gem"
+    done
+
+    bundle update "$@"
+
+    for nm_gem in "$@"; do
+      rm -f "$shome/.local/$nm_gem"
+    done
+    bundle --local --quiet && bundle check > /dev/null
+
+    git add Gemfile.lock vendor/cache
+    git add -u vendor/cache
+    git diff --no-ext-diff --cached Gemfile.lock vendor/cache
+  else
+    local nm_gem="$1"; shift
+
+    local pth_gem
+    if [[ "$#" = 0 ]]; then
+      pth_gem="gems/$nm_gem"
+    else
+      pth_gem="$1"; shift
+    fi
+    
+    if [[ ! -d "$pth_gem" ]]; then
+      logger_fatal "cannot find local gem directoy at $pth_gem"
+      exit 1
+    fi
+
+    pth_gem="$(cd -P -- "$pth_gem" && pwd -P)"
+
+    echo "enabling local gem development on ${nm_gem} at ${pth_gem}"
+    mkdir -p "$shome/.local"
+    echo "$pth_gem" > "$shome/.local/$nm_gem"
+
+    bundle --local --quiet && bundle check > /dev/null
+    git diff --no-ext-diff Gemfile.lock vendor/cache
+  fi
+}
+
+require sub "$BASH_SOURCE" "$@"