donedone 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 85ea18b103a503e2eda28b1f26ef959019a20442
+  data.tar.gz: 4f1593a019af558f1f167d21691d6d01b367a106
+SHA512:
+  metadata.gz: c458cef331617286b28a74dab64132178ea91e05ed25aa930787afd6c3da7d544ed2f82e49e5779a2d83220580f3a4f985a580742978aafeb5f30444dff5ec55
+  data.tar.gz: c0ae992671cecbf2750f4dd71c9e05d9bf928752ea26448f749f93d2bcbe3797cd7545822d11dba20d56eed0d016bbf46e62cd0f918055c53415901fd0d87441

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.rvmrc
+.ignore
+.yardoc
+Gemfile.lock
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/MIT-LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2013 Inquisitive Minds, Inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,73 @@
+# DoneDone API Ruby Client Library (GEM)
+
+## REQUIREMENT
+Ruby
+
+## USAGE
+To use the Ruby library with a DoneDone project, you will need to enable the API option under the Project Settings page.
+
+Please see http://www.getdonedone.com/api for more detailed documentation.
+
+The examples below work for projects with the API enabled.
+
+
+## EXAMPLES
+```
+
+# use it in your own code:
+cmd-prompt> gem install 'donedone'
+require 'donedone'
+
+# or interact via donedone ruby-cmd
+cmd-prompt> donedone -h
+
+# import your LightHouse CSV:
+./examples/lighthouse_csv_importer.rb <domain> <usr> <pwd> <project_id> /path/to/your/light_house.csv
+
+# or via irb
+cmd-prompt> irb
+require 'donedone'
+
+domain = "YOUR_COMPANY_DOMAIN" #e.g. wearemammoth
+username = "YOUR_USERNAME"
+password = "YOUR_PASSWORD"
+
+issue_tracker = DoneDone::IssueTracker.new(domain, username, password)
+
+# list all the api calls (plus the 'result' method):
+issue_tracker.public_methods(false)
+
+issue_tracker.projects
+project_id = issue_tracker.result.first["ID"]
+
+issue_tracker.priority_levels
+
+issue_tracker.people_in_project(project_id)
+  tester_id = issue_tracker.result.first["ID"]
+  resolver_id = issue_tracker.result.last["ID"]
+
+issue_tracker.issues_in_project(project_id)
+  priority_level_id = issue_tracker.result.first["PriorityLevelID"]
+  issue_id = issue_tracker.result.first["OrderNumber"]
+
+issue_tracker.issue_exist?(project_id, issue_id)
+issue_tracker.potential_statuses_for_issue(project_id, issue_id)
+issue_tracker.issue(project_id, issue_id)
+issue_tracker.people_for_issue_assignment(project_id, issue_id)
+
+new_issue_id = issue_tracker.create_issue(project_id, title, priority_id,
+resolver_id, tester_id, {:description => '', :tags=> nil, :watcher_id=>nil, :attachments=>nil})
+
+comment = "blah blah"
+file_name = "./file1.txt"
+File.open(file_name, "w") {|f| f.puts "attachment one." }
+comment_url = issue_tracker.create_comment(project_id, new_issue_id, comment, {:people_to_cc_ids=>nil :attachments=>[file_name]})
+puts issue_tracker.result["SuccesfullyAttachedFiles"] ? "attachment uploaded successfully" : "failed to upload attachment"
+File.unlink(file_name)
+
+issue_url = issue_tracker.update_issue(project_id, new_issue_id, {:title=>nil, :priority_id=>nil, :resolver_id=>nil, :tester_id=nil, :description=>nil, :tags=>nil, :state_id=>nil, :attachments=>nil})
+
+```
+
+## TODO
+improve design via specs

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec)
+
+gemspec = eval(File.read("donedone.gemspec"))
+
+task :build => "#{gemspec.full_name}.gem"
+
+file "#{gemspec.full_name}.gem" => gemspec.files + ["donedone.gemspec"] do
+  system "gem build donedone.gemspec"
+  system "gem install donedone-#{DoneDone::VERSION}.gem"
+end

data/bin/donedone

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'rubygems'
+  gem 'donedone'
+rescue LoadError
+end
+
+begin
+  require 'donedone'
+rescue LoadError
+  require_relative '../lib/donedone'
+end
+
+if ([] == ARGV) || ARGV.length < 4 || (ARGV[0].start_with?("-h"))
+  warn "USAGE: ${$0} <domain> <usr> <pwd> <api-method> [args...]"
+  exit
+end
+init_args = []
+# puts "ARGV start: #{ARGV.inspect}"
+3.times { init_args << ARGV.shift }
+# puts "ARGV now: #{ARGV.inspect}"
+issue_tracker = DoneDone::IssueTracker.new(*init_args)
+puts issue_tracker.send(ARGV.shift, *ARGV)
+exit

data/donedone.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "donedone/version"
+
+Gem::Specification.new do |s|
+  s.name        = "donedone"
+  s.version     = DoneDone::VERSION
+  s.authors     = ["Jonathan Thomas"]
+  s.email       = ["buyer+donedone@his-service.net"]
+  s.homepage    = "https://github.com/zoodles/DoneDone-API-Ruby"
+  s.summary     = %q{donedone.com api client}
+  s.description = %q{Check your existing todo items, add new ones, update old one}
+  s.rubyforge_project = "donedone"
+  s.license     = 'MIT'
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.bindir        = 'bin'
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_dependency "mime-types", "~> 2.0"
+  s.add_development_dependency "rspec", "~> 2.14.0"
+  #s.add_development_dependency "simplecov"
+end

data/examples/lighthouse_csv_importer.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+# Import projct issues from LightHouse CSV exports
+# 
+# This is a simple example that migrates data from LightHouse to DoneDone using
+# the Ruby client. It makes a couple of assumptions. First, the CSV file must
+# contain columns listed below.
+# 
+# number | state | title | milestone | assigned | created | updated | project | tags
+# 
+# Second, it also assumes the accounts have already been created for the
+# project, and throws an execption if not. Because LightHouse handles things a
+# bit different from DoneDone, this script will also create the project with assignee
+# as both resolver and tester.
+
+begin
+  require 'rubygems'
+  gem 'donedone'
+rescue LoadError
+end
+
+begin
+  require 'donedone'
+rescue LoadError
+  require_relative '../lib/donedone'
+end
+
+require 'csv'
+
+DEFAULT_DOMAIN = "Your company domain"
+domain = ARGV.shift || DEFAULT_DOMAIN
+username = ARGV.shift || "Your donedone username"
+password = ARGV.shift || "Your donedone password"
+project_id = ARGV.shift.to_i || "Your donedone project ID"
+
+CSVFilePath = ARGV.shift || "Path to the CSV file exported from lighthouseapp.com"
+priority_id = ARGV.shift || 2 #Assuming medium priority
+
+# puts "domain: #{domain.inspect}, username: #{username.inspect}, password: #{password.inspect}, project_id: #{project_id.inspect}, csv: #{CSVFilePath.inspect}"
+fail( "unknown file: #{CSVFilePath.inspect}") unless File.exists?(CSVFilePath)
+fail( "You must edit pass-in variables or edit the default values in #{$0}" ) if DEFAULT_DOMAIN == domain
+
+issue_tracker = DoneDone::IssueTracker.new(domain, username, password)
+project_peoples = issue_tracker.people_in_project(project_id)
+
+
+# read file
+csv_text = File.binread(CSVFilePath)
+# slurp
+csv = CSV.parse(csv_text, { :headers => true, :return_headers => false, :col_sep => ',', :quote_char =>  '"'})
+
+# loop over issues
+csv.each do |issue|
+  # puts "i: #{issue.inspect}"
+  person_id = nil
+  name = issue['assigned']
+  next if "" == project_peoples
+  # puts "pp: #{project_peoples.inspect}"
+  if person = project_peoples.detect{|people| people["Value"] == name}
+    person_id = person["ID"]
+  else
+    fail "Fail to find DoneDone account for #{name}"
+  end
+
+  # Create issue with medium priority
+  print issue_tracker.create_issue(
+    project_id, issue['title'], priority_id,
+    person_id, person_id,
+    {:description => "Created by DoneDone API Ruby client.", :tags => issue['tags']})
+
+  # Pause execution for API request wait time.
+  sleep(5)
+end

data/lib/donedone.rb

@@ -0,0 +1,5 @@
+require_relative './donedone/version'
+require_relative './donedone/multipart'
+require_relative './donedone/issue_tracker'
+module DoneDone
+end

data/lib/donedone/constant.rb

@@ -0,0 +1,33 @@
+module DoneDone
+  class Constant
+    PROJECTS_WITH_ISSUES = 'Projects/true' unless const_defined?(:PROJECTS_WITH_ISSUES)
+    PROJECTS = 'Projects' unless const_defined?(:PROJECTS)
+    PRIORITY_LEVELS = 'PriorityLevels' unless const_defined?(:PRIORITY_LEVELS)
+    PEOPLE_IN_PROJECT = "PeopleInProject/%s" unless const_defined?(:PEOPLE_IN_PROJECT)
+    ISSUES_IN_PROJECT = "IssuesInProject/%s" unless const_defined?(:ISSUES_IN_PROJECT)
+    DOES_ISSUE_EXIST = "DoesIssueExist/%s/%s" unless const_defined?(:DOES_ISSUE_EXIST)
+    POTENTIAL_STATUSES_FOR_ISSUE = "PotentialStatusesForIssue/%s/%s" unless const_defined?(:POTENTIAL_STATUSES_FOR_ISSUE)
+    CREATE_ISSUE = "Issue/%s" unless const_defined?(:CREATE_ISSUE)
+    ISSUE = "#{CREATE_ISSUE}/%s" unless const_defined?(:ISSUE)
+    PEOPLE_FOR_ISSUE_ASSIGNMENT = "PeopleForIssueAssignment/%s/%s" unless const_defined?(:PEOPLE_FOR_ISSUE_ASSIGNMENT)
+    COMMENT = "Comment/%s/%s" unless const_defined?(:COMMENT)
+
+    HOST = "%s.mydonedone.com" unless const_defined?(:HOST)
+    PROTOCOL = "https" unless const_defined?(:PROTOCOL)
+    BASE_URL_PATH = "IssueTracker/API" unless const_defined?(:BASE_URL_PATH)
+    BASE_URL = "#{PROTOCOL}://%s/#{BASE_URL_PATH}/" unless const_defined?(:BASE_URL)
+
+    SSL_VERIFY_MODE = OpenSSL::SSL::VERIFY_NONE unless const_defined?(:SSL_VERIFY_MODE)
+    SSL_VERSION = :SSLv3 unless const_defined?(:SSL_VERSION)
+
+    def self.url_for(name, *args)
+      format_str = const_get(name)
+      if args.empty?
+        format_str
+      else
+        format_str % args
+      end
+    end
+  end
+end
+

data/lib/donedone/http.rb

@@ -0,0 +1,131 @@
+require 'net/https'
+require 'uri'
+require_relative 'multipart'
+
+module DoneDone
+  class Http
+    attr_reader :domain, :data, :files, :method_url
+    attr_reader :_request, :_debug
+    private :_request
+    private :_debug
+
+    attr_reader :put_class, :get_class, :post_class, :multipart_post_class
+    attr_reader :http_class, :ssl_verify_mode, :ssl_version
+    def initialize(domain, username, password, options={})
+      @domain = domain
+      @_username = username
+      @_password = password
+
+      @put_class = options[:put_class] || Net::HTTP::Put
+      @get_class = options[:get_class] || Net::HTTP::Get
+      @post_class = options[:post_class] || Net::HTTP::Post
+      @multipart_post_class = options[:multipart_post_class] || Multipart::Post
+      @http_class = options[:http_class] || Net::HTTP
+      @ssl_verify_mode = options[:ssl_verify_mode] || Constant::SSL_VERIFY_MODE
+      @ssl_version = options[:ssl_version] || Constant::SSL_VERSION
+    end
+
+    def reset(options = {})
+      @data = options[:data]
+      @files = options[:files]
+      @_request = nil
+      @uri = nil
+      @base_url = nil
+      @host = nil
+      @http = nil
+      @_debug = options.has_key?(:debug) ? options[:debug] : false
+    end
+
+    def host
+      unless @host
+        @host = Constant.url_for('HOST', domain)
+      end
+      @host
+    end
+
+    def get(method_url, options={})
+      @method_url = method_url
+      reset(options)
+      request(get_class)
+    end
+
+    def put(method_url, options={})
+      @method_url = method_url
+      reset(options)
+      request(put_class) do
+        append_any_form_data
+      end
+    end
+
+    def post(method_url, options={})
+      @method_url = method_url
+      reset(options)
+      request(post_class) do
+        files ? append_multipart_data : append_any_form_data
+      end
+    end
+
+
+    private
+
+    def http
+      unless @http
+        @http = http_class.new(uri.host, uri.port)
+        @http.use_ssl = true
+        @http.verify_mode = ssl_verify_mode
+        @http.ssl_version = ssl_version
+      end
+      @http
+    end
+
+    def base_url
+      unless @base_url
+        @base_url = Constant.url_for('BASE_URL', host)
+      end
+      @base_url
+    end
+
+    def uri
+      unless @uri
+        @uri = URI.parse("#{base_url}#{method_url}")
+      end
+      @uri
+    end
+
+    def request(method_class)
+      debug { "#{method_class.name}, #{uri.request_uri.inspect} - host: #{uri.host}, - port: #{uri.port}" }
+      @_request = method_class.new(uri.request_uri)
+
+      yield if block_given?
+
+      debug { "uri: #{uri.inspect}, files: #{files.inspect}" }
+      _request.basic_auth(@_username, @_password)
+
+      debug { "request: #{_request.to_hash.inspect}" }
+      http.request(_request)
+    end
+
+    def append_any_form_data #(data=data)
+      if data
+        debug { "form_data: #{data.inspect}" }
+        _request.set_form_data(data)
+      end
+    end
+
+    def append_multipart_data #(files=files, data=data)
+      body, content_type, useragent =
+        multipart_post_class.prepare_query( files.merge(data) )
+
+      debug { "params: #{params.inspect}; body: #{body.inspect}, content_type: #{content_type.inspect}, useragent: #{useragent.inspect}" }
+      @_request.content_type = content_type
+      @_request.content_length = body.size
+      @_request["User-Agent"] = useragent
+
+      @_request.body = body
+    end
+
+    def debug
+      puts(yield) if _debug && block_given?
+    end
+  end
+end

data/lib/donedone/issue_tracker.rb

@@ -0,0 +1,248 @@
+require_relative "http"
+require_relative "constant"
+require "json"
+
+module DoneDone
+  class IssueTracker
+    HELPER_METHODS = [:response, :result] unless const_defined?(:HELPER_METHODS)
+    def self.api_methods
+      instance_methods(false) - HELPER_METHODS
+    end
+
+    #Provide access to the DoneDone IssueTracker API.
+    #See http://www.getdonedone.com/api for complete documentation for the
+    #API.
+
+    attr_reader :response
+    attr_reader :_debug
+    private :_debug
+    attr_reader :_http_helper
+    private :_http_helper
+
+    #_debug - print debug messages
+    #domain - company's DoneDone domain
+    #username - DoneDone username
+    #password - DoneDone password
+
+    def initialize(domain, username, password=nil, options = {})
+      @_debug = options.has_key?(:debug) ? options[:debug] : false
+      @_http_helper = options[:http_helper] || DoneDone::Http.new(domain, username, password)
+      @response = nil
+    end
+
+    def result
+      response ?  JSON.parse( response.body ) : ""
+    end
+
+
+    # Get all Projects with the API enabled
+    # load_with_issues - Passing true will deep load all of the projects as
+    # well as all of their active issues.
+    def projects(load_with_issues=false)
+      url = load_with_issues ? Constant.url_for('PROJECTS_WITH_ISSUES') : Constant.url_for('PROJECTS')
+      api url
+    end
+
+    # Get priority levels
+    def priority_levels
+      api Constant.url_for('PRIORITY_LEVELS')
+    end
+
+    # Get all people in a project
+    # project_id - project id
+    def people_in_project project_id
+      api Constant.url_for('PEOPLE_IN_PROJECT', project_id)
+    end
+
+    # Get all issues in a project
+    # project_id - project id
+    def issues_in_project project_id
+      api Constant.url_for('ISSUES_IN_PROJECT', project_id)
+    end
+
+    # Check if an issue exists
+    # project_id - project id
+    # issue_id - issue id
+    def issue_exist?(project_id, issue_id)
+      api Constant.url_for('DOES_ISSUE_EXIST', project_id, issue_id)
+      !result.empty? ? result["IssueExists"] : false
+    end
+
+    # Get potential statuses for issue
+    # Note: If you are an admin, you'll get both all allowed statuses
+    # as well as ALL statuses back from the server
+    # project_id - project id
+    # issue_id - issue id
+    def potential_statuses_for_issue( project_id, issue_id)
+      api Constant.url_for('POTENTIAL_STATUSES_FOR_ISSUE', project_id, issue_id)
+    end
+
+    # Note: You can use this to check if an issue exists as well,
+    # since it will return a 404 if the issue does not exist.
+    def issue(project_id, issue_id)
+      api Constant.url_for('ISSUE', project_id, issue_id)
+    end
+
+    # Get a list of people that cane be assigend to an issue
+    def people_for_issue_assignment(project_id, issue_id)
+      api Constant.url_for('PEOPLE_FOR_ISSUE_ASSIGNMENT', project_id, issue_id)
+    end
+
+    #Create Issue
+    # project_id - project id
+    # title - required title.
+    # priority_id - priority levels
+    # resolver_id - person assigned to solve this issue
+    # tester_id - person assigned to test and verify if a issue is
+    # resolved
+    # description - optional description of the issue
+    # tags - a string of tags delimited by comma
+    # watcher_id - a string of people's id delimited by comma
+    # attachments - list of file paths
+    def create_issue( project_id, title, priority_id, resolver_id, tester_id, options={})
+      description=options[:description]
+      tags=options[:tags]
+      watcher_id=options[:watcher_id]
+      attachments=options[:attachments]
+
+      data = {
+        'title' => title,
+        'priority_level_id' => priority_id,
+        'resolver_id' => resolver_id,
+        'tester_id' => tester_id,
+      }
+
+      data['description'] = description if description
+      data['tags'] = tags if tags
+      data['watcher_ids'] = watcher_id if watcher_id
+
+      params = {:data => data, :update => false, :post => true}
+      params[:attachments] = attachments if attachments
+      api Constant.url_for('CREATE_ISSUE', project_id), params
+      !result.empty? ? result["IssueID"] : nil
+    end
+
+    #Create Comment on issue
+    #project_id - project id
+    #issue_id - issue id
+    #comment - comment string
+    #people_to_cc_ids - a string of people to be CCed on this comment,
+    #delimited by comma
+    #attachments - list of absolute file path.
+    def create_comment(project_id, order_number, comment, options={})
+      people_to_cc_ids=options[:people_to_cc_ids]
+      attachments=options[:attachments]
+
+      data = {'comment' => comment}
+      data['people_to_cc_ids']= people_to_cc_ids if people_to_cc_ids
+
+      params = {:data => data, :update => false, :post => true}
+      params[:attachments] = attachments if attachments
+      api Constant.url_for('COMMENT', project_id, order_number), params
+      !result.empty? ? result["CommentURL"] : nil
+    end
+
+    #Update Issue
+    # If you provide any parameters then the value you pass will be
+    # used to update the issue. If you wish to keep the value that's
+    # already on an issue, then do not provide the parameter in your
+    # PUT data. Any value you provide, including tags, will overwrite
+    # the existing values on the issue. If you wish to retain the
+    # tags for an issue and update it by adding one new tag, then
+    # you'll have to provide all of the existing tags as well as the
+    # new tag in your tags parameter, for example.
+
+    # project_id - project id
+    # order_number - issue id
+    # title - required title
+    # priority_id - priority levels
+    # resolver_id - person assigned to solve this issue
+    # tester_id - person assigned to test and verify if a issue is
+    # resolved
+    # description - optional description of the issue
+    # tags - a string of tags delimited by comma
+    # state_id - a valid state that this issue can transition to
+    # attachments - list of file paths
+    def update_issue(project_id, order_number, options={})
+      title=options[:title]
+      priority_id=options[:priority_id]
+      resolver_id=options[:resolver_id]
+      tester_id=options[:tester_id]
+      description=options[:description]
+      tags=options[:tags]
+      state_id=options[:state_id]
+      attachments=options[:attachments]
+
+      data = {}
+      data['title'] = title if title
+      data['priority_level_id'] = priority_id if priority_id
+      data['resolver_id'] = resolver_id if resolver_id
+
+      data['tester_id'] = tester_id if tester_id
+      data['description'] = description if description
+      data['tags'] = tags if tags
+      data['state_id'] = state_id if state_id
+
+      params = {:update => true}
+      params[:data] = data unless data.empty?
+      params[:attachments] = attachments if attachments
+      api Constant.url_for('ISSUE', project_id, order_number), params
+      !result.empty? ? result["IssueURL"] : nil
+    end
+
+
+    private
+
+    # Perform generic API calling
+    #This is the base method for all IssueTracker API calls.
+    # method_url - IssueTracker method URL
+    # data - optional POST form data
+    # attachemnts - optional list of file paths
+    # update - flag to indicate if this is a PUT operation
+    def api(method_url, options={})
+      data = options[:data]
+      attachments = options[:attachments]
+      update = options.has_key?(:update) ? options[:update] : false
+      post = options.has_key?(:post) ? options[:post] : false
+
+      @response = nil
+      files = {}
+      request_method = nil
+
+      if attachments
+        debug { "attachments; using post" }
+        request_method = :post
+        attachments.each_with_index do |attachment, index|
+          files["attachment-#{index}"] = attachment
+        end
+      else
+        request_method = :get
+      end
+
+      if update
+        debug { "using put" }
+        request_method = :put
+      end
+
+      if post
+        debug { "using post" }
+        request_method = :post
+      end
+
+      params = { :debug => _debug }
+      params[:data] = data if data
+      params[:files] = files unless files.empty?
+
+      @response = _http_helper.send(request_method, method_url, params)
+      return result
+    rescue Exception => e
+      warn e.message
+      warn e.backtrace.inspect
+      return ""
+    end
+
+    def debug
+      puts(yield) if _debug && block_given?
+    end
+  end
+end

data/lib/donedone/multipart.rb

@@ -0,0 +1,78 @@
+# Takes a hash of file-key and file-name and returns a string of text
+# formatted to be sent as a multipart form post.
+
+require 'mime/types'
+require 'cgi'
+
+
+module DoneDone
+  module Multipart
+    VERSION = "1.0.0" unless const_defined?(:VERSION)
+
+    # Formats a given hash as a multipart form post
+    # If determine if the params are Files or Strings and process
+    # appropriately
+    class Post
+      # We have to pretend like we're a web browser...
+      USERAGENT = "Mozilla/5.0 (Macintosh; U; PPC Mac OS X; en-us) AppleWebKit/523.10.6 (KHTML, like Gecko) Version/3.0.4 Safari/523.10.6" unless const_defined?(:USERAGENT)
+      BOUNDARY = '--JTMultiPart' + rand(1000000).to_s + 'ZZZZZ' unless const_defined?(:BOUNDARY)
+      CONTENT_TYPE = "multipart/form-data; boundary=#{ BOUNDARY }" unless const_defined?(:CONTENT_TYPE)
+      #HEADER = { "Content-Type" => CONTENT_TYPE, "User-Agent" => USERAGENT } unless const_defined?(:HEADER)
+
+      def self.prepare_query(params)
+        fp = []
+
+        params.each do |k, v|
+          if File.exists?(v) # must be a file
+            path = File.path(v)
+            content = File.binread(v)
+            fp.push(FileParam.new(k, path, content))
+          else # must be a string
+            fp.push(StringParam.new(k, v))
+          end
+        end
+
+        # Assemble the request body using the special multipart format
+        query = fp.collect {|p| "--" + BOUNDARY + "\r\n" + p.to_multipart }.join("")  + "--" + BOUNDARY + "--"
+        return query, CONTENT_TYPE, USERAGENT
+      end
+    end
+
+
+    private
+
+    class StringParam
+      attr_accessor :k, :v
+
+      def initialize(k, v)
+        @k = k
+        @v = v
+      end
+
+      def to_multipart
+        return "Content-Disposition: form-data; name=\"#{CGI::escape(k)}\"\r\n\r\n#{v}\r\n"
+      end
+    end
+
+    # Formats the contents of a file for inclusion with a multipart
+    # form post
+    class FileParam
+      attr_accessor :k, :filename, :content
+
+      def initialize(k, filename, content)
+        @k = k
+        @filename = filename
+        @content = content
+      end
+
+      def to_multipart
+        # If we can tell the possible mime-type from the filename, use the
+        # first in the list; otherwise, use "application/octet-stream"
+        mime_type = MIME::Types.type_for(filename)[0] || MIME::Types["application/octet-stream"][0]
+        return "Content-Disposition: form-data; name=\"#{CGI::escape(k)}\"; filename=\"#{ filename }\"\r\n" +
+          "Content-Transfer-Encoding: binary\r\n" +
+          "Content-Type: #{ mime_type.simplified }\r\n\r\n#{ content }\r\n"
+      end
+    end
+  end
+end

data/lib/donedone/version.rb

@@ -0,0 +1,3 @@
+module DoneDone
+  VERSION = "0.0.4" unless const_defined?(:VERSION)
+end

data/spec/donedone/constant_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe DoneDone::Constant do
+  describe ".url_for" do
+    context 'valid args' do
+      it "generates url with format string" do
+        expect(DoneDone::Constant.url_for('PEOPLE_IN_PROJECT')).to eq(DoneDone::Constant::PEOPLE_IN_PROJECT)
+        expect(DoneDone::Constant.url_for('PEOPLE_IN_PROJECT', '%s')).to eq(DoneDone::Constant::PEOPLE_IN_PROJECT)
+      end
+
+      it "generates url without format string" do
+        expect(DoneDone::Constant.url_for('PROJECTS_WITH_ISSUES')).to eq(DoneDone::Constant::PROJECTS_WITH_ISSUES)
+        expect(DoneDone::Constant.url_for('PROJECTS_WITH_ISSUES', 'bogus_arg1')).to eq(DoneDone::Constant::PROJECTS_WITH_ISSUES)
+      end
+    end
+  end
+end

data/spec/donedone/http_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe DoneDone::Http do
+  class BogusNetHttp
+    attr_reader :host, :port, :use_ssl
+    attr_accessor :ssl_version, :verify_mode
+    def initialize(host, port)
+      @host = host
+      @port = port
+      clear
+    end
+
+    def clear
+      @use_ssl = false
+      @verify_mode = nil
+      @ssl_version = nil
+    end
+
+    def use_ssl=(bool)
+      @use_ssl = !!bool
+    end
+
+    def request(request_object)
+      @request = request_object
+    end
+  end
+
+  let(:net_http_class) { BogusNetHttp }
+  let(:domain) { "domain" }
+  let(:username) { "username" }
+  let(:password) { "password" }
+  let(:new_options) { {:http_class => net_http_class} }
+  let(:new_args) { [domain, username, password, new_options] }
+  let(:donedone_http_object) { DoneDone::Http.new(*new_args) }
+  let(:request_methods) { [:get, :put, :post] }
+
+  describe "init" do
+    context 'invalid args' do
+      it "raises an Exception for 0-2 args" do
+        expect { DoneDone::Http.new }.to raise_error()
+        expect { DoneDone::Http.new(domain) }.to raise_error()
+        expect { DoneDone::Http.new(domain, username) }.to raise_error()
+      end
+      it "raises an Exception for >4 args" do
+        expect { DoneDone::Http.new(domain, username, password, {}, :extra1) }.to raise_error()
+      end
+    end
+
+    context 'valid args' do
+      it "requires 3-4 args" do
+        expect { DoneDone::Http.new(domain, username, password) }.to_not raise_error()
+        expect { DoneDone::Http.new(domain, username, password, {}) }.to_not raise_error()
+      end
+    end
+  end
+
+  describe "request(s)" do
+    let(:method_url) { "method_url" }
+
+    context 'invalid args' do
+      it "will raise an Exception for 0 args" do
+        request_methods.each do |method|
+          expect { donedone_http_object.send(method) }.to raise_error
+        end
+      end
+      it "will raise an Exception for >2 args" do
+        request_methods.each do |method|
+          expect { donedone_http_object.send(method, method_url, {}, :extra1) }.to raise_error
+        end
+      end
+    end
+    context 'valid args' do
+      let(:ssl_port) { 443 }
+      it "will not raise an Exception for 1-2 args" do
+        request_methods.each do |method|
+          expect { donedone_http_object.send(method, method_url) }.to_not raise_error
+          expect { donedone_http_object.send(method, method_url, {}) }.to_not raise_error
+        end
+      end
+
+      # a bit fragile: specific to Net::HTTP
+      it "sets-up a proper http object for :get" do
+        expect(donedone_http_object.host).to start_with(domain)
+        net_http_obj = net_http_class.new(donedone_http_object.host, ssl_port)
+        net_http_class.should_receive(:new).exactly(request_methods.length).times.with(donedone_http_object.host, ssl_port).and_return(net_http_obj)
+
+        request_methods.each do |method|
+          expect(net_http_obj.use_ssl).to eq(false)
+          expect(net_http_obj.verify_mode).to eq(nil)
+          expect(net_http_obj.ssl_version).to eq(nil)
+          donedone_http_object.send(method, method_url)
+          expect(net_http_obj.use_ssl).to eq(true)
+          expect(net_http_obj.verify_mode).to eq(DoneDone::Constant::SSL_VERIFY_MODE)
+          expect(net_http_obj.ssl_version).to eq(DoneDone::Constant::SSL_VERSION)
+          donedone_http_object.reset
+          net_http_obj.clear
+        end
+      end
+    end
+  end
+end

data/spec/donedone/issue_tracker_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+
+describe DoneDone::IssueTracker do
+  let(:bogus_http_helper) { Object.new }
+  let(:http_helper) { bogus_http_helper }
+  let(:domain) { :domain }
+  let(:username) { :username }
+  let(:password) { :password }
+  let(:http_helper_options) { {:debug=>false} }
+  let(:issue_tracker) { DoneDone::IssueTracker.new(domain, username, password, :http_helper => http_helper) }
+
+  describe "init" do
+    context 'invalid args' do
+      it "raises an Exception for 0-1 args" do
+        expect { DoneDone::IssueTracker.new }.to raise_error()
+        expect { DoneDone::IssueTracker.new(domain) }.to raise_error()
+      end
+      it "raises an Exception for >4 args" do
+        expect { DoneDone::IssueTracker.new(domain, username, password, {}, :extra1) }.to raise_error()
+      end
+    end
+
+    context 'valid args' do
+      it "requires 2-4 args" do
+        expect { DoneDone::IssueTracker.new(domain, username) }.to_not raise_error()
+        expect { DoneDone::IssueTracker.new(domain, username, password) }.to_not raise_error()
+        expect { DoneDone::IssueTracker.new(domain, username, password, {}) }.to_not raise_error()
+      end
+    end
+  end
+
+  describe "methods" do
+    let(:expected_api_methods) { [ :projects, :priority_levels, :people_in_project, :issues_in_project, :issue_exist?, :potential_statuses_for_issue, :issue, :people_for_issue_assignment, :create_issue, :create_comment, :update_issue ] }
+
+    let(:actual_helper_methods) { DoneDone::IssueTracker::HELPER_METHODS }
+    let(:actual_api_methods) { DoneDone::IssueTracker.api_methods }
+
+    it "distinguises its api- and helper-methods" do
+      expect(actual_api_methods).to_not include(actual_helper_methods)
+    end
+
+    it "knows its api methods" do
+      expect(DoneDone::IssueTracker.api_methods).to eq(expected_api_methods)
+    end
+
+    it "responds to its expected-helper and -api methods" do
+      (actual_helper_methods + actual_api_methods).each do |expected_method|
+        expect(issue_tracker).to respond_to(expected_method)
+      end
+    end
+  end
+
+  describe "api-requests" do
+    it "requests all projects" do
+      http_helper.should_receive(:get).with( DoneDone::Constant::PROJECTS, http_helper_options )
+
+      issue_tracker.projects
+    end
+
+    it "requests all projects with their issues" do
+      http_helper.should_receive(:get).with( DoneDone::Constant::PROJECTS_WITH_ISSUES, http_helper_options)
+
+      issue_tracker.projects(true)
+    end
+
+    it "requests all priority_levels" do
+      http_helper.should_receive(:get).with( DoneDone::Constant::PRIORITY_LEVELS, http_helper_options)
+
+      issue_tracker.priority_levels
+    end
+
+    it "requests all people_in_project" do
+      project_id = 1
+      http_helper.should_receive(:get).with( DoneDone::Constant.url_for('PEOPLE_IN_PROJECT', project_id), http_helper_options)
+
+      issue_tracker.people_in_project(project_id)
+    end
+
+    it "requests all issues_in_project" do
+      project_id = 1
+      http_helper.should_receive(:get).with( DoneDone::Constant.url_for('ISSUES_IN_PROJECT', project_id), http_helper_options)
+
+      issue_tracker.issues_in_project(project_id)
+    end
+
+    it "requests if an issue exists for a project" do
+      project_id = 1
+      issue_order_number = 1
+      http_helper.should_receive(:get).with( DoneDone::Constant.url_for('DOES_ISSUE_EXIST', project_id, issue_order_number), http_helper_options)
+
+      issue_tracker.issue_exist?(project_id, issue_order_number)
+    end
+
+    it "requests status for a project's issue" do
+      project_id = 1
+      issue_order_number = 1
+      http_helper.should_receive(:get).with( DoneDone::Constant.url_for('POTENTIAL_STATUSES_FOR_ISSUE', project_id, issue_order_number), http_helper_options)
+
+      issue_tracker.potential_statuses_for_issue(project_id, issue_order_number)
+    end
+
+    it "requests a project's issue's details" do
+      project_id = 1
+      issue_order_number = 1
+      http_helper.should_receive(:get).with( DoneDone::Constant.url_for('ISSUE', project_id, issue_order_number), http_helper_options)
+
+      issue_tracker.issue(project_id, issue_order_number)
+    end
+
+    it "requests people for issue assignment" do
+      project_id = 1
+      issue_order_number = 1
+      http_helper.should_receive(:get).with( DoneDone::Constant.url_for('PEOPLE_FOR_ISSUE_ASSIGNMENT', project_id, issue_order_number), http_helper_options)
+
+      issue_tracker.people_for_issue_assignment(project_id, issue_order_number)
+    end
+
+    it "requests to create an issue" do
+      project_id = 1
+      title = 'required title'
+      priority_level_id = 2 # required
+      resolver_id = 2 # required
+      tester_id = 2 # required
+
+      data = {
+        'title' => title,
+        'priority_level_id' => priority_level_id,
+        'resolver_id' => resolver_id,
+        'tester_id' => tester_id,
+      }
+
+      options = http_helper_options.merge(:data => data)
+      http_helper.should_receive(:post).with( DoneDone::Constant.url_for('CREATE_ISSUE', project_id), options)
+
+      issue_tracker.create_issue(project_id, title, priority_level_id, resolver_id, tester_id)
+    end
+
+    # todo: test for passing file upload(s)
+    it "requests to create a comment for a project's issue" do
+      project_id = 1
+      issue_order_number = 1
+      comment = 'required comment'
+
+      data = { 'comment' => comment }
+
+      options = http_helper_options.merge(:data => data)
+      http_helper.should_receive(:post).with( DoneDone::Constant.url_for('COMMENT', project_id, issue_order_number), options)
+
+      issue_tracker.create_comment(project_id, issue_order_number, comment)
+    end
+
+    it "requests to update a project's issue" do
+      project_id = 1
+      issue_order_number = 1
+
+      options = http_helper_options
+      http_helper.should_receive(:put).with( DoneDone::Constant.url_for('ISSUE', project_id, issue_order_number), options)
+
+      issue_tracker.update_issue(project_id, issue_order_number, options)
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require "bundler"
+Bundler.setup
+
+require "rspec"
+require "donedone"
+
+#require 'simplecov'
+
+#SimpleCov.start do
+#  coverage_dir 'coverage'
+#  add_filter "/spec/"
+#end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: donedone
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Jonathan Thomas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.0
+description: Check your existing todo items, add new ones, update old one
+email:
+- buyer+donedone@his-service.net
+executables:
+- donedone
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- bin/donedone
+- donedone.gemspec
+- examples/lighthouse_csv_importer.rb
+- lib/donedone.rb
+- lib/donedone/constant.rb
+- lib/donedone/http.rb
+- lib/donedone/issue_tracker.rb
+- lib/donedone/multipart.rb
+- lib/donedone/version.rb
+- spec/donedone/constant_spec.rb
+- spec/donedone/http_spec.rb
+- spec/donedone/issue_tracker_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/zoodles/DoneDone-API-Ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: donedone
+rubygems_version: 2.0.6
+signing_key: 
+specification_version: 4
+summary: donedone.com api client
+test_files:
+- spec/donedone/constant_spec.rb
+- spec/donedone/http_spec.rb
+- spec/donedone/issue_tracker_spec.rb
+- spec/spec_helper.rb