fig 0.1.38-java

data/lib/fig/parser.rb

@@ -0,0 +1,27 @@
+require 'polyglot'
+require 'treetop'
+
+require 'fig/grammar'
+
+module Fig
+  class Parser
+    def initialize
+      @parser = FigParser.new
+    end
+
+    def parse_package(package_name, version_name, directory, input)
+      input = input.gsub(/#.*$/, '')
+      result = @parser.parse(" #{input} ")
+      if result.nil? 
+        $stderr.puts "#{directory}: #{@parser.failure_reason}"
+        exit 10
+      end
+      result.to_package(package_name, version_name, directory)
+    end
+
+#    def parse_descriptor(descriptor)
+#      puts @parser.methods.sort
+#    end
+  end
+
+end

data/lib/fig/repository.rb

@@ -0,0 +1,241 @@
+require 'fig/parser'
+
+module Fig
+  class Repository
+    def initialize(os, local_repository_dir, remote_repository_url, 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
+      @update = update
+      @update_if_missing = update_if_missing
+      @parser = Parser.new
+
+      @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?(Publish)
+          nil
+        elsif statement.is_a?(Archive) || statement.is_a?(Resource)
+          if statement.is_a?(Resource) && !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 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?(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?(Resource) && !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(Archive.new(file))
+        at_exit { File.delete(file) }
+      end
+      new_package_statements
+    end
+
+    def load_package(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 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 NotFoundException
+        $stderr.puts "Package not found in remote repository: #{package_name}/#{version_name}"
+        delete_local_package(package_name, version_name)
+        exit 1
+      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)
+      @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)
+        $stderr.puts "Fig file not found for package: #{file}"
+        exit 10
+      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)
+        $stderr.puts "Package not found: #{package_name}/#{version_name}" 
+        exit 1
+      end
+      modified_time = @os.mtime(file_name)
+      content = @os.read(file_name)
+      @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
+        $stderr.puts "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 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 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
+        $stderr.puts "Install failed, cleaning up" 
+        delete_local_package(package_name, version_name)
+        exit 10
+      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 is_url?(url)
+      not (/ftp:\/\/|http:\/\/|file:\/\/|ssh:\/\// =~ url).nil?
+    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/retriever.rb

@@ -0,0 +1,107 @@
+require 'ostruct'
+require 'set'
+
+# 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_config(name, version)
+    if name and version
+      @config = @configs[name]
+      if @config && @config.version != version
+        @config.files.each do |relpath|
+          $stderr.puts "\033[31m- [#{@config.name}/#{@config.version}] #{relpath}\033[0m" 
+          FileUtils.rm_f(File.join(@base_dir, relpath))
+        end
+        @config = nil
+      end
+      if not @config
+        @config = new_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_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_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 != ".."
+          copy(File.join(source, child), File.join(relpath, child))
+        end
+      end
+    else
+      if !File.exist?(target) || File.mtime(source) > File.mtime(target)
+        $stderr.puts "\033[32m+ [#{@config.name}/#{@config.version}] #{relpath}\033[0m" 
+        FileUtils.mkdir_p(File.dirname(target))
+        FileUtils.cp(source, target, :preserve => true)
+      end
+      @config.files << relpath if @config
+    end
+  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

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification 
+name: fig
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.38
+platform: java
+authors: 
+- Matthew Foemmel
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-06 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: net-ssh
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.15
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: net-sftp
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.5
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: net-netrc
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.2
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: polyglot
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.9
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: treetop
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.4.2
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: highline
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.6.2
+  type: :runtime
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.3"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: open4
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.1
+  type: :development
+  version_requirements: *id008
+description: Fig is a utility for configuring environments and managing dependencies across a team of developers. You give it a list of packages and a shell command to run; it creates an environment that includes those packages, then executes the shell command in it (the caller's environment is not affected).
+email: git@foemmel.com
+executables: 
+- fig
+- fig-download
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- bin/fig
+- bin/fig-download
+- lib/fig.rb
+- lib/fig/backtrace.rb
+- lib/fig/environment.rb
+- lib/fig/grammar.treetop
+- lib/fig/options.rb
+- lib/fig/os.rb
+- lib/fig/package.rb
+- lib/fig/parser.rb
+- lib/fig/repository.rb
+- lib/fig/retriever.rb
+- lib/fig/windows.rb
+- LICENSE
+- README.md
+has_rdoc: true
+homepage: http://github.com/mfoemmel/fig
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.3
+signing_key: 
+specification_version: 3
+summary: Fig is a utility for configuring environments and managing dependencies across a team of developers..
+test_files: []
+