fig 0.1.57 → 0.1.59

data/lib/fig/environment.rb

@@ -19,7 +19,7 @@ module Fig
 
     def initialize(repository, variables_override, retriever)
       @repository = repository
-      @variables = variables_override || get_system_environment_variables
+      @variables = variables_override || OperatingSystem.get_environment_variables
       @retrieve_vars = {}
       @packages = {}
       @retriever = retriever
@@ -42,7 +42,7 @@ module Fig
     end
 
     def register_package(package)
-      name = package.package_name
+      name = package.name
 
       if get_package(name)
         Logging.fatal %Q<There is already a package with the name "#{name}".>
@@ -54,8 +54,8 @@ module Fig
       return
     end
 
-    def get_package(package_name)
-      return @packages[package_name]
+    def get_package(name)
+      return @packages[name]
     end
 
     def packages
@@ -76,7 +76,7 @@ module Fig
     end
 
     def execute_shell(command)
-      with_environment do
+      @variables.with_environment do
         yield command.map{|arg| expand_command_line_argument(arg)}
       end
 
@@ -84,7 +84,7 @@ module Fig
     end
 
     def execute_command(command, args, package)
-      with_environment do
+      @variables.with_environment do
         argument =
           expand_command_line_argument(
             "#{command.command} #{args.join(' ')}"
@@ -96,8 +96,8 @@ module Fig
       return
     end
 
-    def find_config_name_in_package(package_name)
-      package = get_package(package_name)
+    def find_config_name_in_package(name)
+      package = get_package(name)
       if not package
         return Package::DEFAULT_CONFIG
       end
@@ -105,12 +105,18 @@ module Fig
       return package.primary_config_name || Package::DEFAULT_CONFIG
     end
 
-    def execute_config(base_package, package_name, config_name, version_name, args, &block)
-      config_name ||= find_config_name_in_package(package_name)
+    def execute_config(base_package, descriptor, args, &block)
+      config_name =
+        descriptor.config || find_config_name_in_package(descriptor.name)
+
+      name = descriptor.name || base_package.name
       package = lookup_package(
-        package_name || base_package.package_name,
-        version_name,
-        Backtrace.new(nil, package_name, version_name, config_name)
+        name,
+        descriptor.version,
+        Backtrace.new(
+          nil,
+          PackageDescriptor.new(name, descriptor.version, config_name)
+        )
       )
 
       command = package[config_name].command
@@ -126,11 +132,13 @@ module Fig
     def apply_config_statement(base_package, statement, backtrace)
       case statement
       when Statement::Path
-        append_variable(base_package, statement.name, statement.value)
+        prepend_variable(base_package, statement.name, statement.value)
       when Statement::Set
         set_variable(base_package, statement.name, statement.value)
       when Statement::Include
-        include_config(base_package, statement.package_name, statement.config_name, statement.version_name, statement.overrides, backtrace)
+        include_config(
+          base_package, statement.descriptor, statement.overrides, backtrace
+        )
       when Statement::Command
         # ignore
       else
@@ -140,23 +148,36 @@ module Fig
       return
     end
 
-    def include_config(base_package, package_name, config_name, version_name, overrides, backtrace)
+    def include_config(base_package, descriptor, overrides, backtrace)
+      resolved_descriptor = nil
+
       # Check to see if this include has been overridden.
       if backtrace
-        override = backtrace.get_override(package_name || base_package.package_name)
+        override = backtrace.get_override(
+          descriptor.name || base_package.name
+        )
         if override
-          version_name = override
+          resolved_descriptor =
+            PackageDescriptor.new(
+              descriptor.name, override, descriptor.config
+            )
         end
       end
-      new_backtrace = Backtrace.new(backtrace, package_name, version_name, config_name)
+      resolved_descriptor ||= descriptor
+
+      new_backtrace = Backtrace.new(backtrace, resolved_descriptor)
       overrides.each do |override|
-        new_backtrace.add_override(override.package_name, override.version_name)
+        new_backtrace.add_override(override.package_name, override.version)
       end
       package = lookup_package(
-        package_name || base_package.package_name, version_name, new_backtrace
+        resolved_descriptor.name || base_package.name,
+        resolved_descriptor.version,
+        new_backtrace
       )
       apply_config(
-        package, config_name || Package::DEFAULT_CONFIG, new_backtrace
+        package,
+        resolved_descriptor.config || Package::DEFAULT_CONFIG,
+        new_backtrace
       )
 
       return
@@ -164,70 +185,39 @@ module Fig
 
     private
 
-    def get_system_environment_variables
-      vars = {}
-      ENV.each { |key,value| vars[key]=value }
-
-      return vars
-    end
-
     def set_variable(base_package, name, value)
       @variables[name] = expand_and_retrieve_variable_value(base_package, name, value)
 
       return
     end
 
-    def append_variable(base_package, name, value)
+    def prepend_variable(base_package, name, value)
       value = expand_and_retrieve_variable_value(base_package, name, value)
-      # TODO: converting all environment variables to upcase is not a robust
-      #       comparison. It also assumes all env vars will be in upcase
-      #       in package.fig
-      prev = nil
-      @variables.each do |key, val|
-        if key.upcase == name.upcase
-          name = key
-          prev = val
-        end
-      end
-      if prev
-        @variables[name] = value + File::PATH_SEPARATOR + prev
-      else
-        @variables[name] = value
-      end
-
-      return
-    end
-
-    def with_environment
-      old_env = {}
-      begin
-        @variables.each { |key,value| old_env[key] = ENV[key]; ENV[key] = value }
-        yield
-      ensure
-        old_env.each { |key,value| ENV[key] = value }
-      end
+      @variables.prepend_variable(name, value)
 
       return
     end
 
-    def lookup_package(package_name, version_name, backtrace)
-      package = get_package(package_name)
+    def lookup_package(name, version, backtrace)
+      package = get_package(name)
       if package.nil?
-        if not version_name
-          Logging.fatal "No version specified for #{package_name}."
+        if not version
+          Logging.fatal "No version specified for #{name}."
           raise RepositoryError.new
         end
 
-        package = @repository.get_package(package_name, version_name)
+        package = @repository.get_package(
+          PackageDescriptor.new(name, version, nil)
+        )
         package.backtrace = backtrace
-        @packages[package_name] = package
-      elsif version_name && version_name != package.version_name
+        @packages[name] = package
+      elsif version && version != package.version
         string_handle = StringIO.new
         backtrace.dump(string_handle) if backtrace
         package.backtrace.dump(string_handle) if package.backtrace
         stacktrace = string_handle.string
         Logging.fatal                           \
-            "Version mismatch: #{package_name}" \
+            "Version mismatch: #{name}" \
           + ( stacktrace.empty? ? '' : "\n#{stacktrace}" )
         raise RepositoryError.new
       end
@@ -238,7 +228,7 @@ module Fig
     # Replace @ symbol with the package's directory, "[package]" with the
     # package name.
     def expand_and_retrieve_variable_value(base_package, name, value)
-      return value unless base_package && base_package.package_name
+      return value unless base_package && base_package.name
 
       file = expand_path(value, base_package)
 
@@ -259,8 +249,8 @@ module Fig
             target = File.join(target, File.basename(file))
           end
         end
-        @retriever.with_package_config(
-          base_package.package_name, base_package.version_name
+        @retriever.with_package_version(
+          base_package.name, base_package.version
         ) do
           @retriever.retrieve(file, target)
         end
@@ -335,10 +325,7 @@ module Fig
 
     def translate_retrieve_variables(base_package, name)
       return \
-        @retrieve_vars[name].gsub(
-          / \[package\] /x,
-          base_package.package_name
-        )
+        @retrieve_vars[name].gsub(/ \[package\] /x, base_package.name)
     end
   end
 end

data/lib/fig/environmentvariables.rb

@@ -0,0 +1,44 @@
+module Fig; end;
+
+# Abstract manager of a set of environment variables.
+module Fig::EnvironmentVariables
+  def initialize(variables_override = nil)
+    @variables = variables_override || get_system_environment_variables
+  end
+
+  def empty?
+    return @variables.empty?
+  end
+
+  def keys
+    return @variables.keys
+  end
+
+  def with_environment
+    original_environment = {}
+    original_environment.merge!(ENV.to_hash)
+
+    begin
+      set_system_environment_variables(@variables)
+      yield
+    ensure
+      ENV.clear
+      set_system_environment_variables(original_environment)
+    end
+
+    return
+  end
+
+  private
+
+  def get_system_environment_variables
+    vars = {}
+    ENV.each { |key,value| vars[key]=value }
+
+    return vars
+  end
+
+  def set_system_environment_variables(variables)
+    variables.each { |key, value| ENV[key] = value }
+  end
+end

data/lib/fig/environmentvariables/caseinsensitive.rb

@@ -0,0 +1,49 @@
+require 'fig/environmentvariables'
+
+module Fig; end;
+module EnvironmentVariables; end
+
+# Manager of a set of environment variables where the variable names are
+# case-insensitive, e.g. on MS Windows.
+class Fig::EnvironmentVariables::CaseInsensitive
+  include Fig::EnvironmentVariables
+
+  def [](key)
+    return @variables[key_to_store_under(key)]
+  end
+
+  def []=(key, new_value)
+    @variables[key_to_store_under(key)] = new_value
+
+    return
+  end
+
+  def prepend_variable(key, new_value)
+    existing_key = key_to_store_under(key)
+
+    if existing_key
+      assign_value_to_existing_key(existing_key, new_value)
+    else
+      @variables[key] = new_value
+    end
+
+    return
+  end
+
+  private
+
+  def assign_value_to_existing_key(existing_key, new_value)
+    current_value = @variables[existing_key]
+    if current_value
+      @variables[existing_key] = new_value + File::PATH_SEPARATOR + current_value
+    else
+      @variables[existing_key] = new_value
+    end
+
+    return
+  end
+
+  def key_to_store_under(key)
+    return @variables.keys.detect(lambda {key}) {|stored| stored.downcase == key.downcase}
+  end
+end

data/lib/fig/environmentvariables/casesensitive.rb

@@ -0,0 +1,30 @@
+require 'fig/environmentvariables'
+
+module Fig; end;
+module EnvironmentVariables; end
+
+# Manager of a set of environment variables where the variable names are
+# case-insensitive, e.g. on *nix.
+class Fig::EnvironmentVariables::CaseSensitive
+  include Fig::EnvironmentVariables
+
+  def [](key)
+    return @variables[key]
+  end
+
+  def []=(new_key, new_value)
+    @variables[new_key] = new_value
+
+    return
+  end
+
+  def prepend_variable(key, new_value)
+    if @variables.key?(key)
+      @variables[key] = new_value + File::PATH_SEPARATOR + @variables[key]
+    else
+      @variables[key] = new_value
+    end
+
+    return
+  end
+end

data/lib/fig/grammar.treetop

@@ -1,5 +1,6 @@
 require 'fig/package'
 require 'fig/packagedescriptor'
+require 'fig/parser'
 require 'fig/statement/archive'
 require 'fig/statement/command'
 require 'fig/statement/configuration'
@@ -15,15 +16,15 @@ module Fig
 
 grammar Fig
   rule package
-    ws statements:(package_statement*) {
-      def to_package(package_name, version_name, directory)
+    optional_ws statements:(package_statement*) optional_ws {
+      def to_package(descriptor, directory)
         Package.new(
-          package_name,
-          version_name,
+          descriptor.name,
+          descriptor.version,
           directory,
           statements.elements.map do
             |statement|
-            statement.to_package_statement(package_name)
+            statement.to_package_statement(descriptor)
           end
         )
       end
@@ -35,25 +36,33 @@ grammar Fig
   end
 
   rule archive
-    "archive" ws url {
-      def to_package_statement(package_name)
-        Statement::Archive.new(url.value.text_value)
+    statement_start:"archive" ws url {
+      def to_package_statement(descriptor)
+        Statement::Archive.new(
+          Parser.node_location(statement_start), url.value.text_value
+        )
       end
     }
   end
 
   rule resource
-    "resource" ws url {
-      def to_package_statement(package_name)
-        Statement::Resource.new(url.value.text_value)
+    statement_start:"resource" ws url {
+      def to_package_statement(descriptor)
+        Statement::Resource.new(
+          Parser.node_location(statement_start), url.value.text_value
+        )
       end
     }
   end
 
   rule retrieve
-    "retrieve" ws var:retrieve_variable "->" path:retrieve_path ws {
-      def to_package_statement(package_name)
-        Statement::Retrieve.new(var.text_value, path.text_value)
+    statement_start:"retrieve" ws var:retrieve_variable "->" path:retrieve_path ws {
+      def to_package_statement(descriptor)
+        Statement::Retrieve.new(
+          Parser.node_location(statement_start),
+          var.text_value,
+          path.text_value
+        )
       end
     }
   end
@@ -67,13 +76,14 @@ grammar Fig
   end
 
   rule config
-    "config" ws config_name ws statements:config_statement* "end" ws {
-      def to_package_statement(package_name)
+    statement_start:"config" ws config_name ws statements:config_statement* "end" ws {
+      def to_package_statement(descriptor)
         Statement::Configuration.new(
+          Parser.node_location(statement_start),
           config_name.text_value,
           statements.elements.map do
             |statement|
-            statement.to_config_statement(package_name)
+            statement.to_config_statement(descriptor)
           end
         )
       end
@@ -85,29 +95,38 @@ grammar Fig
   end
 
   rule include
-    "include" ws descriptor overrides:(override*) {
-      def to_config_statement(package_name)
+    statement_start:"include" ws descriptor overrides:(override*) {
+      def to_config_statement(containing_package_descriptor)
         Statement::Include.new(
+          Parser.node_location(statement_start),
           PackageDescriptor.parse(descriptor.text_value.strip),
           overrides.elements.map{ |e| e.to_override },
-          package_name
+          containing_package_descriptor
         )
       end
     }
   end
 
   rule override
-    "override" ws package_name "/" version_name ws {
+    statement_start:"override" ws package_name "/" version_name ws {
       def to_override
-        return Statement::Override.new(package_name.text_value, version_name.text_value)
+        return Statement::Override.new(
+          Parser.node_location(statement_start),
+          package_name.text_value,
+          version_name.text_value
+        )
       end
     }
   end
 
   rule path
-    ("append" / "path" / "add") ws name:path_name "=" value:path_value ws {
-      def to_config_statement(package_name)
-        Statement::Path.new(name.text_value, value.text_value)
+    statement_start:("append" / "path" / "add") ws name:path_name "=" value:path_value ws {
+      def to_config_statement(descriptor)
+        Statement::Path.new(
+          Parser.node_location(statement_start),
+          name.text_value,
+          value.text_value
+        )
       end
     }
   end
@@ -121,9 +140,13 @@ grammar Fig
   end
 
   rule set
-    "set" ws name:set_name "=" value:set_value ws {
-      def to_config_statement(package_name)
-        Statement::Set.new(name.text_value, value.text_value)
+    statement_start:"set" ws name:set_name "=" value:set_value ws {
+      def to_config_statement(descriptor)
+        Statement::Set.new(
+          Parser.node_location(statement_start),
+          name.text_value,
+          value.text_value
+        )
       end
     }
   end
@@ -137,9 +160,11 @@ grammar Fig
   end
 
   rule command
-    "command" ws string {
-      def to_config_statement(package_name)
-        Statement::Command.new(string.value.text_value)
+    statement_start:"command" ws string {
+      def to_config_statement(descriptor)
+        Statement::Command.new(
+          Parser.node_location(statement_start), string.value.text_value
+        )
       end
     }
   end
@@ -183,10 +208,6 @@ grammar Fig
     [a-zA-Z0-9_.-]+
   end
 
-  rule name
-    value:[a-zA-Z0-9]+ ws
-  end
-
   rule url
     (value:[a-zA-Z0-9:/\\._*-]+ ws) / ('"' value:[a-zA-Z0-9:/\\._-]+ '"' ws)
   end
@@ -194,6 +215,10 @@ grammar Fig
   rule ws
     [ \n\r\t]+
   end
+
+  rule optional_ws
+    [ \n\r\t]*
+  end
 end
 
 end