fig18 0.1.45-i386-mingw32

data/lib/fig/environment.rb

@@ -0,0 +1,216 @@
+require 'stringio'
+
+require 'fig/backtrace'
+require 'fig/logging'
+require 'fig/package/command'
+require 'fig/package/include'
+require 'fig/package/path'
+require 'fig/package/set'
+require 'fig/repositoryerror'
+
+module Fig
+  # This class manages the program's state, including the value of all
+  # environment variables, and which packages have already been applied.
+  class Environment
+    DEFAULT_VERSION_NAME = 'current'
+
+    def initialize(os, repository, variables, retriever)
+      @os = os
+      @repository = repository
+      @variables = variables
+      @retrieve_vars = {}
+      @packages = {}
+      @applied_configs = {}
+      @retriever = retriever
+    end
+
+    # Returns the value of an envirionment variable
+    def [](name)
+      @variables[name]
+    end
+
+    # Indicates that the values from a particular envrionment variable path
+
+    def add_retrieve(name, path)
+      @retrieve_vars[name] = path
+    end
+
+    def register_package(package)
+      name = package.package_name
+      if @packages[name]
+        Fig::Logging.fatal %Q<There is already a package with the name "#{name}".>
+        raise RepositoryError.new
+      end
+      @packages[name] = package
+    end
+
+    def apply_config(package, config_name, backtrace)
+      if (@applied_configs[package.package_name] ||= []).member?(config_name)
+        return
+      end
+      new_backtrace = backtrace
+
+      config = package[config_name]
+      config.statements.each { |stmt| apply_config_statement(package, stmt, new_backtrace) }
+      @applied_configs[package.package_name] << config_name
+    end
+
+    def execute_shell(command)
+      with_environment do
+        yield command.map{|arg| expand_arg(arg)}
+      end
+    end
+
+    def execute_config(base_package, package_name, config_name, version_name, args)
+      package = lookup_package(package_name || base_package.package_name, version_name, Backtrace.new(nil, package_name, version_name, config_name))
+      result = nil
+      commands = package[config_name || 'default'].commands
+      with_environment do
+        # TODO nil check
+        commands.each do |command|
+          result = yield expand_arg("#{command.command} #{args.join(' ')}").gsub('@',package.directory).split(' ')
+        end
+      end
+      result
+    end
+
+    def apply_config_statement(base_package, statement, backtrace)
+      case statement
+      when Package::Path
+        append_variable(base_package, statement.name, statement.value)
+      when Package::Set
+        set_variable(base_package, statement.name, statement.value)
+      when Package::Include
+        include_config(base_package, statement.package_name, statement.config_name, statement.version_name, statement.overrides, backtrace)
+      when Package::Command
+        # ignore
+      else
+        fail "Unexpected statement: #{statement}"
+      end
+    end
+
+    def include_config(base_package, package_name, config_name, version_name, overrides, backtrace)
+      # Check to see if this include has been overridden.
+      if backtrace
+        override = backtrace.get_override(package_name || base_package.package_name)
+        if override
+          version_name = override
+        end
+      end
+      new_backtrace = Backtrace.new(backtrace, package_name, version_name, config_name)
+      overrides.each do |override|
+        new_backtrace.add_override(override.package_name, override.version_name)
+      end
+      package = lookup_package(package_name || base_package.package_name, version_name, new_backtrace)
+      apply_config(package, config_name || 'default', new_backtrace)
+    end
+
+    def direct_retrieve(package_name, source_path, target_path)
+      package = lookup_package(package_name, nil, nil)
+      FileUtils.mkdir_p(target_path)
+      FileUtils.cp_r(File.join(package.directory, source_path, '.'), target_path)
+    end
+
+    private
+
+    def set_variable(base_package, name, value)
+      @variables[name] = expand_value(base_package, name, value)
+    end
+
+    def append_variable(base_package, name, value)
+      value = expand_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
+    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
+    end
+
+    def lookup_package(package_name, version_name, backtrace)
+      package = @packages[package_name]
+      if package.nil?
+        package = @repository.load_package(package_name, version_name || DEFAULT_VERSION_NAME)
+        package.backtrace = backtrace
+        @packages[package_name] = package
+      elsif version_name && version_name != package.version_name
+        string_handle = StringIO.new
+        backtrace.dump(string_handle) if backtrace
+        package.backtrace.dump(string_handle) if package.backtrace
+        stacktrace = string_handle.to_s
+        Fig::Logging.fatal                      \
+            "Version mismatch: #{package_name}" \
+          + stacktrace.empty? ? '' : "\n#{stacktrace}"
+        raise RepositoryError.new
+      end
+      package
+    end
+
+    # Replace @ symbol with the package's directory
+    def expand_value(base_package, name, value)
+      return value unless base_package && base_package.package_name
+      file = value.gsub(/\@/, base_package.directory)
+      if @retrieve_vars.member?(name)
+        # A '//' in the source file's path tells us to preserve path
+        # information after the '//' when doing a retrieve.
+        if file.split('//').size > 1
+          preserved_path = file.split('//').last
+          target = File.join(
+            @retrieve_vars[name].gsub(
+              /\[package\]/,
+              base_package.package_name
+            ),
+            preserved_path
+          )
+        else
+          target = File.join(
+            @retrieve_vars[name].gsub(
+              /\[package\]/,
+              base_package.package_name
+            )
+          )
+          if not File.directory?(file)
+            target = File.join(target, File.basename(file))
+          end
+        end
+        @retriever.with_package_config(
+          base_package.package_name, base_package.version_name
+        ) do
+          @retriever.retrieve(file, target)
+        end
+        file = target
+      end
+      file
+    end
+
+    def expand_arg(arg)
+      arg.gsub(/\@([a-zA-Z0-9\-\.]+)/) do |match|
+        package = @packages[$1]
+        if package.nil?
+          Fig::Logging.fatal "Package not found: #{$1}"
+          raise RepositoryError.new
+        end
+        package.directory
+      end
+    end
+  end
+end

data/lib/fig/figrc.rb

@@ -0,0 +1,105 @@
+require 'json'
+
+require 'fig/applicationconfiguration'
+require 'fig/configfileerror'
+require 'fig/os'
+
+REPOSITORY_CONFIGURATION = '_meta/figrc'
+
+module Fig
+  class FigRC
+    def self.find(
+      override_path, repository_url, login, fig_home, disable_figrc = false
+    )
+      configuration = ApplicationConfiguration.new(repository_url)
+
+      handle_override_configuration(configuration, override_path)
+      handle_figrc(configuration) if not disable_figrc
+      handle_repository_configuration(
+        configuration, repository_url, login, fig_home
+      )
+
+      return configuration
+    end
+
+    private
+
+    def self.handle_override_configuration(configuration, override_path)
+      begin
+        if not override_path.nil?
+          configuration.push_dataset(
+            JSON.parse(File::open(override_path).read)
+          )
+        end
+      rescue JSON::ParserError => exception
+        translate_parse_error(exception, override_path)
+      end
+
+      return
+    end
+
+    def self.handle_figrc(configuration)
+      user_figrc_path = File.expand_path('~/.figrc')
+      return if not File.exists? user_figrc_path
+
+      begin
+        configuration.push_dataset(
+          JSON.parse(File::open(user_figrc_path).read)
+        )
+      rescue JSON::ParserError => exception
+        translate_parse_error(exception, user_figrc_path)
+      end
+
+      return
+    end
+
+    def self.handle_repository_configuration(
+      configuration, repository_url, login, fig_home
+    )
+      return if repository_url.nil?
+
+      figrc_url = "#{repository_url}/#{REPOSITORY_CONFIGURATION}"
+      repo_figrc_path =
+        File.expand_path(File.join(fig_home, REPOSITORY_CONFIGURATION))
+
+      os = OS.new(login)
+
+      repo_config_exists = nil
+      begin
+        os.download( figrc_url, repo_figrc_path )
+        repo_config_exists = true
+      rescue NotFoundError => e
+        repo_config_exists = false
+      end
+
+      return configuration if not repo_config_exists
+
+      begin
+        configuration.push_dataset(
+          JSON.parse(File.open(repo_figrc_path).read)
+        )
+      rescue JSON::ParserError => exception
+        translate_parse_error(exception, figrc_url)
+      end
+
+      return
+    end
+
+    def self.translate_parse_error(json_parse_error, config_file_path)
+      message = json_parse_error.message
+      message.chomp!
+
+      # JSON::ParserError tends to include final newline inside of single
+      # quotes, which makes error messages ugly.
+      message.sub!(/ \n+ ' \z /xm, %q<'>)
+
+      # Also, there's a useless source code line number in the message.
+      message.sub!(/ \A \d+ : \s+ /xm, %q<>)
+
+      raise ConfigFileError.new(
+        "Parse issue with #{config_file_path}: #{message}",
+        config_file_path
+      )
+    end
+  end
+end

data/lib/fig/grammar.treetop

@@ -0,0 +1,197 @@
+require 'fig/package'
+require 'fig/package/archive'
+require 'fig/package/command'
+require 'fig/package/configuration'
+require 'fig/package/include'
+require 'fig/package/install'
+require 'fig/package/override'
+require 'fig/package/path'
+require 'fig/package/publish'
+require 'fig/package/resource'
+require 'fig/package/retrieve'
+require 'fig/package/set'
+
+module Fig
+
+grammar Fig
+  rule package
+    ws statements:(package_statement*) {
+      def to_package(package_name, version_name, directory)
+        Package.new(
+          package_name,
+          version_name,
+          directory,
+          statements.elements.map { |statement| statement.to_package_statement }
+        )
+      end
+    }
+  end
+
+  rule package_statement
+    archive / resource / retrieve / config
+  end
+
+  rule archive
+    "archive" ws url {
+      def to_package_statement
+        Package::Archive.new(url.value.text_value)
+      end
+    }
+  end
+
+  rule resource
+    "resource" ws url {
+      def to_package_statement
+        Package::Resource.new(url.value.text_value)
+      end
+    }
+  end
+
+  rule retrieve
+    "retrieve" ws var:retrieve_variable "->" path:retrieve_path ws {
+      def to_package_statement
+        Package::Retrieve.new(var.text_value, path.text_value)
+      end
+    }
+  end
+
+  rule retrieve_variable
+    [@a-zA-Z0-9/._]+
+  end
+
+  rule retrieve_path
+    [a-zA-Z0-9_/.\[\]-]+
+  end
+
+  rule install
+    "install" ws statements:config_statement* "end" ws {
+      def to_package_statement
+        Package::Install.new(statements.elements.map { |statement| statement.to_config_statement })
+      end
+    }
+  end
+
+  rule config
+    "config" ws config_name ws statements:config_statement* "end" ws {
+      def to_package_statement
+        Package::Configuration.new(config_name.text_value, statements.elements.map { |statement| statement.to_config_statement })
+      end
+    }
+  end
+
+  rule config_statement
+    include / command / path / set
+  end
+
+  rule include
+    "include" ws descriptor overrides:(override*) {
+      def to_config_statement
+        package = descriptor.respond_to?(:package) ? descriptor.package.text_value : nil
+        config = descriptor.get_config
+        version = descriptor.get_version
+        Package::Include.new(package, config, version, overrides.elements.map{ |e| e.to_override })
+      end
+    }
+  end
+
+  rule override
+    "override" ws package_name "/" version_name ws {
+      def to_override
+        return Package::Override.new(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::Path.new(name.text_value, value.text_value)
+      end
+    }
+  end
+
+  rule path_name
+    [a-zA-Z0-9_]+
+  end
+
+  rule path_value
+    [@a-zA-Z0-9/\\._-]+
+  end
+
+  rule set
+    "set" ws name:set_name "=" value:set_value ws {
+      def to_config_statement
+        Package::Set.new(name.text_value, value.text_value)
+      end
+    }
+  end
+
+  rule set_name
+    [a-zA-Z0-9_]+
+  end
+
+  rule set_value
+    [@a-zA-Z0-9/\\._-]+
+  end
+
+  rule command
+    "command" ws string {
+      def to_config_statement
+        Package::Command.new(string.value.text_value)
+      end
+    }
+  end
+
+  rule string
+    '"' value:(!'"' . )* '"' ws
+  end
+
+  rule descriptor
+    ((package:package_name ("/" version:version_name)? (":" config:config_name)? ws) /
+    (":" config:config_name ws)) {
+      def get_version
+        elements.each do |element|
+          if element.respond_to?(:version)
+            return element.version.text_value
+          end
+        end
+        nil
+      end
+      def get_config
+        return self.config.text_value if self.respond_to?(:config)
+        elements.each do |element|
+          if element.respond_to?(:config)
+            return element.config.text_value
+          end
+        end
+        nil
+      end
+    }
+  end
+
+  rule package_name
+    [a-zA-Z0-9.-]+
+  end
+
+  rule version_name
+    [a-zA-Z0-9_.-]+
+  end
+
+  rule config_name
+    [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
+
+  rule ws
+    [ \n\r\t]+
+  end
+end
+
+end

data/lib/fig/log4rconfigerror.rb

@@ -0,0 +1,14 @@
+require 'fig/userinputerror'
+
+module Fig
+  class Log4rConfigError < UserInputError
+    def initialize(config_file, original_exception)
+      super(
+        %Q<Problem with #{config_file}: #{original_exception.message}>
+      )
+
+      @config_file = config_file
+      @original_exception = original_exception
+    end
+  end
+end

data/lib/fig/logging.rb

@@ -0,0 +1,131 @@
+require 'log4r'
+require 'log4r/configurator'
+require 'log4r/yamlconfigurator'
+
+require 'fig/configfileerror'
+require 'fig/log4rconfigerror'
+
+module Fig; end
+
+module Fig::Logging
+  if not Log4r::Logger['initial']
+    @@logger = Log4r::Logger.new('initial')
+  end
+
+  STRING_TO_LEVEL_MAPPING = {
+    'off'   => Log4r::OFF,
+    'fatal' => Log4r::FATAL,
+    'error' => Log4r::ERROR,
+    'warn'  => Log4r::WARN,
+    'info'  => Log4r::INFO,
+    'debug' => Log4r::DEBUG,
+    'all'   => Log4r::ALL
+  }
+
+  def self.initialize_pre_configuration(log_level = nil)
+    log_level ||= 'info'
+
+    assign_log_level(@@logger, log_level)
+    setup_default_outputter(@@logger)
+  end
+
+  def self.initialize_post_configuration(
+    config_file = nil,
+    log_level = nil,
+    suppress_default_configuration = false
+  )
+    if config_file
+      begin
+        case config_file
+          when / [.] xml \z /x
+            Log4r::Configurator.load_xml_file(config_file)
+          when / [.] ya?ml \z /x
+            Log4r::YamlConfigurator.load_yaml_file(config_file)
+          else
+            raise ConfigFileError, %Q<Don't know what format #{config_file} is in.>, config_file
+        end
+
+        if Log4r::Logger['fig'].nil?
+          $stderr.puts %q<A value was provided for --log-config but no "fig" logger was defined.>
+        end
+      rescue Log4r::ConfigError, ArgumentError => exception
+        raise Log4rConfigError.new(config_file, exception)
+      end
+    end
+
+    if Log4r::Logger['fig'].nil?
+      @@logger = Log4r::Logger.new('fig')
+    else
+      @@logger = Log4r::Logger['fig']
+    end
+
+    if not config_file and not suppress_default_configuration
+      assign_log_level(@@logger, 'info')
+      setup_default_outputter(@@logger)
+    end
+
+    assign_log_level(@@logger, log_level)
+
+    return
+  end
+
+  def self.fatal(data = nil, propagated = nil)
+    @@logger.fatal data, propagated
+  end
+
+  def self.fatal?()
+    return @@logger.fatal?
+  end
+
+  def self.error(data = nil, propagated = nil)
+    @@logger.error data, propagated
+  end
+
+  def self.error?()
+    return @@logger.error?
+  end
+
+  def self.warn(data = nil, propagated = nil)
+    @@logger.warn data, propagated
+  end
+
+  def self.warn?()
+    return @@logger.warn?
+  end
+
+  def self.info(data = nil, propagated = nil)
+    @@logger.info data, propagated
+  end
+
+  def self.info?()
+    return @@logger.info?
+  end
+
+  def self.debug(data = nil, propagated = nil)
+    @@logger.debug data, propagated
+  end
+
+  def self.debug?()
+    return @@logger.debug?
+  end
+
+  private
+
+  def self.assign_log_level(logger, string_level)
+    return if string_level.nil?
+
+    level = STRING_TO_LEVEL_MAPPING[string_level.downcase]
+    logger.level = level
+    logger.outputters.each { | outputter | outputter.level = level }
+
+    return
+  end
+
+  def self.setup_default_outputter(logger)
+    outputter = Log4r::Outputter.stdout
+    logger.add outputter
+    outputter.formatter = Log4r::PatternFormatter.new :pattern => '%M'
+
+    return
+  end
+end

data/lib/fig/networkerror.rb

@@ -0,0 +1,7 @@
+require 'fig/userinputerror'
+
+module Fig
+  # A problem with file transfer over the network.
+  class NetworkError < UserInputError
+  end
+end

data/lib/fig/notfounderror.rb

@@ -0,0 +1,4 @@
+module Fig
+  class NotFoundError < StandardError
+  end
+end