nugrant 2.0.0.dev2 → 2.0.0.pre1

data/Rakefile

@@ -17,4 +17,5 @@ end
 
 desc "Run tests"
 task :default => :test
+task :tests => :test
 

data/lib/nugrant.rb

@@ -8,16 +8,24 @@ unless defined?(KeyError)
   end
 end
 
+module Nugrant
+  def self.setup_i18n()
+    I18n.load_path << File.expand_path("locales/en.yml", Nugrant.source_root)
+    I18n.reload!
+  end
+
+  def self.source_root
+    @source_root ||= Pathname.new(File.expand_path("../../", __FILE__))
+  end
+end
+
 if defined?(Vagrant)
+  Nugrant.setup_i18n()
+
   case
   when defined?(Vagrant::Plugin::V2)
     require 'nugrant/vagrant/v2/plugin'
-  when Vagrant::VERSION =~ /1\.0\..*/
-    # Nothing to do, v1 plugins are picked by the vagrant_init.rb file
   else
-    abort("You are trying to use Nugrant with an unsupported Vagrant version [#{Vagrant::VERSION}]")
+    raise RuntimeError, "Vagrant [#{Vagrant::VERSION}] is not supported by Nugrant."
   end
 end
-
-module Nugrant
-end

data/lib/nugrant/bag.rb

@@ -1,96 +1,150 @@
 module Nugrant
-  class Bag
-    attr_reader :__elements
+  class Bag < Hash
 
-    def initialize(elements = nil)
-      if elements.kind_of?(Bag)
-        @__elements = elements
+    ##
+    # Create a new Bag object which holds key/value pairs.
+    # The Bag object inherits from the Hash object, the main
+    # differences with a normal Hash are indifferent access
+    # (symbol or string) and method access (via method call).
+    #
+    # =| Arguments
+    #  * `elements`
+    #    The initial elements the bag should be built with it.'
+    #    Must be an object responding to `each` and accepting
+    #    a block with two arguments: `key, value`.]. Defaults to
+    #    the empty hash.
+    #
+    #  * `options`
+    #    An options hash where some customization option can be passed.
+    #    Defaults to an empty hash, see options for specific option default
+    #    values.
+    #
+    # =| Options
+    #  * `:key_error`
+    #    A callable object receiving a single parameter `key` that is
+    #    called when a key cannot be found in the Bag. The received key
+    #    is already converted to a symbol. If the callable does not
+    #    raise an exception, the result of it's execution is returned.
+    #    The default value is a callable that throws a KeyError exception.
+    #
+    def initialize(elements = {}, options = {})
+      super()
+
+      @__key_error = options[:key_error] || Proc.new do |key|
+        raise KeyError, "Undefined parameter '#{key}'" if not key?(key)
       end
 
-      __recompute(elements)
+      (elements || {}).each do |key, value|
+        self[key] = value.kind_of?(Hash) ? Bag.new(value, options) : value
+      end
     end
 
-    def [](key)
-      return __fetch(key)
+    def method_missing(method, *args, &block)
+      return self[method]
     end
 
-    def method_missing(method, *args, &block)
-      return __fetch(method)
+    ##
+    ### Hash Overriden Methods (for string & symbol indifferent access)
+    ##
+
+    def [](input)
+      key = __convert_key(input)
+      return @__key_error.call(key) if not key?(key)
+
+      super(key)
     end
 
-    def has?(key)
-      return @__elements.has_key?(key)
+    def []=(input, value)
+      super(__convert_key(input), value)
     end
 
-    def empty?()
-      @__elements.size() <= 0
+    def key?(key)
+      super(__convert_key(key))
     end
 
     ##
-    # This method always perform a deep merge and will deep merge
-    # array scalar values only. This means that we do not merge
-    # within array themselves.
+    # This method first start by converting the `input` parameter
+    # into a bag. It will then *deep* merge current values with
+    # the new ones coming from the `input`.
     #
-    def __merge!(elements)
-      bag = elements.kind_of?(Bag) ? elements : Bag.new(elements)
-      return if bag.empty?()
-
-      bag.each do |key, value|
-        if has?(key)
-          current = @__elements[key]
-          if current.kind_of?(Bag) and value.kind_of?(Bag)
-            current.__merge!(value)
-          elsif current.kind_of?(Array) and value.kind_of?(Array)
-            @__elements[key] = current | value
-          else
-            @__elements[key] = value
-          end
-
-          next
-        end
+    # The array merge strategy is by default to replace current
+    # values with new ones. You can use option `:array_strategy`
+    # to change this default behavior.
+    #
+    # +Options+
+    #  * :array_strategy
+    #     * :replace (Default) => Replace current values by new ones
+    #     * :extend => Merge current values with new ones
+    #     * :concat => Append new values to current ones
+    #
+    def merge!(input, options = {})
+      options = {:array_strategy => :replace}.merge(options)
 
-        @__elements[key] = value
-      end
-    end
+      array_strategy = options[:array_strategy]
+      input.each do |key, value|
+        current = __get(key)
+        case
+          when current == nil
+            self[key] = value
+
+          when current.kind_of?(Hash) && value.kind_of?(Hash)
+            current.merge!(value, options)
 
-    def each()
-      @__elements.each do |key, value|
-        yield key, value
+          when current.kind_of?(Array) && value.kind_of?(Array)
+            self[key] = send("__#{array_strategy}_array_merge", current, value)
+
+          when value != nil
+            self[key] = value
+        end
       end
     end
 
-    def __to_hash()
+    def to_hash(options = {})
       return {} if empty?()
 
-      hash = {}
-      each do |key, value|
-        hash[key.to_sym()] = value.kind_of?(Bag) ? value.__to_hash() : value
-      end
+      use_string_key = options[:use_string_key]
 
-      return hash
+      Hash[map do |key, value|
+        key = use_string_key ? key.to_s() : key
+        value = value.kind_of?(Bag) ? value.to_hash(options) : value
+
+        [key, value]
+      end]
     end
 
-    def __recompute(hash = nil)
-      @__elements = {}
-      return if hash == nil or not hash.kind_of?(Hash)
+    ##
+    ### Aliases
+    ##
 
-      hash.each do |key, value|
-        if not value.kind_of?(Hash)
-          @__elements[key.to_sym()] = value
-          next
-        end
+    alias_method :to_ary, :to_a
 
-        # It is a hash, transform it into a bag
-        @__elements[key.to_sym()] = Bag.new(value)
-      end
+    ##
+    ### Private Methods
+    ##
+
+    private
+
+    def __convert_key(key)
+      return key.to_sym() if key.respond_to?(:to_sym)
+
+      raise ArgumentError, "Key cannot be converted to symbol, current value [#{key}] (#{key.class.name})"
     end
 
-    def __fetch(key)
-      if not has?(key)
-        raise KeyError, "Undefined parameter '#{key}'"
-      end
+    def __get(key)
+      # Calls Hash method [__convert_key(key)], used internally to retrieve value without raising Undefined parameter
+      self.class.superclass.instance_method(:[]).bind(self).call(__convert_key(key))
+    end
+
+    def __concat_array_merge(current_array, new_array)
+      current_array + new_array
+    end
+
+    def __extend_array_merge(current_array, new_array)
+      current_array | new_array
+    end
 
-      return @__elements[key]
+    def __replace_array_merge(current_array, new_array)
+      new_array
     end
   end
 end

data/lib/nugrant/helper/bag.rb

@@ -6,36 +6,36 @@ require 'nugrant/bag'
 module Nugrant
   module Helper
     module Bag
-      def self.read(filepath, format, error_handler = nil)
-        data = parse_data(filepath, format, error_handler)
+      def self.read(filepath, filetype, options = {})
+        data = parse_data(filepath, filetype, options)
 
-        return Nugrant::Bag.new(data)
+        return Nugrant::Bag.new(data, options)
       end
 
-      def self.parse_data(filepath, format, error_handler = nil)
+      def self.restricted_keys()
+        Nugrant::Bag.instance_methods()
+      end
+
+      def self.parse_data(filepath, filetype, options = {})
         return if not File.exists?(filepath)
 
-        begin
-          File.open(filepath, "rb") do |file|
-            parsing_method = "parse_#{format.to_s}"
-            return send(parsing_method, file.read())
-          end
-        rescue => error
-          if error_handler
-            # TODO: Implements error handler logic
-            error_handler.handle("Could not parse the user #{format.to_s} parameters file '#{filepath}': #{error}")
-          end
+        File.open(filepath, "rb") do |file|
+          return send("parse_#{filetype}", file)
+        end
+      rescue => error
+        if options[:error_handler]
+          options[:error_handler].handle("Could not parse the user #{filetype} parameters file '#{filepath}': #{error}")
         end
       end
 
-      def self.parse_json(input)
-        JSON.parse(input)
+      def self.parse_json(io)
+        MultiJson.load(io.read())
       end
 
-      def self.parse_yaml(input)
-        YAML::ENGINE.yamler= 'syck' if defined?(YAML::ENGINE)
+      def self.parse_yaml(io)
+        YAML::ENGINE.yamler = 'syck' if (defined?(Syck) || defined?(YAML::Syck)) && defined?(YAML::ENGINE)
 
-        YAML.load(input)
+        YAML.load(io.read())
       end
     end
   end

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

@@ -0,0 +1,208 @@
+require 'shellwords'
+
+require 'nugrant/bag'
+require 'nugrant/helper/env/namer'
+
+module Nugrant
+  module Helper
+    module Env
+      module Exporter
+        @@DEFAULT_AUTOENV_PATH = "./.env"
+        @@DEFAULT_SCRIPT_PATH = "./nugrant2env.sh"
+
+        @@VALID_EXPORTERS = [:autoenv, :script, :terminal]
+
+        ##
+        # Returns true if the exporter name received is a valid
+        # valid export, false otherwise.
+        #
+        # @param exporter The exporter name to check validity
+        #
+        # @return true if exporter is valid, false otherwise.
+        def self.valid?(exporter)
+          @@VALID_EXPORTERS.include?(exporter)
+        end
+
+        ##
+        # Creates an autoenv script containing the commands that are required
+        # to export or unset a bunch of environment variables taken from the
+        # bag.
+        #
+        # @param bag The bag to create the script for.
+        #
+        # @return (side-effect) Creates a script file containing commands
+        #                       to export or unset environment variables for
+        #                       bag.
+        #
+        # Options:
+        #  * :autoenv_path => The path where to write the script, defaults to `./.env`.
+        #  * :escape_value => If true, escape the value to export (or unset), default to true.
+        #  * :io => The io where the command should be written, default to nil which create the autoenv on disk.
+        #  * :namer => The namer used to transform bag segments into variable name, default to Namer::default().
+        #  * :override => If true, variable a exported even when the override an existing env key, default to true.
+        #  * :type => The type of command, default to :export.
+        #
+        def self.autoenv_exporter(bag, options = {})
+          io = options[:io] || (File.open(File.expand_path(options[:autoenv_path] || @@DEFAULT_AUTOENV_PATH), "w"))
+
+          terminal_exporter(bag, options.merge({:io => io}))
+        ensure
+          io.close() if io
+        end
+
+        ##
+        # Creates a bash script containing the commands that are required
+        # to export or unset a bunch of environment variables taken from the
+        # bag.
+        #
+        # @param bag The bag to create the script for.
+        #
+        # @return (side-effect) Creates a script file containing commands
+        #                       to export or unset environment variables for
+        #                       bag.
+        #
+        # Options:
+        #  * :escape_value => If true, escape the value to export (or unset), default to true.
+        #  * :io => The io where the command should be written, default to nil which create the script on disk.
+        #  * :namer => The namer used to transform bag segments into variable name, default to Namer::default().
+        #  * :override => If true, variable a exported even when the override an existing env key, default to true.
+        #  * :script_path => The path where to write the script, defaults to `./nugrant2env.sh`.
+        #  * :type => The type of command, default to :export.
+        #
+        def self.script_exporter(bag, options = {})
+          io = options[:io] || (File.open(File.expand_path(options[:script_path] || @@DEFAULT_SCRIPT_PATH), "w"))
+
+          io.puts("#!/bin/env sh")
+          io.puts()
+
+          terminal_exporter(bag, options.merge({:io => io}))
+        ensure
+          io.close() if io
+        end
+
+        ##
+        # Export to terminal the commands that are required
+        # to export or unset a bunch of environment variables taken from the
+        # bag.
+        #
+        # @param bag The bag to create the script for.
+        #
+        # @return (side-effect) Outputs to io the commands generated.
+        #
+        # Options:
+        #  * :escape_value => If true, escape the value to export (or unset), default to true.
+        #  * :io => The io where the command should be displayed, default to $stdout.
+        #  * :namer => The namer used to transform bag segments into variable name, default to Namer::default().
+        #  * :override => If true, variable a exported even when the override an existing env key, default to true.
+        #  * :type => The type of command, default to :export.
+        #
+        def self.terminal_exporter(bag, options = {})
+          io = options[:io] || $stdout
+          type = options[:type] || :export
+
+          export(bag, options) do |key, value|
+            io.puts(command(type, key, value, options))
+          end
+        end
+
+        ##
+        # Generic function to export a bag. This walk the bag,
+        # for each element, it creates the key using the namer
+        # and then forward the key and value to the block if
+        # the variable does not override an existing environment
+        # variable or if options :override is set to true.
+        #
+        # @param bag The bag to export.
+        #
+        # @return (side-effect) Yields each key and value to a block
+        #
+        # Options:
+        #  * :namer => The namer used to transform bag segments into variable name, default to Namer::default().
+        #  * :override => If true, variable a exported even when the override an existing env key, default to true.
+        #
+        def self.export(bag, options = {})
+          namer = options[:namer] || Env::Namer.default()
+          override = options.fetch(:override, true)
+
+          variables = {}
+          walk_bag(bag) do |segments, key, value|
+            key = namer.call(segments)
+
+            variables[key] = value if override or not ENV[key]
+          end
+
+          variables.sort().each do |key, value|
+            yield key, value
+          end
+        end
+
+        ##
+        # Given a key and a value, return a string representation
+        # of the command type requested. Available types:
+        #
+        #  * :export => A bash compatible export command
+        #  * :unset => A bash compatible export command
+        #
+        def self.command(type, key, value, options = {})
+          # TODO: Replace by a map type => function name
+          case
+          when type == :export
+            export_command(key, value, options)
+          when type == :unset
+            unset_command(key, value, options)
+          end
+        end
+
+        ##
+        # Returns a string representation of the command
+        # that needs to be used on the current platform
+        # to export an environment variable.
+        #
+        # @param key The key of the environment variable to export.
+        #            It cannot be nil.
+        # @param value The value of the environment variable to export
+        #
+        # @return The export command, as a string
+        #
+        # Options:
+        #  * :escape_value (true) => If true, escape the value to export.
+        #
+        def self.export_command(key, value, options = {})
+          value = value.to_s()
+          value = Shellwords.escape(value) if options[:escape_value] == nil || options[:escape_value]
+
+          # TODO: Handle platform differently
+          "export #{key}=#{value}"
+        end
+
+        ##
+        # Returns a string representation of the command
+        # that needs to be used on the current platform
+        # to unset an environment variable.
+        #
+        # @param key The key of the environment variable to export.
+        #            It cannot be nil.
+        #
+        # @return The unset command, as a string
+        #
+        def self.unset_command(key, value, options = {})
+          # TODO: Handle platform differently
+          "unset #{key}"
+        end
+
+        # FIXME: Move this directly into bag class
+        def self.walk_bag(bag, parents = [], &block)
+          commands = []
+
+          bag.each do |key, value|
+            segments = parents + [key]
+            nested_bag = value.kind_of?(Nugrant::Bag)
+
+            walk_bag(value, segments, &block) if nested_bag
+            yield segments, key, value if not nested_bag
+          end
+        end
+      end
+    end
+  end
+end