Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package hudson.plugins.rake;
  
  import static hudson.plugins.rake.Util.getCanonicalRubies;
  import static hudson.plugins.rake.Util.getGemsDir;
  import static hudson.plugins.rake.Util.hasGemsInstalled;
  import static hudson.plugins.rake.Util.isRakeInstalled;
  import hudson.CopyOnWrite;
  import hudson.Launcher;
  import hudson.Util;
 
 import java.io.File;
 
 
Rake plugin main class.

Author(s):
David Calavera
 
 @SuppressWarnings({"unchecked""serial"})
 public class Rake extends Builder {
 
 	public static final RakeDescriptor DESCRIPTOR = new RakeDescriptor();
 	private final String rakeInstallation;
 	private final String rakeFile;
 	private final String rakeLibDir;
 	private final String tasks;
 	private final boolean silent;
 	
     public Rake(String rakeInstallationString rakeFileString tasksString rakeLibDirboolean silent) {
 		this. = rakeInstallation;
         this. = rakeFile;
         this. = tasks;
         this. = rakeLibDir;
         this. = silent;
     }
 	
 	private RubyInstallation getRake() {
 			if ( != null && rake.getName().equals()) {
 				return rake;
 			}
 		}
 		return null;
 	}
 	
 	public boolean perform(Build<?,?> buildLauncher launcherBuildListener listenerthrows InterruptedException {
 		Project proj = build.getProject();
         ArgumentListBuilder args = new ArgumentListBuilder();
         String normalizedTasks = .replaceAll("[\t\r\n]+"," ");
                 
         RubyInstallation rake = getRake();
         if (rake != null) {        	
         	File exec = rake.getExecutable();
             if(!exec.exists()) {
                 listener.fatalError(exec + " doesn't exist");
                 return false;
             }
             args.add(exec.getPath());
         } else {
         	args.add(launcher.isUnix()?"rake":"rake.bat");
         }        
         
         if ( != null && .length() > 0) {
         	args.add("--rakefile");
         }
         if ( != null && .length() > 0) {
         	args.add("--libdir");
         }
         if () {
         	args.add("--silent");
         }
         
         args.addTokenized(normalizedTasks);
         
         try {
             int r = launcher.launch(args.toCommandArray(), build.getEnvVars(), listener.getLogger(), proj.getModuleRoot()).join();
             return r == 0;
         } catch (IOException e) {
             Util.displayIOException(e,listener);
             e.printStackTrace(listener.fatalError("rake execution failed"));
             return false;
         }
 	}	
 	
     public RakeDescriptor getDescriptor() {
         return ;
    }
    
    public String getRakeInstallation() {
    	return ;
    }
    
    public String getRakeFile() {
		return ;
	}
	public String getRakeLibDir() {
		return ;
	}
	public String getTasks() {
		return ;
	}
	public boolean isSilent() {
		return ;
	}	
   
	public static final class RakeDescriptor extends Descriptor<Builder> {	
    	
        private volatile RubyInstallation[] installations = new RubyInstallation[0];
    	private RakeDescriptor() {
            super(Rake.class);
            load();
        }
    	
    	@Override
		public synchronized void load() {
			super.load();			
		}
        public String getDisplayName() {
            return "Invoke Rake";
        }
        
        public Builder newInstance(StaplerRequest req) {            
        	return req.bindParameters(Rake.class,"rake.");
        }
        
        @Override
        public String getHelpFile() {
        	return "/plugin/rake/help.html";
        }
		public boolean configure(StaplerRequest reqthrows FormException {
			save();			
	        return true;
		}
		}
		public void doCheckRubyInstallation(StaplerRequest reqStaplerResponse rspthrows IOExceptionServletException {        
	        new FormFieldValidator(req,rsp,true) {
	            public void check() throws IOExceptionServletException {
	                File f = getFileParameter("value");
	                if(!f.isDirectory()) {
	                    error(f + " is not a directory");
	                    return;
	                }
	                
	                if (!hasGemsInstalled(f.getAbsolutePath())) {
	                	error("It seems that ruby gems is not installed");
	                	return;
	                }
	                
	                if (!isRakeInstalled(getGemsDir(f.getAbsolutePath()))) {
	                	error("It seems that rake is not installed");
	                	return;
	                }	                	                
	                	                	                
	                ok();
	            }
	        }.process();
	    }
    }	
New to GrepCode? Check out our FAQ X