jenkins-plugin-runtime 0.1.0

data/.gitignore

@@ -0,0 +1,7 @@
+.rvmrc
+*.gem
+.bundle
+.idea
+Gemfile.lock
+pkg/*
+target/

data/.travis.yml

@@ -0,0 +1,2 @@
+rvm:
+  - jruby

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in jenkins-plugins.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,21 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+require 'jenkins/war'
+Jenkins::War.classpath
+ClassPath =  FileList[File.join(ENV['HOME'], '.jenkins', 'wars', Jenkins::War::VERSION, "**/*.jar")].to_a.join(':')
+
+desc "compile java source code"
+task "compile" => "target" do
+  puts command = "javac -classpath #{ClassPath} #{FileList['src/**/*.java']} -d target"
+  system(command)
+end
+
+require 'rake/clean'
+directory "target"
+CLEAN.include("target")
+
+task :default => [:compile, :spec]

data/jenkins-plugin-runtime.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "jenkins/plugin/runtime/version"
+
+Gem::Specification.new do |s|
+  s.name        = "jenkins-plugin-runtime"
+  s.version     = Jenkins::Plugin::Runtime::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Charles Lowell"]
+  s.email       = ["cowboyd@thefrontside.net"]
+  s.homepage    = "http://github.com/cowboyd/jenkins-plugins.rb"
+  s.summary     = %q{Runtime support libraries for Jenkins Ruby plugins}
+  s.description = %q{I'll think of a better description later, but if you're reading this, then I haven't}
+
+  s.rubyforge_project = "jenkins-plugin-runtime"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "json"
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec", "~> 2.0"
+  s.add_development_dependency "rspec-spies"
+  s.add_development_dependency "cucumber", "~> 1.0"
+  s.add_development_dependency "jenkins-war"
+
+end

data/lib/jenkins/launcher.rb

@@ -0,0 +1,15 @@
+
+module Jenkins
+
+  # Launch processes on build slaves. No functionality is currently exposed
+  class Launcher
+    # the nantive hudson.Launcher object
+    attr_reader :native
+
+    def initialize(native = nil)
+      @native = native
+    end
+
+    Plugin::Proxies.register self, Java.hudson.Launcher
+  end
+end

data/lib/jenkins/model.rb

@@ -0,0 +1,91 @@
+
+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
+
+    module InstanceDisplayName
+      # Get the display name of this Model. This value will be used as a default
+      # whenever this model needs to be shown in the UI. If no display name has
+      # been set, then it will use the Model's class name.
+      #
+      # @return [String] the display name
+      def display_name
+        self.class.display_name
+      end
+    end
+
+    module ClassDisplayName
+
+      # Set or get the display name of this Model Class.
+      #
+      # If `name` is not nil, then sets the display name.
+      # @return [String] the display name
+      def display_name(name = nil)
+        name.nil? ? @display_name || self.name : @display_name = name.to_s
+      end
+    end
+
+    module Transience
+
+      # Mark a set of properties that should not be persisted as part of this Model's lifecycle.
+      #
+      # Jenkins supports transparent persistent
+      def transient(*properties)
+        properties.each do |p|
+          transients[p.to_sym] = true
+        end
+      end
+
+      def transient?(property)
+        transients.keys.member?(property.to_sym) || (superclass < Model && superclass.transient?(property))
+      end
+
+      def transients
+        @transients ||= {}
+      end
+    end
+
+    module Descendants
+      def descendant(mod)
+        @descendants ||= clear
+        @descendants[mod] = true
+      end
+
+      def descendants
+        @descendants.keys
+      end
+
+      def clear
+        @descendants = {}
+      end
+
+      def descendant?(cls)
+        @descendants[cls]
+      end
+    end
+    extend Descendants
+  end
+end

data/lib/jenkins/model/action.rb

@@ -0,0 +1,37 @@
+
+module Jenkins
+  module Model
+    module Action
+      include Model
+
+      module Included
+        def included(cls)
+          super(cls)
+          if cls.class == Module
+            cls.extend(Included)
+          else
+            cls.extend(ClassMethods)
+            cls.send(:include, InstanceMethods)
+          end
+        end
+      end
+      extend Included
+
+      # def included(cls)
+      #   super(cls)
+      #   cls.send(:include)
+      # end
+      module InstanceMethods
+        def icon
+          self.class.icon
+        end
+      end
+      # 
+      module ClassMethods
+        def icon(path = nil)
+          path.nil? ? @path : @path = path.to_s
+        end
+      end
+    end
+  end
+end

data/lib/jenkins/model/build.rb

@@ -0,0 +1,21 @@
+
+module Jenkins
+  module Model
+    ##
+    # Represents a single build. In general, you won't need this
+    #
+    class Build
+
+      ##
+      # the Hudson::Model::AbstractBuild represented by this build
+      attr_reader :native
+
+      def initialize(native = nil)
+        @native = native
+      end
+
+      Jenkins::Plugin::Proxies.register self, Java.hudson.model.AbstractBuild
+    end
+
+  end
+end

data/lib/jenkins/model/describable.rb

@@ -0,0 +1,75 @@
+
+module Jenkins
+  module Model
+
+    # Register a Ruby class as a Jenkins extension point
+
+    # When Jenkins is searching for all the extension points of a particular
+    # type... let's say `Builder` for example. It first asks for all the `Descriptor`s
+    # registered to describe the `Builder` type. It will then use the descriptors
+    # it finds to do things like construct and validate the extension objects.
+    #
+    # It helps me to think about the Jenkins `Descriptor` as a Ruby class. It is a
+    # factory for instances, and contains data about what those instances can do.
+    #
+    # This module, when included, provides a single class method `describe_as`
+    # which tell Jenkins in effect "when you are looking for Java Classes of this type"
+    # you can use this ruby class too. e.g.
+    #
+    #     class Builder
+    #       include Jenkins::Model::Describeable
+    #       describe_as Java.hudson.tasks.Builder
+    #     end
+    #
+    # behind the scenes, this creates a `Descriptor` instance registered against the java type
+    # `Java.hudson.tasks.Builder`. Now, any time Jenkins asks about what kind of `hudson.tasks.Builder`s there
+    # are in the system, this class will come up.
+    #
+    # This class should generally not be needed by plugin authors since it is part of the
+    # glue layer and not the public runtime API.
+    module Describable
+      DescribableError = Class.new(StandardError)
+
+      module DescribeAs
+        def describe_as cls
+          if defined?(cls.java_class) && cls.is_a?(Class)
+            @describe_as_type = cls.java_class
+          else
+            fail DescribableError, "#{cls.class.inspect} is not an instance of java.lang.Class"
+          end
+        end
+        def describe_as_type
+          @describe_as_type
+        end
+      end
+
+      # When a Describable class is subclassed, make it also Describable
+      module Inherited
+        def inherited(cls)
+          super(cls)
+          cls.extend Inherited
+          describe_as_type = @describe_as_type
+          cls.class_eval do
+            @describe_as_type = describe_as_type
+          end
+          if Jenkins::Plugin.instance
+            Jenkins::Plugin.instance.register_describable(cls, describe_as_type)
+          end
+        end
+      end
+
+      module Included
+        def included(mod)
+          super
+          if mod.is_a? Class
+            mod.extend DescribeAs
+            mod.extend Inherited
+          else
+            warn "tried to include Describable into a Module. Are you sure?"
+          end
+        end
+      end
+      self.extend Included
+    end
+  end
+end

data/lib/jenkins/model/descriptor.rb

@@ -0,0 +1,40 @@
+
+require 'json'
+
+module Jenkins
+  module Model
+    class Descriptor < Java.hudson.model.Descriptor
+
+      def initialize(impl, plugin, java_type)
+        super(Java.org.jruby.RubyObject.java_class)
+        @impl, @plugin, @java_type = impl, plugin, java_type
+      end
+
+      def getDisplayName
+        @impl.display_name
+      end
+
+      def getT()
+        @java_type
+      end
+
+      def newInstance(request, form)
+        properties = JSON.parse(form.toString(2))
+        properties.delete("kind")
+        properties.delete("stapler-class")
+        instance = @plugin.export(construct(properties))
+        puts "instance created: #{instance}"
+        return instance
+      end
+
+      private
+
+      def construct(attrs)
+        @impl.new(attrs)
+      rescue ArgumentError
+        @impl.new
+      end
+    end
+
+  end
+end

data/lib/jenkins/model/listener.rb

@@ -0,0 +1,47 @@
+
+module Jenkins
+  module Model
+
+    # Receive/Send events about a running task
+    class Listener
+
+      # the underlying hudson.model.TaskListener object
+      attr_reader :native
+
+      def initialize(native = nil)
+        @native = native
+      end
+
+      ##
+      # Insert a clickable hyperlink into this tasks's output
+      # @param [String] url the link target
+      # @param [String] text the link content
+      def hyperlink(url, text)
+        @native.hyperlink(url, text)
+      end
+
+      ##
+      # Append a message to the task output.
+      # @param [String] msg the message
+      def log(msg)
+        @native.getLogger().write(msg.to_s)
+      end
+
+      ##
+      # Append an error message to the task output.
+      # @param [String] msg the error message
+      def error(msg)
+        @native.error(msg.to_s)
+      end
+
+      ##
+      # Append a fatal error message to the task output
+      # @param [String] msg the fatal error message
+      def fatal(msg)
+        @native.fatalError(msg.to_s)
+      end
+
+      Jenkins::Plugin::Proxies.register self, Java.hudson.util.AbstractTaskListener
+    end
+  end
+end

data/lib/jenkins/plugin.rb

@@ -0,0 +1,141 @@
+
+require 'pathname'
+
+module Jenkins
+  # Acts as the primary gateway between Ruby and Jenkins
+  # There is one instance of this object for the entire
+  # plugin
+  #
+  # On the Java side, it contains a reference to an instance
+  # of RubyPlugin. These two objects talk to each other to
+  # get things done.
+  #
+  # Each running ruby plugin has exactly one instance of
+  # `Jenkins::Plugin`
+  class Plugin
+
+    # A list of all the hudson.model.Descriptor objects
+    # of which this plugin is aware *indexed by Wrapper class*
+    #
+    # This is used so that wrappers can always have a single place
+    # to go when they are asked for a descriptor. That way, wrapper
+    # instances can always return the descriptor associated with
+    # their class.
+    #
+    # This may go away.
+    attr_reader :descriptors
+
+    # the instance of jenkins.ruby.RubyPlugin with which this Plugin is associated
+    attr_reader :peer
+
+    # Initializes this plugin by reading the models.rb
+    # file. This is a manual registration process
+    # Where ruby objects register themselves with the plugin
+    # In the future, this process will be automatic, but
+    # I haven't decided the best way to do this yet.
+    #
+    # @param [org.jenkinsci.ruby.RubyPlugin] java a native java RubyPlugin
+    def initialize(java)
+      @java = @peer = java
+      @start = @stop = proc {}
+      @descriptors = {}
+      @proxies = Proxies.new(self)
+    end
+
+    # Initialize the singleton instance that will run for a
+    # ruby plugin. This method is designed to be called by the
+    # Java side when setting up the ruby plugin
+    # @return [Jenkins::Plugin] the singleton instance
+    def self.initialize(java)
+      #TODO: check for double initialization?!?
+      @instance = new(java)
+      @instance.load_models
+      return @instance
+    end
+
+    # Get the singleton instance associated with this plugin
+    #
+    # This is useful when code in the plugin needs to get a
+    # reference to the plugin in which it is running e.g.
+    #
+    #     Jenkins::Plugin.instance #=> the running plugin
+    #
+    # @return [Jenkins::Plugin] the singleton instance
+    def self.instance
+      @instance
+    end
+
+    # Register a ruby class as a Jenkins extension point of
+    # a particular java type
+    #
+    # This method is invoked automatically as part of the auto-registration
+    # process, and should not need to be invoked by plugin code.
+    #
+    # @param [Class] ruby_class the class implementing the extension point
+    # @param [java.lang.Class] java_class that Jenkins will see this extention point as
+    def register_describable(ruby_class, java_class)
+      descriptor = Jenkins::Model::Descriptor.new(ruby_class, self, java_class)
+      @peer.addExtension(descriptor)
+      @descriptors[ruby_class] = descriptor
+    end
+
+    # unique identifier for this plugin in the Jenkins server
+    def name
+      @peer.getWrapper().getShortName()
+    end
+
+    # Called once when Jenkins first initializes this plugin
+    # currently does nothing, but plugin startup hooks would
+    # go here.
+    def start
+      @start.call()
+    end
+
+    # Called one by Jenkins (via RubyPlugin) when this plugin
+    # is shut down. Currently this does nothing, but plugin
+    # shutdown hooks would go here.
+    def stop
+      @stop.call()
+    end
+
+    # Reflect an Java object coming from Jenkins into the context of this plugin
+    # If the object is originally from the ruby plugin, and it was previously
+    # exported, then it will unwrap it. Otherwise, it will just use the object
+    # as a normal Java object.
+    #
+    # @param [Object] object the object to bring in from the outside
+    # @return the best representation of that object for this plugin
+    def import(object)
+      @proxies.import object
+    end
+
+    # Reflect a native Ruby object into its External Java form.
+    #
+    # Delegates to `Proxies` for the heavy lifting.
+    #
+    # @param [Object] object the object
+    # @returns [java.lang.Object] the Java proxy
+    def export(object)
+      @proxies.export object
+    end
+
+    # Link a plugin-local Ruby object to an external Java object.
+    #
+    # see 'Proxies#link`
+    #
+    # @param [Object] internal the object on the Ruby side of the link
+    # @param [java.lang.Object] external the object on the Java side of the link
+    def link(internal, external)
+      @proxies.link internal, external
+    end
+
+    def load_models
+      p = @java.getModelsPath().getPath()
+      puts "Trying to load models from #{p}"
+      for filename in Dir["#{p}/**/*.rb"]
+        puts "Loading "+filename
+        load filename
+      end
+    end
+  end
+end