fig 0.1.38-java

data/lib/fig/backtrace.rb

@@ -0,0 +1,50 @@
+class Backtrace
+  attr_reader :overrides
+
+  def initialize(parent, package_name, version_name, config_name)
+    @parent = parent
+    @package_name = package_name
+    @version_name = version_name
+    @config_name = config_name || "default"
+    @overrides = {}
+  end
+
+  def collect(stack)
+    if @parent
+      @parent.collect(stack)
+    end
+    elem = ""
+    if @package_name
+      elem = @package_name
+    end
+    if @version_name
+      elem += "/" + @version_name
+    end
+    if @config_name
+      elem += ":" + @config_name
+    end
+    stack << elem
+  end
+
+  def add_override(package_name, version_name)
+    # Don't replace an existing override on the stack
+    return if get_override(package_name)
+    @overrides[package_name] = version_name
+  end
+
+  def get_override(package_name)
+    return @overrides[package_name] || (@parent ? @parent.get_override(package_name) : nil)
+  end
+
+  def dump(out)
+    stack = []
+    collect(stack)
+    i=0
+    for elem in stack
+      indent=""
+      i.times { indent += "  " }
+      out.puts indent+elem
+      i += 1
+    end
+   end
+end

data/lib/fig/environment.rb

@@ -0,0 +1,192 @@
+require 'fig/backtrace'
+
+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 should
+    # be copied to a local directory 
+    def add_retrieve(name, path)
+      @retrieve_vars[name] = path
+    end
+
+    def register_package(package)
+      name = package.package_name
+      if @packages[name]
+        $stderr.puts "Package already exists with name: #{name}"
+        exit 10
+      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 #Backtrace.new(backtrace, package.package_name, package.version_name, config_name)
+
+      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 Path
+        append_variable(base_package, statement.name, statement.value)
+      when Set
+        set_variable(base_package, statement.name, statement.value)
+      when Include
+        include_config(base_package, statement.package_name, statement.config_name, statement.version_name, statement.overrides, backtrace)
+      when 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
+        $stderr.puts "Version mismatch: #{package_name}" 
+        backtrace.dump($stderr) if backtrace
+        package.backtrace.dump($stderr) if package.backtrace
+        exit 10
+      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_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?
+          $stderr.puts "Package not found: #{$1}"
+          exit 10
+        end
+        package.directory
+      end
+    end
+  end
+end

data/lib/fig/grammar.treetop

@@ -0,0 +1,157 @@
+require 'fig/package'
+
+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
+        Archive.new(url.value.text_value)
+      end
+    }
+  end
+
+  rule resource
+    "resource" ws url {
+      def to_package_statement
+        Resource.new(url.value.text_value)
+      end
+    }
+  end
+
+  rule retrieve
+    "retrieve" ws var:[@a-zA-Z0-9/\._]+ "->" path:[a-zA-Z0-9_/\.\-\[\]]+ ws {
+      def to_package_statement
+        Retrieve.new(var.text_value, path.text_value)
+      end
+    }
+  end
+
+  rule install
+    "install" ws statements:config_statement* "end" ws {
+      def to_package_statement
+        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
+        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
+        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 Override.new(package_name.text_value, version_name.text_value)
+      end
+    }
+  end
+
+  rule path
+    ("append" / "path" / "add") ws name:[a-zA-Z0-9_]+ "=" value:[@a-zA-Z0-9/\-\\._]+ ws {
+      def to_config_statement
+        Path.new(name.text_value, value.text_value)
+      end
+    }
+  end
+
+  rule set
+    "set" ws name:[a-zA-Z0-9_]+ "=" value:[@a-zA-Z0-9/\-\\._]+ ws {
+      def to_config_statement
+        Set.new(name.text_value, value.text_value)
+      end
+    }
+  end
+
+  rule command
+    "command" ws string {
+      def to_config_statement
+        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/options.rb

@@ -0,0 +1,106 @@
+require 'optparse'
+require 'fig/package'
+
+module Fig
+  def parse_descriptor(descriptor)
+    # todo should use treetop for these:
+    package_name = descriptor =~ /^([^:\/]+)/ ? $1 : nil
+    config_name = descriptor =~ /:([^:\/]+)/ ? $1 : nil
+    version_name = descriptor =~ /\/([^:\/]+)/ ? $1 : nil  
+    return package_name, config_name, version_name
+  end
+
+  def parse_options(argv)
+    options = {}
+
+    parser = OptionParser.new do |opts|
+      opts.banner = "Usage: fig [--debug] [--update] [--config <config>] [--get <var> | --list | <package> | - <command>]"
+
+      opts.on('-?', '-h','--help','display this help text') do
+        puts opts
+	exit 1
+      end 
+
+      options[:debug] = false
+      opts.on('-d', '--debug', 'print debug info') { options[:debug] = true }
+
+      options[:update] = false
+      opts.on('-u', '--update', 'check remote repository for updates') { options[:update] = true; options[:retrieve] = true }
+
+      options[:update_if_missing] = false
+      opts.on('-m', '--update-if-missing', 'check for updates only if package is missing locally') { options[:update_if_missing] = true; options[:retrieve] = true }
+
+      options[:config] = "default"
+      opts.on('-c', '--config CFG', 'name of configuration to apply') { |config| options[:config] = config }
+
+      options[:echo] = nil
+      opts.on('-g', '--get VAR', 'print value of environment variable') { |echo| options[:echo] = echo }
+
+      options[:publish] = nil
+      opts.on('--publish PKG', 'install package in local and remote repositories') { |publish| options[:publish] = publish }
+
+      options[:publish_local] = nil
+      opts.on('--publish-local PKG', 'install package in local repositorie only') { |publish_local| options[:publish_local] = publish_local }
+
+      options[:force] = nil
+      opts.on('--force', 'force overwriting of an existing remote package version') { |force| options[:force] = force }
+
+      options[:resources] =[]
+      opts.on('--resource PATH', 'resource to include in package (when using --publish)') do |path| 
+        options[:resources] << Resource.new(path) 
+      end
+
+      options[:archives] =[]
+      opts.on('--archive PATH', 'archive to include in package (when using --publish)') do |path| 
+        options[:archives] << Archive.new(path)
+      end
+
+      options[:login] = false
+      opts.on('-l', '--login', 'login into the FTP server as a non-anonymous user') { options[:login] = true }
+
+      options[:list] = false
+      opts.on('--list', 'list packages in local repository') { options[:list] = true }
+
+      options[:list_remote] = false
+      opts.on('--list-remote', 'list packages in remote repository') { options[:list_remote] = true }
+
+      options[:list_configs] = []
+      opts.on('--list-configs PKG', 'list configurations in package') { |descriptor| options[:list_configs] << descriptor }
+
+      options[:cleans] = []
+      opts.on('--clean PKG', 'remove  package from local repository') { |descriptor| options[:cleans] <<  descriptor }
+
+      options[:modifiers] = []
+
+      opts.on('-i', '--include PKG', 'include package in environment') do |descriptor| 
+        package_name, config_name, version_name = parse_descriptor(descriptor)
+        options[:modifiers] << Include.new(package_name, config_name, version_name, {}) 
+      end
+
+#      opts.on('-o', '--override PKG', 'override version of included package') do |descriptor| 
+#        package_name, config_name, version_name = parse_descriptor(descriptor)
+#        options[:modifiers] << Include.new(package_name, config_name, version_name, {}) 
+#      end
+
+      opts.on('-s', '--set VAR=VAL', 'set environment variable') do |var_val| 
+        var, val = var_val.split('=')
+        options[:modifiers] << Set.new(var, val) 
+      end
+
+      opts.on('-p', '--append VAR=VAL', 'append environment variable') do |var_val| 
+        var, val = var_val.split('=')
+        options[:modifiers] << Path.new(var, val)
+      end
+
+      options[:input] = nil
+      opts.on('--file FILE', 'fig file to read (use - for stdin)') { |path| options[:input] = path }
+      opts.on('--no-file', 'ignore package.fig file in current directory') { |path| options[:input] = :none }
+
+      options[:home] = ENV['FIG_HOME'] || File.expand_path("~/.fighome")
+    end
+
+    parser.parse!(argv)
+
+    return options, argv
+  end
+end