taskmapper 0.8.0

data/lib/taskmapper/provider.rb

@@ -0,0 +1,82 @@
+# This is the TaskMapper::Provider Module
+#
+# All provider classes will extend into this module. 
+# See the Dummy provider's code for some specifics on implementing a provider
+#
+# Currently, only Projects and Tickets are standardized in ticket master. Therefore,
+# if your provider has other types--such as People/Members, Messages, Milestones, Notes,
+# Tags, etc--you may implement it at your discretion. We are planning to eventually
+# incorporate and standardize many of these into the overall provider. Keep on the look out for it!
+#
+# We are also planning on standardizing non-standard/provider-specific object models
+module TaskMapper::Provider
+  module Base
+    PROJECT_API = nil # The Class for the project api interaction
+    TICKET_API = nil # The Class for the ticket api interaction
+    
+    include TaskMapper::Provider::Helper
+    
+    # All providers must define this method.
+    # It doesn't *have* to do anything, it just has to be there. But since it's here, you don't
+    # have to worry about it as long as you "include TaskMapper::Provider::Base"
+    #
+    # If you need to do some additional things to initialize the instance, here is where you would put it
+    def authorize(authentication = {})
+      @authentication = TaskMapper::Authenticator.new(authentication)
+    end
+
+    # All providers must define this method. 
+    # It should implement the code for validating the authentication 
+    def valid?
+      raise TaskMapper::Exception.new("#{Base.name}::#{this_method} method must be implemented by the provider")
+    end
+    
+    # Providers should try to define this method
+    #
+    # It returns the project class for this provider, so that there can be calls such as
+    #    taskmapper.project.find :all
+    #    taskmapper.project(:id => 777, :name => 'Proj test')
+    #
+    # Should try to implement a find :first (or find with singular result) if given parameters
+    def project(*options)
+      easy_finder(@provider::Project, :first, options)
+    end
+    
+    # All providers should try to define this method.
+    #
+    # It returns all projects in an array
+    # Should try to implement a find :all if given parameters
+    def projects(*options)
+      easy_finder(@provider::Project, :all, options)
+    end
+    
+    # Create a project same as project.create()
+    def project!(*options)
+      project.create(*options)
+    end
+    
+    # Providers should try to define this method
+    #
+    # It returns the ticket class for this provider, so that there can be calls such as
+    #    taskmapper.ticket.find :all
+    #    taskmapper.ticket(:id => 102, :title => 'Ticket')
+    #
+    # Don't confuse this with project.ticket.find(...) since that deals with tickets specific to a
+    # project. This is deals with tickets
+    #
+    # Should try to implement a find :first (or find with singular result) if given parameters
+    def ticket(*options)
+      easy_finder(@provider::Ticket, :first, options)
+    end
+      
+    # All providers should try to define this method
+    #
+    # It returns all tickets in an array.
+    # Should try to implement a find :all if given parameters
+    def tickets(*options)
+      easy_finder(@provider::Ticket, :all, options)
+    end
+  end
+end
+
+

data/lib/taskmapper/tester/comment.rb

@@ -0,0 +1,18 @@
+module TaskMapper::Provider
+  module Tester
+    # This is the Comment class for the Tester provider
+    class Comment < TaskMapper::Provider::Base::Comment
+                 
+      # You don't need to define an initializer, this is only here to initialize tester data
+      def initialize(project_id, ticket_id, *options)
+        data = {:id => rand(1000), :status => ['lol', 'rofl', 'lmao', 'lamo', 'haha', 'heh'][rand(6)],
+          :priority => rand(10), :summary => 'Tickets ticket ticket ticket', :resolution => false,
+          :created_at => Time.now, :updated_at => Time.now, :description => 'Ticket ticket ticket ticket laughing',
+          :assignee => 'lol-man'}
+        @system = :tester
+        super(data.merge(options.first || {}))
+      end
+      
+    end
+  end
+end

data/lib/taskmapper/tester/project.rb

@@ -0,0 +1,19 @@
+module TaskMapper::Provider
+  module Tester
+    # This is the Project class for the Tester provider
+    class Project < TaskMapper::Provider::Base::Project
+            
+      # You should define @system and @system_data here.
+      # The data stuff is just to initialize fake data. In a real provider, you would use the API
+      # to grab the information and then initialize based on that info.
+      # @system_data would hold the API's model/instance for reference
+      def initialize(*options)
+        data = {:id => rand(1000).to_i, :name => 'Tester', :description => 'Mock!-ing Bird',
+          :created_at => Time.now, :updated_at => Time.now}
+        @system = :tester
+        super(data.merge(options.first || {}))
+      end
+      
+    end
+  end
+end

data/lib/taskmapper/tester/tester.rb

@@ -0,0 +1,28 @@
+module TaskMapper::Provider
+  # This is the Tester Provider
+  #
+  # It doesn't really do anything, it exists in order to test the basic functionality of taskmapper
+  # and to provide an example the basics of what is to be expected from the providers.
+  # 
+  # Note that the initial provider name is a module rather than a class. TaskMapper.new
+  # extends on an instance-based fashion. If you would rather initialize using code that is 
+  # closer to:
+  # 
+  #    TaskMapper::Provider::Tester.new(authentication)
+  #
+  # You will have to do a little magic trick and define new on the provider as a wrapper
+  # around the TaskMapper.new call.
+  module Tester
+    include TaskMapper::Provider::Base
+    # An example of what to do if you would like to do TaskMapper::Provider::Tester.new(...)
+    # rather than TaskMapper.new(:tester, ...)
+    def self.new(authentication = {})
+      TaskMapper.new(:tester, authentication)
+      # maybe do some other stuff
+    end
+  end
+end
+
+%w| project ticket comment |.each do |f|
+  require File.dirname(__FILE__) + '/' + f +'.rb'
+end

data/lib/taskmapper/tester/ticket.rb

@@ -0,0 +1,19 @@
+module TaskMapper::Provider
+  module Tester
+    # The Tester Provider's Ticket class
+    class Ticket < TaskMapper::Provider::Base::Ticket
+      @system = :tester
+      
+      # You don't need to define an initializer, this is only here to initialize tester data
+      def initialize(project_id, *options)
+        data = {:id => rand(1000), :status => ['lol', 'rofl', 'lmao', 'lamo', 'haha', 'heh'][rand(6)],
+          :priority => rand(10), :summary => 'Tickets ticket ticket ticket', :resolution => false,
+          :created_at => Time.now, :updated_at => Time.now, :description => 'Ticket ticket ticket ticket laughing',
+          :assignee => 'lol-man', :project_id => project_id}
+        @system = :tester
+        super(data.merge(options.first || {}))
+      end
+      
+    end
+  end
+end

data/lib/taskmapper/ticket.rb

@@ -0,0 +1,154 @@
+module TaskMapper::Provider
+  module Base
+    # The base ticket class for taskmapper
+    # All providers should inherit this class
+    #
+    # The difference between the class methods and instance methods are that the instance
+    # methods should be treated as though they are called on a known ticket and the class
+    # methods act based on a blank slate (which means the info to find a specific ticket has
+    # to be passed in the parameters in the ticket)
+    #
+    # Methods that the provider should define if feasible:
+    #
+    # * reload!
+    # * initialize
+    # * close
+    # * save
+    # * destroy
+    #
+    # Methods that would probably be okay if the provider left it alone:
+    #
+    # * self.create
+    # * update
+    # * update!
+    # * self.find
+    #
+    # A provider should define as many attributes as feasibly possible. The list below are 
+    # some guidelines as to what attributes are necessary, if your provider's api does not
+    # implement them, point it to an attribute that is close to it. (for example, a title
+    # can point to summary. and assignee might point to assigned_to. Remember to alias it in your class!)
+    # 
+    # * id
+    # * status
+    # * priority
+    # * title
+    # * resolution
+    # * created_at
+    # * updated_at
+    # * description
+    # * assignee
+    # * requestor
+    # * project_id
+    class Ticket < Hashie::Mash
+      include TaskMapper::Provider::Common
+      include TaskMapper::Provider::Helper
+      extend TaskMapper::Provider::Helper
+      attr_accessor :system, :system_data
+      API = nil # Replace with your ticket API's Class
+
+      # Find ticket
+      # You can also retrieve an array of all tickets by not specifying any query.
+      #
+      # * find(<project_id>) or find(<project_id>, :all) - Returns an array of all tickets
+      # * find(<project_id>, ##) - Returns a ticket based on that id or some other primary (unique) attribute
+      # * find(<project_id>, [#, #, #]) - Returns many tickets with these ids
+      # * find(<project_id>, :first, :title => 'ticket name') - Returns the first ticket based on the ticket's attribute(s)
+      # * find(<project_id>, :last, :title => 'Some ticket') - Returns the last ticket based on the ticket's attribute(s)
+      # * find(<project_id>, :all, :title => 'Test ticket') - Returns all tickets based on the given attribute(s)
+      def self.find(project_id, *options)
+        first, attributes = options
+        if first.nil? or (first == :all and attributes.nil?)
+          self.find_by_attributes(project_id)
+        elsif first.is_a? Array
+          first.collect { |id| self.find_by_id(project_id, id) }
+        elsif first == :first
+          tickets = attributes.nil? ? self.find_by_attributes(project_id) : self.find_by_attributes(project_id, attributes)
+          tickets.first
+        elsif first == :last
+          tickets = attributes.nil? ? self.find_by_attributes(project_id) : self.find_by_attributes(project_id, attributes)
+          tickets.last
+        elsif first == :all
+          self.find_by_attributes(project_id, attributes)
+        else
+          self.find_by_id(project_id, first)
+        end
+      end
+      
+      # The first of whatever ticket
+      def self.first(project_id, *options)
+        self.find(project_id, :first, *options)
+      end
+      
+      # The last of whatever ticket
+      def self.last(project_id, *options)
+        self.find(project_id, :last, *options)
+      end
+      
+      # Accepts an integer id and returns the single ticket instance
+      # Must be defined by the provider
+      def self.find_by_id(project_id, ticket_id)
+        if self::API.is_a? Class
+          self.new self::API.find(ticket_id, :params => {:project_id => project_id})
+        else
+          raise TaskMapper::Exception.new("#{self.name}::#{this_method} method must be implemented by the provider")
+        end
+      end
+      
+      # Accepts an attributes hash and returns all tickets matching those attributes in an array
+      # Should return all tickets if the attributes hash is empty
+      # Must be defined by the provider
+      def self.find_by_attributes(project_id, attributes = {})
+        if self::API.is_a? Class
+          self.search(project_id, attributes)
+        else
+          raise TaskMapper::Exception.new("#{self.name}::#{this_method} method must be implemented by the provider")
+        end
+      end
+      
+      # This is a helper method to find
+      def self.search(project_id, options = {}, limit = 1000)
+        if self::API.is_a? Class
+          tickets = self::API.find(:all, :params => {:project_id => project_id}).collect { |ticket| self.new ticket }
+          search_by_attribute(tickets, options, limit)
+        else
+          raise TaskMapper::Exception.new("#{self.name}::#{this_method} method must be implemented by the provider")
+        end
+      end
+
+      # Asks the provider's api for the comment associated with the project,
+      # returns an array of Comment objects.
+      def comments(*options)
+        options.insert 0, project_id
+        options.insert 1, id
+        easy_finder(provider_parent(self.class)::Comment, :all, options, 2)
+      end
+      
+      def comment(*options)
+        if options.length > 0
+          options.insert(0, project_id)
+          options.insert(1, id)
+        end
+        easy_finder(provider_parent(self.class)::Comment, :first, options, 2)
+      end
+      
+      # Create a comment
+      def comment!(*options)
+        options[0].merge!(:project_id => project_id, :ticket_id => id) if options.first.is_a?(Hash)
+        provider_parent(self.class)::Comment.create(*options)
+      end
+      
+      # Close this ticket
+      #
+      # On success it should return true, otherwise false
+      def close(*options)
+        raise TaskMapper::Exception.new("#{self.class.name}::#{this_method} method must be implemented by the provider")
+      end
+      
+      # Reload this ticket
+      def reload!(*options)
+        raise TaskMapper::Exception.new("#{self.class.name}::#{this_method} method must be implemented by the provider")
+      end
+
+    end
+  end
+end

data/spec/project_spec.rb

@@ -0,0 +1,84 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+# This can also act as an example test or test skeleton for your provider.
+# Just replace the Dummy in @project_class and @ticket_class
+# Also, remember to mock or stub any API calls
+describe "Projects" do
+  let(:tm) { TaskMapper.new(:dummy, {}) }
+  let(:project_class) { TaskMapper::Provider::Dummy::Project }
+
+  describe "with a connection to a provider" do
+    context "when #projects" do 
+      subject { tm.projects } 
+      it { should be_an_instance_of Array }
+      it { subject.first.should be_an_instance_of project_class }
+      it { subject.last.should be_an_instance_of project_class }
+    end
+
+    context "when #project with a hash is call" do 
+      subject { tm.project(:name => "Whack whack what?") }
+      it { should be_an_instance_of project_class }
+      it { subject.name.should be_eql("Whack whack what?") }
+    end
+
+    context "when retreiving a project" do 
+      subject { tm.projects.first } 
+      it { subject.description.should_not be_nil }
+      it { subject.description.should be_eql("Mock!-ing Bird") }
+    end
+
+    context "when #projects is call with an ID" do 
+      subject { tm.projects(555) }
+      it { should be_an_instance_of project_class }
+      it { subject.id.should be_eql(555) } 
+    end
+
+    context "when #projects is call with an array of IDs" do 
+      subject { tm.projects([555]) }
+      it { should be_an_instance_of Array }
+      it { subject.first.should be_an_instance_of project_class }
+      it { subject.first.id.should be_eql(555) }
+    end
+
+    context "when #projects is call with a hash" do 
+      subject { tm.projects(:id => 555) }
+      it { should be_an_instance_of Array }
+      it { subject.first.should be_an_instance_of project_class }
+      it { subject.first.id.should be_eql(555) }
+    end
+
+    context "when #project is call" do 
+      subject { tm.project }
+      it { should be_eql project_class }
+      it { subject.first.description be_eql("Mock!-ing Bird") }
+      it { subject.last.description be_eql("Mock!-ing Bird") }
+    end
+
+    context "when #project is call with a hash" do 
+      subject { tm.project.find(:first, :description => "Shocking Dirb") }
+      it { should be_an_instance_of project_class }
+      it { subject.description.should be_eql("Shocking Dirb") }
+    end
+  end
+  
+  describe "declaring a new project" do
+    context "when calling #new" do 
+      subject { tm.project.new(default_info) }
+      it { should be_an_instance_of project_class }
+      it { subject.name.should be_eql("Tiket Name  c") }
+      it { subject.save.should be_true }
+    end
+  end
+  
+  describe "creating a new project" do
+    context "when calling #create" do 
+      subject { tm.project.create(default_info) }
+      it { should be_an_instance_of project_class }
+      it { subject.name.should be_eql("Tiket Name  c") }
+    end
+  end
+  
+  def default_info
+    {:id => 777, :name => "Tiket Name  c", :description => "that c thinks the k is trying to steal it's identity"}
+  end
+end

data/spec/rcov.opts

@@ -0,0 +1 @@
+--exclude "lib/taskmapper/dummy/*,spec/*,gems/*" 

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'taskmapper.rb'
+require 'taskmapper/dummy/dummy.rb'
+require 'rspec'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+end

data/spec/taskmapper-cli_spec.rb

@@ -0,0 +1,60 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'fileutils'
+
+# Tests for the cli
+# I'm not quite sure what the most effective way to test this is...
+describe "TaskMapper CLI" do
+  before(:all) do
+    @ticket = File.expand_path(File.dirname(__FILE__) + '/../bin/tm')
+    @cli_dir = File.expand_path(File.dirname(__FILE__) + '/../lib/taskmapper/cli')
+  end
+
+  it "should output help if no command given" do
+    help = `#{@ticket}`
+    $?.should == 0
+    help.should include('Usage: tm [options] COMMAND [command_options]')
+  end
+
+  it "should be able to show help pages" do
+    `#{@ticket} help`.should include(File.read(@cli_dir + '/commands/help/help'))
+    `#{@ticket} help config`.should include(File.read(@cli_dir + '/commands/help/config'))
+    `#{@ticket} help console`.should include(File.read(@cli_dir + '/commands/help/console'))
+  end
+
+  it "should be able to add and edit config info" do
+    pending
+  end
+
+  it "should be able to open up a console" do
+    pending
+  end
+
+  describe :generate do
+    it "should generate provider skeleton w/o runtime errors" do
+      provider_name = "test-provider"
+      expected_name = "taskmapper-#{provider_name}"
+      begin
+        generate = `#{@ticket} generate #{provider_name}`
+        $?.should == 0
+        File.exists?(expected_name).should == true
+      ensure
+        FileUtils.remove_dir(expected_name) if File.exists? expected_name
+      end
+    end
+
+    it "should not prefix 'taskmapper' when not asked to" do
+      provider_name = "test-provider"
+      begin
+        generate = `#{@ticket} generate _#{provider_name}`
+        $?.should == 0
+        File.exists?(provider_name).should == true
+      ensure
+        FileUtils.remove_dir(provider_name) if File.exists? provider_name
+      end
+    end
+  end
+
+end