xplanner 0.0.1

data/.gitignore

@@ -0,0 +1,7 @@
+*.tar.gz
+*.zip
+.DS_Store
+info
+.rspec
+.rvmrc
+*.gem

data/Gemfile

@@ -0,0 +1,5 @@
+source :rubygems
+
+gem 'savon'
+gem 'nokogiri'
+gem 'activesupport'

data/Gemfile.lock

@@ -0,0 +1,38 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.2.9)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    akami (1.2.0)
+      gyoku (>= 0.4.0)
+      nokogiri (>= 1.4.0)
+    builder (3.1.4)
+    gyoku (0.4.6)
+      builder (>= 2.1.2)
+    httpi (1.1.1)
+      rack
+    i18n (0.6.1)
+    multi_json (1.3.7)
+    nokogiri (1.5.5)
+    nori (1.1.3)
+    rack (1.4.1)
+    savon (1.2.0)
+      akami (~> 1.2.0)
+      builder (>= 2.1.2)
+      gyoku (~> 0.4.5)
+      httpi (~> 1.1.0)
+      nokogiri (>= 1.4.0)
+      nori (~> 1.1.0)
+      wasabi (~> 2.5.0)
+    wasabi (2.5.1)
+      httpi (~> 1.0)
+      nokogiri (>= 1.4.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport
+  nokogiri
+  savon

data/lib/config/savon_config.rb

@@ -0,0 +1,57 @@
+require 'savon'
+require 'nokogiri'
+require 'active_support/core_ext/hash/conversions'
+require 'active_support/inflections'
+
+# Reduce console noise.
+Savon.configure do |config|
+  config.log = false
+  config.log_level = :errors
+  config.raise_errors = false	# we'll handle our own errors 
+end
+HTTPI.log = false
+
+# Helper for decoding multi-ref style SOAP responses
+module Savon
+	module SOAP
+		class Response
+			def decode_soap_response( path = [] )
+				hash = SoapResponseDecoder.decode( self.to_xml )
+				path.each { |p| hash = hash[p] }
+				hash
+			end
+		end
+	end
+end
+
+# Decode multi-ref soap references. 
+class SoapResponseDecoder
+	def self.decode( xml_doc )
+		doc = Nokogiri::XML xml_doc
+
+		while( el = doc.xpath('//soapenv:Body//*[@href]').first )
+			id = el.attribute('href').value.gsub('#', '')
+			el.children = doc.xpath("//soapenv:Body//multiRef[@id='#{id}']").children()
+			el.remove_attribute('href')
+		end
+
+		hash = convert_hash_keys( Hash.from_xml( doc.to_s ) )[:envelope][:body]
+	end
+
+
+	def self.underscore_key(k)
+	  k.to_s.underscore.to_sym
+	end
+
+	def self.convert_hash_keys(value)
+	  case value
+	    when Array
+	      value.map { |v| convert_hash_keys(v) }
+	    when Hash
+	      Hash[value.map { |k, v| [underscore_key(k), convert_hash_keys(v)] if k != 'xsi:type' }]
+	    else
+	      value
+	   end
+	end
+
+end

data/lib/config/version.rb

@@ -0,0 +1,3 @@
+module XPlanner
+	VERSION = '0.0.1'
+end

data/lib/helpers/xplanner_model_helper.rb

@@ -0,0 +1,51 @@
+module XPlanner
+  class ModelHelper
+    @@soap_client = false
+
+    def self.set_soap_client( client )
+      @@soap_client = client
+    end
+
+    def self.invalid_usage
+      raise 'No SoapClient initialised'
+    end
+
+    def self.fetch_from_remote( rpc, payload, path, my_class )
+      invalid_usage unless @@soap_client
+      h = @@soap_client.call( rpc, payload ).decode_soap_response( path )
+      if h.class == Array
+        results = h.collect { |thing| my_class.new( thing ) } 
+      elsif h.class == Hash
+        results = my_class.new( h )
+      end
+      results
+    end
+
+    def self.remote_action( rpc, payload )
+      invalid_usage unless @@soap_client
+      @@soap_client.call( rpc, payload ).success?
+    end
+
+    def remote_action( rpc, payload )
+      invalid_usage unless @@soap_client
+      result = @@soap_client.call( rpc, payload )
+      result.success?
+    end
+
+    def self.parse_date( date )
+      formatter = '%Y-%m-%eT%H:%M:%S.%LZ'
+      DateTime.strptime( date, formatter )
+    end
+
+    def hashify
+      out = {}
+      instance_variables.each { |var| out[var.to_s.gsub(/@/, '').to_sym] = instance_variable_get(var) }
+      out
+    end
+
+    def create_payload
+      payload = hashify.delete_if { |key, value| !key == :last_update_time }
+    end
+
+  end
+end

data/lib/helpers/xplanner_soap_client.rb

@@ -0,0 +1,21 @@
+module XPlanner
+	class SoapClient
+	  def initialize( params )
+	  	@client = Savon.client do |wsdl, http|
+	  		wsdl.document = params[:wsdl]
+	  		http.auth.basic params[:username], params[:password]
+	  	end
+	  end
+
+		def get_services
+			@client.wsdl.type_definitions
+		end
+
+		def call( rpc, payload=nil)
+			response = @client.request( rpc ) do
+				soap.body = payload unless payload.nil?
+			end
+		end
+
+	end
+end

data/lib/models/iteration.rb

@@ -0,0 +1,91 @@
+module XPlanner
+  class Iteration < ModelHelper
+  	attr_accessor :name,
+                  :description,
+                  :project_id,
+                  :status_key,
+                  :actual_hours,
+                  :added_hours,
+                  :adjusted_estimated_hours,
+                  :days_worked,
+                  :estimated_hours,
+                  :overestimated_hours,
+                  :postponed_hours,
+                  :remaining_hours,
+                  :start_date,
+                  :end_date,
+                  :underestimated_hours
+
+    attr_reader   :id,
+                  :last_update_time
+
+
+  	def initialize( iter )
+  		@id                         = iter[:id]
+  		@name                       = iter[:name]
+  		@description                = iter[:description]
+  		@project_id                 = iter[:project_id]
+  		@status_key                 = iter[:status_key]
+  		@actual_hours               = iter[:actual_hours]
+  		@added_hours                = iter[:added_hours]
+  		@adjusted_estimated_hours   = iter[:adjusted_estimated_hours]
+  		@days_worked                = iter[:days_worked]
+  		@estimated_hours            = iter[:estimated_hours]
+  		@overestimated_hours        = iter[:overestimated_hours]
+  		@postponed_hours            = iter[:postponed_hours]
+  		@remaining_hours            = iter[:remaining_hours]
+  		@start_date                 = Iteration.parse_date iter[:start_date]
+  		@end_date                   = Iteration.parse_date iter[:end_date]
+  		@last_update_time           = Iteration.parse_date iter[:last_update_time]
+  		@underestimated_hours       = iter[:underestimated_hours]
+  	end
+
+    def self.all( project_id )
+    	rpc = :get_iterations
+    	payload = { :projectId => project_id }
+    	path = [:get_iterations_response, :get_iterations_return, :get_iterations_return]
+    	fetch_from_remote( rpc, payload, path, Iteration )
+    end
+
+    def self.retrieve( iteration_id )
+    	rpc = :get_iteration
+    	payload = { :iterationId => iteration_id }
+    	path = [:get_iteration_response, :get_iteration_return]
+    	fetch_from_remote( rpc, payload, path, Iteration )
+    end
+
+    # needs status setting
+  	def self.create( project_id, name, description, start_date, end_date )
+    	rpc = :add_iteration
+    	payload = { 
+    		:iterationData => {
+    			:project_id => project_id, 
+    			:name => name, 
+    			:description => description, 
+    			:start_date => start_date, 
+    			:end_date => end_date,
+          :status_key => 'inactive'
+    		} 
+    	}
+    	path = [:add_iteration_response, :add_iteration_return]
+    	fetch_from_remote( rpc, payload, path, Iteration )
+    end
+
+    def self.delete( id )
+    	rpc = :remove_iteration
+    	payload = { :id => id }
+      remote_action( rpc, payload )
+    end
+
+    def delete
+    	Iteration.delete( @id )
+    end
+
+    def save
+    	rpc = :update
+    	payload = { :iterationData => create_payload }
+  		remote_action( rpc, payload )
+    end
+
+  end
+end

data/lib/models/person.rb

@@ -0,0 +1,64 @@
+module XPlanner
+  class Person < ModelHelper
+    attr_accessor :name, 
+                  :email,
+                  :initials,
+                  :phone,
+                  :user_id
+
+    attr_reader   :id,
+                  :last_update_time
+
+    def initialize( p )
+        @id                = p[:id]
+        @name              = p[:name]
+        @last_update_time  = Person.parse_date p[:last_update_time]
+        @initials          = p[:initials]
+        @phone             = p[:phone]
+        @user_id           = p[:user_id]
+        @email             = p[:email]
+    end
+
+    def self.all
+        rpc = :get_people
+        path = [:get_people_response, :get_people_return, :get_people_return]
+        fetch_from_remote( rpc, payload, path, Person )
+    end
+
+    def self.retrieve( id )
+        rpc = :get_person
+        payload = { :id => id }
+        path = [:get_person_response, :get_person_return]
+        fetch_from_remote( rpc, payload, path, Person )
+    end
+
+    def self.create( name, email, user_id, initials = '', phone = '' )
+        rpc = :add_person
+        payload = { :personData => {
+            :name => name, 
+            :email => email, 
+            :user_id => user_id,
+            :initials => initials,
+            :phone => phone
+        } }
+        path = [:add_person_response, :add_person_return]
+        fetch_from_remote( rpc, payload, path, Person )
+    end
+
+    def self.delete( id )
+        rpc = :remove_person
+        payload = { :id => id }
+        remote_action( rpc, payload )
+    end
+
+    def delete
+        Person.delete @id
+    end
+
+    def save
+        rpc = :update
+        payload = { :personData => create_payload }
+        remote_action( rpc, payload )
+    end
+  end
+end

data/lib/models/project.rb

@@ -0,0 +1,52 @@
+module XPlanner
+  class Project < ModelHelper
+    attr_accessor :name, 
+                  :description
+
+    attr_reader   :id,
+                  :last_update_time
+
+    def initialize( p )
+    	@id                = p[:id]
+    	@name              = p[:name]
+    	@last_update_time  = Project.parse_date p[:last_update_time]
+    	@description       = p[:description]
+    end
+
+    def self.all
+    	rpc = :get_projects
+    	path = [:get_projects_response, :get_projects_return, :get_projects_return]
+    	fetch_from_remote( rpc, payload, path, Project )
+    end
+
+    def self.retrieve( id )
+    	rpc = :get_project
+    	payload = { :id => id }
+    	path = [:get_project_response, :get_project_return]
+        fetch_from_remote( rpc, payload, path, Project )
+    end
+
+    def self.create( name, description )
+    	rpc = :add_project
+    	payload = { :projectData => { :name => name, :description => description } }
+        path = [:add_project_response, :add_project_return]
+    	fetch_from_remote( rpc, payload, path, Project )
+    end
+
+    def self.delete( id )
+    	rpc = :remove_project
+    	payload = { :id => id }
+      remote_action( rpc, payload )
+    end
+
+    def delete
+    	Project.delete @id
+    end
+
+    def save
+    	rpc = :update
+    	payload = { :projectData => create_payload }
+        remote_action( rpc, payload )
+    end
+  end
+end

data/lib/models/story.rb

@@ -0,0 +1,88 @@
+module XPlanner
+  class Story < ModelHelper
+
+    attr_accessor  :actual_hours,
+                   :adjusted_estimated_hours,
+                   :completed,
+                   :customer_id,
+                   :description,
+                   :disposition_name,
+                   :estimated_hours,
+                   :estimated_original_hours,
+                   :iteration_id,
+                   :last_update_time,
+                   :name,
+                   :postponed_hours,
+                   :priority,
+                   :remaining_hours,
+                   :tracker_id
+
+    attr_reader    :id
+
+
+    def initialize( story )
+      @actual_hours             = story[:actual_hours]
+      @adjusted_estimated_hours = story[:adjusted_estimated_hours]
+      @completed                = story[:completed]
+      @customer_id              = story[:customer_id]
+      @description              = story[:description]
+      @disposition_name         = story[:disposition_name]
+      @estimated_hours          = story[:estimated_hours]
+      @estimated_original_hours = story[:estimated_original_hours]
+      @id                       = story[:id]
+      @iteration_id             = story[:iteration_id]
+      @last_update_time         = Story.parse_date story[:last_update_time]
+      @name                     = story[:name]
+      @postponed_hours          = story[:postponed_hours]
+      @priority                 = story[:priority]
+      @remaining_hours          = story[:remaining_hours]
+      @tracker_id               = story[:tracker_id]
+    end
+
+    def self.all( iteration_id )
+    	rpc = :get_user_stories
+    	payload = { :containerId => iteration_id }
+    	path = [:get_user_stories_response, :get_user_stories_return, :get_user_stories_return]
+    	fetch_from_remote( rpc, payload, path, Story )
+    end
+
+   def self.retrieve( story_id )
+      rpc = :get_user_story
+      payload = { :userStoryId => story_id }
+      path = [:get_user_story_response, :get_user_story_return]
+      fetch_from_remote( rpc, payload, path, Story )
+    end
+
+    def self.create( iteration_id, name, description, disposition = 'planned', completed = 'false', priority = '4' )
+      rpc = :add_user_story
+      payload = { :userStoryData =>{
+          :iteration_id =>iteration_id, 
+          :name => name, 
+          :description => description,
+          :disposition_name => disposition,
+          :completed => completed,
+          :priority => priority
+        } 
+      }
+      path = [:add_user_story_response, :add_user_story_return]
+      fetch_from_remote( rpc, payload, path, Story )
+    end
+
+    def self.delete( id )
+      rpc = :remove_user_story
+      payload = { :id => id }
+      remote_action( rpc, payload )
+    end
+
+    def delete
+      Story.delete( @id )
+    end
+
+    def save
+      rpc = :update
+      payload = { :userStoryData => create_payload }
+      remote_action( rpc, payload )
+    end
+
+  end
+end

data/lib/models/task.rb

@@ -0,0 +1,87 @@
+module XPlanner
+  class Task < ModelHelper
+
+    attr_accessor  :acceptor_id,
+                   :actual_hours,
+                   :adjusted_estimated_hours,
+                   :completed,
+                   :created_date,
+                   :description,
+                   :disposition_name,
+                   :estimated_hours,
+                   :estimated_original_hours,
+                   :last_update_time,
+                   :name,
+                   :remaining_hours,
+                   :story_id,
+                   :type
+
+    attr_reader    :id
+
+
+    def initialize( task )
+      @acceptor_id              = task[:acceptor_id]
+      @actual_hours             = task[:actual_hours]
+      @adjusted_estimated_hours = task[:adjusted_estimated_hours]
+      @completed                = task[:completed]
+      @created_date             = Task.parse_date task[:created_date]
+      @description              = task[:description]
+      @disposition_name         = task[:disposition_name]
+      @estimated_hours          = task[:estimated_hours]
+      @estimated_original_hours = task[:estimated_original_hours]
+      @last_update_time         = task[:last_update_time]
+      @name                     = task[:name]
+      @remaining_hours          = task[:remaining_hours]
+      @story_id                 = task[:story_id]
+      @type                     = task[:type]
+      @id                       = task[:id]
+    end
+
+    def self.all( story_id )
+    	rpc = :get_tasks
+    	payload = { :containerId => story_id }
+    	path = [:get_taskss_response, :get_tasks_return, :get_tasks_return]
+    	fetch_from_remote( rpc, payload, path, Task )
+    end
+
+   def self.retrieve( task_id )
+      rpc = :get_task
+      payload = { :taskId => task_id }
+      path = [:get_task_response, :get_task_return]
+      fetch_from_remote( rpc, payload, path, Task )
+    end
+
+    def self.create( story_id, name, description, disposition = 'planned', completed = 'false', type = 'Feature' )
+      rpc = :add_task
+      payload = { :taskData => {
+          :story_id => story_id, 
+          :name => name, 
+          :description => description,
+          :disposition_name => disposition,
+          :completed => completed,
+          :type => type,
+          :created_date => DateTime.now
+        } 
+      }
+      path = [:add_task_response, :add_task_return]
+      fetch_from_remote( rpc, payload, path, Task )
+    end
+
+    def self.delete( id )
+      rpc = :remove_task
+      payload = { :id => id }
+      remote_action( rpc, payload )
+    end
+
+    def delete
+      Task.delete( @id )
+    end
+
+    def save
+      rpc = :update
+      payload = { :taskData => create_payload }
+      remote_action( rpc, payload )
+    end
+
+  end
+end

data/lib/xplanner.rb

@@ -0,0 +1,25 @@
+project_root = File.expand_path('../', __FILE__)
+project_dirs = ['config', 'helpers', 'models']
+
+project_dirs.each do |d|
+	Dir.glob(project_root + '/' + d + '/*.rb') {|file| require file}
+end
+
+require 'uri'
+
+module XPlanner
+	def self.setup( config = {} )
+		url = config[:xplanner_url] ||= @@default_config[:xplanner_url]
+		wsdl = URI::join(url, 'soap/XPlanner?wsdl').to_s
+		user = config[:username] ||= @@default_config[:username]
+		pass = config[:password] ||= @@default_config[:password]
+
+		client_config = {
+			:wsdl => wsdl,
+			:username => user,
+			:password => pass
+		}
+
+		ModelHelper.set_soap_client SoapClient.new( client_config )
+	end
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'rspec'
+require File.expand_path('../../lib/xplanner', __FILE__)

data/test/tests.rb

@@ -0,0 +1,197 @@
+require File.expand_path('../test_helper', __FILE__)
+XPlanner::setup
+
+describe 'XPlanner+ SOAP interface' do
+  describe 'Model: Project' do
+    before(:all) do
+      @myProject = XPlanner::Project.create( 'delete me', 'delete me: test project' )
+    end
+
+    it 'Create' do
+      @myProject.should be_an_instance_of XPlanner::Project
+      @myProject.id.should_not be_nil
+      @myProject.id.should_not eq( 0 )
+    end
+
+    it 'Retrieve' do
+      this_project = XPlanner::Project.retrieve( @myProject.id )
+      this_project.should be_instance_of XPlanner::Project
+      this_project.id.should eq( @myProject.id )
+    end
+
+    it 'Update' do
+      @myProject.description += ' O_o '
+      result = @myProject.save
+      result.should equal true
+      this_project = XPlanner::Project.retrieve( @myProject.id )
+      this_project.description.should include ' O_o '
+    end
+
+    it 'Delete' do
+      result = @myProject.delete
+      result.should equal true
+    end
+  end
+
+  describe 'Model: Iteration' do
+    before(:all) do
+      @myProject = XPlanner::Project.create( 'delete me', 'delete me: test project' )
+      @myIteration = XPlanner::Iteration.create(  @myProject.id, 
+                                        'delete me', 
+                                        'delete me: test iteration', 
+                                        DateTime.now, 
+                                        DateTime.now+5 )
+    end
+
+    after(:all) do
+      @myProject.delete
+    end
+
+    it 'Create' do
+      @myIteration.should be_an_instance_of XPlanner::Iteration
+      @myIteration.id.should_not be_nil
+      @myIteration.id.should_not eq( 0 )
+    end
+
+    it 'Retrieve' do
+      this_iteration = XPlanner::Iteration.retrieve( @myIteration.id )
+      this_iteration.should be_instance_of XPlanner::Iteration
+      this_iteration.id.should eq( @myIteration.id )
+    end
+
+    it 'Update' do
+      @myIteration.description += ' O_o '
+      result = @myIteration.save
+      result.should equal true
+      this_iteration = XPlanner::Iteration.retrieve( @myIteration.id )
+      this_iteration.description.should include ' O_o '
+    end
+
+    it 'Delete' do
+      result = @myIteration.delete
+      result.should equal true
+    end
+
+  end
+
+  describe 'Model: User Story' do
+    before(:all) do
+      @myProject = XPlanner::Project.create( 'delete me', 'delete me: test project' )
+      @myIteration = XPlanner::Iteration.create(  @myProject.id, 
+                                        'delete me', 
+                                        'delete me: test iteration', 
+                                        DateTime.now, 
+                                        DateTime.now+5 )
+      @myStory = XPlanner::Story.create( @myIteration.id, 'delete me', 'delete me: test story')
+    end
+
+    after(:all) do
+      @myIteration.delete
+      @myProject.delete
+    end
+
+    it 'Create' do
+      @myStory.should be_an_instance_of XPlanner::Story
+      @myStory.id.should_not be_nil
+      @myStory.id.should_not eq( 0 )
+    end
+
+    it 'Retrieve' do
+      this_story = XPlanner::Story.retrieve( @myStory.id )
+      this_story.should be_instance_of XPlanner::Story
+      this_story.id.should eq( @myStory.id )
+    end
+
+    it 'Update' do
+      @myStory.description += ' O_o '
+      result = @myStory.save
+      result.should equal true
+      this_story = XPlanner::Story.retrieve( @myStory.id )
+      this_story.description.should include ' O_o '
+    end
+
+    it 'Delete' do
+      result = @myStory.delete
+      result.should equal true
+    end
+
+  end
+
+
+  describe 'Model: Task' do
+    before(:all) do
+      @myProject = XPlanner::Project.create( 'delete me', 'delete me: test project' )
+      @myIteration = XPlanner::Iteration.create(  @myProject.id, 
+                                        'delete me', 
+                                        'delete me: test iteration', 
+                                        DateTime.now, 
+                                        DateTime.now+5 )
+      @myStory = XPlanner::Story.create( @myIteration.id, 'delete me', 'delete me: test story')
+      @myTask = XPlanner::Task.create( @myStory.id, 'delete me', 'delete me: test task')
+    end
+
+    after(:all) do
+      @myStory.delete
+      @myIteration.delete
+      @myProject.delete
+    end
+
+    it 'Create' do
+      @myTask.should be_an_instance_of XPlanner::Task
+      @myTask.id.should_not be_nil
+      @myTask.id.should_not eq( 0 )
+    end
+
+    it 'Retrieve' do
+      this_task = XPlanner::Task.retrieve( @myTask.id )
+      this_task.should be_instance_of XPlanner::Task
+      this_task.id.should eq( @myTask.id )
+    end
+
+    it 'Update' do
+      @myTask.description += ' O_o '
+      result = @myTask.save
+      result.should equal true
+      this_task = XPlanner::Task.retrieve( @myTask.id )
+      this_task.description.should include ' O_o '
+    end
+
+    it 'Delete' do
+      result = @myTask.delete
+      result.should equal true
+    end
+
+  end
+
+  describe 'Model: Person' do
+    before(:all) do
+      @myPerson = XPlanner::Person.create( 'delete me', 'delete@me.com', 'delete_me' )
+    end
+
+    it 'Create' do
+      @myPerson.should be_an_instance_of XPlanner::Person
+      @myPerson.id.should_not be_nil
+      @myPerson.id.should_not eq( 0 )
+    end
+
+    it 'Retrieve' do
+      this_person = XPlanner::Person.retrieve( @myPerson.id )
+      this_person.should be_instance_of XPlanner::Person
+      this_person.id.should eq( @myPerson.id )
+    end
+
+    it 'Update' do
+      @myPerson.user_id += ' O_o '
+      result = @myPerson.save
+      result.should equal true
+      this_person = XPlanner::Person.retrieve( @myPerson.id )
+      this_person.user_id.should include ' O_o '
+    end
+
+    it 'Delete' do
+      result = @myPerson.delete
+      result.should equal true
+    end
+  end
+
+end

data/xplanner.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'config/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "xplanner"
+  gem.version       = XPlanner::VERSION
+  gem.authors       = ["whoojemaflip"]
+  gem.email         = ["whoojemaflip@gmail.com"]
+  gem.description   = %q{Ruby wrapper for XPlanner+ SOAP interface}
+  gem.summary       = %q{Ruby wrapper for XPlanner+ SOAP interface}
+  gem.homepage      = "http://github.com/whoojemaflip/xplanner"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: xplanner
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- whoojemaflip
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-20 00:00:00.000000000 +00:00
+default_executable: 
+dependencies: []
+description: Ruby wrapper for XPlanner+ SOAP interface
+email:
+- whoojemaflip@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- lib/config/savon_config.rb
+- lib/config/version.rb
+- lib/helpers/xplanner_model_helper.rb
+- lib/helpers/xplanner_soap_client.rb
+- lib/models/iteration.rb
+- lib/models/person.rb
+- lib/models/project.rb
+- lib/models/story.rb
+- lib/models/task.rb
+- lib/xplanner.rb
+- test/test_helper.rb
+- test/tests.rb
+- xplanner.gemspec
+has_rdoc: true
+homepage: http://github.com/whoojemaflip/xplanner
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Ruby wrapper for XPlanner+ SOAP interface
+test_files:
+- test/test_helper.rb
+- test/tests.rb