mort666-jira4r 1.0.2

data/LICENSE

@@ -0,0 +1,14 @@
+
+   Copyright 2006 Codehaus Foundation
+
+   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.

data/NOTICE

@@ -0,0 +1,3 @@
+Codehaus JIRA4R
+
+Copyright 2007-2008 The Codehaus Foundation

data/README.rdoc

@@ -0,0 +1,11 @@
+= jira4r
+
+this is a git import of jira4r, real website: http://jira4r.rubyhaus.org
+
+i didn't make this!  this is Licensed under the Apache License, Version 2.0
+
+any of my changes are also released under the Apache License, Version 2.0
+
+== TODO
+
+* add extensions!  @filter.issues ... @issue.type ... etc.  maybe with some caching?

data/Rakefile

@@ -0,0 +1,57 @@
+require 'rake'
+require 'rubygems'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name        = "jira4r"
+    s.summary     = "Ruby library for controlling JIRA"
+    s.email       = "remi@remitaylor.com"
+    s.homepage    = "http://github.com/remi/jira4r"
+    s.description = "Ruby library for controlling JIRA"
+    s.authors     = %w( bwalding remi )
+    s.files       = FileList["[A-Z]*", "{lib,spec,examples,rails_generators}/**/*"] 
+    # s.executables = "neato" 
+    # s.add_dependency 'person-project' 
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new('rcov') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.rcov = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'jira4r'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Confirm that gemspec is $SAFE'
+task :safe do
+  require 'yaml'
+  require 'rubygems/specification'
+  data = File.read('jira4r.gemspec')
+  spec = nil
+  if data !~ %r{!ruby/object:Gem::Specification}
+    Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
+  else
+    spec = YAML.load(data)
+  end
+  spec.validate
+  puts spec
+  puts "OK"
+end
+
+task :default => :spec

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 0
+:major: 1
+:minor: 0

data/examples/addComment.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+#
+#If running as part of distribution
+require File.dirname(__FILE__) + '/../lib/jira4r/jira4r.rb'
+#If using GEM install
+#require 'jira4r/jira4r'
+
+
+
+jira = Jira::JiraTool.new(2, "http://test.jira.codehaus.org")
+jira.login("admin", "password")
+
+#So we have an existing user
+if not jira.getUser("midget")
+  jira.createUser("midget", `date`.strip, "Midget User", "midget@example.com")
+end
+
+

data/examples/getGroup-https.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+#
+#If running as part of distribution
+require File.dirname(__FILE__) + '/../lib/jira4r/jira4r.rb'
+#If using GEM install
+#require 'jira4r/jira4r'
+
+#This is for testing the SSL connection; you will need to install http-access2 to really see the SSL 
+#certificate verification in action.
+
+jira = Jira::JiraTool.new(2, "https://jira.atlassian.com")
+
+jira.driver.options["protocol.http.ssl_config.verify_mode"] = nil
+
+jira.login("soaptester", "soaptester")
+
+jira.getGroup("montage-developers")

data/examples/getGroup.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+#
+#If running as part of distribution
+require File.dirname(__FILE__) + '/../lib/jira4r/jira4r.rb'
+#If using GEM install
+#require 'jira4r/jira4r'
+
+
+
+jira = Jira::JiraTool.new(2, "http://jira.atlassian.com")
+
+jira.login("soaptester", "soaptester")
+
+group = jira.getGroup("montage-developers")
+if not group
+  jira.createGroup("montage-developers", nil)
+end
+

data/examples/getNotificationScheme.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+#
+#If running as part of distribution
+require File.dirname(__FILE__) + '/../lib/jira4r/jira4r.rb'
+#If using GEM install
+#require 'jira4r/jira4r'
+
+
+
+jira = Jira::JiraTool.new(2, "http://jira.atlassian.com")
+
+jira.login("soaptester", "soaptester")
+
+puts jira.getNotificationScheme("Default Notification Scheme").inspect

data/examples/getProject.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+#
+#If running as part of distribution
+require File.dirname(__FILE__) + '/../lib/jira4r/jira4r.rb'
+#If using GEM install
+#require 'jira4r/jira4r'
+
+
+
+jira = Jira::JiraTool.new(2, "http://jira.atlassian.com")
+
+jira.login("soaptester", "soaptester")
+
+puts jira.getProject("DEMO").inspect

data/examples/getProjects.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+#If running as part of distribution
+require File.dirname(__FILE__) + '/../lib/jira4r/jira4r.rb'
+#If using GEM install
+#require 'jira4r/jira4r'
+
+
+
+jira = Jira::JiraTool.new(2, "http://jira.atlassian.com")
+
+jira.login("soaptester", "soaptester")
+
+jira.getProjects().each { |project|
+  puts project.key
+}

data/examples/subtract-members

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+################################################################################
+#  Copyright 2007 Codehaus Foundation                                          #
+#                                                                              #
+#  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.                                              #
+################################################################################
+# This script is extremely useful for migrating users from one group to another
+# where you don't want duplicates; i.e. creating an admin group which has a superset
+# of the permission of the second group.
+$: <<  'lib'
+require 'jira4r/jira_tool.rb'
+
+# Will 
+if ARGV.length != 5
+  puts "Usage: subtract-members URL USER PASS GROUP-A GROUP-B"
+  puts "       Removes all members from GROUP-A that are in GROUP-B"
+  puts "       subtract-members http://jira.example.com jim password clown-developers clown-dev"
+  exit 1
+end
+
+url, username, password, group_a, group_b = ARGV
+jira =  Jira4R::JiraTool.new(2, url)
+jira.login(username, password)
+
+
+jira_group_a = jira.getGroup(group_a)
+jira_group_b = jira.getGroup(group_b)
+
+remote_users = {}
+users_a = jira_group_a.users.collect { |u| 
+  remote_users[u.name] = u
+  u.name 
+}
+users_b = jira_group_b.users.collect { |u| 
+  remote_users[u.name] = u
+  u.name 
+}
+
+for user in users_a
+  if users_b.include?(user)
+    puts "Removing #{user} from #{group_a}"
+    jira.removeUserFromGroup(jira_group_a, remote_users[user])
+  end
+end

data/lib/jira4r.rb

@@ -0,0 +1,27 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'rubygems' # i'd like to not need this
+
+begin
+  gem 'soap4r'
+  require 'soap/rpc/driver'
+rescue LoadError
+  raise "jira4r requires soap4r.  to install: gem install soap4r"
+end
+
+require 'jira4r/jira_tool'
+
+# Due to refactoring, this class should no longer be used.
+module Jira
+  class JiraTool
+    
+    def initialize(version, base_url)
+      puts "Jira::JiraTool is deprecated; use Jira4R::JiraTool"
+      @proxy = ::Jira4R::JiraTool.new(version, base_url)
+    end
+    
+    def method_missing(name, *args)
+      @proxy.send(name, *args)
+    end
+  end
+end

data/lib/jira4r/jira4r.rb

@@ -0,0 +1 @@
+require 'jira4r' # for backwards compatibility

data/lib/jira4r/jira_tool.rb

@@ -0,0 +1,213 @@
+require 'logger'
+require 'rubygems'
+gem 'soap4r'
+
+module Jira4R
+  
+  class JiraTool
+    attr_accessor :enhanced
+    
+    # Create a new JiraTool
+    # 
+    # where:
+    # version ... the version of the SOAP API you wish to use - currently supported versions  [ 2 ]
+    # base_url ... the base URL of the JIRA instance - eg. http://confluence.atlassian.com
+    def initialize(version, base_url)
+      @version = version
+      @base_url = base_url  
+      @logger = Logger.new(STDERR)
+      @endpoint_url = "#{@base_url}/rpc/soap/jirasoapservice-v#{version}"
+    end
+    
+    #Assign a new logger to the tool. By default a STDERR logger is used.
+    def logger=(logger)
+      @logger = logger
+    end
+    
+    #Retrieve the driver, creating as required.
+    def driver()
+      if not @driver
+        @logger.info( "Connecting driver to #{@endpoint_url}" )
+
+        require "jira4r/v#{@version}/jiraService.rb"
+        require "jira4r/v#{@version}/JiraSoapServiceDriver.rb"
+        require "jira4r/v#{@version}/jiraServiceMappingRegistry.rb"
+        
+        service_classname = "Jira4R::V#{@version}::JiraSoapService"
+        puts "Service: #{service_classname}"
+        service = eval(service_classname)
+        @driver = service.send(:new, @endpoint_url)
+        # Ignore SSL Certs that are Self Signed or Signed by a None Standard CA
+        @driver.options['protocol.http.ssl_config.verify_mode'] = OpenSSL::SSL::VERIFY_NONE
+      end
+      @driver
+    end
+    
+    #Assign a wiredump file prefix to the driver.
+    def wiredump_file_base=(base)
+      driver().wiredump_file_base = base
+    end
+    
+  
+    #Login to the JIRA instance, storing the token for later calls. 
+    # 
+    #This is typically the first call that is made on the JiraTool.
+    def login(username, password)
+      @token = driver().login(username, password)
+    end
+
+    #Clients should avoid using the authentication token directly.    
+    def token()
+      @token
+    end
+    
+    #Call a method on the driver, adding in the authentication token previously determined using login()
+    def call_driver(method_name, *args)
+      @logger.debug("Finding method #{method_name}")
+      method = driver().method(method_name)     
+      
+      if args.length > 0
+        method.call(@token, *args)     
+      else
+        method.call(@token)
+      end
+    end
+    
+    #Retrieve a project without the associated PermissionScheme.
+    #This will be significantly faster for larger Jira installations.
+    #See: JRA-10660
+    def getProjectNoScheme(key)
+      puts "getProjectNoScheme is deprecated. Please call getProjectNoSchemes."
+      getProjectNoSchemes(key)
+    end
+    
+    def getProjectNoSchemes(key)
+      self.getProjectsNoSchemes().find { |project| project.key == key }
+    end
+    
+    def getProject(key)
+      #Jira > 3.10 has been patched to support this method directly as getProjectByKey
+      puts "Using deprecated JIRA4R API call getProject(key); replace with getProjectByKey(key)"
+      return getProjectByKey(key)
+    end
+    
+    def getProjectByKey( projectKey )
+      begin
+        return call_driver( "getProjectByKey", projectKey )
+      rescue SOAP::FaultError => soap_error
+        #XXX surely there is a better way to detect this kind of condition in the JIRA server
+        if soap_error.faultcode.to_s == "soapenv:Server.userException" and soap_error.faultstring.to_s == "com.atlassian.jira.rpc.exception.RemoteException: Project: #{projectKey} does not exist"
+          return nil
+        else
+          raise soap_error
+        end
+      end
+    end
+    
+    def getGroup( groupName )
+      begin
+        return call_driver( "getGroup", groupName )
+      rescue SOAP::FaultError => soap_error
+        #XXX surely there is a better way to detect this kind of condition in the JIRA server
+        if soap_error.faultcode.to_s == "soapenv:Server.userException" and soap_error.faultstring.to_s == "com.atlassian.jira.rpc.exception.RemoteValidationException: no group found for that groupName: #{groupName}"
+          return nil
+        else
+          raise soap_error
+        end
+      end
+    end
+    
+    def getProjectRoleByName( projectRoleName )
+      getProjectRoles.each{ |projectRole|
+        return projectRole if projectRole.name == projectRoleName
+      }
+    end
+    
+    def getPermissionScheme( permissionSchemeName )
+      self.getPermissionSchemes().each { |permission_scheme| 
+        return permission_scheme if permission_scheme.name == permissionSchemeName
+      }
+      return nil
+    end
+    
+    def getNotificationScheme( notificationSchemeName )
+      self.getNotificationSchemes().each { |notification_scheme| 
+        return notification_scheme if notification_scheme.name == notificationSchemeName
+      }
+      return nil
+    end
+    
+    def getPermission( permissionName )
+      if not @permissions
+        @permissions = self.getAllPermissions()
+      end
+      
+      @permissions.each { |permission|
+        return permission if permission.name.downcase == permissionName.downcase
+      }
+      
+      @logger.warn("No permission #{permissionName} found")
+      return nil
+    end
+    
+    def findPermission(allowedPermissions, permissionName)
+		allowedPermissions.each { |allowedPermission|
+		   #puts "Checking #{allowedPermission.name} against #{permissionName} "
+		   return allowedPermission if allowedPermission.name == permissionName
+		}
+		return nil    
+    end
+    
+    def findEntityInPermissionMapping(permissionMapping, entityName)
+      permissionMapping.remoteEntities.each { |entity|
+	    return entity if entity.name == entityName
+	  }
+	  return nil
+	end
+    
+    #Removes entity
+    def setPermissions( permissionScheme, allowedPermissions, entity)
+      allowedPermissions = [ allowedPermissions ].flatten.compact
+      #Remove permissions that are no longer allowed
+      permissionScheme.permissionMappings.each { |mapping|
+        next unless findEntityInPermissionMapping(mapping, entity.name)
+      
+        allowedPermission = findPermission(allowedPermissions, mapping.permission.name)
+	    if allowedPermission
+  	      puts "Already has #{allowedPermission.name} in #{permissionScheme.name} for #{entity.name}"
+		  allowedPermissions.delete(allowedPermission)
+	      next
+	    end
+
+		puts "Deleting #{mapping.permission.name} from #{permissionScheme.name} for #{entity.name}"
+        deletePermissionFrom( permissionScheme, mapping.permission, entity)
+      }
+      
+      puts allowedPermissions.inspect
+      allowedPermissions.each { |allowedPermission|
+		puts "Granting #{allowedPermission.name} to #{permissionScheme.name} for #{entity.name}"
+		addPermissionTo(permissionScheme, allowedPermission, entity) 
+	  }   
+    end
+
+private
+    def fix_args(args)
+      args.collect { |arg|
+        if arg == nil
+          SOAP::SOAPNil.new
+        else
+          arg
+        end
+      }
+    end
+    
+    def method_missing(method_name, *args)
+      args = fix_args(args)
+      call_driver(method_name, *args)
+    end
+    
+    
+  
+  end  
+
+end