fig 0.1.24-universal-darwin9.0

data/lib/fig/package.rb

@@ -0,0 +1,197 @@
+module Fig
+  class Package
+    attr_reader :package_name, :version_name, :directory, :statements
+    
+    def initialize(package_name, version_name, directory, statements) 
+      @package_name = package_name
+      @version_name = version_name
+      @directory = directory
+      @statements = statements
+    end
+
+    def [](config_name)
+      @statements.each do |stmt|
+        return stmt if stmt.is_a?(Configuration) && stmt.name == config_name
+      end
+      puts "Configuration not found: #{@package_name}/#{@version_name}:#{config_name}"
+      exit 10
+    end
+
+    def configs
+      @statements.select { |statement| statement.is_a?(Configuration) }
+    end
+
+    def retrieves
+      retrieves = {}
+      statements.each { |statement| retrieves[statement.var] = statement.path if statement.is_a?(Retrieve) }
+      retrieves
+    end
+
+    def archive_urls
+      @statements.select{|s| s.is_a?(Archive)}.map{|s|s.url}
+    end
+    
+    def resource_urls
+      @statements.select{|s| s.is_a?(Resource)}.map{|s|s.url}
+    end
+    
+    def unparse
+      @statements.map { |statement| statement.unparse('') }.join("\n")
+    end
+
+    def ==(other)
+      @package_name == other.package_name && @version_name == other.version_name && @statements.to_yaml == other.statements.to_yaml
+    end
+  end
+  
+  class Archive
+    attr_reader :url
+    
+    def initialize(url)
+      @url = url
+    end
+    
+    def unparse(indent)
+      "#{indent}archive \"#{url}\""
+    end
+  end
+  
+  class Resource
+    attr_reader :url
+    
+    def initialize(url)
+      @url = url
+    end
+    
+    def unparse(indent)
+      "#{indent}resource #{url}"
+    end
+  end
+  
+  class Retrieve
+    attr_reader :var, :path
+
+    def initialize(var, path)
+      @var = var
+      @path = path
+    end
+
+    def unparse(indent)
+      "#{indent}retrieve #{var}->#{path}"
+    end
+  end
+
+  class Publish
+    attr_reader :local_name, :remote_name
+
+    def initialize(local_name, remote_name)
+      @local_name = local_name
+      @remote_name = remote_name
+    end
+    
+    def unparse(indent)
+      "#{indent}publish #{@local_name}->#{@remote_name}"
+    end
+  end
+
+  class Install
+    def initialize(statements)
+      @statements = statements
+    end
+
+    def unparse(indent)
+      prefix = "\n#{indent}install"
+      body = @statements.map { |statement| statement.unparse(indent+'  ') }.join("\n")
+      suffix = "#{indent}end"
+      return [prefix, body, suffix].join("\n")
+    end 
+  end
+  
+  class Configuration
+    attr_reader :name, :statements
+
+    def initialize(name, statements)
+      @name = name
+      @statements = statements
+    end
+
+    def with_name(name)
+      Configuration.new(name, statements)
+    end
+
+    def commands
+      result = statements.select { |statement| statement.is_a?(Command) }
+#      if result.empty?
+#        raise "No commands found for config: #{@name}"
+#      end
+      result
+    end
+
+    def unparse(indent)
+      unparse_statements(indent, "config #{@name}", @statements, "end")
+    end
+  end
+
+  class Path
+    attr_reader :name, :value
+
+    def initialize(name, value)
+      @name = name
+      @value = value
+    end
+  
+    def unparse(indent)
+      "#{indent}append #{name}=#{value}"
+    end
+  end
+
+  class Set
+    attr_reader :name, :value
+
+    def initialize(name, value)
+      @name = name
+      @value = value
+    end
+  
+    def unparse(indent)
+      "#{indent}set #{name}=#{value}"
+    end
+  end
+
+  class Include
+    attr_reader :package_name, :config_name, :version_name
+
+    def initialize(package_name, config_name, version_name)
+      @package_name = package_name
+      @config_name = config_name
+      @version_name = version_name
+    end
+
+    def unparse(indent)
+      descriptor = ""
+      descriptor += @package_name if @package_name
+      descriptor += "/#{@version_name}" if @version_name
+      descriptor += ":#{@config_name}" if @config_name
+      "#{indent}include #{descriptor}"
+    end
+  end
+
+  class Command
+    attr_reader :command
+
+    def initialize(command)
+      @command = command
+    end
+
+    def unparse(indent)
+      "#{indent}command \"#{@command}\""
+    end
+  end
+
+end
+
+def unparse_statements(indent, prefix, statements, suffix)
+  body = @statements.map { |statement| statement.unparse(indent+'  ') }.join("\n")
+  return ["\n#{indent}#{prefix}", body, "#{indent}#{suffix}"].join("\n")
+end   
+

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? 
+        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,240 @@
+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}"
+        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)
+        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