confuddle 0.0.1

data/lib/graft/test/unit/xml/model_test.rb

@@ -0,0 +1,173 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+class EmptyXmlModel
+  include Graft::Xml::Model
+end
+
+class XmlModelWithAttributes
+  include Graft::Xml::Model
+
+  attribute :name
+  attribute :description, :from => 'desc'
+  attribute :rating,      :from => 'rating@value'
+  attribute :size,        :from => "node[@type='size']@value"
+  
+end
+
+class XmlModelWithAttributeType
+  include Graft::Xml::Model
+  
+  attribute :id, :type => :integer
+end
+
+class XmlModelTest < Test::Unit::TestCase
+
+  context "The EmptyXmlModel class" do
+    should "have an empty list of attributes if none are supplied" do
+      EmptyXmlModel.attributes.should == []
+    end
+    
+    should "be able to return a collection of XML nodes" do
+      xml =<<-XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <things>
+          <thing><id>1</id></thing>
+          <thing><id>2</id></thing>
+        </things>
+      XML
+      
+      document = Hpricot.XML(xml)
+      
+      EmptyXmlModel.expects(:data_from).with(xml).returns(document)
+      
+      EmptyXmlModel.expects(:new).with((document/'things/thing').first).returns('model_1')
+      EmptyXmlModel.expects(:new).with((document/'things/thing').last).returns('model_2')
+      
+      collection = EmptyXmlModel.collection_from(xml, 'things/thing')
+      collection.should == ['model_1', 'model_2']
+    end
+
+    should "be able to retrieve data from the source XML string" do
+      xml = '<name>Graft</name>'
+      Hpricot.expects(:XML).with(xml).returns('document')
+
+      EmptyXmlModel.data_from(xml).should == 'document'
+    end
+    
+    should "be able to retrieve data from the source document data" do
+      document = Hpricot.XML('<name>Graft</name>')
+      EmptyXmlModel.data_from(document).should == document
+    end
+    
+  end
+  
+  context "The XmlModelWithAttributes class" do
+    should "know the names of all its attributes" do
+      XmlModelWithAttributes.attributes.map {|a| a.name.to_s }.should == %w(name description rating size)
+    end
+  end
+  
+  context "The XmlModelWithAttributeType class" do
+    should "know that it's attribute is of type :integer" do
+      attribute = XmlModelWithAttributeType.attributes.first
+      attribute.type_class.should == Graft::Xml::Type::Integer
+    end
+    
+    should "be able to generate an XML representation of itself" do
+      
+      m = XmlModelWithAttributeType.new
+      m.id = 1
+      
+      xml = String.new
+      xml << '<?xml version="1.0" encoding="UTF-8"?>'
+      xml << '<model>'
+      xml << '<id>1</id>'
+      xml << '</model>'
+      
+      m.to_xml('model').should == xml
+      
+    end
+  end
+
+  context "An instance of the EmptyXmlModel class" do
+    
+    should "return an empty hash when calling :to_hash" do
+      m = EmptyXmlModel.new
+      m.to_hash.should == {}
+    end
+    
+  end
+
+  context "An instance of the XmlModelWithAttributes class" do
+
+    setup { @simple_xml = '<name>Graft</name>' }
+
+    should "have default reader method for :name" do
+      XmlModelWithAttributes.new.respond_to?(:name).should be(true)
+    end
+    
+    should "be able to populate its data on initialization" do
+      xml = Hpricot.XML(@simple_xml)
+      XmlModelWithAttributes.new(xml).name.should == 'Graft'
+    end
+    
+    should "have a reference to the original document" do
+      xml = Hpricot.XML(@simple_xml)
+      XmlModelWithAttributes.new(xml).source_data.should == xml
+    end
+    
+    should "be able to populate from an XML string" do
+      XmlModelWithAttributes.new(@simple_xml).name.should == 'Graft'
+    end
+    
+    should "return a hash representation of itself" do
+      m = XmlModelWithAttributes.new
+      
+      m.name        = 'name'
+      m.description = 'description'
+      m.rating      = '5'
+      m.size        = 'large'
+    
+      m.to_hash.should == {
+        'name'        => 'name',
+        'description' => 'description',
+        'rating'      => '5',
+        'size'        => 'large'
+      }
+    end
+    
+    context "when populating data from an XML document" do
+      
+      setup do
+        xml = <<-XML
+          <name>Graft</name>
+          <desc>A sweet Ruby library</desc>
+          <rating value="100" />
+          <node type="color" value="blue" />
+          <node type="size" value="large" />
+        XML
+
+        @model = XmlModelWithAttributes.new
+        @model.populate_from(Hpricot.XML(xml))
+      end
+
+      should "have the correct value for :name" do
+        @model.name.should == 'Graft'
+      end
+      
+      should "have the correct value for :description" do
+        @model.description.should == 'A sweet Ruby library'
+      end
+      
+      should "have the correct value for :rating" do
+        @model.rating.should == '100'
+      end
+      
+      # should "have the correct value for :size" do
+      #   @model.size.should == 'large'
+      # end
+      
+    end
+  end
+  
+end

data/lib/graft/test/unit/xml/type_test.rb

@@ -0,0 +1,65 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+
+module Graft
+  module Xml
+
+    class StringTest < Test::Unit::TestCase
+      context "An instance of the Graft::Xml::Type::String class" do
+
+        should_convert 'a string', :to => 'a string'
+        should_convert '',         :to => nil
+
+      end
+    end
+
+    class BooleanTest < Test::Unit::TestCase
+      context "An instance of the Graft::Xml::Type::Boolean class" do
+
+        should_convert 'true',  :to => true
+        should_convert 'false', :to => false
+        should_convert '0',     :to => false
+        should_convert '1',     :to => true
+        should_convert '',      :to => nil
+
+        should_fail_when_converting 'foo'
+
+      end
+    end
+
+    class IntegerTest < Test::Unit::TestCase
+      context "An instance of the Graft::Xml::Type::Integer class" do
+
+        should_convert '1', :to => 1
+        should_convert '',  :to => nil
+
+        should_fail_when_converting 'foo'
+
+      end
+    end
+
+    class DateTest < Test::Unit::TestCase
+
+      context "An instance of the Graft::Xml::Type::Date class" do
+
+        should_convert '2008-08-01', :to => Date.parse('2008-08-01')
+        should_convert '',           :to => nil
+
+      end
+
+    end
+
+    class TimeTest < Test::Unit::TestCase
+
+      context "An instance of the Graft::Xml::Type::Time class" do
+
+        should_convert '2008-07-28T16:57:10Z', :to => Time.parse('2008-07-28T16:57:10Z')
+        should_convert '2008-12-25 18:26:55',  :to => Time.parse('2008-12-25 18:26:55')
+        should_convert '1230274722',           :to => Time.at(1230274722)
+        should_convert '',                     :to => nil
+
+      end
+
+    end
+
+  end
+end

data/lib/unfuzzle/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+/pkg/
+/doc/
+/coverage/

data/lib/unfuzzle/README.rdoc

@@ -0,0 +1,129 @@
+= Unfuzzle
+
+== Description
+
+The Unfuzzle gem provides an interface to the Unfuddle XML 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"
+
+Unfuddle has additional associations for a ticket, including component, severity,
+and priority:
+
+    ticket.component      # => #<Unfuzzle::Component:0x12c5b54 ...>
+    ticket.component_name # => "User Accounts"
+    ticket.severity       # => #<Unfuzzle::Severity:0x12a357c ...>
+    ticket.severity_name  # => "Development"
+    ticket.priority       # => #<Unfuzzle::Priority:0x12811fc @id=3>
+    ticket.priority_name  # => "Normal"
+
+See the Ticket documentation for more information.
+
+== Updating
+
+Currently, only ticket updating is supported and only for a subset of the data:
+
+    ticket.title = 'This is a new title' # => "This is a new title"
+    ticket.update                        # => #<Unfuzzle::Response:0x1275280 ...>
+
+This will update the title of the ticket.  Other fields that can be updated include
+description and status. 
+
+== 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/lib/unfuzzle/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 XML 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('graft', '>= 0.1.1')
+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/lib/unfuzzle.rb

@@ -0,0 +1,87 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'uri'
+require 'net/http'
+require 'net/https'
+require 'json'
+require 'builder'
+require File.dirname(__FILE__) + '/../../graft/lib/graft/xml'
+
+Dir[File.dirname(__FILE__) + "/unfuzzle/*.rb"].each { |x| require x }
+
+# = 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:
+#
+#   >> Unfuzzle.projects
+#   => [#<Unfuzzle::Project:0x5f5c44 @id=1, @name="BlipCo", ...>, ... ]
+#
+# Or a specific project by its 'short name':
+#
+#   >> Unfuzzle.project('sample')
+#   => #<Unfuzzle::Project:0x123f888 @id=2, @name="Sample Project", ... >
+#
+# For more usage documentation, see README.doc.
+#
+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
+  
+  # Use SSL: yes or no
+  def self.use_ssl=(value)
+    @use_ssl = value
+  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
+  
+  def self.use_ssl # :nodoc:
+    @use_ssl
+  end
+  
+end