fig 0.1.39 → 0.1.41

data/lib/fig.rb

@@ -0,0 +1,222 @@
+require 'rubygems'
+require 'net/ftp'
+require 'log4r'
+
+require 'fig/environment'
+require 'fig/figrc'
+require 'fig/logging'
+require 'fig/options'
+require 'fig/os'
+require 'fig/parser'
+require 'fig/repository'
+require 'fig/retriever'
+require 'fig/userinputerror'
+require 'fig/windows'
+
+module Fig
+  DEFAULT_FIG_FILE = 'package.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 run_fig(argv)
+    shell_command = nil
+    argv.each_with_index do |arg, i|
+      if arg == '--'
+        shell_command = argv[(i+1)..-1]
+        argv.slice!(i..-1)
+        break
+      end
+    end
+
+    options, argv, exit_value = parse_options(argv)
+    if not exit_value.nil?
+      return exit_value
+    end
+
+    Logging.initialize_pre_configuration(options[:log_level])
+
+    vars = {}
+    ENV.each {|key,value| vars[key]=value }
+
+    remote_url = nil
+    if options[:update] || options[:publish] || options[:update_if_missing] || options[:list_remote]
+      remote_url = ENV['FIG_REMOTE_URL']
+      if remote_url.nil?
+        $stderr.puts 'Please define the FIG_REMOTE_URL environment variable.'
+        return 1
+      end
+    end
+
+    configuration = FigRC.find(
+      options[:figrc],
+      remote_url,
+      options[:login],
+      options[:home],
+      options[:no_figrc]
+    )
+
+    Logging.initialize_post_configuration(options[:log_config] || configuration['log configuration'], options[:log_level])
+
+    remote_user = nil
+
+    os = OS.new(options[:login])
+    repos = Repository.new(
+      os,
+      File.expand_path(File.join(options[:home], 'repos')),
+      remote_url,
+      configuration,
+      remote_user,
+      options[:update],
+      options[:update_if_missing]
+    )
+    retriever = Retriever.new('.')
+  # Check to see if this is still happening with the new layers of abstraction.
+    at_exit { retriever.save }
+    env = Environment.new(os, repos, vars, retriever)
+
+    options[:modifiers].each do |modifier|
+      env.apply_config_statement(nil, modifier, nil)
+    end
+
+    input = nil
+    if options[:input] == :none
+      # ignore
+    elsif options[:input] == '-'
+      input = $stdin.read
+    elsif options[:input].nil?
+      input = os.read(DEFAULT_FIG_FILE) if os.exist?(DEFAULT_FIG_FILE)
+    else
+      if os.exist?(options[:input])
+        input = os.read(options[:input])
+      else
+        $stderr.puts %Q<File not found: "#{options[:input]}".>
+        return 1
+      end
+    end
+
+    options[:cleans].each do |descriptor|
+      package_name, version_name = descriptor.split('/')
+      repos.clean(package_name, version_name)
+    end
+    if options[:list]
+      repos.list_packages.sort.each do |item|
+        puts item
+      end
+      return 0
+    end
+
+    if options[:list_remote]
+      repos.list_remote_packages.sort.each do |item|
+        puts item
+      end
+      return 0
+    end
+
+    if not options[:list_configs].empty?
+      options[:list_configs].each do |descriptor|
+        package_name, version_name = descriptor.split('/')
+        repos.read_local_package(package_name, version_name).configs.each do |config|
+          puts config.name
+        end
+      end
+      return 0
+    end
+
+    if input
+      package = Parser.new.parse_package(nil, nil, '.', input)
+      direct_retrieves=[]
+      if options[:retrieve]
+        package.retrieves.each do |var, path|
+          if var =~ /^@([^\/]+)(.*)/
+            direct_retrieves << [$1, $2, path]
+          else
+            env.add_retrieve(var, path)
+          end
+        end
+      end
+      unless options[:publish] || options[:list] || options[:publish_local]
+        env.register_package(package)
+        env.apply_config(package, options[:config], nil)
+        direct_retrieves.each do |info|
+          env.direct_retrieve(info[0], info[1], info[2])
+        end
+      end
+    else
+      package = Package.new(nil, nil, '.', [])
+    end
+
+    if options[:publish] || options[:publish_local]
+      if !argv.empty?
+        $stderr.puts %Q<Unexpected arguments: #{argv.join(' ')}>
+        return 10
+      end
+      package_name, config_name, version_name = parse_descriptor(options[:publish] || options[:publish_local])
+      if package_name.nil? || version_name.nil?
+        $stderr.puts 'Please specify a package name and a version name.'
+        return 10
+      end
+      if not options[:modifiers].empty?
+        publish_statements = options[:resources] + options[:archives] + [Configuration.new('default', options[:modifiers])]
+        publish_statements << Publish.new('default','default')
+      elsif not package.statements.empty?
+        publish_statements = package.statements
+      else
+        $stderr.puts 'Nothing to publish.'
+        return 1
+      end
+      if options[:publish]
+        Logging.info "Checking status of #{package_name}/#{version_name}..."
+        if repos.list_remote_packages.include?("#{package_name}/#{version_name}")
+          Logging.info "#{package_name}/#{version_name} has already been published."
+          if not options[:force]
+            Logging.fatal 'Use the --force option if you really want to overwrite, or use --publish-local for testing.'
+            return 1
+          else
+            Logging.info 'Overwriting...'
+          end
+        end
+      end
+      Logging.info "Publishing #{package_name}/#{version_name}."
+      repos.publish_package(publish_statements, package_name, version_name, options[:publish_local])
+    elsif options[:echo]
+      puts env[options[:echo]]
+    elsif shell_command
+      argv.shift
+      env.execute_shell(shell_command) { |cmd| os.shell_exec cmd }
+    elsif argv[0]
+      package_name, config_name, version_name = parse_descriptor(argv.shift)
+      env.include_config(package, package_name, config_name, version_name, {}, nil)
+      env.execute_config(package, package_name, config_name, nil, argv) { |cmd| os.shell_exec cmd }
+    elsif input
+      env.execute_config(package, nil, options[:config], nil, argv) { |cmd| os.shell_exec cmd }
+    elsif !repos.updating?
+      $stderr.puts USAGE
+      $stderr.puts %q<Run "fig --help" for a full list of commands.>
+    end
+
+    return 0
+  end
+
+  def run_with_exception_handling(argv)
+    begin
+      return_code = run_fig(argv)
+      return return_code
+    rescue URLAccessError => exception
+      $stderr.puts "Access to #{exception.url} not allowed."
+      return 1
+    rescue UserInputError => exception
+      # If there's no message, we assume that the cause has already been logged.
+      if not exception.message.nil?
+        $stderr.puts exception.to_s
+      end
+
+      return 1
+    end
+  end
+end

data/lib/fig/applicationconfiguration.rb

@@ -0,0 +1,52 @@
+
+module Fig
+  class ApplicationConfiguration
+    def initialize(remote_repository_url)
+      @data = []
+      @remote_repository_url = remote_repository_url
+      clear_cached_data
+    end
+
+    def ensure_url_whitelist_initialized()
+      return if not @whitelist.nil?
+      whitelist = self['url_whitelist']
+      if whitelist.nil?
+        @whitelist = []
+      else
+        @whitelist = [@remote_repository_url, whitelist].flatten
+      end
+    end
+
+    def [](key)
+      @data.each do |dataset|
+        if dataset.has_key?(key)
+          return dataset[key]
+        end
+      end
+      return nil
+    end
+
+    def push_dataset(dataset)
+      @data.push(dataset)
+    end
+
+    def unshift_dataset(dataset)
+      @data.unshift(dataset)
+    end
+
+    # after push_dataset or unshift_dataset, call clear_cached, and lazy initialize as far as the list of things to exclude
+
+    def clear_cached_data()
+      @whitelist = nil
+    end
+
+    def url_access_allowed?(url)
+      ensure_url_whitelist_initialized
+      return true if @whitelist.empty?
+      @whitelist.each do |allowed_url|
+        return true if url.match(/\A#{Regexp.quote(allowed_url)}\b/)
+      end
+      return false
+    end
+  end
+end

data/lib/fig/backtrace.rb

@@ -5,7 +5,7 @@ class Backtrace
     @parent = parent
     @package_name = package_name
     @version_name = version_name
-    @config_name = config_name || "default"
+    @config_name = config_name || 'default'
     @overrides = {}
   end
 
@@ -13,15 +13,15 @@ class Backtrace
     if @parent
       @parent.collect(stack)
     end
-    elem = ""
+    elem = ''
     if @package_name
       elem = @package_name
     end
     if @version_name
-      elem += "/" + @version_name
+      elem += '/' + @version_name
     end
     if @config_name
-      elem += ":" + @config_name
+      elem += ':' + @config_name
     end
     stack << elem
   end
@@ -41,8 +41,8 @@ class Backtrace
     collect(stack)
     i=0
     for elem in stack
-      indent=""
-      i.times { indent += "  " }
+      indent=''
+      i.times { indent += '  ' }
       out.puts indent+elem
       i += 1
     end

data/lib/fig/configfileerror.rb

@@ -0,0 +1,15 @@
+require 'fig/userinputerror'
+
+module Fig
+  # Could not determine some kind of information from a configuration file,
+  # whether .figrc, log4r, package.fig, etc.
+  class ConfigFileError < UserInputError
+    def initialize(message, file)
+      super(message)
+
+      @file = file
+
+      return
+    end
+  end
+end

data/lib/fig/environment.rb

@@ -1,11 +1,14 @@
+require 'stringio'
+
 require 'fig/backtrace'
+require 'fig/logging'
+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
+  # 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"
+    DEFAULT_VERSION_NAME = 'current'
 
     def initialize(os, repository, variables, retriever)
       @os = os
@@ -22,8 +25,8 @@ module Fig
       @variables[name]
     end
 
-    # Indicates that the values from a particular envrionment variable path should
-    # be copied to a local directory 
+    # Indicates that the values from a particular envrionment variable path
+
     def add_retrieve(name, path)
       @retrieve_vars[name] = path
     end
@@ -31,8 +34,8 @@ module Fig
     def register_package(package)
       name = package.package_name
       if @packages[name]
-        $stderr.puts "Package already exists with name: #{name}"
-        exit 10
+        Fig::Logging.fatal %Q<There is already a package with the name "#{name}".>
+        raise RepositoryError.new
       end
       @packages[name] = package
     end
@@ -41,7 +44,7 @@ module Fig
       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)
+      new_backtrace = backtrace
 
       config = package[config_name]
       config.statements.each { |stmt| apply_config_statement(package, stmt, new_backtrace) }
@@ -57,11 +60,11 @@ module Fig
     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
+      commands = package[config_name || 'default'].commands
       with_environment do
-        # todo nil check
+        # TODO nil check
         commands.each do |command|
-          result = yield expand_arg("#{command.command} #{args.join(' ')}").gsub("@",package.directory).split(" ")
+          result = yield expand_arg("#{command.command} #{args.join(' ')}").gsub('@',package.directory).split(' ')
         end
       end
       result
@@ -83,7 +86,7 @@ module Fig
     end
 
     def include_config(base_package, package_name, config_name, version_name, overrides, backtrace)
-      # Check to see if this include has been overridden
+      # Check to see if this include has been overridden.
       if backtrace
         override = backtrace.get_override(package_name || base_package.package_name)
         if override
@@ -95,7 +98,7 @@ module Fig
         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)
+      apply_config(package, config_name || 'default', new_backtrace)
     end
 
     def direct_retrieve(package_name, source_path, target_path)
@@ -104,7 +107,7 @@ module Fig
       FileUtils.cp_r(File.join(package.directory, source_path, '.'), target_path)
     end
 
-    private 
+    private
 
     def set_variable(base_package, name, value)
       @variables[name] = expand_value(base_package, name, value)
@@ -146,10 +149,14 @@ module Fig
         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
+        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
@@ -159,18 +166,31 @@ module Fig
       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.
+        # 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)
+          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))
+          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.with_package_config(
+          base_package.package_name, base_package.version_name
+        ) do
           @retriever.retrieve(file, target)
         end
         file = target
@@ -182,8 +202,8 @@ module Fig
       arg.gsub(/\@([a-zA-Z0-9\-\.]+)/) do |match|
         package = @packages[$1]
         if package.nil?
-          $stderr.puts "Package not found: #{$1}"
-          exit 10
+          Fig::Logging.fatal "Package not found: #{$1}"
+          raise RepositoryError.new
         end
         package.directory
       end