fig 0.1.57 → 0.1.59

data/lib/fig/command/listing.rb

@@ -1,6 +1,8 @@
 require 'set'
 
+require 'fig/backtrace'
 require 'fig/package'
+require 'fig/packagedescriptor'
 require 'fig/userinputerror'
 
 module Fig; end
@@ -48,7 +50,7 @@ module Fig::Command::Listing
 
   def display_dependencies()
     if @options.list_tree?
-      display_dependencies_in_tree(@package, derive_base_display_config_names())
+      display_dependencies_in_tree()
     else
       display_dependencies_flat()
     end
@@ -58,35 +60,60 @@ module Fig::Command::Listing
 
   def display_variables()
     if @options.list_tree?
-      raise Fig::UserInputError.new('--list-variables --list-tree not yet implemented.')
+      display_variables_in_tree()
+    elsif @options.list_all_configs?
+      display_variables_flat_from_repository()
     else
-      display_variables_flat()
+      display_variables_flat_from_environment()
     end
 
     return
   end
 
-  def display_dependencies_in_tree(base_package, config_names, indent = 0)
+  def display_dependencies_in_tree()
+    walk_dependency_tree(@package, derive_base_display_config_names(), nil, 0) do
+      |package, config_name, depth|
+
+      print ' ' * (depth * 4)
+      puts package.to_s_with_config(config_name)
+    end
+
+    return
+  end
+
+  def walk_dependency_tree(base_package, config_names, backtrace, depth, &block)
     config_names.each do
       |config_name|
 
-      print ' ' * (indent * 4)
-      puts base_package.to_s_with_config(config_name)
+      if depth < 1
+        @repository.reset_cached_data
+      end
+
+      yield base_package, config_name, depth
+
+      new_backtrace = Fig::Backtrace.new(
+        backtrace,
+        Fig::PackageDescriptor.new(
+          base_package.name(),
+          base_package.version(),
+          config_name
+        )
+      )
 
-      base_package.package_dependencies(config_name).each do
+      base_package.package_dependencies(config_name, new_backtrace).each do
         |descriptor|
 
         package = nil
         if descriptor.name
           package =
-            @repository.get_package(
-              descriptor.name, descriptor.version, false, :allow_any_version
-            )
+            @repository.get_package(descriptor, :allow_any_version)
         else
           package = base_package
         end
 
-        display_dependencies_in_tree(package, [descriptor.config], indent + 1)
+        walk_dependency_tree(
+          package, [descriptor.config], new_backtrace, depth + 1, &block
+        )
       end
     end
 
@@ -94,25 +121,28 @@ module Fig::Command::Listing
   end
 
   def display_dependencies_flat()
-    base_config_names = derive_base_display_config_names()
-    packages = gather_package_depencency_configurations(base_config_names)
+    packages = gather_package_dependency_configurations()
 
     if packages.empty? and $stdout.tty?
       puts '<no dependencies>'
     else
-      packages.keys.sort.each do
+      strings = []
+
+      packages.keys.each do
         |package|
 
         if @options.list_all_configs?
-          packages[package].sort.each do
+          packages[package].each do
             |config_name|
 
-            puts package.to_s_with_config(config_name)
+            strings << package.to_s_with_config(config_name)
           end
         else
-          puts package
+          strings << package
         end
       end
+
+      puts strings.uniq.sort.join("\n")
     end
 
     return
@@ -123,40 +153,36 @@ module Fig::Command::Listing
       return @package.config_names
     end
 
-    return [
-      @descriptor && @descriptor.config || Fig::Package::DEFAULT_CONFIG
-    ]
+    return [ base_config() ]
   end
 
-  def gather_package_depencency_configurations(starting_config_names)
+  def gather_package_dependency_configurations()
     packages = {}
+    starting_config_names = derive_base_display_config_names()
 
-    if ! @package.package_name.nil?
+    if ! @package.name.nil?
       packages[@package] = starting_config_names.to_set
     end
 
-    starting_config_names.each do
-      |config_name|
+    walk_dependency_tree(@package, starting_config_names, nil, 0) do
+      |package, config_name, depth|
 
-      @package[config_name].walk_statements_following_package_dependencies(
-        @repository, @package
-      ) do
-        |package, statement|
-
-        if (
-              ! package.package_name.nil?               \
-          &&  statement.is_a?(Fig::Statement::Configuration)
-        )
-          packages[package] ||= Set.new
-          packages[package] << statement.name
-        end
+      if (
+            ! package.name.nil?           \
+        &&  ! (
+                  ! @options.list_all_configs?    \
+              &&  @descriptor                     \
+              &&  package.name == @descriptor.name
+            )
+      )
+        packages[package] ||= Set.new
+        packages[package] << config_name
       end
     end
 
     if ! @options.list_all_configs? && @descriptor
-      packages.reject! do
-        |package, config_names|
-        package.package_name == @descriptor.name
+      packages.reject! do |package, config_names|
+        package.name == @descriptor.name
       end
     end
 
@@ -178,7 +204,148 @@ module Fig::Command::Listing
     return
   end
 
-  def display_variables_flat()
+  VariableTreePackageConfig =
+    Struct.new(
+      :package, :config_name, :variable_statements, :child_configs, :parent
+    )
+
+  def display_variables_in_tree()
+    # We can't just display as we walk the dependency tree because we need to
+    # know in advance how many configurations we're going display under
+    # another.
+    tree = build_variable_tree()
+
+    tree.child_configs().each do
+      |child|
+
+      display_variable_tree_level(child, '', '')
+    end
+
+    return
+  end
+
+  def build_variable_tree()
+    tree = VariableTreePackageConfig.new(nil, nil, nil, [], nil)
+    prior_depth = 0
+    prior_node = nil
+    current_parent = tree
+
+    walk_dependency_tree(@package, derive_base_display_config_names(), nil, 0) do
+      |package, config_name, depth|
+
+      if depth < prior_depth
+        (depth .. (prior_depth - 1)).each do
+          current_parent = current_parent.parent
+        end
+      elsif depth == prior_depth + 1
+        current_parent = prior_node
+      elsif depth > prior_depth
+        raise "Bug in code! Descended more than one level! (#{prior_depth} to #{depth}"
+      end
+
+      variable_statements = gather_variable_statements(package[config_name])
+      node = VariableTreePackageConfig.new(
+        package, config_name, variable_statements, [], current_parent
+      )
+      current_parent.child_configs() << node
+
+      prior_depth = depth
+      prior_node = node
+    end
+
+    return tree
+  end
+
+  def gather_variable_statements(config_statement)
+    variable_statements = []
+    config_statement.walk_statements() do |statement|
+      case statement
+        when Fig::Statement::Path
+          variable_statements << statement
+        when Fig::Statement::Set
+          variable_statements << statement
+      end
+    end
+
+    return variable_statements
+  end
+
+  def display_variable_tree_level(node, base_indent, package_indent)
+    print package_indent
+    puts node.package().to_s_with_config(node.config_name())
+
+    display_variable_tree_level_variables(node, base_indent)
+
+    child_configs = node.child_configs()
+    child_count = child_configs.size()
+
+    new_indent = base_indent + (child_count > 0 ? '|' : ' ') + ' ' * 3
+    new_package_indent = base_indent + %q<'--->
+
+    (0 .. (child_count - 2)).each do
+      |child_index|
+
+      display_variable_tree_level(
+        child_configs[child_index], new_indent, new_package_indent
+      )
+    end
+
+    if child_count > 0
+      display_variable_tree_level(
+        child_configs[-1], (base_indent + ' ' * 4), new_package_indent
+      )
+    end
+  end
+
+  def display_variable_tree_level_variables(node, base_indent)
+    if node.child_configs().size() > 0
+      variable_indent = base_indent + '|' + ' ' * 3
+    else
+      variable_indent = base_indent + ' ' * 4
+    end
+
+    variable_statements = node.variable_statements()
+
+    name_width =
+      (variable_statements.map { |statement| statement.name().length() }).max()
+
+    variable_statements.each do
+      |statement|
+
+      print "#{variable_indent}"
+      print "#{statement.name().ljust(name_width)}"
+      print " = #{statement.value}"
+      if statement.is_a?(Fig::Statement::Path)
+        print ":$#{statement.name}"
+      end
+      print "\n"
+    end
+
+    return
+  end
+
+  def display_variables_flat_from_repository()
+    variable_names = Set.new()
+
+    walk_dependency_tree(@package, derive_base_display_config_names(), nil, 0) do
+      |package, config_name, depth|
+
+      package[config_name].walk_statements() do |statement|
+        case statement
+          when Fig::Statement::Path
+            variable_names << statement.name()
+          when Fig::Statement::Set
+            variable_names << statement.name()
+        end
+      end
+    end
+
+    variable_names.sort.each { |name| puts name }
+
+    return
+  end
+
+  def display_variables_flat_from_environment()
     register_package_with_environment()
 
     variables = @environment.variables()
@@ -193,5 +360,4 @@ module Fig::Command::Listing
 
     return
   end
-
 end

data/lib/fig/command/packageload.rb

@@ -0,0 +1,137 @@
+require 'fig/package'
+require 'fig/packagedescriptor'
+require 'fig/parser'
+
+module Fig; end
+class Fig::Command; end
+
+# Parts of the Command class related to loading of the primary Package object,
+# simply to keep the size of command.rb down.
+module Fig::Command::PackageLoad
+  DEFAULT_FIG_FILE = 'package.fig'
+
+  private
+
+  def read_in_package_config_file(config_file)
+    if File.exist?(config_file)
+      @package_loaded_from_path = config_file
+
+      return File.read(config_file)
+    else
+      raise Fig::UserInputError.new(%Q<File not found: "#{config_file}".>)
+    end
+  end
+
+  def load_package_config_file_contents()
+    package_config_file = @options.package_config_file()
+
+    if package_config_file == :none
+      return nil
+    elsif package_config_file == '-'
+      @package_loaded_from_path = '<standard input>'
+
+      return $stdin.read
+    elsif package_config_file.nil?
+      if File.exist?(DEFAULT_FIG_FILE)
+        @package_loaded_from_path = DEFAULT_FIG_FILE
+
+        return File.read(DEFAULT_FIG_FILE)
+      end
+    else
+      return read_in_package_config_file(package_config_file)
+    end
+
+    return
+  end
+
+  def register_package_with_environment_if_not_listing_or_publishing()
+    return if @options.listing || @options.publishing?
+
+    register_package_with_environment()
+
+    return
+  end
+
+  def register_package_with_environment()
+    if @options.updating?
+      @package.retrieves.each do |var, path|
+        @environment.add_retrieve(var, path)
+      end
+    end
+
+    @environment.register_package(@package)
+
+    config = base_config()
+    begin
+      @environment.apply_config(@package, config, nil)
+    rescue Fig::NoSuchPackageConfigError => exception
+      raise exception if not @descriptor
+
+      descriptor = exception.descriptor
+
+      raise exception if
+        descriptor.name    && descriptor.name    != @descriptor.name
+      raise exception if
+        descriptor.version && descriptor.version != @descriptor.version
+      raise exception if      descriptor.config  != config
+
+      source = nil
+      if @package_loaded_from_path
+        source = @package_loaded_from_path
+      else
+        source =
+          Fig::PackageDescriptor.format(@descriptor.name, @descriptor.version, nil)
+      end
+      source_component = source ? %Q< in #{source}> : ''
+
+      message = %Q<There's no "#{config}" configuration#{source_component}.>
+      message += %q< Specify one that does like this: ">
+      message +=
+        Fig::PackageDescriptor.format(@descriptor.name, @descriptor.version, 'some_existing_config')
+      message += %q<".>
+
+      if @options.publishing?
+        message += ' (Yes, this does work with --publish.)'
+      end
+
+      raise Fig::UserInputError.new(message)
+    end
+
+    return
+  end
+
+  def parse_package_config_file(config_raw_text)
+    if config_raw_text.nil?
+      @package = Fig::Package.new(nil, nil, '.', [])
+      return
+    end
+
+    @package =
+      Fig::Parser.new(@configuration, :check_include_versions).parse_package(
+        Fig::PackageDescriptor.new(nil, nil, nil), '.', config_raw_text
+      )
+
+    register_package_with_environment_if_not_listing_or_publishing()
+
+    return
+  end
+
+  def load_package_file()
+    config_raw_text = load_package_config_file_contents()
+
+    parse_package_config_file(config_raw_text)
+  end
+
+  def load_package_object()
+    if @descriptor.nil?
+      load_package_file()
+    else
+      # TODO: complain if config file was specified on the command-line.
+      @package = @repository.get_package(@descriptor)
+
+      register_package_with_environment_if_not_listing_or_publishing()
+    end
+
+    return
+  end
+end