raven 1.0 → 1.1

data/bin/raven

@@ -1,4 +1,4 @@
-!#/usr/bin/env ruby
+#!/usr/bin/env ruby
 require 'rubygems'
 require 'raven'
 

data/bin/raven~

@@ -0,0 +1,5 @@
+!#/usr/bin/env ruby
+require 'rubygems'
+require 'raven'
+
+Raven::Command.run(ARGV)

data/lib/raven.rb

@@ -20,6 +20,7 @@ require 'raven/gem_init'
 require 'raven/deps_tasks'
 require 'raven/repo_builder'
 require 'raven/java_tasks'
+require 'raven/search_install'
 require 'raven/index_gem_repository'
 
 require 'optparse'
@@ -28,51 +29,95 @@ module Raven
   module Command
     def self.run(args)
       opts = OptionParser.new
-      opts.banner = "Usage: raven [options] (import | repository * | server)"
-      repo_url = ''
-      opts.on('-m=ARG', '--mavenrepo repo_url') { |val| puts'x';repo_url = val }
+      opts.banner = "Usage: raven [options] (import | repository * | server | install *)"
+      repo_url, index_url, all, groupId, allver = '', '', false, nil, false
+      opts.on('-m=ARG', '--mavenrepo repo_url', '[repository] Maven repository to build your gem repository from.') { |val| repo_url = val }
+      opts.on('-i=ARG', '--index index_url', '[install] URL of a directory containing repository indices.') { |val| index_url = val }
+      opts.on('-g=ARG', '--group', '[install] Install artifacts in the provided group.') { |val| groupId = val }
+      opts.on('-a', '--all', '[install] Install all selected artifacts.') { |val| all = true }
+      opts.on('-v', '--allversions', '[install] Select all versions, not only the latest.') { |val| allver = true }
       
-      rest = opts.parse(*args)
+      begin
+        rest = opts.parse(*args)
+      rescue ArgumentError
+        puts 'Wrong option.'
+      end
       
-      ARGV.pop while ARGV.length > 0      
-      if (rest[0] == 'import')
+      ARGV.pop while ARGV.length > 0
+      
+      case rest[0]
+      when 'import'
         Raven::MavenLocalRepoImport.run() 
-      else
-        if (rest[0] == 'repository')
-          if (repo_url.length > 0)
-            puts 'repodef'
-            match = repo_url.match('http://([^/]*)(/.*)')
-            server = match[1]
-            rel_url = match[2]
-            rel_url = rel_url + '/' if rel_url[-1..-1] != '/'
-          else
-            server = 'www.ibiblio.org'
-            rel_url = '/maven2/'
-          end
-          
-          puts "Using server #{server} and url #{rel_url}"
-          builder = Raven::GemRepoBuilder.new(server, rel_url)
-          if (rest.size > 1)
-            rest.shift
-            puts "Packages #{rest}"
-            builder.group_filters = rest
-          end
-          builder.build
-          main_index(ARGV)
+      when 'repository'
+        if (repo_url.length > 0)
+          puts 'repodef'
+          match = repo_url.match('http://([^/]*)(/.*)')
+          server = match[1]
+          rel_url = match[2]
+          rel_url = rel_url + '/' if rel_url[-1..-1] != '/'
         else
-          if (rest[0] == 'server')
-            require 'webrick'
-            include WEBrick
-            s = HTTPServer.new(
-                 :Port         => 2233,
-                 :DocumentRoot => Dir.pwd )
-            trap("INT") { s.shutdown }
-            s.start            
-          else
-            puts opts.to_s
+          server = 'www.ibiblio.org'
+          rel_url = '/maven2/'
+        end
+        puts "Using server #{server} and url #{rel_url}"
+        builder = Raven::GemRepoBuilder.new(server, rel_url)
+        if (rest.size > 1)
+          rest.shift
+          puts "Packages #{rest}"
+          builder.group_filters = rest
+        end
+        builder.build
+        main_index(ARGV)
+      when 'server'
+        require 'webrick'
+        include WEBrick
+        s = HTTPServer.new(
+             :Port         => 2233,
+             :DocumentRoot => Dir.pwd )
+        trap("INT") { s.shutdown }
+        s.start
+      when 'install'
+        params = ['raven.rubyforge.org', '80', '/indices/']
+        if (index_url.length > 0)
+          params = Raven::Command.parse_url(index_url)
+          params[2] = '/' if params[2].empty?
+        end
+        installer = Raven::GemSearchInstaller.new(*params)
+        # Refreshes local gem indices if needed
+        installer.get_indices
+        
+        rest.shift
+        rest << '' if (rest.empty? && groupId)
+        rest.each do |artifact| 
+          av = artifact.match(/([^:]*):?(.*)/).to_a
+          # Trock to see if we've been passed a version number or an artifact
+          begin
+            Integer(av[1][0..0])
+            av[2] = av[1]
+            av[1] = ''
+          rescue
+          end
+          begin
+            installer.install(av[1].length > 0 ? av[1] : nil, 
+                groupId, av[2].length > 0 ? av[2] : nil, all, allver)
+          rescue GemTooManyInstallError => toomany
+            puts "Couldn't install a gem from name #{av[1]||groupId}, more than on potential"
+            puts "gem was found for this name. If this is intentional and you want to"
+            puts "install all these Gems please run again with the --all option."
+            toomany.artifacts.each { |a| puts "   #{a.to_s}"}
           end
         end
-      end      
+      when 'build_index'
+        RepoIndexBuilder.new('m2_central', 'repo1.maven.org', '/maven2/').build_idx
+      else
+        puts opts.to_s
+      end
+    end
+    
+    def self.parse_url(url)
+      parsed = /http:\/\/([^\/:]*):?([^\/]*)(\/?.*)/.match(url).to_a
+      parsed.shift
+      parsed
     end
   end
 end

data/lib/raven/deps_tasks.rb

@@ -102,7 +102,7 @@ module Raven
       unless hems[1]
         installer = Gem::RemoteInstaller.new
         params = [gem_spec.name, gem_spec.version.to_s, false]
-        params << USER_HOME + '/.raven_gems' if defined?(GEMS_IN_HOME)
+        params << RAVEN_HOME if defined?(GEMS_IN_HOME)
         gem_spec = installer.install(*params)[0]
       end
       gem_spec.full_gem_path

data/lib/raven/gem_init.rb

@@ -54,8 +54,9 @@ set_sources(["http://localhost:2233"])
 # under the user home directory.
 GEMS_IN_HOME = true
 USER_HOME = ENV['HOME'] ? ENV['HOME'] : ENV['USERPROFILE']
-FileUtils.mkdir(USER_HOME + '/.raven_gems') unless File.exist?(USER_HOME + '/.raven_gems')
-Dir.glob(USER_HOME + "/.raven_gems/specifications/*.gemspec").each do |file_name|
+RAVEN_HOME = USER_HOME + '/.raven/'
+FileUtils.mkdir(RAVEN_HOME) unless File.exist?(RAVEN_HOME)
+Dir.glob(RAVEN_HOME + "/specifications/*.gemspec").each do |file_name|
   gemspec = Gem::SourceIndex.load_specification(file_name.untaint)
   Gem::cache.add_spec(gemspec) if gemspec
 end

data/lib/raven/java_tasks.rb

@@ -278,7 +278,7 @@ module Raven
     def execute
       super
       params = [false]
-      params << USER_HOME + "/.raven_gems" if defined?(GEMS_IN_HOME)
+      params << RAVEN_HOME if defined?(GEMS_IN_HOME)
       Gem::Installer.new("target/#{@group}-#{@artifact}-#{@version}-java.gem").install(*params)
     end
   end

data/lib/raven/repo_builder.rb

@@ -25,9 +25,29 @@ module Raven
   # all the groupId and artifactId crap.
   class Artifact
     attr_reader :groupId, :artifactId, :versionId, :path
+    attr_accessor :server
     def initialize(groupId, artifactId, versionId, path)
       @groupId, @artifactId, @versionId, @path = groupId, artifactId, versionId, path
     end
+
+    def to_yaml_properties
+      %w{ @groupId @artifactId @versionId @path }
+    end
+    
+    def ==(art) eql?(art); end
+    def ===(art) eql?(art); end
+    def eql?(art)
+      false if art.class != Artifact
+      art.groupId == @groupId && art.artifactId == @artifactId && art.versionId == @versionId
+    end
+    
+    def hash
+      @groupId.hash ^ (@artifactId.hash << 1) ^ (@versionId.hash << 2)
+    end
+    
+    def to_s
+      "#{artifactId} v#{versionId} (module #{groupId})"
+    end
   end
   
   # Enumerates on a Maven repository by scraping HTML. Yields on every
@@ -41,12 +61,12 @@ module Raven
       @group_filters
     end
     
-    def initialize(server, url)
-      @server, @url = server, url
+    def initialize(server, url, port="80")
+      @server, @url, @port = server, url, port
     end
     
     def each
-      http = Net::HTTP.new(@server, 80)
+      http = Net::HTTP.new(@server, @port)
       folder_regexp = /<img src="\/icons\/folder.gif" alt="\[DIR\]"> <a href="[^\/]*\/">/
       file_regexp = /<img src="\/icons\/unknown.gif" alt="\[   \]"> <a href="[^"]*">/
       read_page(http, @url, folder_regexp) do |url1, groupId|
@@ -84,7 +104,7 @@ module Raven
   class GemRepoBuilder
     attr_writer :group_filters
     
-    def initialize(server, url)
+    def initialize(server, port, url)
       @server, @url = server, url
     end
     
@@ -97,43 +117,34 @@ module Raven
       
       Dir.chdir('gems') do
         repo.each do |artifact, http|
-          gemname = "#{artifact.groupId}-#{artifact.artifactId}-#{artifact.versionId}-java.gem"
-          if !File.exist?(gemname) || overwrite
-            with(artifact, 'ext', http) do
-              # The fileset is computed when gemspec is created, file must be there
-              gemspec = Raven.create_gemspec(artifact)
-              Gem::Builder.new(gemspec).build
-            end
-          end
+          Raven.install_remote_gem(artifact, http, @url, overwrite)
         end
       end      
       
     end
-        
-    def with(artifact, subdir, http)
-      response = http.get(@url + artifact.path, nil)
-      file = File.new(subdir + "/#{artifact.artifactId}-#{artifact.versionId}.jar", 'wb')
-      file.write(response.body)
-      file.close
-      yield
-      File.delete(subdir + "/#{artifact.artifactId}-#{artifact.versionId}.jar")
-    end    
   end
   
-  def self.create_gemspec(artifact)
-    spec = Gem::Specification.new do |s|
-      s.platform = Gem::Platform::JAVA
-      s.summary = "Raven wrapped library #{artifact.artifactId} from project #{artifact.groupId}."
-      s.name = "#{artifact.groupId}-#{artifact.artifactId}"
-      s.version = artifact.versionId
-      s.requirements << 'none'
-      s.require_path = 'ext'
-      s.autorequire = 'rake'
-      s.files = Dir.glob("{ext}/**/*")
+  def self.install_remote_gem(artifact, http, base_url, overwrite=true)
+    gemname = "#{artifact.groupId}-#{artifact.artifactId}-#{artifact.versionId}-java.gem"
+    if !File.exist?(gemname) || overwrite
+      Raven.with(artifact, 'ext', http, base_url) do
+        # The fileset is computed when gemspec is created, file must be there
+        gemspec = Raven.create_gemspec(artifact)
+        Gem::Builder.new(gemspec).build
+      end
     end
+    gemname
   end
-  
-  
+
+  def self.with(artifact, subdir, http, base_url)
+    response = http.get(base_url + artifact.path, nil)
+    file = File.new(subdir + "/#{artifact.artifactId}-#{artifact.versionId}.jar", 'wb')
+    file.write(response.body)
+    file.close
+    yield
+    File.delete(subdir + "/#{artifact.artifactId}-#{artifact.versionId}.jar")
+  end    
+    
   class M2LocalRepository
     def initialize(dir)
       @dir = dir
@@ -232,7 +243,7 @@ module Raven
           Gem::Builder.new(gemspec).build
           # Installing Gem
           params = [false]
-          params << USER_HOME + "/.raven_gems" if defined?(GEMS_IN_HOME)
+          params << RAVEN_HOME if defined?(GEMS_IN_HOME)
           Gem::Installer.new("#{artifact.groupId}-#{artifact.artifactId}-#{artifact.versionId}-java.gem").install(*params)
           # Cleaning up for next iteration
           FileUtils.rm(Dir.glob('ext/*'))
@@ -249,7 +260,7 @@ module Raven
       nil
     end
   end
-  
+    
   def self.dir_each(path)
     Dir.foreach(path) do |elmt|
       next if DIR_EXCL.include?(elmt)
@@ -257,10 +268,24 @@ module Raven
     end
   end
   
-end
-  
-# builder = Raven::GemRepoBuilder.new('www.ibiblio.org', '/maven2/')
-# builder.group_filters = ['log4j', 'wsdl4j', 'commons-logging', 'commons-lang']
-# builder.build()
+  def self.create_gemspec(artifact)
+    spec = Gem::Specification.new do |s|
+      s.platform = Gem::Platform::JAVA
+      s.summary = "Raven wrapped library #{artifact.artifactId} from project #{artifact.groupId}."
+      s.name = "#{artifact.groupId}-#{artifact.artifactId}"
+      s.version = artifact.versionId
+      s.requirements << 'none'
+      s.require_path = 'ext'
+      s.autorequire = 'rake'
+      s.files = Dir.glob("{ext}/**/*")
+    end
+  end
   
-
+  class GemTooManyInstallError < RuntimeError
+    attr_reader :artifacts    
+    def initialize(arts)
+      @artifacts = arts
+    end
+  end
+    
+end

data/lib/raven/search_install.rb

@@ -0,0 +1,233 @@
+#!/usr/bin/env ruby
+
+#  Copyright 2006 Matthieu Riou
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+require 'net/http'
+
+module Raven
+
+  class RepoIndexBuilder
+    def initialize(name, server, base_url, port='80')
+      @name, @server, @base_url, @port = name, server, base_url, port
+    end
+    
+    def build_idx
+      require 'yaml'
+      require 'zlib'
+      Zlib::GzipWriter.open("#{@name}.mvnidx.gz") do |f|
+        f << @server + "#" + @port + "#" + @base_url + "\n"
+        Raven::Maven2Repository.new(@server, @base_url, @port).each do |artifact, http|
+          f << YAML.dump(artifact)
+        end
+      end
+    end
+  end
+  
+  class GemSearchInstaller
+    def initialize(server, port, base_url)
+      @server, @base_url, @port = server, base_url, port
+    end
+    
+    def list_indices
+      indices = []
+      http = Net::HTTP.new(@server, @port)
+      response = http.get(@base_url, nil)
+      expr = /HREF="([^"]*idx.gz)"/
+      if response.message.strip == "OK"
+        response.body.each_line do |line|
+          if expr =~ line
+            indices << expr.match(line)[1]
+          end
+        end
+      else
+        puts "Got a bad response from server http://#{@server}:#{@port}/#{@base_url}, couldn't update local index"
+      end
+      indices
+    end
+    
+    def get_indices
+      require 'stringio'
+      http = Net::HTTP.new(@server, @port)
+      
+      list_indices.each do |file|
+        http_fn, fs_fn = @base_url + file, RAVEN_HOME + file[0..-4]
+        
+        # Checking file size to see if it changed
+        header = http.head(http_fn)
+        zipsize = header["content-length"]
+        oldsize = File.exist?(fs_fn) ? File.new(fs_fn).readline.chomp : '0'
+        
+        unless (zipsize.to_i == oldsize.to_i)
+          puts "Refreshing index file #{file[0..-4]}"
+          response = StringIO.new(http.get(@base_url + file, nil).body)
+          zlib = Zlib::GzipReader.new(response)
+          file = File.new(RAVEN_HOME + file[0..-4], 'wb')
+          file << zipsize + "\n"
+          file.write(zlib.read)
+          file.close
+          zlib.close
+        end
+      end
+    end
+    
+    def search(artifactId, groupId=nil, versionId=nil)
+      idx_files = Dir[RAVEN_HOME + '*.mvnidx']
+      found = []
+      idx_files.each do |idx_file|
+        puts "Searching in #{idx_file}..."
+        f = File.new(idx_file)
+        found.concat(search_index(f, artifactId, groupId, versionId))
+      end
+      found
+    end
+    
+    def search_index(idx_file, artifactId, groupId, versionId)
+      # Removing gz file size header
+      idx_file.gets
+      # Getting server name and gz file size header
+      server_addr = idx_file.gets.chomp.split("#")
+      aid_line = /artifactId: (.*#{artifactId}.*)/
+      gid_line = /groupId: (.*#{groupId}.*)/
+      vid_line = /versionId: "?(#{versionId})"?/
+
+      # a, a+v, a+g, g, v+g, a+v+g
+      found = []
+      while (lines = read_lines(idx_file, 5))
+        ma, mg, mv = false, false, false
+        ma = lines[2].strip =~ aid_line if artifactId
+        mg = lines[1].strip =~ gid_line if groupId
+        mv = lines[3].strip =~ vid_line if versionId
+        if ((ma && groupId.nil? && versionId.nil?) ||
+            (ma && mg && versionId.nil?) ||
+            (ma && mv && groupId.nil?) ||
+            (ma && mg && mv) ||
+            (mg && mv && artifactId.nil?) ||
+            (mg && artifactId.nil? && versionId.nil?))
+           artifact = YAML.load(lines.join("\n"))
+           artifact.server = server_addr
+           found << artifact
+        end
+      end
+      found
+    end
+    
+    def read_lines(file, size)
+      lines = []
+      0.upto(size-1) { |m| lines[m] = file.gets }
+      return nil if lines[size-1].nil?
+      lines
+    end
+  
+    def install(artifactId, groupId, versionId, all=false, all_versions=false)
+      artifacts = search(artifactId, groupId, versionId).uniq
+      
+      if (versionId.nil? && !all_versions)
+        artifacts = filtrate_latest(artifacts)
+        puts artifacts
+      end
+      
+      # Selected several artifacts but supposed to have only one
+      if (artifacts.nil?)
+        puts "Gem indices couldn't be found properly (either you provided a wrong URL or the main site is down)."
+        return
+      end
+      raise GemTooManyInstallError.new(artifacts), "Too many artifacts" if (!all && artifacts.size > 1)
+      
+      if (artifacts.empty?)
+        puts "Nothing found."
+      else
+        # TODO install from the servers returned by search
+        # Proceeding with installation
+        FileUtils.mkdir('ext')
+        puts "Installing Gems:"
+        artifacts.each do |artifact|
+          http = Net::HTTP.new(artifact.server[0], artifact.server[1])
+          puts "  - #{artifact.to_s}"
+          gemname = Raven.install_remote_gem(artifact, http, artifact.server[2], true)
+          params = [false]
+          params << RAVEN_HOME if defined?(GEMS_IN_HOME)
+          Gem::Installer.new(gemname).install(*params)      
+          FileUtils.rm(gemname)
+        end
+        FileUtils.rm_rf('ext')
+      end
+    end
+    
+    def filtrate_latest(artifacts)
+      # Create a hash with all versions of each artifact
+      arth = {}
+      artifacts.each do |art| 
+        key = "#{art.groupId}%#{art.artifactId}"
+        arth[key] ||= []
+        arth[key] << Version.new(art.versionId)
+      end
+      
+      arth.keys.collect do |key|
+        last_ver = arth[key].sort[-1].version
+        find_artifact(artifacts, *(key.split('%') << last_ver))
+      end
+    end
+    
+    def find_artifact(artifacts, groupId, artifactId, versionId)
+      artifacts.select do |art|
+        art if art.artifactId == artifactId && 
+                art.groupId == groupId && art.versionId == versionId
+      end[0]
+    end
+  end
+  
+  # Structured version class used to try to make some sense
+  # out of Maven version numbers. A difficult task indeed.
+  class Version
+    include Comparable
+    attr_reader :timestamp, :ver_struct, :version
+    
+    def initialize(version)
+      @version = version
+      elmts = @version.split(/\.|-/)
+      @timestamp = elmts[0].length > 3 ? true : false
+      @ver_struct = elmts.collect do |elmt|
+        val = ''
+        begin
+          val = Integer(elmt)
+        rescue ArgumentError
+          val = elmt
+        end
+        val
+      end
+    end
+    
+    def <=>(ver)
+      false if !(Version === ver)
+      return -1 if @timestamp && !ver.timestamp
+      return 1 if !@timestamp && ver.timestamp
+      # Setting string elements to 0 (mostly weaker) if they need
+      # to be compared to an int otherwise <=> could produce nil
+      @me, you = @ver_struct.dup, ver.ver_struct.dup
+      (0..@me.size).each do |m|
+        if (m < you.size && @me[m].class != you[m].class)
+          @me[m] = 0 if String === @me[m]
+          you[m] = 0 if String === you[m]
+        end
+      end      
+      @me <=> you
+    end
+    
+    def to_s
+      puts "v#{@version}, ts #{timestamp}, #{ @ver_struct.collect{ |v| v.class }.join('/') }"
+    end
+  end
+  
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: raven
 version: !ruby/object:Gem::Version 
-  version: "1.0"
-date: 2006-09-17 00:00:00 -07:00
+  version: "1.1"
+date: 2006-11-02 00:00:00 -08:00
 summary: Java build system based on Rake and Gem.
 require_paths: 
 - lib
@@ -29,6 +29,7 @@ post_install_message:
 authors: 
 - Matthieu Riou
 files: 
+- bin/raven~
 - bin/raven
 - lib/raven
 - lib/raven.rb
@@ -36,6 +37,7 @@ files:
 - lib/raven/gem_init.rb
 - lib/raven/java_tasks.rb
 - lib/raven/repo_builder.rb
+- lib/raven/search_install.rb
 - lib/raven/index_gem_repository.rb
 - README.rdoc
 - LICENSE