doubleshot 0.1.0-java → 0.2.0-java

data/Doubleshot

@@ -1,21 +1,33 @@
-# encoding: UTF-8
+# encoding: utf-8
 
 Doubleshot.new do |config|
 
+  config.project = "doubleshot"
+  config.group   = "org.sam.doubleshot"
+  config.version = "0.2.0"
+
   config.gem "bundler", ">= 0"
-  config.gem "jbundler", ">= 0"
-  
+
   config.gem "rdoc", ">= 2.4.2"
   config.gem "perfer", ">= 0"
   config.gem "minitest", ">= 3.0.1"
   config.gem "minitest-wscolor", ">= 0"
-  config.gem "listen", ">= 0"
-  config.gem "rb-fsevent", "~> 0.9.1"
+  config.gem "listen", ">= 0.5.3"
+  config.gem "rb-fsevent", ">= 0.9.1"
   config.gem "simplecov", ">= 0"
-  
+
+  config.jar "org.sonatype.aether:aether-api:jar:1.13.1"
+  config.jar "org.sonatype.aether:aether-util:jar:1.13.1"
+  config.jar "org.sonatype.aether:aether-impl:jar:1.13.1"
+  config.jar "org.sonatype.aether:aether-connector-file:jar:1.13.1"
+  config.jar "org.sonatype.aether:aether-connector-asynchttpclient:jar:1.13.1"
+  config.jar "org.sonatype.aether:aether-connector-wagon:jar:1.13.1"
+  config.jar "org.apache.maven:maven-aether-provider:jar:3.0.4"
+  config.jar "org.apache.maven.wagon:wagon-file:jar:2.2"
+  config.jar "org.apache.maven.wagon:wagon-http:jar:2.2"
+  config.jar "org.apache.maven.wagon:wagon-provider-api:jar:2.2"
+
   config.gemspec do |spec|
-    spec.name           = "doubleshot"
-    spec.version        = "0.1.0"
     spec.summary        = "Doubleshot is a build and dependency tool for mixed Java and Ruby projects"
     spec.description    = <<-DESCRIPTION
 Doubleshot will download dependencies on demand, compile your Java sources and
@@ -27,7 +39,6 @@ DESCRIPTION
     spec.author         = "Sam Smoot"
     spec.email          = "ssmoot@gmail.com"
     spec.license        = "MIT-LICENSE"
-    spec.executables    = ["doubleshot"]
   end
 
-end
+end

data/README.textile

@@ -1,6 +1,6 @@
 h1. Doubleshot
 
-Latest test results (currently Travis CI's JRuby ~1.7 mode is broken as it runs `bundle install` but doesn't have the Bundler gem installed):
+Latest test results:
 
 !https://secure.travis-ci.org/sam/doubleshot.png(Build Status)!:http://travis-ci.org/sam/doubleshot
 
@@ -131,6 +131,10 @@ Doubleshot also provides a @doubleshot@ bin file. Running @doubleshot test@ in y
 
 This is the typical use-case for day to day development of new projects/features when using Doubleshot to manage your build process. It allows you to write and test new code, without ever having to restart your Java VM, saving you ten seconds or so for every run, encouraging continuous testing so you can spend more time writing code, and less time waiting for processes to load.
 
+For your continuous testing/integration (CI) environment, you can also run all your tests just once by using the --ci-test option:
+
+bc. doubleshot test --ci-test
+
 h2. Packaging
 
 # TODO: This is all out of date...
@@ -177,23 +181,27 @@ Bundler includes a @bundle show some_gem@ command that shows you the path where
 
 It's our opinion that you don't _need_ this functionality, and it opens the window to abuse, so we're not implementing it.
 
-h2. Where is @doubleshot install@?
+h2. I just ran @doubleshot install@ and I'm not sure what happened?
 
 With Bundler it's common to:
 
 # @bundle install@ to inspect your Gemfile and download/install any missing dependencies
 # @require "bundler/setup"@ to check/require dependencies at runtime
 
-With Doubleshot you'll:
+With Doubleshot you'll just:
 
-bc. require "doubleshot/setup"
+bc. require "doubleshot"
+
+In your @test/helper.rb@ (or whatever common file you use for test bootstrapping). Or you can run @doubleshot test@.
 
 Doubleshot will first see if all it's dependencies are available, and if not, install any that are missing. So you don't have to manually run an installation step.
 
+If you run @doubleshot help@ you'll see that the @install@ command actually packages up your project as a Gem and installs it locally. So @doubleshot install@ is analogous to @gem install@, *not* @bundle install@.
+
 bq.. But I just want to install my Gem dependencies on a remote server and not actually attempt to run any code!
 *-- Said No One Ever*
 
-p. If you _really_ want to pre-download your dependencies just run @jruby -r "doubleshot/setup"@ in your project's home-directory. Nothing to it.
+p. If you _really_ want to pre-download your dependencies just run @doubleshot build@ in your project's home-directory. Dependencies will be installed as part of the build process.
 
 h2. What if I want to create a unified JAR containing all my dependencies?
 

data/bin/doubleshot

@@ -1,7 +1,15 @@
 #!/usr/bin/env jruby
 
+# encoding: utf-8
+
 require "pathname"
 require Pathname(__FILE__).dirname.parent + "lib/doubleshot"
 require Pathname(__FILE__).dirname.parent + "lib/doubleshot/cli"
 
-exit Doubleshot::CLI::start ? 0 : 1
+result = Doubleshot::CLI::start
+
+case result
+  when Numeric  then exit result
+  when nil      then exit 0
+  else               puts(result.inspect) and exit 1
+end

data/ext/java/Aether.java

@@ -0,0 +1,199 @@
+// This class was lifted from the JBundler project:
+// https://github.com/mkristian/jbundler
+
+package org.sam.doubleshot;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.HashMap;
+
+import org.apache.maven.repository.internal.MavenRepositorySystemSession;
+import org.apache.maven.repository.internal.MavenServiceLocator;
+import org.sonatype.aether.RepositorySystem;
+import org.sonatype.aether.RepositorySystemSession;
+import org.sonatype.aether.artifact.Artifact;
+import org.sonatype.aether.collection.CollectRequest;
+import org.sonatype.aether.collection.DependencyCollectionException;
+import org.sonatype.aether.connector.wagon.WagonProvider;
+import org.sonatype.aether.connector.wagon.WagonRepositoryConnectorFactory;
+import org.sonatype.aether.graph.Dependency;
+import org.sonatype.aether.graph.DependencyNode;
+import org.sonatype.aether.impl.Installer;
+import org.sonatype.aether.installation.InstallRequest;
+import org.sonatype.aether.installation.InstallationException;
+import org.sonatype.aether.repository.LocalRepository;
+import org.sonatype.aether.repository.LocalRepositoryManager;
+import org.sonatype.aether.repository.RemoteRepository;
+import org.sonatype.aether.resolution.DependencyRequest;
+import org.sonatype.aether.resolution.DependencyResolutionException;
+import org.sonatype.aether.spi.connector.RepositoryConnectorFactory;
+import org.sonatype.aether.spi.locator.ServiceLocator;
+import org.sonatype.aether.util.artifact.DefaultArtifact;
+import org.sonatype.aether.util.graph.PreorderNodeListGenerator;
+
+public class Aether {
+
+    private DependencyNode node;
+    private RepositorySystem repoSystem;
+    private RepositorySystemSession session;
+    private List<Artifact> artifacts = new LinkedList<Artifact>();
+    private List<RemoteRepository> repos = new LinkedList<RemoteRepository>();
+    private Installer installer;
+
+    public Aether(String localRepo, boolean verbose, boolean offline){
+        ServiceLocator locator = newServiceLocator();
+        repoSystem = locator.getService( RepositorySystem.class );
+        installer = locator.getService( Installer.class );
+
+        session = newSession( repoSystem, localRepo, verbose, offline );
+
+        RemoteRepository central = new RemoteRepository( "central", "default", "http://repo1.maven.org/maven2/" );
+        repos.add(central);
+    }
+
+    private ServiceLocator newServiceLocator() {
+        MavenServiceLocator locator = new MavenServiceLocator();// when using maven 3.0.4
+        //locator.addService( RepositoryConnectorFactory.class, FileRepositoryConnectorFactory.class );
+        locator.addService( RepositoryConnectorFactory.class, WagonRepositoryConnectorFactory.class );
+
+        locator.setServices( WagonProvider.class, new ManualWagonProvider() );
+
+        return locator;
+    }
+
+    private RepositorySystemSession newSession( RepositorySystem system, String localRepoPath, boolean verbose,
+            boolean offline ) {
+        MavenRepositorySystemSession session = new MavenRepositorySystemSession();
+
+        LocalRepository localRepo = new LocalRepository( localRepoPath );
+        session.setLocalRepositoryManager( system.newLocalRepositoryManager( localRepo ) );
+        session.setRepositoryListener( new SimpleRepositoryListener(verbose, session.getLocalRepositoryManager()) );
+        session.setOffline(offline);
+        return session;
+    }
+
+    public void addArtifact(String coordinate){
+        artifacts.add(new DefaultArtifact(coordinate));
+    }
+
+    public void addRepository(String id, String url){
+        repos.add(new RemoteRepository(id, "default", url));
+    }
+
+    public void resolve() throws DependencyCollectionException, DependencyResolutionException {
+        if (artifacts.size() == 0){
+            throw new IllegalArgumentException("no artifacts given");
+        }
+
+        CollectRequest collectRequest = new CollectRequest();
+        for( Artifact a: artifacts ){
+            collectRequest.addDependency( new Dependency( a, "compile" ) );
+        }
+
+        for( RemoteRepository r: repos ){
+            collectRequest.addRepository( r );
+        }
+
+        node = repoSystem.collectDependencies( session, collectRequest ).getRoot();
+
+        DependencyRequest dependencyRequest = new DependencyRequest( node, null );
+
+        repoSystem.resolveDependencies( session, dependencyRequest  );
+    }
+
+    public List<RemoteRepository> getRepositories(){
+        return Collections.unmodifiableList( repos );
+    }
+
+    public List<Artifact> getArtifacts(){
+        return Collections.unmodifiableList( artifacts );
+    }
+
+    public String getClasspath() {
+        PreorderNodeListGenerator nlg = new PreorderNodeListGenerator();
+        node.accept( nlg );
+
+        StringBuilder buffer = new StringBuilder( 1024 );
+
+        for ( Iterator<DependencyNode> it = nlg.getNodes().iterator(); it.hasNext(); )
+        {
+            DependencyNode node = it.next();
+            if ( node.getDependency() != null )
+            {
+                Artifact artifact = node.getDependency().getArtifact();
+                // skip pom artifacts
+                if ( artifact.getFile() != null && !"pom".equals(artifact.getExtension()))
+                {
+                    buffer.append( artifact.getFile().getAbsolutePath() );
+                    if ( it.hasNext() )
+                    {
+                        buffer.append( File.pathSeparatorChar );
+                    }
+                }
+            }
+        }
+
+        return buffer.toString();
+    }
+
+    public HashMap getClasspathMap() {
+        PreorderNodeListGenerator nlg = new PreorderNodeListGenerator();
+        node.accept( nlg );
+
+        HashMap<String,String> map = new HashMap<String,String>();
+
+        for ( Iterator<DependencyNode> it = nlg.getNodes().iterator(); it.hasNext(); ) {
+            DependencyNode node = it.next();
+            if ( node.getDependency() != null ) {
+                Artifact artifact = node.getDependency().getArtifact();
+                // skip pom artifacts
+                if ( artifact.getFile() != null && !"pom".equals(artifact.getExtension())) {
+                    map.put(artifact.toString(), artifact.getFile().getAbsolutePath());
+                }
+            }
+        }
+
+        return map;
+    }
+
+    public List<String> getResolvedCoordinates() {
+        List<String> result = new ArrayList<String>();
+
+        PreorderNodeListGenerator nlg = new PreorderNodeListGenerator();
+        node.accept( nlg );
+
+        for ( DependencyNode node: nlg.getNodes() )
+        {
+            if ( node.getDependency() != null )
+            {
+                Artifact artifact = node.getDependency().getArtifact();
+                if ( artifact.getFile() != null)
+                {
+                    StringBuilder coord = new StringBuilder(artifact.getGroupId()).append(":").append(artifact.getArtifactId())
+                            .append(":").append(artifact.getExtension()).append(":").append(artifact.getVersion());
+                    result.add(coord.toString());
+                }
+            }
+        }
+
+        return result;
+    }
+
+    public void install(String coordinate, String file) throws InstallationException{
+        LocalRepositoryManager lrm = session.getLocalRepositoryManager();
+
+        Artifact artifact = new DefaultArtifact(coordinate);
+
+        File dstFile = new File( lrm.getRepository().getBasedir(), lrm.getPathForLocalArtifact( artifact ) );
+        if (!dstFile.exists() ){
+            artifact = artifact.setFile(new File(file));
+            InstallRequest request = new InstallRequest();
+            request.addArtifact(artifact);
+            installer.install(session, request);
+        }
+   }
+}

data/ext/java/ManualWagonProvider.java

@@ -0,0 +1,24 @@
+// This class was lifted from the JBundler project:
+// https://github.com/mkristian/jbundler
+
+package org.sam.doubleshot;
+
+import org.apache.maven.wagon.Wagon;
+import org.apache.maven.wagon.providers.http.HttpWagon;
+import org.sonatype.aether.connector.wagon.WagonProvider;
+
+public class ManualWagonProvider implements WagonProvider {
+
+    public Wagon lookup( String roleHint )
+        throws Exception {
+        if ( "http".equals( roleHint ) ) {
+            return new HttpWagon();
+        }
+        return null;
+    }
+
+    public void release( Wagon wagon ) {
+
+    }
+
+}

data/ext/java/SimpleRepositoryListener.java

@@ -0,0 +1,77 @@
+// This class was lifted from the JBundler project:
+// https://github.com/mkristian/jbundler
+
+package org.sam.doubleshot;
+
+import java.io.PrintStream;
+
+import org.sonatype.aether.AbstractRepositoryListener;
+import org.sonatype.aether.RepositoryEvent;
+import org.sonatype.aether.repository.LocalRepositoryManager;
+import org.sonatype.aether.repository.RemoteRepository;
+
+public class SimpleRepositoryListener extends AbstractRepositoryListener {
+
+    private PrintStream out = System.out;
+    private PrintStream err = System.err;
+    private final boolean verbose;
+    private LocalRepositoryManager lrm;
+
+    public SimpleRepositoryListener(LocalRepositoryManager lrm) {
+        this(false, lrm);
+    }
+
+    public SimpleRepositoryListener(boolean verbose, LocalRepositoryManager lrm) {
+        this.verbose = verbose;
+        this.lrm = lrm;
+    }
+
+    public void artifactDescriptorInvalid(RepositoryEvent event) {
+        err.println("artifact descriptor invalid: " + event.getArtifact()
+                + " : " + event.getException().getMessage());
+    }
+
+    public void artifactDescriptorMissing(RepositoryEvent event) {
+        err.println("artifact descriptor missing: " + event.getArtifact());
+    }
+
+    public void artifactInstalled(RepositoryEvent event) {
+        if (verbose) {
+            out.println("artifact installed: " + event.getArtifact() + " : "
+                + event.getFile());
+        }
+    }
+
+    public void artifactResolved(RepositoryEvent event) {
+        if (verbose) {
+            out.println("artifact resolved: " + event.getArtifact() + " : "
+                + event.getRepository().getId());
+        }
+    }
+
+    public void artifactDownloading(RepositoryEvent event) {
+        out.println("downloading " + toUrl(event));
+    }
+
+    private String toUrl(RepositoryEvent event) {
+        RemoteRepository repository = (RemoteRepository) event.getRepository();
+        String path = lrm.getPathForRemoteArtifact(event.getArtifact(), repository, null);
+        String url = repository.getUrl() + "/" + path;
+        return url;
+    }
+
+    public void artifactDownloaded(RepositoryEvent event) {
+        out.println("artifact downloaded: " + event.getArtifact());
+    }
+
+    public void metadataInvalid(RepositoryEvent event) {
+        err.println("metadata invalid: " + event.getMetadata());
+    }
+
+    public void metadataResolved(RepositoryEvent event) {
+        if (verbose) {
+            out.println("metadata resolved: " + event.getMetadata() + " : "
+                + event.getRepository().getId());
+        }
+    }
+}

data/lib/doubleshot.rb

@@ -1,8 +1,13 @@
+require "java"
 require "pathname"
 require "set"
+require "yaml"
 
 $:.unshift(Pathname(__FILE__).dirname)
 
+doubleshot_jar = Pathname(__FILE__).dirname.parent + "target/doubleshot.jar"
+require doubleshot_jar if doubleshot_jar.exist?
+
 require "ruby/gem/requirement"
 require "ruby/string"
 require "ruby/blank"
@@ -12,26 +17,167 @@ require "ruby/time"
 require "doubleshot/readonly_collection"
 require "doubleshot/configuration"
 require "doubleshot/compiler"
+require "doubleshot/lockfile"
 
 class Doubleshot
-  def initialize(&b)
+
+  attr_accessor :path
+  attr_reader   :config
+  attr_reader   :lockfile
+  attr_reader   :classpath
+
+  def initialize
+    @classpath = Set.new
     @config = Doubleshot::Configuration.new
-    yield @config
+    @lockfile = Doubleshot::Lockfile.new
+    yield @config if block_given?
   end
 
   def build_gemspec
     @config.gemspec.to_ruby
   end
 
-  def config
-    @config
-  end
-
   def self.current
     @current ||= load
   end
-  
-  def self.load
-    eval(Pathname("Doubleshot").read)
+
+  def self.load(path = "Doubleshot")
+    path = Pathname(path)
+    doubleshot = eval(path.read)
+    doubleshot.path = path
+    doubleshot
+  end
+
+  # This modifies the current environment.
+  # Do not run this unless you really know what you're
+  # doing (modifying global shared state). The recommended
+  # way to call this, and ensure it's only called once for
+  # your current configuration, is to:
+  #   require "doubleshot/setup"
+  def setup!
+    # This will add your compiled sources to $CLASSPATH so
+    # you can reference your Java classes in Ruby.
+    $CLASSPATH << @config.target.to_url if @config.target.exist?
+
+    # BEGIN: Cleanup tasks
+    #
+    # Delete +lockfile+ and +classpath_file+ if the
+    # Doubleshot file has been modified since they were written.
+    #
+    # SCENARIO: You will run into this if you've added a new dependency
+    # (or made any other change) to your Doubleshot configuration file.
+    if path.exist? && lockfile.exist? && path.mtime > lockfile.mtime
+      lockfile.delete
+      classpath_cache.delete if classpath_cache.exist?
+    end
+
+    # If the above is not true, your Doubleshot file hasn't
+    # been modified, but you may have updated the +lockfile+,
+    # in which case we need to check if the classpath_cache is
+    # still current, or needs to be flushed.
+    #
+    # SCENARIO: You will typically run into this if you've cloned
+    # a Doubleshotted project, where the Doubleshot file and Lockfile
+    # have been committed to the repository, but you have not ever
+    # started the project on your local machine.
+    if lockfile.exist? && classpath_cache.exist? && lockfile.mtime > classpath_cache.mtime
+      classpath_cache.delete
+    end
+    # END: Cleanup tasks
+
+    load_jars! unless @config.runtime.jars.empty? && @config.development.jars.empty?
+  end
+
+  def load_jars!
+    if classpath_cache.exist?
+      # We survived the cleanup checks, go ahead and just load
+      # the cached version of your JARs.
+      cached_paths = YAML::load(classpath_cache)
+
+      lockfile.jars.each do |jar|
+        jar.path = cached_paths[jar.to_s]
+        begin
+          require jar.path
+          self.classpath << jar.path
+        rescue LoadError
+          warn "Could not load: #{jar.path.inspect}"
+          raise
+        end
+      end
+    else
+      # No classpath_cache exists, we must resolve the paths
+      # to our dependencies, then store the results in
+      # classpath_cache for future processes to use.
+      require "doubleshot/resolver"
+
+      if @config.mvn_repositories.empty?
+        @config.mvn_repository Resolver::JarResolver::DEFAULT_REPOSITORY
+      end
+
+      resolver = Resolver::JarResolver.new(*@config.mvn_repositories)
+      jars = nil
+
+      if lockfile.exist?
+        jars = Dependencies::JarDependencyList.new
+        lockfile.jars.each do |jar|
+          jars.add jar
+        end
+      else
+        jars = @config.runtime.jars + @config.development.jars
+      end
+
+      resolver.resolve! jars
+
+      jars.each { |jar| lockfile.add jar }
+      lockfile.flush!
+
+      cache = {}
+      jars.each do |jar|
+        cache[jar.to_s] = jar.path
+        begin
+          require jar.path
+          self.classpath << jar.path
+        rescue LoadError
+          warn "Could not load: #{jar.path.inspect}"
+          raise
+        end
+      end
+
+      classpath_cache.open("w+") do |file|
+        file << cache.to_yaml
+      end
+    end
+  end
+
+  def classpath_cache
+    @classpath_cache ||= Pathname(".classpath.cache")
+  end
+
+  def bootstrap!
+    if !@config.target.exist? || !lockfile.exist? || !classpath_cache.exist? || Pathname("pom.xml").mtime > classpath_cache.mtime
+      # Dependencies classpath:
+      paths = `mvn dependency:build-classpath`.split(/\bDependencies classpath\b/).last.split($/).grep(/\.jar\b/).map { |line| line.split(":") }.flatten
+      coordinates = `mvn dependency:list`.split(/\bfiles have been resolved\b/).last.split($/).grep(/\bcompile$/).map do |line|
+        line.split.last.sub /\:compile$/, ""
+      end
+
+      resolved = Hash[*coordinates.zip(paths).flatten]
+
+      resolved.each_pair do |coordinate, path|
+        require path
+        self.classpath << path
+        jar = Dependencies::JarDependency.new(coordinate)
+        jar.path = path
+        lockfile.add jar
+      end
+
+      lockfile.flush!
+
+      classpath_cache.open("w+") do |file|
+        file << resolved.to_yaml
+      end
+    else
+      setup!
+    end
   end
 end