nugrant 1.2.0 → 1.3.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    Y2U0MTBmOTMyYzhmYzk5NDBjOTRlZmNhMWYyMDkyYzM3ZTBkOGRmZA==
+    YjUxMDRmNWQ5NTE4OWRjYWNiNzJlMzIxMTc1NWI2ZmI3MDBiZGUxOQ==
   data.tar.gz: !binary |-
-    OGFkNTY2MjRjZTQ1ODhhM2FjNDBlNzVkZDE4NTA1NDdiODExNTExZA==
-!binary "U0hBNTEy":
+    NGY1MzI0ZTQ3NjVmNjBhMmViYzA0OWUwMDJjMDM1MDI2MWZlNGY1Mw==
+SHA512:
   metadata.gz: !binary |-
-    MjNmODVmZGQ1YjFlYjAxMjFjZWRmMWQyMDE0N2ZhNTlkM2RjNjM2NDJjYjVj
-    NGE1NGE0NzE0MzNmMDc5MTNmODZiMWI3MWZmMDA4ZWM3NzI4ZmYxOTMzMTI5
-    Njc0Zjg5ZTAwZTFmMzg5MTJhMjBiNzhlNzFmNzRhYTVlNmZlYzk=
+    YTE0NzgxZWM4YzcxODQ1MzA2ZmE1NTEyYTBkMjAyM2VhZjJiYmJlYzAxNzk2
+    NWVkYzQ0NWM4MGU1MDQ4ZWIzNDAxMGI3NWM2MDYzYWNkZTMzZmNhMTBlMzYy
+    OTAxYjQ5MmExNDBmOTk0YjJmNmNkNjliOTc3OGM4NTg5YjY0MWU=
   data.tar.gz: !binary |-
-    NTFjZTVhZjIyNDEwN2VlMGMxZDg1MTYxY2ExZDVmZGMzYzI5NjExODgxZjY0
-    NWQ5NTBhNzYxNWRlYTUzNTE1NzU5MWY5YTE0MTJkMGEyYzdkNjM2OWNlMmZh
-    MmVkOGRiNmQ2OGIyZWVmMTVkN2FkZGZlZDY5MzdhY2YxY2I2M2Q=
+    NDIyMTA5ZDM1OTg1NDMwNTc4MDY0MGEzMTI2MWM1YWZkZTE3ZjM0NDQyNWMx
+    NDUyZTNiMmE3ZmYxYmQ2OTk1YTI2Mzc2NThlZDhjZGY0ODJjMWZmMGViNTgx
+    ZGU0Y2E5Y2I5NzJlNmVmMWQxN2Q0MWIyMWQ0NWU3ODIxNDY0YzU=

data/.gitignore

@@ -19,3 +19,4 @@ test/version_tmp
 tmp
 
 test/resources/vagrantfiles/Vagrantfile
+test/resources/vagrantfiles/.vagrantuser

data/CHANGELOG.md

@@ -1,3 +1,21 @@
+# 1.3.0 (November 19th, 2013)
+
+* Now using [minitest](https://github.com/seattlerb/minitest) as our
+  testing library.
+
+* Added a new command that can be used either standalone or via
+  a small bash script to easily export environment variables
+  from your currently set parameters. See
+  [GH-13](https://github.com/maoueh/nugrant/issues/13).
+
+* Keys associated to a null value are considered as being missing
+  by the merge process. It is still possible to define a null
+  parameter, but it will be overridden by any parameter and will not
+  override any. See [GH-12](https://github.com/maoueh/nugrant/issues/12).
+
+* Fixed output of command `vagrant user parameters`, the keys were
+  serialized as symbol instead of string.
+
 # 1.2.0 (October 24th, 2013)
 
 * Now showing better error message to the end-user when a parameter
@@ -16,9 +34,11 @@
   ```
 
   See [GH-8] (https://github.com/maoueh/nugrant/issues/8).
+
 * Ensured that keys used within a `Bag` are always symbol. This make
   sure that it is possible to retrieve a value with any access method.
   See [GH-9](https://github.com/maoueh/nugrant/issues/9).
+
 * Now using [multi_json](https://rubygems.org/gems/multi_json)
   for JSON handling.
 
@@ -27,8 +47,10 @@
 * Rewrite completely classes `Parameters` and `Bag`.
 * Reduced chances to have a parameter name collapsing with an
   implementation method.
+
 * Removed dependency on `deep_merge`. We do now perform
   our own merge.
+
 * Added possibility to iterate through keys by using
   `.each`:
 
@@ -41,6 +63,7 @@
 ### Backward Incompatibilities
 
 * `Parameters` is not extending the `Bag` class anymore.
+
 * `Parameters` and `Bag` attributes and methods are now almost
   all prefixed with __ to reduce clashes to a minimum when
   accessing parameters with method-like syntax
@@ -49,7 +72,8 @@
 # 1.0.1 (April 9th, 2013)
 
 * Fixed a crash when `user` config value is `nil` preventing `vagrant user parameters`
-  from working as expected. [GH-4](https://github.com/maoueh/nugrant/issues/4)
+  from working as expected. See [GH-4](https://github.com/maoueh/nugrant/issues/4).
+
 * Fixed a bug preventing the version from being printed when doing `vagrant user -v`.
 
 # 1.0.0 (March 21th, 2013)
@@ -61,6 +85,7 @@
 # 0.0.14
 
 * Renamed `ParameterBag` to `Bag`
+
 * Cleanup `Bag` api
  * Renamed method `has_param?` to `has_key?` in `Bag`
  * Removed method `get_params` from `Bag`
@@ -70,6 +95,7 @@
 * Cleanup `Parameters` and `ParameterBag` interface
  * The method `defaults` has been removed from the bag
  * Setting defaults on `Parameters` now recompute the final bag
+
 * Improved `vagrant user parameters` command
  * Now using the exact config as seen by Vagrant, this includes defaults parameters
  * An option has been added to only see defaults parameters
@@ -77,8 +103,11 @@
 # 0.0.12
 
 * Added travis configuration file
+
 * Added travis build status icon to readme
+
 * Fixed a bug when `.vagrantuser` file is empty or not a hash type
+
 * Improved parameters command
  * The parameters command is now a proper subcommand
  * An option has been added to see system parameters
@@ -92,6 +121,7 @@
 # 0.0.10
 
 * Added a subcommand `parameters` for vagrant command `user`
+
 * Added a vagrant command `vagrant user subcommand [options]`
 
 # 0.0.9
@@ -101,7 +131,9 @@
 # 0.0.8
 
 * Introduced possibility to set default values
-* Introduced restricted keys (For now, restricted keys are [`defaults`])
+
+* Introduced restricted keys (For now, restricted keys are [`defaults`]).
+
 * Fixed a bug with system-wide parameters
 
 # 0.0.7
@@ -119,4 +151,5 @@
 # 0.0.4
 
 * JSON is now the default file format for parameters (due to problem with YAML)
+
 * It is now possible to store parameters in the JSON format

data/README.md

@@ -27,7 +27,7 @@ If you would like to use Nugrant as a library, simply reference
 it as a dependency of your application. Probably by adding it to
 your `Gemfile` or your `.gemspec` file.
 
-    nugrant ~> 1.0.1
+    "nugrant", "~> 1.3"
 
 ### Vagrant
 
@@ -214,7 +214,7 @@ Here the list of locations where Nugrant looks for parameters:
 ### Paths
 
 When you want to specify paths on, specially on Windows, it's probably
-better to only use foward slash (`/`). The main reason for this is because
+better to only use forward slash (`/`). The main reason for this is because
 Ruby, which will be used at the end by Vagrant is able to deal with forward
 slash even on Windows. This is great because with this, you can avoid
 values escaping in YAML file. If you need to use backward slash (`\`), don't
@@ -223,6 +223,18 @@ forget to properly escape it!
     value: "C:/Users/user/work/git"
     value: "C:\\Users\\user\\work\\git"
 
+Moreover, it is preferable that paths are specified in full
+(i.e. no `~` for HOME directory for example). Normally, they
+should be handled by `Vagrant` but it may happen that it's not
+the case. If your have an error with a specific parameter,
+either expand it in your config:
+
+    project: "/home/joe/work/ruby/git"
+
+Of expand it in the `Vagrantfile`:
+
+    config.vm.synced_folder File.expand_path(config.user.repository.project), "/git"
+
 ### Parameters access
 
 Parameters in the `Vagrantfile` can be retrieved via method call
@@ -295,6 +307,101 @@ Usage:
           nodes_path: /Users/Chef/kitchen/nodes
           roles_path: /Users/Chef/kitchen/roles
 
+Add flag `-h` (or `--help`) for description of the command and a
+list of available options.
+
+#### Env
+
+Sometimes, you would like to have acces to the different values
+stored in your `.vagrantuser` from environment variables. This
+command is meant is exactly for this.
+
+By using one of the two methods below, you will be able to export
+(but also unset) environment variables from your current
+parameters as seen by Nugrant.
+
+You can see the commands that will be executed by simply
+calling the method:
+
+    vagrant user env
+
+The name of the environment will be upper cased and full path of
+the key, without the `config.user` prefix, separated
+with `_`. For example, the key accessible using
+`config.user.db.user` and with value `root` would generate the
+export command:
+
+    export DB_USER=root
+
+And the unset command:
+
+    unset DB_USER
+
+The value are escaped so it is possible to define value containing
+spaces for example.
+
+A last note about generate commands is that pre-existing environment
+variable are not taking in consideration by this command. So if
+an environment variable with name `DB_USER` already exist, it
+would be overwritten by an export command.
+
+Add flag `-h` (or `--help`) for description of the command and a
+list of available options.
+
+##### Method #1
+
+If you plan to use frequently this feature, our best suggestion
+is to create a little bash script that will simply delegates
+to the real command. By having a bash script that calls the
+command, you will be able to easily export environment variables
+by sourcing the script.
+
+Create a file named `nugrant2env` somewhere accessible from
+the `$PATH` variable with the following content:
+
+    ```bash
+    #!/bin/env sh
+
+    $(vagrant user env "$@")
+    ```
+
+This script will simply delegates to the `vagrant user env`
+command and pass all arguments it receives to it. The
+magic happens because the command `vagrant user env` outputs
+the various export commands to the standard output.
+
+By sourcing the simple delegating bash script, the parameters
+seen by Nugrant will be available in your environment:
+
+    . nugrant2env
+
+By default, export commands are generated. But you can pass
+some options to the `nugrant2env` script, For example, to
+generate the unset ones, add `--unset` (or simply `-u`).
+
+    . nugrant2env --unset
+
+For a list of options, see the help of the command delegated
+to:
+
+    vagrant user env -h
+
+##### Method #2
+
+Use the command to generate a base script in the current
+directory that you will then source:
+
+    vagrant user env -s
+
+This will generate a script called `nugrant2env.sh` into the
+current directory. You then simply source this script:
+
+    . nugrant2env.sh
+
+Using vagrant user env -s -u will instead generate the bash
+script that will unset the enviornment variables. Don't forget
+to source it to unset variables.
+
 ## Contributing
 
 You can contribute by filling issues when something goes

data/lib/nugrant/bag.rb

@@ -42,7 +42,7 @@ module Nugrant
             current.__merge!(value)
           elsif current.kind_of?(Array) and value.kind_of?(Array)
             @__elements[key] = current | value
-          else
+          elsif value != nil
             @__elements[key] = value
           end
 
@@ -59,12 +59,16 @@ module Nugrant
       end
     end
 
-    def __to_hash()
+    def __to_hash(options = {})
       return {} if empty?()
 
+      string_key = options[:string_key]
+
       hash = {}
       each do |key, value|
-        hash[key] = value.kind_of?(Bag) ? value.__to_hash() : value
+        key = key.to_s() if string_key
+
+        hash[key] = value.kind_of?(Bag) ? value.__to_hash(:string_key => string_key) : value
       end
 
       return hash

data/lib/nugrant/helper/bag.rb

@@ -6,25 +6,23 @@ require 'nugrant/bag'
 module Nugrant
   module Helper
     module Bag
-      def self.read(filepath, filetype, error_handler = nil)
-        data = parse_data(filepath, filetype, error_handler)
+      def self.read(filepath, filetype, options = {})
+        data = parse_data(filepath, filetype, options)
 
         return Nugrant::Bag.new(data)
       end
 
-      def self.parse_data(filepath, filetype, error_handler = nil)
+      def self.parse_data(filepath, filetype, options = {})
         return if not File.exists?(filepath)
 
-        begin
-          File.open(filepath, "rb") do |file|
-            parsing_method = "parse_#{filetype}"
-            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 #{filetype} parameters file '#{filepath}': #{error}")
-          end
+        File.open(filepath, "rb") do |file|
+          parsing_method = "parse_#{filetype}"
+          return send(parsing_method, file.read)
+        end
+      rescue => error
+        if options[:error_handler]
+          # TODO: Implements error handler logic
+          options[:error_handler].handle("Could not parse the user #{filetype} parameters file '#{filepath}': #{error}")
         end
       end
 
@@ -33,7 +31,7 @@ module Nugrant
       end
 
       def self.parse_yml(data_string)
-        YAML::ENGINE.yamler= 'syck' if defined?(YAML::ENGINE)
+        YAML::ENGINE.yamler = 'syck' if defined?(YAML::ENGINE)
 
         YAML.load(data_string)
       end

data/lib/nugrant/helper/env.rb

@@ -0,0 +1,232 @@
+require 'shellwords'
+
+module Nugrant
+  module Helper
+    class Env
+
+      @@DEFAULT_SCRIPT_PATH = "./nugrant2env.sh"
+
+      ##
+      # Notes on `namer`
+      #
+      # 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.
+      #
+
+      ##
+      # 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_namer(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_namer(prefix, delegate_namer)
+        lambda do |segments|
+          delegate_namer.call([prefix] + segments)
+        end
+      end
+
+      def self.commands(type, bag, options = {})
+        # TODO: Replace by a map type => function name
+        case
+        when type == :export
+          export_commands(bag, options)
+        when type == :unset
+          unset_commands(bag, options)
+        end
+      end
+
+      ##
+      # Generate the list of export commands that must be
+      # executed so each bag variables is export to an
+      # environment variables
+      #
+      # @param bag The bag to export to environment variables
+      #
+      # @return A list of commands that can be used to
+      #         export the bag to environment variables.
+      #
+      # Options:
+      #  * :escape_value (true) => If true, escape the value to export.
+      #
+      #  * :namer (nil) => A block taking as options the full path of
+      #                    an export variable key and return what
+      #                    the name the should be exported.
+      #
+      # * :override (true) => If true, an export command will be put
+      #                       in the list even if it already exist in
+      #                       the ENV array.
+      #
+      def self.export_commands(bag, options = {})
+        namer = options[:namer] || default_namer()
+        override = options.fetch(:override, true)
+
+        commands = []
+        walk_bag(bag) do |segments, key, value|
+          key = namer.call(segments)
+
+          commands << export_command(key, value, options) if override or not ENV[key]
+        end
+
+        commands
+      end
+
+      ##
+      # Generate the list of unset commands that must be
+      # executed so each bag variables is unset from the
+      # environment variables
+      #
+      # @param bag The bag to unset environment variables
+      #
+      # @return A list of commands that can be used to
+      #         unset the bag from environment variables.
+      #
+      # Options:
+      #  * :namer (nil) => A block taking as options the full path of
+      #                    an export variable key and return what
+      #                    the name the should be exported.
+      #
+      # * :override (true) => If true, an export command will be put
+      #                       in the list even if it already exist in
+      #                       the ENV array.
+      #
+      def self.unset_commands(bag, options = {})
+        namer = options[:namer] || default_namer()
+        override = options.fetch(:override, true)
+
+        commands = []
+        walk_bag(bag) do |segments, key, value|
+          key = namer.call(segments)
+
+          commands << unset_command(key, value, options) if override or not ENV[key]
+        end
+
+        commands
+      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
+
+      ##
+      # 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:
+      #  * :type => The type of command, default to :export
+      #  * :script_path => The path where to write the script, defaults to `./nugrant2env.sh`.
+      #  * See commands, export_commands and unset_commands for further options.
+      #
+      def self.write_script(bag, options = {})
+        file = File.open(File.expand_path(options[:script_path] || @@DEFAULT_SCRIPT_PATH), "w")
+
+        file.puts("#!/bin/env sh")
+        file.puts()
+
+        write_commands(bag, options, file)
+      ensure
+        file.close() if file
+      end
+
+      ##
+      # Creates a bash script containing the commands that are required
+      # to export or unset a bunch of environment variables taken from the
+      # bag.
+      #
+      # The
+      #
+      # @param bag The bag to create the script for.
+      # @param io The io where to output the commands, defaults to $stdout.
+      #
+      # @return (side-effect) Outputs to io the commands generated.
+      #
+      # Options:
+      #  * :type => The type of command, default to :export
+      #  * See commands, export_commands and unset_commands for further options.
+      #
+      def self.write_commands(bag, options = {}, io = $stdout)
+        commands = commands(options[:type] || :export, bag, options)
+
+        commands.each do |command|
+          io.puts(command)
+        end
+      end
+
+      private
+
+      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