jenkins-plugin-runtime 0.1.18 → 0.1.20

data/README.md

@@ -0,0 +1,12 @@
+
+# Jenkins Plugin Runtime
+
+This gem provides the glue between the native Jenkins runtime
+which is implemented in Java, and an idiomatic API that allows
+for development with a Ruby 'feel'
+
+If you're interested in developing actual plugin, see the
+[plugin development tools][1]
+
+[1]:https://github.com/jenkinsci/jpi.rb
+

data/Rakefile

@@ -3,6 +3,7 @@ Bundler::GemHelper.install_tasks
 
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
+task :spec => :compile
 
 require 'jenkins/war'
 Jenkins::War.classpath
@@ -18,4 +19,4 @@ require 'rake/clean'
 directory "target"
 CLEAN.include("target")
 
-task :default => [:compile, :spec]
+task :default => [:compile, :spec]

data/jenkins-plugin-runtime.gemspec

@@ -20,9 +20,10 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.add_dependency "json"
+  s.add_dependency "slop", "~> 3.0.2"
 
   s.add_development_dependency "rake", "0.8.7"
-  s.add_development_dependency "rspec", "~> 2.0"
+  s.add_development_dependency "rspec", "~> 2.7.0" # something in rspec 2.8 breaks rspec-spies
   s.add_development_dependency "rspec-spies"
   s.add_development_dependency "jenkins-war", "~> 1.445"
 

data/lib/core_ext/exception.rb

@@ -0,0 +1,36 @@
+# From utilrb's full_message.rb, http://utilrb.rubyforge.org/
+# http://gitorious.org/+rock-core-maintainers/orocos-toolchain/rock-utilrb
+#
+# Copyright (c) 2006-2008
+# Sylvain Joyeux <sylvain.joyeux@m4x.org>
+# LAAS/CNRS <openrobots@laas.fr>
+#
+# Released under the BSD license,
+# http://gitorious.org/+rock-core-maintainers/orocos-toolchain/rock-utilrb/blobs/master/License.txt
+
+class Exception
+  def full_message(options = {}, &block)
+    since_matches, until_matches = options[:since], options[:until]
+
+    trace = backtrace
+    if since_matches || until_matches
+      found_beginning, found_end = !since_matches, false
+      trace = trace.find_all do |line|
+        found_beginning ||= (line =~ since_matches)
+        found_end     ||= (line =~ until_matches) if until_matches
+        found_beginning && !found_end
+      end
+    end
+
+    first, *remaining = if block_given? then trace.find_all(&block)
+                        else trace
+                        end
+
+    msg = "#{first}: #{message} (#{self.class})"
+    unless remaining.empty?
+      msg << "\n\tfrom " + remaining.join("\n\tfrom ")
+    end
+
+    msg
+  end
+end

data/lib/jenkins/cli/command.rb

@@ -0,0 +1,167 @@
+require 'slop'
+
+module Jenkins::CLI
+  # Extend the Jenkins CLI
+  #
+  # Jenkins ships with a CLI which can be used to iteract with it
+  # from a terminal, or from a program. It also exposes an API with
+  # which developers can extend the CLI with their own commands.
+  #
+  # The Ruby API allows you define a command as a Ruby class, which
+  # is then instantiated once for each invocation of the command via
+  # the CLI.
+  #
+  # Argument parsing is flexible, and a parsing scheme (Slop) is
+  # provided by default, but this is optional behavior which can
+  # be overridden.
+  #
+  # Include this to define a new CLI / SSHD command. Example:
+  #
+  #   class HelloWorldCommand
+  #     include Jenkins::CLI::Command
+  #
+  #     description "Hello world sample command"
+  #
+  #     arguments do
+  #       on :v, :verbose, 'Print verbosely'
+  #       on :n, :name=, 'Set your name, if not Joe', :default => 'Joe'
+  #     end
+  #
+  #     run do
+  #       puts "Hello #{options[:name]}!"
+  #       if options.verbose?
+  #         puts "It's currently #{Time.now}"
+  #         puts "Very glad to see you! How are you doing today?"
+  #       end
+  #     end
+  #   end
+  #
+  # This will create a Jenkins CLI command called `hello-world`
+  # Which can be used as
+  #     jenkins-cli hello-world --n cowboyd -v
+  #
+  # @see {https://github.com/injekt/slop Slop}
+  # @see {https://wiki.jenkins-ci.org/display/JENKINS/Jenkins+CLI Running Jenkins CLI}
+  module Command
+    extend Jenkins::Plugin::Behavior
+
+    implemented do |cls|
+      cls.instance_eval do
+        @slop_block = Proc.new {}
+        @run_block = Proc.new {}
+        @description = 'No description'
+        command_name default_command_name
+      end
+      Jenkins.plugin.register_extension CommandProxy.new(Jenkins.plugin, cls.new)
+    end
+
+    module ClassMethods
+      attr_reader :slop_block, :run_block
+
+      # Set (or get) the description shown by this command in the 'help' CLI
+      # command. Also used in the default implementation of Slop's banner -
+      # meaning the my-command --help output.
+      #
+      # Example: description "Cool command that'll rock your world!"
+      # @param [String] description the description of the command
+      # @return [String] the description of the command
+      def description(desc = nil)
+        desc ? @description = desc : @description
+      end
+
+      # Set up the block passed to Slop.parse. See the Slop README for
+      # information on the way this block works:
+      # https://github.com/injekt/slop/blob/master/README.md
+      #
+      # Example: arguments { on :v, :verbose, "Be verbose" }
+      #
+      # @yield a declaration of arguments and options of this command
+      def arguments(&slop_block)
+        @slop_block = slop_block
+      end
+
+      # Define the actual implementation of the command
+      #
+      # This block specified with {#run} will be invoked in the
+      # scope of a fresh instance for each command invocation.
+      #
+      # Example: run { puts "Hello world" }
+      #
+      # @yield the command body
+      def run(&run_block)
+        @run_block = run_block
+      end
+
+      # Get/set the name by which the command will be invoked.
+      #
+      # This is what the user has to call the command as. The default value is
+      # the class name, with any 'Command' suffix removed, and the 'CamelCase'
+      # words separated using hypen, into 'camel-case'. For example this turns
+      # `HelloWorldCommand` into `hello-world`.
+      #
+      # To use a custom name, just invoke it with that name. E.g.
+      #
+      #    command_name "my-cooler-name"
+      #
+      # @param [String] the name with which the command will be invoked
+      # @return [String] the command name
+      def command_name(command_name = nil)
+        command_name ? @command_name = command_name : @command_name
+      end
+
+      # We use this to initialize the default value of @command_name. You can
+      # override this using the above `command_name`.
+      def default_command_name
+        command = name
+
+        # Replace any 'CLICommand' or 'Command' suffix on class name.
+        command = command.sub(/(CLI)?Command$/, '')
+
+        # Then convert "FooBarZot" into "Foo-Bar-Zot"
+        command = command.gsub(/([a-z0-9])([A-Z])/, '\1-\2')
+
+        # Then lower-case it.
+        command.downcase
+      end
+    end
+
+    module InstanceMethods
+      attr_reader :options
+
+      # Set up the instance with command-line arguments.
+      #
+      # Any arguments from the terminal will be passed to {#parse} as
+      # a whitespace separated list. The default implementation uses
+      # Slop to parse this list with the block passed to {.arguments}
+      #
+      # Note: If this method returns a falsy value, then the command will
+      # *not* be run.
+      #
+      # You can override this instance method if you don't want to use Slop, or
+      # if you want to do some preprocessing before Slop is called.
+      # param [Array] args the list of whitespace separated command line arguments
+      # return [Object] a truthy value if the parse succeeded and the command can be run.
+      def parse(args)
+        default_banner = "#{self.class.command_name} [options] - #{self.class.description}"
+        @options = Slop.new(:help => true, :strict => true,
+                            :banner => default_banner, &self.class.slop_block)
+        @options.parse(args)
+      rescue Slop::Error => e
+        $stderr.puts e.message
+        $stderr.puts @options.help
+      end
+
+      # Run the command.
+      #
+      # This method is invoked immediately after {#parse} and
+      # implements the "meat" of the command. By default, it invokes
+      # body specified with {.run}.
+      #
+      # There should generally be no reason to override this, but hey
+      # it's your world! :-)
+      def run
+        self.instance_eval(&self.class.run_block)
+      end
+    end
+  end
+end

data/lib/jenkins/cli/command_proxy.rb

@@ -0,0 +1,62 @@
+require 'core_ext/exception'
+
+module Jenkins::CLI
+  # The native Java CLICommand class has a static initializer
+  # that prevents the class from being loaded without a running
+  # Jenkins instance. This disgusting hack detects if we're in
+  # RSpec mode and just creates the proxy class without descending
+  # from the Java class.
+  if Jenkins.rspec_ewwww_gross_hack?
+    class CommandProxy; end
+  else
+    class CommandProxy < Java.hudson.cli.CLICommand; end
+  end
+
+  class CommandProxy
+    include Jenkins::Plugin::Proxy
+
+    AbortException = Java.hudson.AbortException
+
+    def getShortDescription
+      @object.class.description
+    end
+
+    def createClone
+      self.dup.tap do |dup|
+        dup.instance_variable_set(:@object, @object.dup)
+      end
+    end
+
+    # This mirrors what Java.hudson.cli.CLICommand#getName does, but with the
+    # @object's class instead.
+    def getName
+      @object.class.command_name
+    end
+
+    def run
+      # We don't call run from within our main, but needs to be here to satisfy the Java Interface
+      raise RuntimeError, "This method should never be called."
+    end
+
+    # main(List<String> args, Locale locale, InputStream stdin, PrintStream stdout, PrintStream stderr)
+    def main(args, locale, stdin, stdout, stderr)
+      old_in, old_out, old_err = $stdin, $stdout, $stderr
+      begin
+        $stdin, $stdout, $stderr = stdin.to_io, stdout.to_io, stderr.to_io
+        if @object.parse(args.to_a)
+          @object.run
+          return 0
+        else
+          return -1
+        end
+      rescue AbortException
+        return -1
+      rescue => e
+        $stderr.puts e.full_message
+        return -1
+      ensure
+        $stdin, $stdout, $stderr = old_in, old_out, old_err
+      end
+    end
+  end
+end

data/lib/jenkins/filepath.rb

@@ -2,14 +2,9 @@ require 'pathname'
 
 module Jenkins
   class FilePath
+    include Jenkins::Plugin::Wrapper
     Stat = Struct.new(:size, :mode, :mtime)
 
-    attr_reader :native
-
-    def initialize(native)
-      @native = native
-    end
-
     # Ruby's Pathname internace
 
     def +(name)

data/lib/jenkins/launcher.rb

@@ -2,12 +2,11 @@ module Jenkins
 
   # Launch processes on build slaves. No functionality is currently exposed
   class Launcher
-    class Proc
-      attr_reader :native
+    include Jenkins::Plugin::Wrapper
+    wrapper_for Java.hudson.Launcher
 
-      def initialize(native)
-        @native = native
-      end
+    class Proc
+      include Jenkins::Plugin::Wrapper
 
       def alive?
         @native.isAlive()
@@ -35,13 +34,6 @@ module Jenkins
       end
     end
 
-    # the native hudson.Launcher object
-    attr_reader :native
-
-    def initialize(native = nil)
-      @native = native
-    end
-
     # execute([env,] command... [,options]) -> fixnum
     def execute(*args)
       spawn(*args).join
@@ -113,7 +105,5 @@ module Jenkins
       end
       [env || {}, cmd, opt || {}]
     end
-
-    Plugin::Proxies.register self, Java.hudson.Launcher
   end
 end

data/lib/jenkins/model.rb

@@ -1,30 +1,7 @@
 
 module Jenkins
   module Model
-
-    module Included
-      def included(cls)
-        super(cls)
-        if cls.class == Module
-          cls.extend(Included)
-        else
-          cls.extend(Inherited)
-          cls.extend(ClassDisplayName)
-          cls.extend(Transience)
-          cls.send(:include, InstanceDisplayName)
-        end
-        Model.descendant(cls)
-      end
-    end
-    extend Included
-
-    module Inherited
-      def inherited(cls)
-        super(cls)
-        Model.descendant(cls)
-        cls.extend(Inherited)
-      end
-    end
+    extend Plugin::Behavior
 
     module InstanceDisplayName
       # Get the display name of this Model. This value will be used as a default
@@ -66,26 +43,16 @@ module Jenkins
       def transients
         @transients ||= {}
       end
-    end
 
-    module Descendants
-      def descendant(mod)
-        @descendants ||= clear
-        @descendants[mod] = true
-      end
-
-      def descendants
-        @descendants.keys
-      end
+    end
 
-      def clear
-        @descendants = {}
-      end
+    module ClassMethods
+      include ClassDisplayName
+      include Transience
+    end
 
-      def descendant?(cls)
-        @descendants[cls]
-      end
+    module InstanceMethods
+      include InstanceDisplayName
     end
-    extend Descendants
   end
 end

data/lib/jenkins/model/action.rb

@@ -1,13 +1,8 @@
-
 require 'jenkins/model'
 
 module Jenkins
   module Model
-
-    # TODO: I turned Action into Class from Module but it should be a bad idea.
-    # The change may be reverted. I used class Action for implementing a model
-    # as a describable but I really should do is implementing describable.
-    class Action
+    module Action
       include Model
 
       module InstanceMethods
@@ -29,9 +24,6 @@ module Jenkins
           path.nil? ? @url_path : @url_path = path.to_s
         end
       end
-
-      include InstanceMethods
-      extend ClassMethods
     end
   end
 end