vigetlabs-unfuzzle 0.1.0

data/README.rdoc

@@ -0,0 +1,109 @@
+= Unfuzzle
+
+== Description
+
+The Unfuzzle gem provides an interface to the Unfuddle JSON API
+
+== Installation
+
+    sudo gem install vigetlabs-unfuzzle --source=http://gems.github.com
+
+== Usage
+
+To get started, you'll need your Unfuddle subdomain and a valid username / 
+password combination:
+
+    require 'unfuzzle'
+    
+    Unfuzzle.subdomain = 'viget'
+    Unfuzzle.username  = 'bopbip'
+    Unfuzzle.password  = 'bleep'
+    
+Once that is configured, you can start accessing data from the API.
+
+=== Projects
+
+Pulling back a list of projects is simple.  Based on the currently logged-in
+user, you can see which ones he has access to:
+
+    projects = Unfuzzle.projects # => [#<Unfuzzle::Project:0x11e9280 ...> , ...]
+    
+If you don't want all projects, you can find one by its slug (or short name):
+
+    Unfuzzle.project('salty') # => #<Unfuzzle::Project:0x11e9280 ...>
+    
+Or by ID:
+
+    Unfuzzle.project(1) # => #<Unfuzzle::Project:0x11e9280 ...>
+
+There are a few attributes available for a project:
+
+    project = Unfuzzle.projects.first
+    project.id                              # => 123
+    project.slug                            # => "salty"
+    project.name                            # => "Salty Co."
+    project.archived?                       # => false
+    project.created_at.strftime('%Y-%m-%d') # => "2008-07-28"
+    
+To see a list of additional attributes, take a look at the documentation for
+Project.
+
+=== Milestones
+
+Each project can have milestones.  You can access these from a single project:
+
+    project.milestones # => [#<Unfuzzle::Milestone:0x10bdca8 ...>, ...]
+
+Milestones have attributes:
+
+    milestone = project.milestones.first
+    milestone.id                          # => 1
+    milestone.name                        # => "Milestone #1"
+    milestone.due_on.strftime('%m/%d/%Y') # => "07/30/2008"
+
+A full list is available in the Milestone documentation.
+
+=== Tickets
+
+Tickets exist for a project:
+
+    ticket = project.tickets.first
+    ticket.title        # => "Ticket #23"
+    ticket.number       # => 23
+    ticket.description  # => "Yo dawg, I hear you like tickets in your project ..."
+    ticket.status       # => "closed"
+
+And can also be associated to a milestone for the project:
+
+    ticket = project.milestones.first.tickets.first
+    ticket.title        # => "Ticket #1"
+    ticket.number       # => 1
+    ticket.description  # => "Wash my car"
+    ticket.status       # => "closed"
+
+See the Ticket documentation for more information.
+
+== License
+
+Copyright (c) 2009 Patrick Reagan of Viget Labs (mailto:patrick.reagan@viget.com)
+
+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/Rakefile

@@ -0,0 +1,39 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+
+require 'lib/unfuzzle/version'
+
+task :default => :test
+
+spec = Gem::Specification.new do |s|
+  s.name             = 'unfuzzle'
+  s.version          = Unfuzzle::Version.to_s
+  s.has_rdoc         = true
+  s.extra_rdoc_files = %w(README.rdoc)
+  s.rdoc_options     = %w(--main README.rdoc)
+  s.summary          = "This gem provides an interface to the Unfuddle JSON API"
+  s.author           = 'Patrick Reagan'
+  s.email            = 'patrick.reagan@viget.com'
+  s.homepage         = 'http://www.viget.com/extend'
+  s.files            = %w(README.rdoc Rakefile) + Dir.glob("{lib,test}/**/*")
+  
+  s.add_dependency('json', '>= 1.1.6')
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+end
+
+desc 'Generate the gemspec to serve this Gem from Github'
+task :github do
+  file = File.dirname(__FILE__) + "/#{spec.name}.gemspec"
+  File.open(file, 'w') {|f| f << spec.to_ruby }
+  puts "Created gemspec: #{file}"
+end

data/lib/unfuzzle/milestone.rb

@@ -0,0 +1,54 @@
+module Unfuzzle
+
+  # = Milestone
+  #
+  # A representation of an Unfuddle Milestone.  Has the following attributes:
+  #
+  # [id] Unique identifier for this milestone
+  # [name] Name of the milestone
+  #
+  class Milestone
+
+    include Unfuzzle::Model
+
+    attribute :id
+    attribute :project_id
+    attribute :archived
+    attribute :name, :from => :title
+    attribute :created_timestamp, :from => :created_at
+    attribute :updated_timestamp, :from => :updated_at
+    attribute :due_datestamp, :from => :due_on
+
+    # Return a list of all milestones for a given project
+    def self.find_all_by_project_id(project_id)
+      response = Request.get("/projects/#{project_id}/milestones")
+      response.data.map {|data| new(data) }
+    end
+
+    # Has this milestone been archived?
+    def archived?
+      archived == true
+    end
+
+    # The DateTime that this milestone was created
+    def created_at
+      DateTime.parse(created_timestamp)
+    end
+
+    # The DateTime that this milestone was last updated
+    def updated_at
+      DateTime.parse(updated_timestamp)
+    end
+
+    # The Date that this milestone is due
+    def due_on
+      Date.parse(due_datestamp) unless due_datestamp.nil?
+    end
+
+    # The collection of Tickets associated to this milestone
+    def tickets
+      Ticket.find_all_by_project_id_and_milestone_id(project_id, id)
+    end
+
+  end
+end

data/lib/unfuzzle/model.rb

@@ -0,0 +1,30 @@
+module Unfuzzle
+  module Model # :nodoc:
+
+    module ClassMethods
+      def attribute(name, options = {}) # :nodoc:
+        key = options.delete(:from) || name
+
+        class_eval %(
+        def #{name}
+          @response_data['#{key}']
+        end
+        )
+      end
+    end
+
+    module InstanceMethods
+
+      def initialize(response_data)
+        @response_data = response_data
+      end
+
+    end
+
+    def self.included(other)
+      other.send(:extend, Unfuzzle::Model::ClassMethods)
+      other.send(:include, Unfuzzle::Model::InstanceMethods)
+    end
+
+  end
+end

data/lib/unfuzzle/project.rb

@@ -0,0 +1,68 @@
+module Unfuzzle
+  
+  # = Project
+  #
+  # Represents an Unfuddle project.  Has the following attributes:
+  #
+  # [id] The unique identifier for this project
+  # [slug] The "short name" for this project
+  # [name] The name of this project
+  # [description] The description for the project
+  #
+  class Project
+    
+    include Unfuzzle::Model
+    
+    attribute :id
+    attribute :slug, :from => :short_name
+    attribute :archived
+    attribute :name, :from => :title
+    attribute :description
+    attribute :created_timestamp, :from => :created_at
+    attribute :updated_timestamp, :from => :updated_at
+
+    # Return a list of all projects to which the current user has access
+    def self.all
+      response = Request.get('/projects')
+      response.data.map {|data| new(data) }
+    end
+    
+    # Find a single project by its slug (short name)
+    def self.find_by_slug(slug)
+      response = Request.get("/projects/by_short_name/#{slug}")
+      new(response.data)
+    end
+
+    # Find a single project by its ID
+    def self.find_by_id(id)
+      response = Request.get("/projects/#{id}")
+      new(response.data)
+    end
+
+    # Has this project been archived?
+    def archived?
+      archived == true
+    end
+    
+    # The DateTime that this project was created
+    def created_at
+      DateTime.parse(created_timestamp)
+    end
+    
+    # The DateTime that this project was last updated
+    def updated_at
+      DateTime.parse(updated_timestamp)
+    end
+
+    # The collection of Milestones associated to this project
+    def milestones
+      Milestone.find_all_by_project_id(id)
+    end
+
+    # The collection of Tickets associated to this project
+    def tickets
+      Ticket.find_all_by_project_id(id)
+    end
+
+  end
+end

data/lib/unfuzzle/request.rb

@@ -0,0 +1,37 @@
+module Unfuzzle
+  
+  # = Request
+  #
+  # A basic wrapper for GET requests to the Unfuddle API
+  #
+  class Request 
+
+    # Retrieve a response from the given resource path
+    def self.get(resource_path)
+      request = new(resource_path)
+      request.get
+    end
+    
+    # Create a new request for the given resource path
+    def initialize(resource_path)
+      @resource_path = resource_path
+    end
+    
+    def endpoint_uri  # :nodoc:
+      URI.parse("http://#{Unfuzzle.subdomain}.unfuddle.com/api/v1#{@resource_path}.json")
+    end
+
+    def client # :nodoc:
+      Net::HTTP.new(endpoint_uri.host)
+    end
+
+    # Retrieve a response from the current resource path    
+    def get
+      request = Net::HTTP::Get.new(endpoint_uri.path)
+      request.basic_auth Unfuzzle.username, Unfuzzle.password
+      
+      Response.new(client.request(request))
+    end
+    
+  end
+end

data/lib/unfuzzle/response.rb

@@ -0,0 +1,32 @@
+module Unfuzzle
+  
+  # = Response
+  #
+  # A simple wrapper around an HTTP response from the Unfuddle API
+  #
+  class Response
+    
+    # Create a new response from an HTTP response object
+    def initialize(http_response)
+      @http_response = http_response
+    end
+    
+    # Was there an error produced as part of the request?
+    def error?
+      !@http_response.is_a?(Net::HTTPSuccess)
+    end
+    
+    # Raw body of the HTTP response
+    def body
+      @http_response.body
+    end
+    
+    # Parsed JSON response body
+    def data
+      if !error?
+        @parsed_data ||= JSON.parse(body)
+      end
+    end
+    
+  end
+end

data/lib/unfuzzle/ticket.rb

@@ -0,0 +1,55 @@
+module Unfuzzle
+
+  # = Ticket
+  #
+  # Represents a single Unfuddle Ticket - is associated to a project
+  # and optionally a project's milestone.  Has the following attributes:
+  #
+  # [id] The unique identifier for this ticket
+  # [number] The ticket's number - this is displayed in the web interface
+  # [title] The title of the ticket (short)
+  # [description] The full description of the ticket
+  # [status] The ticket's status (new / accepted / resolved / closed)
+  #
+  class Ticket
+
+    include Unfuzzle::Model
+
+    attribute :id
+    attribute :number
+    attribute :title, :from => :summary
+    attribute :description
+    attribute :due_datestamp, :from => :due_on
+    attribute :created_timestamp, :from => :created_at
+    attribute :updated_timestamp, :from => :updated_at
+    attribute :status
+
+    # Return a list of all tickets for an individual project
+    def self.find_all_by_project_id(project_id)
+      response = Request.get("/projects/#{project_id}/tickets")
+      response.data.map {|data| new(data) }
+    end
+
+    # Return a list of all tickets for a given milestone as part of a project
+    def self.find_all_by_project_id_and_milestone_id(project_id, milestone_id)
+      response = Request.get("/projects/#{project_id}/milestones/#{milestone_id}/tickets")
+      response.data.map {|data| new(data) }
+    end
+
+    # The DateTime that this milestone was created
+    def created_at
+      DateTime.parse(created_timestamp)
+    end
+
+    # The DateTime that this milestone was last updated
+    def updated_at
+      DateTime.parse(updated_timestamp)
+    end
+
+    # The Date that this milestone is due
+    def due_on
+      Date.parse(due_datestamp) unless due_datestamp.nil?
+    end
+
+  end
+end

data/lib/unfuzzle/version.rb

@@ -0,0 +1,13 @@
+module Unfuzzle
+  module Version
+    
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+    
+    def self.to_s # :nodoc:
+      [MAJOR, MINOR, TINY].join('.')
+    end
+    
+  end
+end

data/lib/unfuzzle.rb

@@ -0,0 +1,72 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'uri'
+require 'net/http'
+require 'json'
+
+require 'unfuzzle/request'
+require 'unfuzzle/response'
+require 'unfuzzle/model'
+require 'unfuzzle/project'
+require 'unfuzzle/milestone'
+require 'unfuzzle/ticket'
+
+# = Unfuzzle: A simple wrapper around the Unfuddle JSON API
+#
+# == Quick Start
+#
+# To get started, you need to set the subdomain and a valid username / 
+# password combination:
+#
+#    require 'rubygems'
+#    require 'unfuzzle'
+#
+#    Unfuzzle.subdomain = 'viget'
+#    Unfuzzle.username = 'bopbip'
+#    Unfuzzle.password = 'bleep'
+# 
+# From there, you can start accessing a list of projects:
+#
+#    Project.all
+#
+module Unfuzzle
+  
+  # Set the subdomain for all requests
+  def self.subdomain=(subdomain)
+    @subdomain = subdomain
+  end
+
+  # Set the username for all requests. Data retrieved from the API will be
+  # scoped to the data that this user has access to.
+  def self.username=(username)
+    @username = username
+  end
+
+  # Set the password for the supplied username
+  def self.password=(password)
+    @password = password
+  end
+  
+  # Retrieve a project for the current user by its ID or slug
+  def self.project(id_or_slug)
+    id_or_slug.is_a?(String) ? Project.find_by_slug(id_or_slug) : Project.find_by_id(id_or_slug)
+  end
+  
+  # Get a list of all projects for this user
+  def self.projects
+    Project.all
+  end
+    
+  def self.subdomain # :nodoc:
+    @subdomain
+  end
+  
+  def self.username # :nodoc:
+    @username
+  end
+  
+  def self.password # :nodoc:
+    @password
+  end
+  
+end

data/test/fixtures/milestones.json

@@ -0,0 +1,22 @@
+[{
+    "archived": false,
+    "created_at": "2008-07-30T22:12:37Z",
+    "completed": true,
+    "title": "Milestone 1",
+    "person_responsible_id": 12345,
+    "due_on": "2008-07-30",
+    "updated_at": "2008-12-26T22:32:03Z",
+    "id": 1,
+    "project_id": 1
+},
+{
+    "archived": false,
+    "created_at": "2009-02-09T15:15:30Z",
+    "completed": true,
+    "title": "Milestone 2",
+    "person_responsible_id": 12344,
+    "due_on": "2009-02-13",
+    "updated_at": "2009-02-17T15:37:01Z",
+    "id": 2,
+    "project_id": 1
+}]

data/test/fixtures/project.json

@@ -0,0 +1,16 @@
+{
+    "archived": false,
+    "short_name": "blip",
+    "created_at": "2008-07-28T16:57:10Z",
+    "title": "Blip Bleep Co.",
+    "close_ticket_simultaneously_default": true,
+    "account_id": 1,
+    "description": "This is the project for Blip Bleep Co.",
+    "enable_time_tracking": true,
+    "default_ticket_report_id": 0,
+    "updated_at": "2009-04-28T18:48:52Z",
+    "id": 1,
+    "theme": "teal",
+    "disk_usage": 1416,
+    "assignee_on_resolve": "none"
+}

data/test/fixtures/projects.json

@@ -0,0 +1,32 @@
+[{
+    "archived": false,
+    "short_name": "aa",
+    "created_at": "2008-07-28T16:57:10Z",
+    "title": "A Client",
+    "close_ticket_simultaneously_default": true,
+    "account_id": 12345,
+    "description": "A great project",
+    "enable_time_tracking": true,
+    "default_ticket_report_id": 0,
+    "updated_at": "2009-04-28T18:48:52Z",
+    "id": 1,
+    "theme": "teal",
+    "disk_usage": 1416,
+    "assignee_on_resolve": "none"
+},
+{
+    "archived": true,
+    "short_name": "zz",
+    "created_at": "2008-06-23T21:06:01Z",
+    "title": "Zee Client",
+    "close_ticket_simultaneously_default": false,
+    "account_id": 12345,
+    "description": null,
+    "enable_time_tracking": true,
+    "default_ticket_report_id": null,
+    "updated_at": "2009-05-20T23:15:24Z",
+    "id": 2,
+    "theme": "grey",
+    "disk_usage": 14008,
+    "assignee_on_resolve": "reporter"
+}]

data/test/fixtures/tickets.json

@@ -0,0 +1,44 @@
+[{
+    "severity_id": null,
+    "hours_estimate_current": 0.0,
+    "resolution_description": "",
+    "reporter_id": 1,
+    "created_at": "2008-11-25T14:00:19Z",
+    "priority": "4",
+    "number": 1,
+    "milestone_id": 1,
+    "description": "Do something important",
+    "assignee_id": null,
+    "due_on": null,
+    "status": "closed",
+    "summary": "Ticket #1",
+    "resolution": "fixed",
+    "component_id": null,
+    "version_id": null,
+    "updated_at": "2008-12-31T15:51:41Z",
+    "id": 1,
+    "project_id": 1,
+    "hours_estimate_initial": 1.75
+},
+{
+    "severity_id": null,
+    "hours_estimate_current": 0.25,
+    "resolution_description": "",
+    "reporter_id": 1,
+    "created_at": "2009-02-09T15:17:52Z",
+    "priority": "3",
+    "number": 2,
+    "milestone_id": 1,
+    "description": "Do something else important",
+    "assignee_id": null,
+    "due_on": null,
+    "status": "closed",
+    "summary": "Ticket #2",
+    "resolution": "fixed",
+    "component_id": null,
+    "version_id": null,
+    "updated_at": "2009-02-17T15:36:40Z",
+    "id": 2,
+    "project_id": 1,
+    "hours_estimate_initial": 0.0
+}]

data/test/test_helper.rb

@@ -0,0 +1,49 @@
+# http://sneaq.net/textmate-wtf
+$:.reject! { |e| e.include? 'TextMate' }
+
+require 'rubygems'
+require 'throat_punch'
+
+require File.dirname(__FILE__) + '/../lib/unfuzzle'
+
+
+class Test::Unit::TestCase
+  
+  def self.read_fixture(method_name)
+    file = File.dirname(__FILE__) + "/fixtures/#{method_name}.json"
+    JSON.parse(File.read(file))
+  end
+
+  def read_fixture(method_name)
+    self.class.read_fixture(method_name)
+  end
+  
+  def mock_request_cycle(options)
+    response = Unfuzzle::Response.new(stub())
+
+    data = read_fixture(options[:data])
+
+    response.stubs(:data).with().returns(data)
+
+    Unfuzzle::Request.stubs(:get).with(options[:for]).returns(response)
+
+    response
+  end
+
+  def self.when_populating(klass, options, &block)
+    # data = options[:from].is_a?(String) ? read_fixture(options[:from])[0] : options[:from].call
+
+    context "with data populated for #{klass}" do
+      setup { @object = klass.new(read_fixture(options[:from])[0]) }
+      merge_block(&block)
+    end
+
+  end
+
+  def self.value_for(method_name, options)
+    should "have a value for :#{method_name}" do
+      @object.send(method_name).should == options[:is]
+    end
+  end
+  
+end

data/test/unit/unfuzzle/milestone_test.rb

@@ -0,0 +1,97 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+module Unfuzzle
+  class MilestoneTest < Test::Unit::TestCase
+
+    context "The Milestone class" do
+
+      should "be able to find all by project ID" do
+        project_id = 1
+
+        response = mock_request_cycle :for => "/projects/#{project_id}/milestones", :data => 'milestones'
+
+        milestones = Array.new
+
+        response.data.each do |data|
+          milestone = stub()
+          Unfuzzle::Milestone.expects(:new).with(data).returns(milestone)
+          milestones << milestone
+        end
+
+        Milestone.find_all_by_project_id(1).should == milestones
+      end
+
+    end
+
+    context "An instance of the Milestone class" do
+
+      when_populating Milestone, :from => 'milestones' do
+
+        value_for :id,                :is => 1
+        value_for :project_id,        :is => 1
+        value_for :archived,          :is => false
+        value_for :created_timestamp, :is => '2008-07-30T22:12:37Z'
+        value_for :name,              :is => 'Milestone 1'
+        value_for :due_datestamp,     :is => '2008-07-30'
+        value_for :updated_timestamp, :is => '2008-12-26T22:32:03Z'
+
+      end
+
+      context "with a new instance" do
+
+        setup { @milestone = Milestone.new(stub()) }
+
+        should "know that it is archived" do
+          @milestone.stubs(:archived).with().returns(true)
+          @milestone.archived?.should be(true)
+        end
+
+        should "know that it isn't archived" do
+          @milestone.stubs(:archived).with().returns(false)
+          @milestone.archived?.should be(false)
+        end
+
+        should "have a create date/time" do
+          DateTime.expects(:parse).with('2008-07-28T16:57:10Z').returns('create_date')
+
+          @milestone.stubs(:created_timestamp).with().returns('2008-07-28T16:57:10Z')
+          @milestone.created_at.should == 'create_date'
+        end
+
+        should "have an update date/time" do
+          DateTime.expects(:parse).with('2009-04-28T18:48:52Z').returns('update_date')
+
+          @milestone.stubs(:updated_timestamp).with().returns('2009-04-28T18:48:52Z')
+          @milestone.updated_at.should == 'update_date'
+        end
+
+        should "have a due date" do
+          Date.expects(:parse).with('2008-07-30').returns('due_date')
+
+          @milestone.stubs(:due_datestamp).with().returns('2008-07-30')
+          @milestone.due_on.should == 'due_date'
+        end
+
+        should "not have a due date if there isn't one associated" do
+          @milestone.stubs(:due_datestamp).with().returns(nil)
+          @milestone.due_on.should be(nil)
+        end
+
+        should "have associated tickets" do
+          id         = 1
+          project_id = 1
+
+          Ticket.expects(:find_all_by_project_id_and_milestone_id).with(project_id, id).returns('tickets')
+
+          @milestone.stubs(:id).with().returns(id)
+          @milestone.stubs(:project_id).with().returns(project_id)
+
+          @milestone.tickets.should == 'tickets'
+        end
+
+      end
+
+    end
+
+  end
+end

data/test/unit/unfuzzle/project_test.rb

@@ -0,0 +1,107 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+module Unfuzzle
+  class ProjectTest < Test::Unit::TestCase
+
+    context "The Project class" do
+
+      should "be able to return a list of all projects" do
+        response = mock_request_cycle :for => '/projects', :data => 'projects'
+
+        elements = Array.new
+
+        response.data.each do |data|
+          element = stub()
+          Unfuzzle::Project.expects(:new).with(data).returns(element)
+          elements << element
+        end
+
+        Project.all.should == elements
+      end
+
+      should "be able to find a project by its slug" do
+        slug = 'blip'
+
+        response = mock_request_cycle :for => "/projects/by_short_name/#{slug}", :data => 'project'
+
+        Unfuzzle::Project.expects(:new).with(response.data).returns('project')
+
+        Project.find_by_slug(slug).should == 'project'
+      end
+
+      should "be able to find a project by its ID" do
+        id = 1
+
+        response = mock_request_cycle :for => "/projects/#{id}", :data => 'project'
+
+        Unfuzzle::Project.expects(:new).with(response.data).returns('project')
+
+        Project.find_by_id(id).should == 'project'
+      end
+
+
+    end
+
+    context "An instance of the Project class" do
+
+      when_populating Project, :from => 'projects' do
+
+        value_for :id,                :is => 1
+        value_for :archived,          :is => false
+        value_for :slug,              :is => 'aa'
+        value_for :name,              :is => 'A Client'
+        value_for :description,       :is => 'A great project'
+        value_for :created_timestamp, :is => '2008-07-28T16:57:10Z'
+        value_for :updated_timestamp, :is => '2009-04-28T18:48:52Z'
+
+      end
+
+      context "with a new instance" do
+
+        setup { @project = Project.new(stub()) }
+
+        should "know that it's archived" do
+          @project.stubs(:archived).with().returns(true)
+          @project.archived?.should be(true)
+        end
+
+        should "know that it's not archived" do
+          @project.stubs(:archived).with().returns(false)
+          @project.archived?.should be(false)
+        end
+
+        should "have a create date" do
+          DateTime.expects(:parse).with('2008-07-28T16:57:10Z').returns('create_date')
+
+          @project.stubs(:created_timestamp).with().returns('2008-07-28T16:57:10Z')
+          @project.created_at.should == 'create_date'
+        end
+
+        should "have an update date" do
+          DateTime.expects(:parse).with('2009-04-28T18:48:52Z').returns('update_date')
+
+          @project.stubs(:updated_timestamp).with().returns('2009-04-28T18:48:52Z')
+          @project.updated_at.should == 'update_date'
+        end
+
+        should "have a list of associated milestones" do
+          id = 1
+          Milestone.expects(:find_all_by_project_id).with(id).returns('milestones')
+
+          @project.stubs(:id).with().returns(id)
+          @project.milestones.should == 'milestones'
+        end
+
+        should "have a list of associated tickets" do
+          id = 1
+          Ticket.expects(:find_all_by_project_id).with(id).returns('tickets')
+
+          @project.stubs(:id).with().returns(id)
+          @project.tickets.should == 'tickets'
+        end
+
+      end
+    end
+
+  end
+end

data/test/unit/unfuzzle/request_test.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+module Unfuzzle
+  class RequestTest < Test::Unit::TestCase
+    
+    context "The Request class" do
+      
+      should "be able to perform a GET request" do
+        request = mock() {|r| r.expects(:get).with().returns('response') }
+        Unfuzzle::Request.expects(:new).with('/projects').returns(request)
+        
+        Unfuzzle::Request.get('/projects').should == 'response'
+      end
+      
+    end
+    
+    context "An instance of the Request class" do
+      
+      should "have an endpoint URI" do
+        Unfuzzle.stubs(:subdomain).with().returns('viget')
+        
+        request = Unfuzzle::Request.new('/projects')
+        request.endpoint_uri.should == URI.parse('http://viget.unfuddle.com/api/v1/projects.json')
+      end
+      
+      should "have a client" do
+        client = stub()
+        
+        request = Unfuzzle::Request.new('/projects')
+        request.stubs(:endpoint_uri).with().returns(URI.parse('http://example.com'))
+        
+        Net::HTTP.expects(:new).with('example.com').returns(client)
+        
+        request.client.should == client
+      end
+      
+      should "be able to perform a GET request" do
+        Unfuzzle.stubs(:username).with().returns('username')
+        Unfuzzle.stubs(:password).with().returns('password')
+        
+        request = Unfuzzle::Request.new('/projects')
+        request.stubs(:endpoint_uri).returns(URI.parse('http://example.com/projects'))
+        
+        get_request = mock() do |g|
+          g.expects(:basic_auth).with('username', 'password')
+        end
+        
+        client = mock() {|c| c.expects(:request).with(get_request).returns('response') }
+        
+        response = stub()
+        Unfuzzle::Response.expects(:new).with('response').returns(response)
+        
+        Net::HTTP::Get.expects(:new).with('/projects').returns(get_request)
+        
+        request.stubs(:client).with().returns(client)
+        
+        request.get.should == response
+      end
+      
+    end
+    
+  end
+end

data/test/unit/unfuzzle/response_test.rb

@@ -0,0 +1,65 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+module Unfuzzle
+  class ResponseTest < Test::Unit::TestCase
+    
+    context "An instance of the Response class" do
+      
+      should "delegate to the HTTP response to determine the body" do
+        http_response = mock() {|r| r.expects(:body).with().returns('check mah boday') }
+        
+        response = Unfuzzle::Response.new(http_response)
+        
+        response.body.should == 'check mah boday'
+      end
+      
+      should "know that there are no errors" do
+        http_response = mock() do |r|
+          r.expects(:is_a?).with(Net::HTTPSuccess).returns(true)
+        end
+        
+        response = Unfuzzle::Response.new(http_response)
+        response.error?.should be(false)
+      end
+      
+      should "know if there are errors" do
+        http_response = mock() do |r|
+          r.expects(:is_a?).with(Net::HTTPSuccess).returns(false)
+        end
+        
+        response = Unfuzzle::Response.new(http_response)
+        response.error?.should be(true)
+      end
+      
+      should "be able to parse the response" do
+        response = Unfuzzle::Response.new(stub())
+        response.expects(:body).with().returns('json')
+        response.stubs(:error?).with().returns(false)
+                
+        JSON.expects(:parse).with('json').returns('data')
+        
+        response.data.should == 'data'
+      end
+      
+      should "cache the parsed data from the response" do
+        response = Unfuzzle::Response.new(stub())
+        response.stubs(:body).with().returns('json')
+        response.stubs(:error?).with().returns(false)
+        
+        JSON.stubs(:parse).with('json').once.returns('data')
+        
+        2.times { response.data }
+      end
+      
+      should "return nil when parsing data if there are errors in the response" do
+        response = Unfuzzle::Response.new(stub())
+        response.expects(:error?).with().returns(true)
+        
+        response.data.should be(nil)
+        
+      end
+      
+    end
+    
+  end
+end

data/test/unit/unfuzzle/ticket_test.rb

@@ -0,0 +1,92 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+module Unfuzzle
+  class TicketTest < Test::Unit::TestCase
+
+    context "The Ticket class" do
+
+      should "be able to return a list of tickets for a project" do
+        project_id = 1
+
+        response = mock_request_cycle :for => "/projects/#{project_id}/tickets", :data => 'tickets'
+
+        tickets = []
+
+        response.data.each do |data|
+          ticket = stub()
+          Ticket.expects(:new).with(data).returns(ticket)
+          tickets << ticket
+        end
+
+        Ticket.find_all_by_project_id(project_id).should == tickets
+      end
+
+      should "be able to return a list of tickets for a milestone" do
+        milestone_id = 1
+        project_id   = 1
+
+        response = mock_request_cycle :for => "/projects/#{project_id}/milestones/#{milestone_id}/tickets", :data => 'tickets'
+
+        tickets = []
+
+        response.data.each do |data|
+          ticket = stub()
+          Ticket.expects(:new).with(data).returns(ticket)
+          tickets << ticket
+        end
+
+        Ticket.find_all_by_project_id_and_milestone_id(project_id, milestone_id).should == tickets
+      end
+
+    end
+
+    context "An instance of the Ticket class" do
+
+      when_populating Ticket, :from => 'tickets' do
+
+        value_for :id,                :is => 1
+        value_for :created_timestamp, :is => '2008-11-25T14:00:19Z'
+        value_for :updated_timestamp, :is => '2008-12-31T15:51:41Z'
+        value_for :number,            :is => 1
+        value_for :title,             :is => 'Ticket #1'
+        value_for :description,       :is => 'Do something important'
+        value_for :due_datestamp,     :is => nil
+        value_for :status,            :is => 'closed'
+
+      end
+
+      context "with a new instance" do
+        setup { @ticket = Ticket.new(stub()) }
+
+        should "have a create date/time" do
+          DateTime.expects(:parse).with('2008-07-28T16:57:10Z').returns('create_date')
+
+          @ticket.stubs(:created_timestamp).with().returns('2008-07-28T16:57:10Z')
+          @ticket.created_at.should == 'create_date'
+        end
+
+        should "have an update date/time" do
+          DateTime.expects(:parse).with('2009-04-28T18:48:52Z').returns('update_date')
+
+          @ticket.stubs(:updated_timestamp).with().returns('2009-04-28T18:48:52Z')
+          @ticket.updated_at.should == 'update_date'
+        end
+
+        should "have a due date" do
+          Date.expects(:parse).with('2008-07-30').returns('due_date')
+
+          @ticket.stubs(:due_datestamp).with().returns('2008-07-30')
+          @ticket.due_on.should == 'due_date'
+        end
+
+        should "not have a due date if there isn't one associated" do
+          @ticket.stubs(:due_datestamp).with().returns(nil)
+          @ticket.due_on.should be(nil)
+        end
+
+      end
+
+    end
+
+  end
+end

data/test/unit/unfuzzle_test.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class UnfuzzleTest < Test::Unit::TestCase
+
+  context "The Unfuzzle module" do
+    
+    should "be able to set the subdomain" do
+      Unfuzzle.subdomain = 'viget'
+      Unfuzzle.subdomain.should == 'viget'
+    end
+    
+    should "be able to set the username" do
+      Unfuzzle.username = 'username'
+      Unfuzzle.username.should == 'username'
+    end
+    
+    should "be able to set the password" do
+      Unfuzzle.password = 'password'
+      Unfuzzle.password.should == 'password'
+    end
+    
+    should "be able to retrieve a project by id" do
+      Unfuzzle::Project.expects(:find_by_id).with(1).returns('project')
+      Unfuzzle.project(1).should == 'project'
+    end
+    
+    should "be able to retrieve a project by slug" do
+      Unfuzzle::Project.expects(:find_by_slug).with('slug').returns('project')
+      Unfuzzle.project('slug').should == 'project'
+    end
+    
+    should "be able to retrieve a list of all projects for the current user" do
+      Unfuzzle::Project.expects(:all).with().returns('projects')
+      Unfuzzle.projects.should == 'projects'
+    end
+    
+  end
+  
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: vigetlabs-unfuzzle
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Patrick Reagan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-24 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.6
+    version: 
+description: 
+email: patrick.reagan@viget.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- lib/unfuzzle
+- lib/unfuzzle/milestone.rb
+- lib/unfuzzle/model.rb
+- lib/unfuzzle/project.rb
+- lib/unfuzzle/request.rb
+- lib/unfuzzle/response.rb
+- lib/unfuzzle/ticket.rb
+- lib/unfuzzle/version.rb
+- lib/unfuzzle.rb
+- test/fixtures
+- test/fixtures/milestones.json
+- test/fixtures/project.json
+- test/fixtures/projects.json
+- test/fixtures/tickets.json
+- test/test_helper.rb
+- test/unit
+- test/unit/unfuzzle
+- test/unit/unfuzzle/milestone_test.rb
+- test/unit/unfuzzle/project_test.rb
+- test/unit/unfuzzle/request_test.rb
+- test/unit/unfuzzle/response_test.rb
+- test/unit/unfuzzle/ticket_test.rb
+- test/unit/unfuzzle_test.rb
+has_rdoc: true
+homepage: http://www.viget.com/extend
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: This gem provides an interface to the Unfuddle JSON API
+test_files: []
+