fig 0.1.57 → 0.1.59

data/lib/fig/packagecache.rb

@@ -7,13 +7,13 @@ class Fig::PackageCache
   end
 
   def add_package(package)
-    versions = @packages[package.package_name]
+    versions = @packages[package.name]
     if not versions
       versions = {}
-      @packages[package.package_name] = versions
+      @packages[package.name] = versions
     end
 
-    versions[package.version_name] = package
+    versions[package.version] = package
 
     return
   end

data/lib/fig/packagedescriptor.rb

@@ -1,18 +1,38 @@
 module Fig; end
 
-# Parsed representation of a package name:config/version.
+# Parsed representation of a package (name/version:config).
 class Fig::PackageDescriptor
   include Comparable
 
-  DEFAULT_CONFIG = 'default'
-
   attr_reader :name, :version, :config
 
+  def self.format(name, version, config, use_default_config = false)
+    string = name || ''
+
+    if version
+      string += '/'
+      string += version
+    end
+
+    if config
+      string += ':'
+      string += config
+    elsif use_default_config
+      string += ':default'
+    end
+
+    return string
+  end
+
   def self.parse(raw_string)
+    # Additional checks in validate_component() will take care of the looseness
+    # of the regexes.  These just need to ensure that the entire string gets
+    # assigned to one component or another.
+
     self.new(
-      raw_string =~ %r< ^ ( [^:/]+ ) >x ? $1 : nil,
-      raw_string =~ %r< / ( [^:/]+ ) >x ? $1 : nil,
-      raw_string =~ %r< : ( [^:/]+ ) >x ? $1 : nil
+      raw_string =~ %r< \A         ( [^:/]+ )    >x ? $1 : nil,
+      raw_string =~ %r< \A [^/]* / ( [^:]+  )    >x ? $1 : nil,
+      raw_string =~ %r< \A [^:]* : ( .+     ) \z >x ? $1 : nil
     )
   end
 
@@ -22,22 +42,19 @@ class Fig::PackageDescriptor
     @config   = config
   end
 
-  def to_string(use_default_config = false)
-    string = @name || ''
+  def validate_component(value, name)
+    return if value.nil?
 
-    if @version
-      string += '/'
-      string += @version
-    end
+    return if value =~ / \A [a-zA-Z0-9_.-]+ \z /x
 
-    if @config
-      string += ':'
-      string += @config
-    elsif use_default_config
-      string += ':default'
-    end
+    raise %Q<Invalid #{name} for package descriptor: "#{value}".>
+  end
 
-    return string
+  # Specifically not named :to_s because it doesn't act like that should.
+  def to_string(use_default_config = false)
+    return Fig::PackageDescriptor.format(
+      @name, @version, @config, use_default_config
+    )
   end
 
   def <=>(other)

data/lib/fig/packageparseerror.rb

@@ -0,0 +1,7 @@
+require 'fig/userinputerror'
+
+module Fig
+  # An issue with parsing a .fig file.
+  class PackageParseError < UserInputError
+  end
+end

data/lib/fig/parser.rb

@@ -3,61 +3,98 @@ require 'treetop'
 
 require 'fig/grammar'
 require 'fig/logging'
-require 'fig/packageerror'
+require 'fig/packageparseerror'
 require 'fig/repository'
 require 'fig/urlaccesserror'
 require 'fig/userinputerror'
 
-module Fig
-  # Parses configuration files and deals with a few restrictions on them.
-  class Parser
-    def initialize(application_config)
-      @parser = FigParser.new
-      @application_config = application_config
-    end
+module Fig; end
 
-    def find_bad_urls(package, package_name, version_name)
-      bad_urls = []
-      package.walk_statements do |statement|
-        statement.urls.each do |url|
-          # collect all bad urls in bad_urls
-          next if not Repository.is_url?(url)
-          bad_urls << url if not @application_config.url_access_allowed?(url)
-        end
-      end
+# Parses .fig files (wrapping the Treetop-generated parser object) and deals
+# with a few restrictions on them.
+class Fig::Parser
+  def self.node_location(node)
+    offset_from_start_of_file = node.interval.first
+    input = node.input
 
-      raise URLAccessError.new(bad_urls, package_name, version_name) if not bad_urls.empty?
+    return [
+      input.line_of(offset_from_start_of_file),
+      input.column_of(offset_from_start_of_file)
+    ]
+  end
+
+  def initialize(application_config, check_include_versions)
+    @parser                 = Fig::FigParser.new
+    @application_config     = application_config
+    @check_include_versions = check_include_versions
+  end
+
+  def parse_package(descriptor, directory, input)
+    # Bye bye comments.
+    input = input.gsub(/#.*$/, '')
+
+    # Extra space at the end because most of the rules in the grammar require
+    # trailing whitespace.
+    result = @parser.parse(input + ' ')
+
+    if result.nil?
+      Fig::Logging.fatal "#{directory}: #{@parser.failure_reason}"
+      raise Fig::PackageParseError.new("#{directory}: #{@parser.failure_reason}")
     end
 
-    def find_multiple_command_statements(package)
-      command_processed = false
-      package.walk_statements do |statement|
-        if statement.is_a?(Statement::Command)
-          if command_processed == true
-            raise UserInputError.new("Multiple command statements cannot be processed.")
-          end
-          command_processed = true
-        elsif statement.is_a?(Statement::Configuration)
-          command_processed = false
-        end
+    package = result.to_package(descriptor, directory)
+
+    check_for_bad_urls(package, descriptor)
+    check_for_multiple_command_statements(package)
+    check_for_missing_versions_on_include_statements(package)
+
+    return package
+  end
+
+  private
+
+  def check_for_bad_urls(package, descriptor)
+    bad_urls = []
+    package.walk_statements do |statement|
+      statement.urls.each do |url|
+        # collect all bad urls in bad_urls
+        next if not Fig::Repository.is_url?(url)
+        bad_urls << url if not @application_config.url_access_allowed?(url)
       end
     end
 
-    def parse_package(package_name, version_name, directory, input)
-      input = input.gsub(/#.*$/, '')
-      result = @parser.parse(" #{input} ")
+    raise Fig::URLAccessError.new(bad_urls, descriptor) if not bad_urls.empty?
+
+    return
+  end
 
-      if result.nil?
-        Logging.fatal "#{directory}: #{@parser.failure_reason}"
-        raise PackageError.new("#{directory}: #{@parser.failure_reason}")
+  def check_for_multiple_command_statements(package)
+    command_processed = false
+    package.walk_statements do |statement|
+      if statement.is_a?(Fig::Statement::Command)
+        if command_processed == true
+          raise Fig::UserInputError.new(
+            %Q<Found a second "command" statement within a "config" block#{statement.position_string()}.>
+          )
+        end
+        command_processed = true
+      elsif statement.is_a?(Fig::Statement::Configuration)
+        command_processed = false
       end
+    end
 
-      package = result.to_package(package_name, version_name, directory)
+    return
+  end
 
-      find_bad_urls(package, package_name, version_name)
-      find_multiple_command_statements(package)
+  def check_for_missing_versions_on_include_statements(package)
+    return if not @check_include_versions
 
-      return package
+    package.walk_statements do |statement|
+      if statement.is_a?(Fig::Statement::Include)
+        statement.complain_if_version_missing()
+      end
     end
+
+    return
   end
 end

data/lib/fig/repository.rb

@@ -1,6 +1,10 @@
+require 'socket'
+require 'sys/admin'
+
 require 'fig/logging'
 require 'fig/notfounderror'
 require 'fig/packagecache'
+require 'fig/packagedescriptor'
 require 'fig/parser'
 require 'fig/repositoryerror'
 require 'fig/statement/archive'
@@ -22,27 +26,33 @@ module Fig
       local_repository_dir,
       remote_repository_url,
       application_config,
-      remote_repository_user  = nil,
-      update                  = false,
-      update_if_missing       = true
+      remote_repository_user,
+      update,
+      update_if_missing,
+      check_include_versions
     )
-      @operating_system = os
-      @local_repository_dir = local_repository_dir
-      @remote_repository_url = remote_repository_url
+      @operating_system       = os
+      @local_repository_dir   = local_repository_dir
+      @remote_repository_url  = remote_repository_url
       @remote_repository_user = remote_repository_user
-      @update = update
-      @update_if_missing = update_if_missing
+      @update                 = update
+      @update_if_missing      = update_if_missing
+
+      @parser = Parser.new(application_config, check_include_versions)
 
-      @parser = Parser.new(application_config)
+      reset_cached_data()
+    end
+
+    def reset_cached_data()
       @packages = PackageCache.new()
     end
 
     def list_packages
       results = []
       if File.exist?(@local_repository_dir)
-        @operating_system.list(@local_repository_dir).each do |package_name|
-          @operating_system.list(File.join(@local_repository_dir, package_name)).each do |version_name|
-            results << "#{package_name}/#{version_name}"
+        @operating_system.list(@local_repository_dir).each do |name|
+          @operating_system.list(File.join(@local_repository_dir, name)).each do |version|
+            results << PackageDescriptor.format(name, version, nil)
           end
         end
       end
@@ -57,69 +67,66 @@ module Fig
     end
 
     def get_package(
-      package_name,
-      version_name,
-      disable_updating = false,
+      descriptor,
       allow_any_version = false
     )
-      if not version_name
+      if not descriptor.version
         if allow_any_version
-          package = @packages.get_any_version_of_package(package_name)
+          package = @packages.get_any_version_of_package(descriptor.name)
           if package
             Logging.warn(
-              "Picked version #{package.version_name} of #{package.package_name} at random."
+              "Picked version #{package.version} of #{package.name} at random."
             )
             return package
           end
         end
 
         raise RepositoryError.new(
-          %Q<Cannot retrieve "#{package_name}" without a version.>
+          %Q<Cannot retrieve "#{descriptor.name}" without a version.>
         )
       end
 
-      package = @packages.get_package(package_name, version_name)
+      package = @packages.get_package(descriptor.name, descriptor.version)
       return package if package
 
-      Logging.debug "Considering #{package_name}/#{version_name}."
+      Logging.debug \
+        "Considering #{PackageDescriptor.format(descriptor.name, descriptor.version, nil)}."
 
-      if should_update?(package_name, version_name, disable_updating)
-        update_package(package_name, version_name)
+      if should_update?(descriptor)
+        update_package(descriptor)
       end
 
-      return read_local_package(package_name, version_name)
+      return read_local_package(descriptor)
     end
 
-    def clean(package_name, version_name)
-      @packages.remove_package(package_name, version_name)
+    def clean(descriptor)
+      @packages.remove_package(descriptor.name, descriptor.version)
 
-      dir = File.join(@local_repository_dir, package_name)
-      dir = File.join(dir, version_name) if version_name
+      dir = File.join(@local_repository_dir, descriptor.name)
+      dir = File.join(dir, descriptor.version) if descriptor.version
 
       FileUtils.rm_rf(dir)
 
       return
     end
 
-    def publish_package(
-      package_statements, package_name, version_name, local_only
-    )
-      temp_dir = temp_dir_for_package(package_name, version_name)
+    def publish_package(package_statements, descriptor, local_only)
+      temp_dir = temp_dir_for_package(descriptor)
       @operating_system.clear_directory(temp_dir)
-      local_dir = local_dir_for_package(package_name, version_name)
+      local_dir = local_dir_for_package(descriptor)
       @operating_system.clear_directory(local_dir)
       fig_file = File.join(temp_dir, '.fig')
       content = derive_package_content(
-        package_statements, package_name, version_name, local_dir, local_only
+        package_statements, descriptor, local_dir, local_only
       )
       @operating_system.write(fig_file, content.join("\n").strip)
       @operating_system.upload(
         fig_file,
-        remote_fig_file_for_package(package_name, version_name),
+        remote_fig_file_for_package(descriptor),
         @remote_repository_user
       ) unless local_only
       @operating_system.copy(
-        fig_file, local_fig_file_for_package(package_name, version_name)
+        fig_file, local_fig_file_for_package(descriptor)
       )
 
       FileUtils.rm_rf(temp_dir)
@@ -131,18 +138,15 @@ module Fig
 
     private
 
-    def should_update?(package_name, version_name, disable_updating)
-      return false if disable_updating
-
+    def should_update?(descriptor)
       return true if @update
 
-      return @update_if_missing &&
-        package_missing?(package_name, version_name)
+      return @update_if_missing && package_missing?(descriptor)
     end
 
-    def read_local_package(package_name, version_name)
-      dir = local_dir_for_package(package_name, version_name)
-      return read_package_from_directory(dir, package_name, version_name)
+    def read_local_package(descriptor)
+      directory = local_dir_for_package(descriptor)
+      return read_package_from_directory(directory, descriptor)
     end
 
     def bundle_resources(package_statements)
@@ -163,42 +167,43 @@ module Fig
         resources = expand_globs_from(resources)
         file = 'resources.tar.gz'
         @operating_system.create_archive(file, resources)
-        new_package_statements.unshift(Statement::Archive.new(file))
+        new_package_statements.unshift(Statement::Archive.new(nil, file))
         at_exit { File.delete(file) }
       end
 
       return new_package_statements
     end
 
-    def install_package(package_name, version_name)
+    def install_package(descriptor)
       temp_dir = nil
 
       begin
-        package = read_local_package(package_name, version_name)
-        temp_dir = temp_dir_for_package(package_name, version_name)
+        package = read_local_package(descriptor)
+        temp_dir = temp_dir_for_package(descriptor)
         @operating_system.clear_directory(temp_dir)
         package.archive_urls.each do |archive_url|
           if not Repository.is_url?(archive_url)
-            archive_url = remote_dir_for_package(package_name, version_name) + '/' + archive_url
+            archive_url = remote_dir_for_package(descriptor) + '/' + archive_url
           end
           @operating_system.download_archive(archive_url, File.join(temp_dir))
         end
         package.resource_urls.each do |resource_url|
           if not Repository.is_url?(resource_url)
-            resource_url = remote_dir_for_package(package_name, version_name) + '/' + resource_url
+            resource_url =
+              remote_dir_for_package(descriptor) + '/' + resource_url
           end
           @operating_system.download_resource(resource_url, File.join(temp_dir))
         end
-        local_dir = local_dir_for_package(package_name, version_name)
+        local_dir = local_dir_for_package(descriptor)
         @operating_system.clear_directory(local_dir)
         # some packages contain no files, only a fig file.
         if not (package.archive_urls.empty? && package.resource_urls.empty?)
           FileUtils.mv(Dir.glob(File.join(temp_dir, '*')), local_dir)
         end
-        write_local_package(package_name, version_name, package)
+        write_local_package(descriptor, package)
       rescue
         Logging.fatal 'Install failed, cleaning up.'
-        delete_local_package(package_name, version_name)
+        delete_local_package(descriptor)
         raise RepositoryError.new
       ensure
         if temp_dir
@@ -207,49 +212,55 @@ module Fig
       end
     end
 
-    def update_package(package_name, version_name)
-      remote_fig_file = remote_fig_file_for_package(package_name, version_name)
-      local_fig_file = local_fig_file_for_package(package_name, version_name)
+    def update_package(descriptor)
+      remote_fig_file = remote_fig_file_for_package(descriptor)
+      local_fig_file = local_fig_file_for_package(descriptor)
       begin
         if @operating_system.download(remote_fig_file, local_fig_file)
-          install_package(package_name, version_name)
+          install_package(descriptor)
         end
       rescue NotFoundError
-        Logging.fatal "Package not found in remote repository: #{package_name}/#{version_name}"
-        delete_local_package(package_name, version_name)
+        Logging.fatal "Package not found in remote repository: #{descriptor.to_string()}"
+        delete_local_package(descriptor)
         raise RepositoryError.new
       end
     end
 
-    # 'resources' is an Array of filenames: ['tmp/foo/file1', 'tmp/foo/*.jar']
+    # 'resources' is an Array of fileglob patterns: ['tmp/foo/file1',
+    # 'tmp/foo/*.jar']
     def expand_globs_from(resources)
       expanded_files = []
       resources.each {|f| expanded_files.concat(Dir.glob(f))}
       expanded_files
     end
 
-    def read_package_from_directory(dir, package_name, version_name)
-      file = File.join(dir, '.fig')
-      if not File.exist?(file)
-        file = File.join(dir, 'package.fig')
-      end
-      if not File.exist?(file)
-        Logging.fatal %Q<Fig file not found for package "#{package_name || '<unnamed>'}": #{file}>
-        raise RepositoryError.new
+    def read_package_from_directory(dir, descriptor)
+      file = nil
+      dot_fig_file = File.join(dir, '.fig')
+      if File.exist?(dot_fig_file)
+        file = dot_fig_file
+      else
+        package_dot_fig_file = File.join(dir, 'package.fig')
+        if not File.exist?(package_dot_fig_file)
+          Logging.fatal %Q<Fig file not found for package "#{descriptor.name || '<unnamed>'}". Looked for "#{dot_fig_file}" and "#{package_dot_fig_file}" and found neither.>
+          raise RepositoryError.new
+        end
+
+        file = package_dot_fig_file
       end
 
-      return read_package_from_file(file, package_name, version_name)
+      return read_package_from_file(file, descriptor)
     end
 
-    def read_package_from_file(file_name, package_name, version_name)
+    def read_package_from_file(file_name, descriptor)
       if not File.exist?(file_name)
-        Logging.fatal "Package not found: #{package_name}/#{version_name}"
+        Logging.fatal "Package not found: #{descriptor.to_string()}"
         raise RepositoryError.new
       end
       content = File.read(file_name)
 
       package = @parser.parse_package(
-        package_name, version_name, File.dirname(file_name), content
+        descriptor, File.dirname(file_name), content
       )
 
       @packages.add_package(package)
@@ -257,52 +268,79 @@ module Fig
       return package
     end
 
-    def delete_local_package(package_name, version_name)
-      FileUtils.rm_rf(local_dir_for_package(package_name, version_name))
+    def delete_local_package(descriptor)
+      FileUtils.rm_rf(local_dir_for_package(descriptor))
     end
 
-    def write_local_package(package_name, version_name, package)
-      file = local_fig_file_for_package(package_name, version_name)
+    def write_local_package(descriptor, package)
+      file = local_fig_file_for_package(descriptor)
       @operating_system.write(file, package.unparse)
     end
 
-    def remote_fig_file_for_package(package_name, version_name)
-      "#{@remote_repository_url}/#{package_name}/#{version_name}/.fig"
+    def remote_fig_file_for_package(descriptor)
+      "#{@remote_repository_url}/#{descriptor.name}/#{descriptor.version}/.fig"
     end
 
-    def local_fig_file_for_package(package_name, version_name)
-      File.join(local_dir_for_package(package_name, version_name), '.fig')
+    def local_fig_file_for_package(descriptor)
+      File.join(local_dir_for_package(descriptor), '.fig')
     end
 
-    def remote_dir_for_package(package_name, version_name)
-      "#{@remote_repository_url}/#{package_name}/#{version_name}"
+    def remote_dir_for_package(descriptor)
+      "#{@remote_repository_url}/#{descriptor.name}/#{descriptor.version}"
     end
 
-    def local_dir_for_package(package_name, version_name)
-      return File.join(@local_repository_dir, package_name, version_name)
+    def local_dir_for_package(descriptor)
+      return File.join(
+        @local_repository_dir, descriptor.name, descriptor.version
+      )
     end
 
-    def temp_dir_for_package(package_name, version_name)
+    def temp_dir_for_package(descriptor)
       File.join(@local_repository_dir, 'tmp')
     end
 
-    def package_missing?(package_name, version_name)
-      not File.exist?(local_fig_file_for_package(package_name, version_name))
+    def package_missing?(descriptor)
+      not File.exist?(local_fig_file_for_package(descriptor))
     end
 
     def derive_package_content(
-      package_statements, package_name, version_name, local_dir, local_only
+      package_statements, descriptor, local_dir, local_only
+    )
+      header_strings = derive_package_metadata_comments(descriptor)
+      resource_statement_strings = derive_package_resources(
+        package_statements, descriptor, local_dir, local_only
+      )
+
+      return [header_strings, resource_statement_strings].flatten()
+    end
+
+    def derive_package_metadata_comments(descriptor)
+      now = Time.now()
+
+      return [
+        %Q<# Publishing information for #{descriptor.to_string()}:>,
+        %q<#>,
+        %Q<#    Time: #{now} (epoch: #{now.to_i()})>,
+        %Q<#    User: #{Sys::Admin.get_login()}>,
+        %Q<#    Host: #{Socket.gethostname()}>,
+        %Q<#    Args: "#{ARGV.join %q[", "]}">,
+        %q<#>
+      ]
+    end
+
+    def derive_package_resources(
+      package_statements, descriptor, local_dir, local_only
     )
       return bundle_resources(package_statements).map do |statement|
         if statement.is_a?(Statement::Publish)
           nil
         elsif statement.is_a?(Statement::Archive) || statement.is_a?(Statement::Resource)
-          if statement.is_a?(Statement::Resource) && !Repository.is_url?(statement.url)
+          if statement.is_a?(Statement::Resource) && ! Repository.is_url?(statement.url)
             archive_name = statement.url
-            archive_remote = "#{remote_dir_for_package(package_name, version_name)}/#{statement.url}"
+            archive_remote = "#{remote_dir_for_package(descriptor)}/#{statement.url}"
           else
             archive_name = statement.url.split('/').last
-            archive_remote = "#{remote_dir_for_package(package_name, version_name)}/#{archive_name}"
+            archive_remote = "#{remote_dir_for_package(descriptor)}/#{archive_name}"
           end
           if Repository.is_url?(statement.url)
             archive_local = File.join(temp_dir, archive_name)
@@ -315,11 +353,11 @@ module Fig
           if statement.is_a?(Statement::Archive)
             @operating_system.unpack_archive(local_dir, archive_name)
           end
-          statement.class.new(archive_name).unparse('')
+          statement.class.new(nil, archive_name).unparse('')
         else
           statement.unparse('')
         end
-      end.select { |s|not s.nil? }
+      end.select { |s| not s.nil? }
     end
   end
 end