fig18 0.1.45-i386-mingw32

data/lib/fig/package/configuration.rb

@@ -0,0 +1,40 @@
+require 'fig/logging'
+require 'fig/packageerror'
+require 'fig/package/command'
+require 'fig/package/statement'
+
+module Fig; end
+class Fig::Package; end
+
+class Fig::Package::Configuration
+  include Fig::Package::Statement
+
+  attr_reader :name, :statements
+
+  def initialize(name, statements)
+    @name = name
+    @statements = statements
+  end
+
+  def with_name(name)
+    Configuration.new(name, statements)
+  end
+
+  def commands
+    result = statements.select do
+      |statement| statement.is_a?(Fig::Package::Command)
+    end
+    result
+  end
+
+  def walk_statements(&block)
+    @statements.each do |statement|
+      yield statement
+      statement.walk_statements &block
+    end
+  end
+
+  def unparse(indent)
+    unparse_statements(indent, "config #{@name}", @statements, 'end')
+  end
+end

data/lib/fig/package/include.rb

@@ -0,0 +1,30 @@
+require 'fig/logging'
+require 'fig/packageerror'
+require 'fig/package/statement'
+
+module Fig; end
+class Fig::Package; end
+
+class Fig::Package::Include
+  include Fig::Package::Statement
+
+  attr_reader :package_name, :config_name, :version_name, :overrides
+
+  def initialize(package_name, config_name, version_name, overrides)
+    @package_name = package_name
+    @config_name = config_name
+    @version_name = version_name
+    @overrides = overrides
+  end
+
+  def unparse(indent)
+    descriptor = ''
+    descriptor += @package_name if @package_name
+    descriptor += "/#{@version_name}" if @version_name
+    descriptor += ":#{@config_name}" if @config_name
+    @overrides.each do |override|
+      descriptor += override.unparse
+    end
+    return "#{indent}include #{descriptor}"
+  end
+end

data/lib/fig/package/install.rb

@@ -0,0 +1,21 @@
+require 'fig/logging'
+require 'fig/packageerror'
+require 'fig/package/statement'
+
+module Fig; end
+class Fig::Package; end
+
+class Fig::Package::Install
+  include Fig::Package::Statement
+
+  def initialize(statements)
+    @statements = statements
+  end
+
+  def unparse(indent)
+    prefix = "\n#{indent}install"
+    body = @statements.map { |statement| statement.unparse(indent+'  ') }.join("\n")
+    suffix = "#{indent}end"
+    return [prefix, body, suffix].join("\n")
+  end
+end

data/lib/fig/package/override.rb

@@ -0,0 +1,21 @@
+require 'fig/logging'
+require 'fig/packageerror'
+require 'fig/package/statement'
+
+module Fig; end
+class Fig::Package; end
+
+class Fig::Package::Override
+  include Fig::Package::Statement
+
+  attr_reader :package_name, :version_name
+
+  def initialize(package_name, version_name)
+    @package_name = package_name
+    @version_name = version_name
+  end
+
+  def unparse()
+    return ' override ' + @package_name + '/' + @version_name
+  end
+end

data/lib/fig/package/path.rb

@@ -0,0 +1,21 @@
+require 'fig/logging'
+require 'fig/packageerror'
+require 'fig/package/statement'
+
+module Fig; end
+class Fig::Package; end
+
+class Fig::Package::Path
+  include Fig::Package::Statement
+
+  attr_reader :name, :value
+
+  def initialize(name, value)
+    @name = name
+    @value = value
+  end
+
+  def unparse(indent)
+    "#{indent}append #{name}=#{value}"
+  end
+end

data/lib/fig/package/publish.rb

@@ -0,0 +1,21 @@
+require 'fig/logging'
+require 'fig/packageerror'
+require 'fig/package/statement'
+
+module Fig; end
+class Fig::Package; end
+
+class Fig::Package::Publish
+  include Fig::Package::Statement
+
+  attr_reader :local_name, :remote_name
+
+  def initialize(local_name, remote_name)
+    @local_name = local_name
+    @remote_name = remote_name
+  end
+
+  def unparse(indent)
+    "#{indent}publish #{@local_name}->#{@remote_name}"
+  end
+end

data/lib/fig/package/resource.rb

@@ -0,0 +1,24 @@
+require 'fig/logging'
+require 'fig/packageerror'
+require 'fig/package/statement'
+
+module Fig; end
+class Fig::Package; end
+
+class Fig::Package::Resource
+  include Fig::Package::Statement
+
+  attr_reader :url
+
+  def initialize(url)
+    @url = url
+  end
+
+  def urls
+    return [@url]
+  end
+
+  def unparse(indent)
+    "#{indent}resource #{url}"
+  end
+end

data/lib/fig/package/retrieve.rb

@@ -0,0 +1,21 @@
+require 'fig/logging'
+require 'fig/packageerror'
+require 'fig/package/statement'
+
+module Fig; end
+class Fig::Package; end
+
+class Fig::Package::Retrieve
+  include Fig::Package::Statement
+
+  attr_reader :var, :path
+
+  def initialize(var, path)
+    @var = var
+    @path = path
+  end
+
+  def unparse(indent)
+    "#{indent}retrieve #{var}->#{path}"
+  end
+end

data/lib/fig/package/set.rb

@@ -0,0 +1,21 @@
+require 'fig/logging'
+require 'fig/packageerror'
+require 'fig/package/statement'
+
+module Fig; end
+class Fig::Package; end
+
+class Fig::Package::Set
+  include Fig::Package::Statement
+
+  attr_reader :name, :value
+
+  def initialize(name, value)
+    @name = name
+    @value = value
+  end
+
+  def unparse(indent)
+    "#{indent}set #{name}=#{value}"
+  end
+end

data/lib/fig/package/statement.rb

@@ -0,0 +1,12 @@
+module Fig; end
+class Fig::Package; end
+
+module Fig::Package::Statement
+  def walk_statements(&block)
+    return
+  end
+
+  def urls
+    return []
+  end
+end

data/lib/fig/package.rb

@@ -0,0 +1,73 @@
+require 'fig/logging'
+require 'fig/packageerror'
+require 'fig/package/archive'
+require 'fig/package/configuration'
+require 'fig/package/resource'
+require 'fig/package/retrieve'
+
+module Fig; end
+
+class Fig::Package
+  attr_reader :package_name, :version_name, :directory, :statements
+  attr_accessor :backtrace
+
+  def initialize(package_name, version_name, directory, statements)
+    @package_name = package_name
+    @version_name = version_name
+    @directory = directory
+    @statements = statements
+    @backtrace = nil
+  end
+
+  def [](config_name)
+    @statements.each do |stmt|
+      return stmt if stmt.is_a?(Configuration) && stmt.name == config_name
+    end
+    Fig::Logging.fatal "Configuration not found: #{@package_name}/#{@version_name}:#{config_name}"
+    raise PackageError.new
+  end
+
+  def configs
+    @statements.select { |statement| statement.is_a?(Configuration) }
+  end
+
+  def retrieves
+    retrieves = {}
+    statements.each { |statement| retrieves[statement.var] = statement.path if statement.is_a?(Retrieve) }
+    retrieves
+  end
+
+  def archive_urls
+    @statements.select{|s| s.is_a?(Archive)}.map{|s|s.url}
+  end
+
+  def resource_urls
+    @statements.select{|s| s.is_a?(Resource)}.map{|s|s.url}
+  end
+
+  def walk_statements(&block)
+    @statements.each do |statement|
+      yield statement
+      statement.walk_statements &block
+    end
+  end
+
+  def unparse
+    @statements.map { |statement| statement.unparse('') }.join("\n")
+  end
+
+  def ==(other)
+    return false if other.nil?
+    @package_name == other.package_name && @version_name == other.version_name && @statements.to_yaml == other.statements.to_yaml
+  end
+
+  def to_s
+    @package_name + '/' + @version_name
+  end
+end
+
+def unparse_statements(indent, prefix, statements, suffix)
+  body = @statements.map { |statement| statement.unparse(indent+'  ') }.join("\n")
+  return ["\n#{indent}#{prefix}", body, "#{indent}#{suffix}"].join("\n")
+end
+

data/lib/fig/packageerror.rb

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

data/lib/fig/parser.rb

@@ -0,0 +1,37 @@
+require 'polyglot'
+require 'treetop'
+
+require 'fig/grammar'
+require 'fig/logging'
+require 'fig/packageerror'
+require 'fig/repository'
+require 'fig/urlaccesserror'
+
+module Fig
+  class Parser
+    def initialize(application_config)
+      @parser = FigParser.new
+      @application_config = application_config
+    end
+
+    def parse_package(package_name, version_name, directory, input)
+      input = input.gsub(/#.*$/, '')
+      result = @parser.parse(" #{input} ")
+      if result.nil?
+        Logging.fatal "#{directory}: #{@parser.failure_reason}"
+        raise PackageError.new("#{directory}: #{@parser.failure_reason}")
+      end
+      package = result.to_package(package_name, version_name, directory)
+      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
+      raise URLAccessError.new(bad_urls, package_name, version_name) if not bad_urls.empty?
+      return package
+    end
+  end
+end

data/lib/fig/repository.rb

@@ -0,0 +1,252 @@
+require 'fig/logging'
+require 'fig/notfounderror'
+require 'fig/package/archive'
+require 'fig/package/resource'
+require 'fig/parser'
+require 'fig/repositoryerror'
+require 'fig/urlaccesserror'
+
+module Fig
+  class Repository
+    def self.is_url?(url)
+      not (/ftp:\/\/|http:\/\/|file:\/\/|ssh:\/\// =~ url).nil?
+    end
+
+    def initialize(os, local_repository_dir, remote_repository_url, application_config, remote_repository_user=nil, update=false, update_if_missing=true)
+      @os = os
+      @local_repository_dir = local_repository_dir
+      @remote_repository_url = remote_repository_url
+      @remote_repository_user = remote_repository_user
+      @application_config = application_config
+      @update = update
+      @update_if_missing = update_if_missing
+      @parser = Parser.new(@application_config)
+
+      @overrides = {}
+      if File.exist?('fig.properties')
+        File.readlines('fig.properties').each do |line|
+          descriptor, path = line.strip.split('=')
+          @overrides[descriptor] = path
+        end
+      end
+    end
+
+    def clean(package_name, version_name)
+      dir = File.join(@local_repository_dir, package_name)
+      dir = File.join(dir, version_name) if version_name
+      FileUtils.rm_rf(dir)
+    end
+
+    def list_packages
+      results = []
+      if File.exist?(@local_repository_dir)
+        @os.list(@local_repository_dir).each do |package_name|
+          @os.list(File.join(@local_repository_dir, package_name)).each do |version_name|
+            results << "#{package_name}/#{version_name}"
+          end
+        end
+      end
+      results
+    end
+
+    def list_remote_packages
+      @os.download_list(@remote_repository_url)
+    end
+
+    def publish_package(package_statements, package_name, version_name, local_only)
+      temp_dir = temp_dir_for_package(package_name, version_name)
+      @os.clear_directory(temp_dir)
+      local_dir = local_dir_for_package(package_name, version_name)
+      @os.clear_directory(local_dir)
+      fig_file = File.join(temp_dir, '.fig')
+      content = bundle_resources(package_statements).map do |statement|
+        if statement.is_a?(Package::Publish)
+          nil
+        elsif statement.is_a?(Package::Archive) || statement.is_a?(Package::Resource)
+          if statement.is_a?(Package::Resource) && !Repository.is_url?(statement.url)
+            archive_name = statement.url
+            archive_remote = "#{remote_dir_for_package(package_name, version_name)}/#{statement.url}"
+          else
+            archive_name = statement.url.split('/').last
+            archive_remote = "#{remote_dir_for_package(package_name, version_name)}/#{archive_name}"
+          end
+          if Repository.is_url?(statement.url)
+            archive_local = File.join(temp_dir, archive_name)
+            @os.download(statement.url, archive_local)
+          else
+            archive_local = statement.url
+          end
+          @os.upload(archive_local, archive_remote, @remote_repository_user) unless local_only
+          @os.copy(archive_local, local_dir + '/' + archive_name)
+          if statement.is_a?(Package::Archive)
+            @os.unpack_archive(local_dir, archive_name)
+          end
+          statement.class.new(archive_name).unparse('')
+        else
+          statement.unparse('')
+        end
+      end.select {|s|not s.nil?}
+      @os.write(fig_file, content.join("\n").strip)
+      @os.upload(fig_file, remote_fig_file_for_package(package_name, version_name), @remote_repository_user) unless local_only
+      @os.copy(fig_file, local_fig_file_for_package(package_name, version_name))
+    end
+
+    def bundle_resources(package_statements)
+      resources = []
+      new_package_statements = package_statements.reject do |statement|
+        if statement.is_a?(Package::Resource) && !Repository.is_url?(statement.url)
+          resources << statement.url
+          true
+        else
+          false
+        end
+      end
+      if resources.size > 0
+        resources = expand_globs_from(resources)
+        file = 'resources.tar.gz'
+        @os.create_archive(file, resources)
+        new_package_statements.unshift(Package::Archive.new(file))
+        at_exit { File.delete(file) }
+      end
+      new_package_statements
+    end
+
+    def load_package(package_name, version_name)
+      Logging.debug "Considering #{package_name}/#{version_name}."
+      if @update || (@update_if_missing && package_missing?(package_name, version_name))
+        update_package(package_name, version_name)
+      end
+      read_local_package(package_name, version_name)
+    end
+
+    def updating?
+      return @update || @update_if_missing
+    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)
+      begin
+        if @os.download(remote_fig_file, local_fig_file)
+          install_package(package_name, version_name)
+        end
+      rescue NotFoundError
+        Logging.fatal "Package not found in remote repository: #{package_name}/#{version_name}"
+        delete_local_package(package_name, version_name)
+        raise RepositoryError.new
+      end
+    end
+
+    def read_local_package(package_name, version_name)
+      dir = local_dir_for_package(package_name, version_name)
+      read_package_from_directory(dir, package_name, version_name)
+    end
+
+    def read_remote_package(package_name, version_name)
+      url = remote_fig_file_for_package(package_name, version_name)
+      content = @os.read_url(url)
+      return @parser.parse_package(package_name, version_name, nil, content)
+    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 "Fig file not found for package: #{file}"
+        raise RepositoryError.new
+      end
+      read_package_from_file(file, package_name, version_name)
+    end
+
+    def read_package_from_file(file_name, package_name, version_name)
+      if not @os.exist?(file_name)
+        Logging.fatal "Package not found: #{package_name}/#{version_name}"
+        raise RepositoryError.new
+      end
+      content = @os.read(file_name)
+      return @parser.parse_package(package_name, version_name, File.dirname(file_name), content)
+    end
+
+    def local_dir_for_package(package_name, version_name)
+      descriptor = "#{package_name}/#{version_name}"
+      dir = @overrides[descriptor]
+      if dir
+        Logging.info "override: #{descriptor}=#{dir}"
+      else
+        dir = File.join(@local_repository_dir, package_name, version_name)
+      end
+      dir
+    end
+
+  private
+
+    def install_package(package_name, version_name)
+      begin
+        package = read_local_package(package_name, version_name)
+        temp_dir = temp_dir_for_package(package_name, version_name)
+        @os.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
+          end
+          @os.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
+          end
+          @os.download_resource(resource_url, File.join(temp_dir))
+        end
+        local_dir = local_dir_for_package(package_name, version_name)
+        @os.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)
+      rescue
+        Logging.fatal 'Install failed, cleaning up.'
+        delete_local_package(package_name, version_name)
+        raise RepositoryError.new
+      end
+    end
+
+    # 'resources' is an Array of filenames: ['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 delete_local_package(package_name, version_name)
+      FileUtils.rm_rf(local_dir_for_package(package_name, version_name))
+    end
+
+    def write_local_package(package_name, version_name, package)
+      file = local_fig_file_for_package(package_name, version_name)
+      @os.write(file, package.unparse)
+    end
+
+    def remote_fig_file_for_package(package_name, version_name)
+      "#{@remote_repository_url}/#{package_name}/#{version_name}/.fig"
+    end
+
+    def local_fig_file_for_package(package_name, version_name)
+      File.join(local_dir_for_package(package_name, version_name), '.fig')
+    end
+
+    def remote_dir_for_package(package_name, version_name)
+      "#{@remote_repository_url}/#{package_name}/#{version_name}"
+    end
+
+    def temp_dir_for_package(package_name, version_name)
+      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))
+    end
+  end
+end

data/lib/fig/repositoryerror.rb

@@ -0,0 +1,7 @@
+require 'fig/userinputerror'
+
+module Fig
+  # A problem within/related to a repository.
+  class RepositoryError < UserInputError
+  end
+end