nugrant 2.0.0.dev2 → 2.0.0.pre1

data/lib/nugrant/helper/env/namer.rb

@@ -0,0 +1,47 @@
+module Nugrant
+  module Helper
+    module Env
+      ##
+      # A namer is a lambda taking as argument an array of segments
+      # that should return a string representation of those segments.
+      # How the segments are transformed to a string is up to the
+      # namer. By using various namer, we can change how a bag key
+      # is transformed into and environment variable name. This is
+      # like the strategy pattern.
+      #
+      module Namer
+
+        ##
+        # Returns the default namer, which join segments together
+        # using a character and upcase the result.
+        #
+        # @param `char` The character used to join segments together, default to `"_"`.
+        #
+        # @return A lambda that will simply joins segment using the `char` argument
+        #         and upcase the result.
+        #
+        def self.default(char = "_")
+          lambda do |segments|
+            segments.join(char).upcase()
+          end
+        end
+
+        ##
+        # Returns the prefix namer, which add a prefix to segments
+        # and delegate its work to another namer.
+        #
+        # @param prefix The prefix to add to segments.
+        # @param delegate_namer A namer that will be used to transform the prefixed segments.
+        #
+        # @return A lambda that will simply add prefix to segments and will call
+        #         the delegate_namer with those new segments.
+        #
+        def self.prefix(prefix, delegate_namer)
+          lambda do |segments|
+            delegate_namer.call([prefix] + segments)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nugrant/helper/parameters.rb

@@ -0,0 +1,12 @@
+require 'nugrant/parameters'
+
+module Nugrant
+  module Helper
+    module Parameters
+      def self.restricted_keys()
+        methods = Nugrant::Parameters.instance_methods() + Nugrant::Bag.instance_methods()
+        methods.uniq!
+      end
+    end
+  end
+end

data/lib/nugrant/helper/stack.rb

@@ -0,0 +1,86 @@
+module Nugrant
+  module Helper
+    class Stack
+      @@DEFAULT_MATCHER = /^(.+):([0-9]+)/
+
+      def self.fetch_error_region(stack, options = {})
+        entry = find_entry(stack, options)
+        location = extract_error_location(entry, options)
+
+        return (options[:unknown] || "Unknown") if not location[:file] and not location[:line]
+        return location[:file] if not location[:line]
+
+        fetch_error_region_from_location(location, options)
+      end
+
+      def self.fetch_error_region_from_location(location, options = {})
+        prefix = options[:prefix] || "   "
+        width = options[:width] || 4
+        file = File.new(location[:file], "r")
+        line = location[:line]
+
+        index = 0
+
+        lines = []
+        while (line_string = file.gets())
+          index += 1
+          next if (line - index).abs > width
+
+          line_prefix = "#{prefix}#{index}:"
+          line_prefix += (line == index ? ">>   " : "     ")
+
+          lines << "#{line_prefix}#{line_string}"
+        end
+
+        lines.join().chomp()
+      rescue
+        return (options[:unknown] || "Unknown") if not location[:file] and not location[:line]
+        return location[:file] if not location[:line]
+
+        "#{location[:file]}:#{location[:line]}"
+      ensure
+        file.close() if file
+      end
+
+      ##
+      # Search a stack list (as simple string array) for the first
+      # entry that match the +:matcher+.
+      #
+      def self.find_entry(stack, options = {})
+        matcher = options[:matcher] || @@DEFAULT_MATCHER
+
+        stack.find do |entry|
+          entry =~ matcher
+        end
+      end
+
+      ##
+      # Extract error location information from a stack entry using the
+      # matcher received in arguments.
+      #
+      # The usual stack entry format is:
+      #   > /home/users/joe/work/lib/ruby.rb:4:Error message
+      #
+      # This function will extract the file and line information from
+      # the stack entry using the matcher. The matcher is expected to
+      # have two groups, the first for the file and the second for
+      # line.
+      #
+      # The results is returned in form of a hash with two keys, +:file+
+      # for the file information and +:line+ for the line information.
+      #
+      # If the matcher matched zero group, return +{:file => nil, :line => nil}+.
+      # If the matcher matched one group, return +{:file => file, :line => nil}+.
+      # If the matcher matched two groups, return +{:file => file, :line => line}+.
+      #
+      def self.extract_error_location(entry, options = {})
+        matcher = options[:matcher] || @@DEFAULT_MATCHER
+
+        result = matcher.match(entry)
+        captures = result ? result.captures : []
+
+        {:file => captures[0], :line => captures[1] ? captures[1].to_i() : nil}
+      end
+    end
+  end
+end

data/lib/nugrant/mixin/parameters.rb

@@ -0,0 +1,98 @@
+module Nugrant
+  module Mixin
+    ##
+    # Mixin module so it's possible to share parameters
+    # logic between default Parameters class and Vagrant
+    # implementation.
+    #
+    # This method delegates method missing to the overall
+    # bag instance. This means that even if the class
+    # including this module doesn't inherit Bag directly,
+    # it act exactly like one.
+    #
+    # To initialize the mixin module correctly, you must call
+    # the compute_bags! method at least once to initialize
+    # all variables. You should make this call in including
+    # class' constructor directly.
+    #
+    module Parameters
+      def method_missing(method, *args, &block)
+        case
+        when @__all.class.method_defined?(method)
+          @__all.send(method, *args, &block)
+        else
+          @__all[method]
+        end
+      end
+
+      def defaults()
+        @__defaults
+      end
+
+      ##
+      # Set the new default values for the
+      # various parameters contain by this instance.
+      # This will call __compute_all() to recompute
+      # correct precedences.
+      #
+      # =| Attributes
+      #  * +elements+ - The new default elements
+      #
+      def defaults=(elements)
+        @__defaults = Bag.new(elements, @__options)
+
+        # When defaults change, we need to recompute parameters hierarchy
+        compute_all!(@__options)
+      end
+
+      ##
+      # Compute all parameters bags (current, user, system, default and all).
+      #
+      # =| Arguments
+      #  * `config`
+      #    The configuration object used to determine where to find the various
+      #    bag source data. This can be either directly a `Nugrant::Config`
+      #    object or a hash that will be pass to `Nugrant::Config` constructor.
+      #
+      #  * `options`
+      #    An options hash where some customization option can be passed.
+      #    Defaults to an empty hash, see options for specific option default
+      #    values.
+      #
+      # =| Options
+      #  * `:defaults`
+      #    A hash that is used as the initial data for the defaults bag. Defaults
+      #    to an empty hash.
+      #
+      #  * `:key_error`
+      #    This option is passed to Bag.new constructor in it's options hash. See
+      #    Bag.new for details on this options.
+      #
+      def compute_bags!(config, options = {})
+        config = config.kind_of?(Nugrant::Config) ? config : Nugrant::Config.new(config)
+
+        @__options = options
+
+        @__current = Helper::Bag.read(config.current_path, config.params_format, options)
+        @__user = Helper::Bag.read(config.user_path, config.params_format, options)
+        @__system = Helper::Bag.read(config.system_path, config.params_format, options)
+        @__defaults = Bag.new(options[:defaults] || {}, options)
+
+        compute_all!(options)
+      end
+
+      ##
+      # Recompute the correct precedences by merging the various
+      # bag in the right order and return the result as a Nugrant::Bag
+      # object.
+      #
+      def compute_all!(options = {})
+        @__all = Bag.new({}, options)
+        @__all.merge!(@__defaults)
+        @__all.merge!(@__system)
+        @__all.merge!(@__user)
+        @__all.merge!(@__current)
+      end
+    end
+  end
+end

data/lib/nugrant/parameters.rb

@@ -1,87 +1,33 @@
 require 'nugrant/bag'
 require 'nugrant/config'
 require 'nugrant/helper/bag'
+require 'nugrant/mixin/parameters'
 
 module Nugrant
   class Parameters
-    attr_reader :__current, :__user, :__system, :__defaults, :__all
-
     ##
     # Create a new parameters object which holds completed
     # merged values. The following precedence is used to decide
     # which location has precedence over which location:
     #
     #    (Highest)  ------------------ (Lowest)
-    #      current < user < system < defaults
+    #      project < user < system < defaults
     #
-    # =| Options
-    #  * +:config+   - A hash that will be passed to Nugrant::Config.new().
-    #                  See Nugrant::Config constructor for options that you can use.
-    #  * +:defaults+ - The default values for the various parameters that will be read. This
-    #                  must be a Hash object.
+    # =| Arguments
+    #  * `config`
+    #    A hash that will be passed to Nugrant::Config.new() or
+    #    a Nugrant::Config instance directly.
+    #    See Nugrant::Config constructor for options that you can use.
     #
-    def initialize(options = {})
-      @__config = Config.new(options[:config])
-
-      @__current = Helper::Bag.read(@__config.current_path, @__config.params_format)
-      @__user = Helper::Bag.read(@__config.user_path, @__config.params_format)
-      @__system = Helper::Bag.read(@__config.system_path, @__config.params_format)
-      @__defaults = Bag.new(options[:defaults] || {})
-
-      __compute_all()
-    end
-
-    def [](key)
-      return @__all[key]
-    end
-
-    def method_missing(method, *args, &block)
-      return  @__all[method]
-    end
-
-    def empty?()
-      @__all.empty?()
-    end
-
-    def has?(key)
-      return @__all.has?(key)
-    end
-
-    def each(&block)
-      @__all.each(&block)
-    end
-
-    ##
-    # Set the new default values for the
-    # various parameters contain by this instance.
-    # This will call __compute_all() to recompute
-    # correct precedences.
-    #
-    # =| Attributes
-    #  * +elements+ - The new default elements
+    #  * `options`
+    #    An options hash that is passed to Mixin::Parameters.compute_bags! method.
+    #    See Mixin::Parameters.compute_bags! for details on the various options
+    #    available.
     #
-    def defaults=(elements)
-      @__defaults = Bag.new(elements)
-
-      # When defaults change, we need to recompute parameters hierarchy
-      __compute_all()
+    def initialize(config, options = {})
+      compute_bags!(config, options)
     end
 
-    ##
-    # Recompute the correct precedences by merging the various
-    # bag in the right order and return the result as a Nugrant::Bag
-    # object.
-    #
-    def __compute_all()
-      @__all = Bag.new()
-      @__all.__merge!(@__defaults)
-      @__all.__merge!(@__system)
-      @__all.__merge!(@__user)
-      @__all.__merge!(@__current)
-    end
-
-    def __to_hash()
-      @__all.__to_hash()
-    end
+    include Mixin::Parameters
   end
 end

data/lib/nugrant/vagrant/errors.rb

@@ -0,0 +1,27 @@
+require 'vagrant/errors'
+
+require 'nugrant/helper/stack'
+
+module Nugrant
+  module Vagrant
+    module Errors
+      class NugrantVagrantError < ::Vagrant::Errors::VagrantError
+        error_namespace("nugrant.vagrant.errors")
+      end
+
+      class ParameterNotFoundError < NugrantVagrantError
+        error_key(:parameter_not_found)
+
+        def initialize(options = nil, *args)
+          super({:context => compute_context()}.merge(options || {}), *args)
+        end
+
+        def compute_context()
+          Helper::Stack.fetch_error_region(caller(), {
+            :matcher => /(.+Vagrantfile):([0-9]+)/
+          })
+        end
+      end
+    end
+  end
+end

data/lib/nugrant/vagrant/v2/command/env.rb

@@ -0,0 +1,101 @@
+require 'nugrant'
+require 'nugrant/helper/env/exporter'
+require 'nugrant/parameters'
+
+EnvExporter = Nugrant::Helper::Env::Exporter
+
+module Nugrant
+  module Vagrant
+    module V2
+      module Command
+        class Env < ::Vagrant.plugin("2", :command)
+          def initialize(arguments, environment)
+            super(arguments, environment)
+
+            @unset = false
+            @format = :terminal
+            @show_help = false
+          end
+
+          def create_parser()
+            return OptionParser.new do |parser|
+              parser.banner = "Usage: vagrant user env [<options>]"
+              parser.separator ""
+
+              parser.separator "Outputs the commands that should be executed to export\n" +
+                               "the various parameter as environment variables. By default,\n" +
+                               "existing ones are overridden. The --format argument can be used\n" +
+                               "to choose in which format the variables should be displayed.\n" +
+                               "Changing the format will also change where they are displayed.\n"
+              parser.separator ""
+
+              parser.separator "Available formats:"
+              parser.separator "  autoenv  => Write commands to a file named `.env` in the current directory.\n" +
+                               "               See https://github.com/kennethreitz/autoenv for more info."
+              parser.separator "  terminal => Display commands to terminal so they can be sourced."
+              parser.separator "  script   => Write commands to a bash script named `nugrant2env.sh` so it can be sourced."
+              parser.separator ""
+
+              parser.separator "Available options:"
+              parser.separator ""
+
+              parser.on("-u", "--[no-]unset", "Generates commands needed to unset environment variables, default false") do |unset|
+                @unset = unset
+              end
+
+              parser.on("-f", "--format FORMAT", "Determines in what format variables are output, default to terminal") do |format|
+                 @format = format.to_sym()
+              end
+
+              parser.on("-h", "--help", "Print this help") do
+                @show_help = true
+              end
+            end
+          end
+
+          def error(message, parser)
+            @env.ui.info("ERROR: #{message}", :prefix => false)
+            @env.ui.info("", :prefix => false)
+
+            help(parser)
+
+            return 1
+          end
+
+          def help(parser)
+            @env.ui.info(parser.help, :prefix => false)
+          end
+
+          def execute
+            parser = create_parser()
+            arguments = parse_options(parser)
+
+            return error("Invalid format value '#{@format}'", parser) if not EnvExporter.valid?(@format)
+            return help(parser) if @show_help
+
+            @logger.debug("Nugrant 'Env'")
+            with_target_vms(arguments) do |vm|
+              config = vm.config.user
+              parameters = config ? config : Nugrant::Parameters.new()
+              bag = parameters.__all
+
+              options = {:type => @unset ? :unset : :export}
+
+              case
+              when @format == :script
+                EnvExporter.script_exporter(bag, options)
+              when @format == :autoenv
+                EnvExporter.autoenv_exporter(bag, options)
+              when @format == :terminal
+                EnvExporter.terminal_exporter(bag, options)
+              end
+
+              # No need to execute for the other VMs
+              return 0
+            end
+          end
+        end
+      end
+    end
+  end
+end