fig18 0.1.45-i386-mingw32

data/lib/fig/retriever.rb

@@ -0,0 +1,116 @@
+require 'ostruct'
+require 'set'
+
+require 'fig/logging'
+
+# This class copies files from the project directories in ~/.fighome to the
+# user's working directory. It keeps track of which files have already been copied, and which
+# package/versions they came from, and deletes files as necessary to ensure that
+# we never have files from two different versions of the same package in the user's
+# working directory.
+class Retriever
+  def initialize(base_dir)
+    @base_dir = base_dir
+    @configs = {}
+    @fig_dir = File.join(@base_dir, '.fig')
+
+    file = File.join(@fig_dir, 'retrieve')
+    if File.exist?(file)
+      load(file)
+    end
+  end
+
+  def with_package_config(name, version)
+    if name and version
+      @config = @configs[name]
+      if @config && @config.version != version
+        @config.files.each do |relpath|
+          Fig::Logging.info "- [#{@config.name}/#{@config.version}] #{relpath}"
+          FileUtils.rm_f(File.join(@base_dir, relpath))
+        end
+        @config = nil
+      end
+      if not @config
+        @config = new_package_config(name, version)
+        @configs[name] = @config
+      end
+    else
+      @config = nil
+    end
+    yield
+  end
+
+  def retrieve(source, relpath)
+    copy(source, relpath)
+  end
+
+  def save
+    FileUtils.mkdir_p(@fig_dir)
+    File.open(File.join(@fig_dir, 'retrieve'), 'w') do |f|
+      @configs.each do |name,config|
+        config.files.each do |target|
+          f << target << '=' << config.name << '/' << config.version << "\n"
+        end
+      end
+    end
+  end
+
+private
+
+  def load(file)
+    File.open(file).each_line do |line|
+      line = line.strip()
+      if line =~ /^(.+)=(.+)\/(.+)$/
+        target = $1
+        config_name = $2
+        config_version = $3
+        config = @configs[config_name]
+        if config
+          if config.version != config_version
+            raise 'version mismatch in .figretrieve'
+          end
+        else
+          config = new_package_config(config_name, config_version)
+          @configs[config_name] = config
+        end
+        config.files << target
+      else
+        raise "parse error in #{file}: #{line}"
+      end
+    end
+  end
+
+  def new_package_config(name, version)
+    config = OpenStruct.new
+    config.name = name
+    config.version = version
+    config.files = Set.new()
+    return config
+  end
+
+  def copy(source, relpath)
+    target = File.join(@base_dir, relpath)
+    if File.directory?(source)
+      FileUtils.mkdir_p(target)
+      Dir.foreach(source) do |child|
+        if child != '.' and child != '..'
+          source_file = File.join(source, child)
+          target_file = File.join(relpath, child)
+          Fig::Logging.debug "Copying #{source_file} to #{target_file}."
+          copy(source_file, target_file)
+        end
+      end
+    else
+      if !File.exist?(target) || File.mtime(source) > File.mtime(target)
+        if Fig::Logging.debug?
+          Fig::Logging.debug "Copying package [#{@config.name}/#{@config.version}] from #{source} to #{target}."
+        else
+          Fig::Logging.info "+ [#{@config.name}/#{@config.version}] #{relpath}"
+        end
+        FileUtils.mkdir_p(File.dirname(target))
+        FileUtils.cp(source, target, :preserve => true)
+      end
+      @config.files << relpath if @config
+    end
+  end
+end

data/lib/fig/urlaccesserror.rb

@@ -0,0 +1,13 @@
+require 'fig/userinputerror'
+
+module Fig
+  class URLAccessError < UserInputError
+    attr_reader :urls, :package, :version
+
+    def initialize(urls, package, version)
+      @urls = urls
+      @package = package
+      @version = version
+    end
+  end
+end

data/lib/fig/userinputerror.rb

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

data/lib/fig/windows.rb

@@ -0,0 +1,46 @@
+# Keeping Windows-specific implementation details here.
+
+require 'erb'
+require 'fileutils'
+
+# I don't know how to set environment variables so that a sub-shell will
+# be able to use them.  Therefore, I'm punting, and creating a batch script
+# on the fly to run a user supplied command.
+
+module Fig
+  class Windows
+
+    BATCH_SCRIPT_TEMPLATE = <<EOF
+@echo off
+% ENV.each do |k,v|
+set <%= k %>=<%= v %>
+% end
+
+cmd /C <%= command %>
+EOF
+
+
+    def self.with_generated_batch_script(cmd)
+      command = cmd.join(' ')
+      template = ERB.new(BATCH_SCRIPT_TEMPLATE, 0, '%')
+      output = template.result(binding)
+      begin
+        tf = File.new('C:/tmp/fig_command.bat', 'w')
+        FileUtils.chmod(0755, tf.path)
+        File.open(tf.path, 'w') do |fh|
+          fh.puts output
+        end
+        tf.close
+        yield tf.path
+      ensure
+#        tf.delete
+      end
+    end
+
+    def self.shell_exec_windows(cmd)
+      with_generated_batch_script(cmd) do |f|
+        Kernel.exec(f)
+      end
+    end
+  end
+end

data/lib/fig.rb

@@ -0,0 +1,230 @@
+require 'rubygems'
+require 'net/ftp'
+require 'log4r'
+
+require 'fig/environment'
+require 'fig/figrc'
+require 'fig/logging'
+require 'fig/options'
+require 'fig/os'
+require 'fig/package'
+require 'fig/package/configuration'
+require 'fig/package/publish'
+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 =~ %r< ^ ( [^:/]+ ) >x ? $1 : nil
+    config_name  = descriptor =~ %r< : ( [^:/]+ ) >x ? $1 : nil
+    version_name = descriptor =~ %r< / ( [^:/]+ ) >x ? $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(configuration).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] + [Package::Configuration.new('default', options[:modifiers])]
+        publish_statements << Package::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
+      urls = exception.urls.join(', ')
+      $stderr.puts "Access to #{urls} in #{exception.package}/#{exception.version} 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
+    rescue OptionParser::InvalidOption => exception
+      $stderr.puts exception.to_s
+      $stderr.puts USAGE
+      return 1
+    end
+  end
+end