fig 0.1.57 → 0.1.59

data/lib/fig/retriever.rb

@@ -2,6 +2,8 @@ require 'ostruct'
 require 'set'
 
 require 'fig/logging'
+require 'fig/logging/colorizable'
+require 'fig/packagedescriptor'
 
 module Fig; end
 
@@ -13,31 +15,37 @@ module Fig; end
 class Fig::Retriever
   def initialize(base_dir)
     @base_dir = base_dir
-    @configs = {}
-    @fig_dir = File.join(@base_dir, '.fig')
+    @package_metadata_by_name = {}
+    @local_fig_data_directory = File.join(@base_dir, '.fig')
 
-    file = File.join(@fig_dir, 'retrieve')
+    file = File.join(@local_fig_data_directory, 'retrieve')
     if File.exist?(file)
-      load(file)
+      load_metadata(file)
     end
   end
 
-  def with_package_config(name, version)
+  def with_package_version(name, version)
     if name and version
-      @config = @configs[name]
-      if @config && @config.version != version
-        @config.files.each do |relpath|
-          Fig::Logging.info "- [#{@config.name}/#{@config.version}] #{relpath}"
+      @package_meta = @package_metadata_by_name[name]
+      if @package_meta && @package_meta.version != version
+        @package_meta.files.each do |relpath|
+          Fig::Logging.info(
+            Fig::Logging::Colorizable.new(
+              "- [#{formatted_meta()}] #{relpath}",
+              :magenta,
+              nil
+            )
+          )
           FileUtils.rm_f(File.join(@base_dir, relpath))
         end
-        @config = nil
+        @package_meta = nil
       end
-      if not @config
-        @config = new_package_config(name, version)
-        @configs[name] = @config
+      if not @package_meta
+        @package_meta = new_package_metadata(name, version)
+        @package_metadata_by_name[name] = @package_meta
       end
     else
-      @config = nil
+      @package_meta = nil
     end
     yield
   end
@@ -46,12 +54,12 @@ class Fig::Retriever
     copy(source, relpath)
   end
 
-  def save
-    FileUtils.mkdir_p(@fig_dir)
-    File.open(File.join(@fig_dir, 'retrieve'), 'w') do |f|
-      @configs.each do |name,config|
-        config.files.each do |target|
-          f << target << '=' << config.name << '/' << config.version << "\n"
+  def save_metadata
+    FileUtils.mkdir_p(@local_fig_data_directory)
+    File.open(File.join(@local_fig_data_directory, 'retrieve'), 'w') do |f|
+      @package_metadata_by_name.each do |name, package_meta|
+        package_meta.files.each do |target|
+          f << target << '=' << formatted_meta(package_meta) << "\n"
         end
       end
     end
@@ -59,35 +67,36 @@ class Fig::Retriever
 
   private
 
-  def load(file)
+  def load_metadata(file)
     File.open(file).each_line do |line|
       line = line.strip()
       if line =~ /^(.+)=(.+)\/(.+)$/
         target = $1
-        config_name = $2
-        config_version = $3
-        config = @configs[config_name]
-        if config
-          if config.version != config_version
+        package_name = $2
+        package_version = $3
+        package_meta = @package_metadata_by_name[package_name]
+        if package_meta
+          if package_meta.version != package_version
             raise 'version mismatch in .figretrieve'
           end
         else
-          config = new_package_config(config_name, config_version)
-          @configs[config_name] = config
+          package_meta = new_package_metadata(package_name, package_version)
+          @package_metadata_by_name[package_name] = package_meta
         end
-        config.files << target
+        package_meta.files << target
       else
         raise "parse error in #{file}: #{line}"
       end
     end
   end
 
-  def new_package_config(name, version)
-    config = OpenStruct.new
-    config.name = name
-    config.version = version
-    config.files = Set.new()
-    return config
+  def new_package_metadata(name, version)
+    package_meta = OpenStruct.new
+    package_meta.name = name
+    package_meta.version = version
+    package_meta.files = Set.new()
+
+    return package_meta
   end
 
   def copy(source, relpath)
@@ -103,17 +112,30 @@ class Fig::Retriever
         end
       end
     else
-      if !File.exist?(target) || File.mtime(source) > File.mtime(target)
+      if ! File.exist?(target) || File.mtime(source) > File.mtime(target)
         if Fig::Logging.debug?
-          Fig::Logging.debug "Copying package [#{@config.name}/#{@config.version}] from #{source} to #{target}."
+          Fig::Logging.debug \
+            "Copying package [#{formatted_meta()}] from #{source} to #{target}."
         else
-          Fig::Logging.info "+ [#{@config.name}/#{@config.version}] #{relpath}"
+          Fig::Logging.info(
+            Fig::Logging::Colorizable.new(
+              "+ [#{formatted_meta()}] #{relpath}",
+              :green,
+              nil
+            )
+          )
         end
         FileUtils.mkdir_p(File.dirname(target))
 
         FileUtils.cp(source, target, :preserve => true)
       end
-      @config.files << relpath if @config
+      @package_meta.files << relpath if @package_meta
     end
   end
+
+  def formatted_meta(package_meta = @package_meta)
+    return Fig::PackageDescriptor.format(
+      package_meta.name, package_meta.version, nil
+    )
+  end
 end

data/lib/fig/statement.rb

@@ -1,18 +1,40 @@
 module Fig; end
 
 # A statement within a package configuration file (package.fig).
-module Fig::Statement
+class Fig::Statement
+  attr_reader :line, :column
+
+  # This mess of getting these as a single array necessary is due to
+  # limitations of the "*" array splat operator in ruby v1.8.
+  def initialize(line_column)
+    if line_column
+      @line, @column = *line_column
+    end
+  end
+
   # Block will receive a Statement.
   def walk_statements(&block)
     return
   end
 
   # Block will receive a Package and a Statement.
-  def walk_statements_following_package_dependencies(repository, package, &block)
+  def walk_statements_following_package_dependencies(repository, package, configuration, &block)
     return
   end
 
   def urls
     return []
   end
+
+  # Returns a representation of the position of this statement, if the position
+  # is known, empty string otherwise.  This is written with the idea that you
+  # can do something like "puts %Q<Found a
+  # statement%{statement.position_string()}.>" and get nice looking output
+  # regardless of whether the position is actually known or not.
+  def position_string
+    return '' if not @line
+    return '' if not @column
+
+    return " (line #{@line}, column #{@column})"
+  end
 end

data/lib/fig/statement/archive.rb

@@ -1,5 +1,3 @@
-require 'fig/logging'
-require 'fig/packageerror'
 require 'fig/statement'
 
 module Fig; end
@@ -7,12 +5,12 @@ module Fig; end
 # Specifies an archive file (possibly via a URL) that is part of the current package.
 #
 # Differs from a Resource in that the contents will be extracted.
-class Fig::Statement::Archive
-  include Fig::Statement
-
+class Fig::Statement::Archive < Fig::Statement
   attr_reader :url
 
-  def initialize(url)
+  def initialize(line_column, url)
+    super(line_column)
+
     @url = url
   end
 

data/lib/fig/statement/command.rb

@@ -1,17 +1,15 @@
-require 'fig/logging'
-require 'fig/packageerror'
 require 'fig/statement'
 
 module Fig; end
 
 # Specifies a default command that will be executed for a given Configuration
 # if no command is specified on the command-line.
-class Fig::Statement::Command
-  include Fig::Statement
-
+class Fig::Statement::Command < Fig::Statement
   attr_reader :command
 
-  def initialize(command)
+  def initialize(line_column, command)
+    super(line_column)
+
     @command = command
   end
 

data/lib/fig/statement/configuration.rb

@@ -1,17 +1,15 @@
-require 'fig/logging'
-require 'fig/packageerror'
 require 'fig/statement'
 require 'fig/statement/command'
 
 module Fig; end
 
 # A grouping of statements within a configuration.  May not be nested.
-class Fig::Statement::Configuration
-  include Fig::Statement
-
+class Fig::Statement::Configuration < Fig::Statement
   attr_reader :name, :statements
 
-  def initialize(name, statements)
+  def initialize(line_column, name, statements)
+    super(line_column)
+
     @name = name
     @statements = statements
   end
@@ -35,11 +33,11 @@ class Fig::Statement::Configuration
   end
 
   # Block will receive a Package and a Statement.
-  def walk_statements_following_package_dependencies(repository, package, &block)
+  def walk_statements_following_package_dependencies(repository, package, configuration, &block)
     @statements.each do |statement|
-      yield package, statement
+      yield package, self, statement
       statement.walk_statements_following_package_dependencies(
-        repository, package, &block
+        repository, package, self, &block
       )
     end
 

data/lib/fig/statement/include.rb

@@ -1,4 +1,3 @@
-require 'fig/logging'
 require 'fig/packagedescriptor'
 require 'fig/statement'
 
@@ -6,32 +5,22 @@ module Fig; end
 
 # Dual role: "include :configname" incorporates one configuration into another;
 # "include package[/version]" declares a dependency upon another package.
-class Fig::Statement::Include
-  include Fig::Statement
+class Fig::Statement::Include < Fig::Statement
+  attr_reader :descriptor, :overrides, :containing_package_descriptor
 
-  attr_reader :descriptor, :overrides
+  def initialize(line_column, descriptor, overrides, containing_package_descriptor)
+    super(line_column)
 
-  def initialize(descriptor, overrides, containing_package_name)
-    if descriptor.name && ! descriptor.version
-      message =
-        %Q<No version in the package descriptor of "#{descriptor.name}" in an include statement>
-      if containing_package_name
-        message += %Q< in the .fig file for "#{containing_package_name}">
-      end
-      message += '. Whether or not the include statement will work is dependent upon the recursive dependency load order.'
-
-      Fig::Logging.warn(message)
-    end
-
-    @descriptor = descriptor
-    @overrides = overrides
+    @descriptor                    = descriptor
+    @overrides                     = overrides
+    @containing_package_descriptor = containing_package_descriptor
   end
 
   def package_name
     return @descriptor.name
   end
 
-  def version_name
+  def version
     return @descriptor.version
   end
 
@@ -39,23 +28,40 @@ class Fig::Statement::Include
     return @descriptor.config
   end
 
+  def complain_if_version_missing()
+    if @descriptor.name && ! @descriptor.version
+      message =
+        %Q<No version in the package descriptor of "#{@descriptor.name}" in an include statement>
+      if @containing_package_descriptor
+        package_string = @containing_package_descriptor.to_string()
+        if package_string && package_string != ''
+          message += %Q< in the .fig file for "#{package_string}">
+        end
+      end
+      message += %Q<#{position_string()}. Whether or not the include statement will work is dependent upon the recursive dependency load order.>
+
+      Fig::Logging.warn(message)
+    end
+  end
+
   # Assume that this statement is part of the parameter and return a descriptor
-  # that represents the fully resolved dependency.
-  def resolved_dependency_descriptor(package)
+  # that represents the fully resolved dependency, taking into account that the
+  # version might have been overridden.
+  def resolved_dependency_descriptor(containing_package, backtrace)
     return Fig::PackageDescriptor.new(
-      referenced_package_name(package),
-      referenced_version_name(package),
+      referenced_package_name(containing_package),
+      referenced_version(containing_package, backtrace),
       referenced_config_name()
     )
   end
 
   # Block will receive a Package and a Statement.
   def walk_statements_following_package_dependencies(
-    repository, package, &block
+    repository, package, configuration, &block
   )
     referenced_package = nil
     if package_name()
-      referenced_package = repository.get_package(package_name, version_name)
+      referenced_package = repository.get_package(descriptor())
     else
       referenced_package = package
     end
@@ -64,7 +70,7 @@ class Fig::Statement::Include
 
     yield referenced_package, configuration
     configuration.walk_statements_following_package_dependencies(
-      repository, referenced_package, &block
+      repository, referenced_package, nil, &block
     )
 
     return
@@ -73,7 +79,7 @@ class Fig::Statement::Include
   def unparse(indent)
     text = ''
     text += package_name() if package_name()
-    text += "/#{version_name()}" if version_name()
+    text += "/#{version()}" if version()
     text += ":#{config_name()}" if config_name()
     @overrides.each do |override|
       text += override.unparse
@@ -83,16 +89,27 @@ class Fig::Statement::Include
 
   private
 
-  def referenced_package_name(package)
-    return package_name() || package.package_name()
+  def referenced_package_name(containing_package)
+    return package_name() || containing_package.name()
   end
 
-  def referenced_version_name(package)
+  def referenced_version(containing_package, backtrace)
+    overrides().each do
+      |override|
+      backtrace.add_override(override.package_name(), override.version())
+    end
+
+    package_name = nil
+    original_version = nil
     if package_name()
-      return version_name()
+      package_name = package_name()
+      original_version = version()
+    else
+      package_name = containing_package.name()
+      original_version = containing_package.version()
     end
 
-    return version_name() || package.version_name()
+    return backtrace.get_override(package_name, original_version)
   end
 
   def referenced_config_name()

data/lib/fig/statement/override.rb

@@ -1,5 +1,4 @@
-require 'fig/logging'
-require 'fig/packageerror'
+require 'fig/packagedescriptor'
 require 'fig/statement'
 
 module Fig; end
@@ -11,17 +10,17 @@ module Fig; end
 #
 # indicates that, regardless of which version of somedependency the blah
 # package says it needs, the blah package will actually use v3.2.6.
-class Fig::Statement::Override
-  include Fig::Statement
+class Fig::Statement::Override < Fig::Statement
+  attr_reader :package_name, :version
 
-  attr_reader :package_name, :version_name
+  def initialize(line_column, package_name, version)
+    super(line_column)
 
-  def initialize(package_name, version_name)
     @package_name = package_name
-    @version_name = version_name
+    @version = version
   end
 
   def unparse()
-    return ' override ' + @package_name + '/' + @version_name
+    return ' override ' + Fig::PackageDescriptor.format(@package_name, @version, nil)
   end
 end