basecamp-classic 0.0.13

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e6218d06f92cc42fa10b9ce7a609f5222dbdb7788c0b392dc277509d641bbf70
+  data.tar.gz: 6542df68bb8d80b4d1cca63830f99fa21a6d90f8630dabf06f81f6445a96ea15
+SHA512:
+  metadata.gz: '099c52ef38ca3c99005a985bc2fa029a9d827f973a457b80c919adc838567c32bbbc3d6508bb30bc459ed8ab199cfd1df175e01cd39f8791b8ab348da215a71d'
+  data.tar.gz: c93f318cd2923538e511a63bb08991913aca518881219108bef32fc9b8bd38c5d33077ec72bba2e4e541020a4d5637ad7fcf6a97ca3fd4fd70a0dc0ea7c18c86

data/README.rdoc

@@ -0,0 +1,278 @@
+= A Ruby library for working with the Basecamp web-services API.
+
+For more information about the Basecamp web-services API, visit:
+
+  http://developer.37signals.com/basecamp
+
+You can find the original code in:
+
+  http://developer.37signals.com/basecamp/basecamp.rb
+
+NOTE: not all of Basecamp's web-services are accessible via REST. This
+library provides access to RESTful services via ActiveResource. Services not
+yet upgraded to REST are accessed via the Basecamp class. Continue reading
+for more details.
+
+== Installation
+
+Install the gem
+
+  gem install basecamp-classic
+
+Include the system gems and require the library in your script
+
+  require 'rubygems'
+  require 'basecamp'
+
+=== Dependencies
+
+  * activeresource >= 2.3.0
+  * xml-simple
+  * oauth2
+
+== Establishing a Connection
+
+The first thing you need to do is establish a connection to Basecamp. This
+requires your Basecamp site address and your login credentials or API token.
+
+=== Using username and password
+
+  Basecamp.establish_connection!('yoururl.basecamphq.com', 'username', 'password')
+
+=== Using API token (My Info -> Show your tokens)
+
+  Basecamp.establish_connection!('yoururl.basecamphq.com', 'APITOKEN', 'X')
+
+=== Using OAuth access token
+
+  Basecamp.establish_oauth_connection!('yoururl.basecamphq.com', 'oauth_access_token')
+
+=== Using SSL/Non SSL basecamp accounts (https://yoururl.basecamphq.com)
+
+Basecamp uses SSL in all accounts so that's the default value here for establish_connection!. This will use https for the connection:
+
+  Basecamp.establish_connection!('yoururl.basecamphq.com', 'APITOKEN', 'X')
+
+  Basecamp.establish_oauth_connection!('yoururl.basecamphq.com', 'oauth_access_token')
+
+But if for some reason your basecamp account doesn't use SSL, you can disable with:
+
+  Basecamp.establish_connection!('yoururl.basecamphq.com', 'APITOKEN', 'X', false)
+
+  Basecamp.establish_oauth_connection!('yoururl.basecamphq.com', 'oauth_access_token', false)
+
+This is the same whether you're accessing using the ActiveResource interface,
+or the legacy interface.
+
+== Using the REST interface via ActiveResource
+
+The REST interface is accessed via ActiveResource, a popular Ruby library
+that implements object-relational mapping for REST web-services. For more
+information on working with ActiveResource, see:
+
+ * http://api.rubyonrails.org/files/activeresource/README.html
+ * http://api.rubyonrails.org/classes/ActiveResource/Base.html
+
+== Basecamp API rate limit and app identification
+
+If your app creates a lot of requests, you may hit the (new) basecamp rate limit. ({read more here about rate limiting}[https://github.com/basecamp/basecamp-classic-api#rate-limiting]).
+
+To raise your limit you can send a custom user-agent to basecamp with your identifying information ({read more here}[https://github.com/basecamp/basecamp-classic-api#rate-limiting]).
+
+For this you need to create an initializer in your rails application, for example: +config/inititalizer/basecamp_user_agent.rb+ with the following line:
+
+  ActiveResource::Base.headers["User-Agent"] = "Fabian's Ingenious Integration (fabian@example.com)"
+
+This initializer ensures that all requests made through ActiveResource (which this gem uses) are identifiable with your information.
+
+**NOTE**: If you are using ActiveResource for accessing multiple APIs at once and not only basecamp's, you will need the following initializer instead:
+
+  Basecamp::Resource.headers["User-Agent"] = "Fabian's Ingenious Integration (fabian@example.com)"
+
+=== Finding a Resource
+
+Find a specific resource using the +find+ method. Attributes of the resource
+are available as instance methods on the resulting object. For example, to
+find a message with the ID of 8675309 and access its title attribute, you
+would do the following:
+
+  m = Basecamp::Message.find(8675309)
+  m.title # => 'Jenny'
+
+To find all messages for a given project, use find(:all), passing the
+project_id as a parameter to find. Example:
+
+  messages = Basecamp::Message.find(:all, params => { :project_id => 1037 })
+  messages.size # => 25
+
+To get the current logged in user:
+
+  Basecamp::Person.me
+
+Note: You can access the API token using this object. This is useful if you only have username/password and you want to use the API token in future calls:
+
+  Basecamp::Person.me.token
+
+To get all people by company:
+
+  Basecamp::Person.find(:all, :params => {:company_id => company.id})
+
+To get all people by project:
+
+  Basecamp::Person.find(:all, :params => {:project_id => project.id})
+
+=== Creating a Resource
+
+Create a resource by making a new instance of that resource, setting its
+attributes, and saving it. If the resource requires a prefix to identify
+it (as is the case with resources that belong to a sub-resource, such as a
+project), it should be specified when instantiating the object. Examples:
+
+  m = Basecamp::Message.new(:project_id => 1037)
+  m.category_id = 7301
+  m.title = 'Message in a bottle'
+  m.body = 'Another lonely day, with no one here but me'
+  m.save # => true
+
+  c = Basecamp::Comment.new(:post_id => 25874)
+  c.body = 'Did you get those TPS reports?'
+  c.save # => true
+
+You can also create a resource using the +create+ method, which will create
+and save it in one step. Example:
+
+  Basecamp::TodoItem.create(:todo_list_id => 3422, :contents => 'Do it')
+
+
+=== Updating a Resource
+
+To update a resource, first find it by its id, change its attributes, and
+save it. Example:
+
+  m = Basecamp::Message.find(8675309)
+  m.body = 'Changed'
+  m.save # => true
+
+
+=== Deleting a Resource
+
+To delete a resource, use the +delete+ method with the ID of the resource
+you want to delete. Example:
+
+  Basecamp::Message.delete(1037)
+
+
+=== Attaching Files to a Resource
+
+If the resource accepts file attachments, the +attachments+ parameter should
+be an array of Basecamp::Attachment objects. Example:
+
+  f1 = File.open('primary.doc')
+  s1 = StringIO.new('a string')
+
+  a1 = Basecamp::Attachment.create('primary', f1)
+  a2 = Basecamp::Attachment.create('another', s1))
+
+  m = Basecamp::Message.new(:project_id => 1037)
+  ...
+  m.attachments = [a1, a2]
+  m.save # => true
+
+  f1.close
+
+=== Milestones
+
+Is not implemented as an active resource, it uses the non-REST interface.
+Browse the source (lib/basecamp/resources/milestone) to see all available methods.
+
+For example, to list all milestones in a project:
+
+  milestones = Basecamp::Milestone.list(1037)
+  milestones.first.title # => "The Milestone"
+
+=== More about Todo Items
+
+To access all todo items in a todo list:
+
+  Basecamp::TodoItem.find(:all, :params => { :todo_list_id => 3422 })
+
+You can't access all todo items in a project with a single API call.
+So you have to do something like this:
+
+  def todo_items_on_project(project_id)
+    todo_items = []
+    todo_lists = TodoList.find(:all, :params => { :project_id => project_id })
+    todo_lists.each do |todo_list|
+      todo_items += TodoItem.find(:all, :params => { :todo_list_id => todo_list.id })
+    end
+    todo_items
+  end
+
+=== Time entries
+
+There are two ways to create time-entries
+
+  # TodoItem as Parent Resource
+  Basecamp::TimeEntry.create(:todo_item_id => item_id, :date => date, :person_id => person_id, :hours => hours, :description => '')
+  # Project as Parent Resource
+    Basecamp::TimeEntry.create(:project_id => project_id, :date => date, :person_id => person_id, :hours => hours, :description => '')
+
+
+= Using the non-REST interface
+
+You can access other resources not included in this wrapper yet using "record" and "records".
+
+  person = Basecamp.record("/contacts/person/93832")
+  person.first_name # => "Jason"
+
+  people_in_company = Basecamp.records("person", "/contacts/people/85")
+  people_in_company.first.first_name # => "Jason"
+
+= Using json as the default format
+
+By default the wrapper will use :xml for the active record connection but you can set :json as the default format:
+
+  Basecamp.establish_connection!('yoururl.basecamphq.com', 'APITOKEN', 'X', true, false)
+
+Note: We recommend using xml. There are some API calls that don't behave well with json.
+
+= Access active resource response object
+
+You can acces the last response object:
+
+  Basecamp::Message.find(:all, params => { :project_id => 1037 })
+  Basecamp::Message.connection.response["status"] # => "200 OK"
+
+= Using the raw response body
+
+This is useful for example to get pagination data to access all comments in a commentable resource: https://github.com/37signals/basecamp-classic-api/blob/master/sections/comments.md#get-recent-comments-for-a-commentable-resource
+
+  def get_threshold
+    # Get the last response object
+    response = Basecamp::Comment.connection.response
+    # Parse the xml
+    xml = XmlSimple.xml_in(response.body)
+    # continued-at is an attribute specifying the path where the next oldest 75 comments can be retrieved
+    if continued_at = xml["continued-at"]
+      # There are more comments
+      # We need to extract the threshold parameter from the continued-at url
+      hash = CGI::parse(URI.parse(continued_at).query)
+      hash["threshold"].first
+    else
+      # We're done
+      nil
+    end
+  end
+
+  comments = Basecamp::Comment.find(:all, :params => { :post_id => 1037 })
+  if threshold = get_threshold
+    # Get the next set of comments using the threshold
+    Basecamp::Comment.find(:all, :params => { :post_id => 1037, :threshold => threshold })
+  end
+
+== Contributors
+
+* jamesarosen
+* defeated
+* justinbarry
+* fmiopensource

data/lib/basecamp/active_resource.rb

@@ -0,0 +1,23 @@
+# ActiveResource connection patch to let users access the last response object and the headers.
+#
+# Example:
+#   >> Basecamp::Message.find(:all, params => { :project_id => 1037 })
+#   >> Basecamp::Message.connection.response["status"]
+#   => "200 OK"
+class ActiveResource::Connection
+  alias_method :original_handle_response, :handle_response
+  alias :static_default_header :default_header
+
+  def handle_response(response)
+    Thread.current[:active_resource_connection_headers] = response
+    original_handle_response(response)
+  end
+
+  def response
+    Thread.current[:active_resource_connection_headers]
+  end
+
+  def set_header(key, value)
+    default_header.update(key => value)
+  end
+end

data/lib/basecamp/base.rb

@@ -0,0 +1,142 @@
+module Basecamp
+  class << self
+    attr_accessor :use_xml
+    attr_reader :site, :user, :password, :use_ssl, :use_oauth, :access_token
+
+    def establish_connection!(site, user, password, use_ssl = true, use_xml = true)
+      @site       = site
+      @user       = user
+      @password   = password
+      @use_ssl    = use_ssl
+      @use_xml    = use_xml
+      @use_oauth  = false
+
+      Resource.user     = user
+      Resource.password = password
+      Resource.site     = (use_ssl ? "https" : "http") + "://" + site
+      Resource.format   = (use_xml ? :xml : :json)
+
+      @connection = Connection.new(self)
+    end
+
+    def establish_oauth_connection!(site, access_token, use_ssl = true, use_xml = true)
+      @site         = site
+      @use_ssl      = use_ssl
+      @use_xml      = use_xml
+      @use_oauth    = true
+      @access_token = access_token
+
+      Resource.site         = (use_ssl ? "https" : "http") + "://" + site
+      Resource.format       = (use_xml ? :xml : :json)
+      Resource.connection.set_header('Authorization', "Bearer #{access_token}")
+
+      @connection = Connection.new(self)
+    end
+
+    def connection
+      @connection || raise('No connection established')
+    end
+
+    # Make a raw web-service request to Basecamp. This will return a Hash of
+    # Arrays of the response, and may seem a little odd to the uninitiated.
+    def request(path, parameters = {})
+      headers = { "Content-Type" => content_type }
+      headers.merge!('Authorization' => "Bearer #{@access_token}") if @use_oauth
+      headers.merge!(Resource.headers) if Resource.headers.present?
+
+      if parameters.empty?
+        response = Basecamp.connection.get(path, headers)
+      else
+        response = Basecamp.connection.post(path, StringIO.new(convert_body(parameters)), headers)
+      end
+
+      if response.code.to_i / 100 == 2
+        return {} if response.body.blank?
+        result = XmlSimple.xml_in(response.body, 'keeproot' => true, 'contentkey' => '__content__', 'forcecontent' => true)
+        typecast_value(result)
+      else
+        raise "#{response.message} (#{response.code})"
+      end
+    end
+
+    # A convenience method for wrapping the result of a query in a Record
+    # object. This assumes that the result is a singleton, not a collection.
+    def record(path, parameters={})
+      result = request(path, parameters)
+      (result && !result.empty?) ? Record.new(result.keys.first, result.values.first) : nil
+    end
+
+    # A convenience method for wrapping the result of a query in Record
+    # objects. This assumes that the result is a collection--any singleton
+    # result will be wrapped in an array.
+    def records(node, path, parameters={})
+      result = request(path, parameters).values.first or return []
+      result = result[node] or return []
+      result = [result] unless Array === result
+      result.map { |row| Record.new(node, row) }
+    end
+
+    private
+
+      def convert_body(body)
+        body = use_xml ? body.to_legacy_xml : body.to_yaml
+      end
+
+      def content_type
+        use_xml ? "application/xml" : "application/x-yaml"
+      end
+
+      def typecast_value(value)
+        case value
+        when Hash
+          if value.has_key?("__content__")
+            content = translate_entities(value["__content__"]).strip
+            case value["type"]
+            when "integer"  then content.to_i
+            when "boolean"  then content == "true"
+            when "datetime" then Time.parse(content)
+            when "date"     then Date.parse(content)
+            else                 content
+            end
+          # a special case to work-around a bug in XmlSimple. When you have an empty
+          # tag that has an attribute, XmlSimple will not add the __content__ key
+          # to the returned hash. Thus, we check for the presense of the 'type'
+          # attribute to look for empty, typed tags, and simply return nil for
+          # their value.
+          elsif value.keys == %w(type)
+            nil
+          elsif value["nil"] == "true"
+            nil
+          # another special case, introduced by the latest rails, where an array
+          # type now exists. This is parsed by XmlSimple as a two-key hash, where
+          # one key is 'type' and the other is the actual array value.
+          elsif value.keys.length == 2 && value["type"] == "array"
+            value.delete("type")
+            typecast_value(value)
+          else
+            value.empty? ? nil : value.inject({}) do |h,(k,v)|
+              h[k] = typecast_value(v)
+              h
+            end
+          end
+        when Array
+          value.map! { |i| typecast_value(i) }
+          case value.length
+          when 0 then nil
+          when 1 then value.first
+          else value
+          end
+        else
+          raise "can't typecast #{value.inspect}"
+        end
+      end
+
+      def translate_entities(value)
+        value.gsub(/&lt;/, "<").
+              gsub(/&gt;/, ">").
+              gsub(/&quot;/, '"').
+              gsub(/&apos;/, "'").
+              gsub(/&amp;/, "&")
+      end
+  end
+end

data/lib/basecamp/connection.rb

@@ -0,0 +1,22 @@
+module Basecamp; class Connection
+  def initialize(master)
+    @master = master
+    @connection = Net::HTTP.new(master.site, master.use_ssl ? 443 : 80)
+    @connection.use_ssl = master.use_ssl
+    @connection.verify_mode = OpenSSL::SSL::VERIFY_NONE if master.use_ssl
+  end
+
+  def post(path, iostream, headers = {})
+    request = Net::HTTP::Post.new(path, headers.merge('Accept' => 'application/xml'))
+    request.basic_auth(@master.user, @master.password) unless @master.use_oauth
+    request.body_stream = iostream
+    request.content_length = iostream.size
+    @connection.request(request)
+  end
+
+  def get(path, headers = {})
+    request = Net::HTTP::Get.new(path, headers.merge('Accept' => 'application/xml'))
+    request.basic_auth(@master.user, @master.password) unless @master.use_oauth
+    @connection.request(request)
+  end
+end; end

data/lib/basecamp/hash.rb

@@ -0,0 +1,5 @@
+class Hash
+  def to_legacy_xml
+    XmlSimple.xml_out({:request => self}, 'keeproot' => true, 'noattr' => true)
+  end
+end

data/lib/basecamp/record.rb

@@ -0,0 +1,56 @@
+module Basecamp; class Record
+  attr_reader :type
+
+  def initialize(type, hash)
+    @type, @hash = type, hash
+  end
+
+  def [](name)
+    name = dashify(name)
+
+    case @hash[name]
+    when Hash then 
+      @hash[name] = if (@hash[name].keys.length == 1 && @hash[name].values.first.is_a?(Array))
+        @hash[name].values.first.map { |v| Record.new(@hash[name].keys.first, v) }
+      else
+        Record.new(name, @hash[name])
+      end
+    else
+      @hash[name]
+    end
+  end
+
+  def id
+    @hash['id']
+  end
+
+  def attributes
+    @hash.keys
+  end
+
+  def respond_to?(sym)
+    super || @hash.has_key?(dashify(sym))
+  end
+
+  def method_missing(sym, *args)
+    if args.empty? && !block_given? && respond_to?(sym)
+      self[sym]
+    else
+      super
+    end
+  end
+
+  def to_s
+    "\#<Record(#{@type}) #{@hash.inspect[1..-2]}>"
+  end
+
+  def inspect
+    to_s
+  end
+
+  private
+
+    def dashify(name)
+      name.to_s.tr("_", "-")
+    end
+end; end

data/lib/basecamp/resource.rb

@@ -0,0 +1,42 @@
+module Basecamp; class Resource < ActiveResource::Base
+  class << self
+    def parent_resources(*parents)
+      @parent_resources = parents
+    end
+
+    def prefix_source
+      if @parent_resources
+        @parent_resources.map { |resource| "/#{resource.to_s.pluralize}/:#{resource}_id" }.join + '/'
+      else
+        '/'
+      end
+    end
+
+    def check_prefix_options(options)
+    end
+
+    def prefix(options = {})
+      if options.any?
+        options.map { |name, value| "/#{name.to_s.chomp('_id').pluralize}/#{value}" }.join + '/'
+      else
+        '/'
+      end
+    end
+
+    def all(options = {})
+      find(:all, options)
+    end
+
+    def first(options = {})
+      find(:first, options)
+    end
+
+    def last(options = {})
+      find(:last, options)
+    end
+  end
+
+  def prefix_options
+    id ? {} : super
+  end
+end; end

data/lib/basecamp/resources/attachment.rb

@@ -0,0 +1,36 @@
+module Basecamp; class Attachment
+  attr_accessor :id, :filename, :content, :category_id
+
+  def self.create(filename, content)
+    returning new(filename, content) do |attachment|
+      attachment.save
+    end
+  end
+
+  def initialize(filename, content)
+    @filename, @content = filename, content
+  end
+
+  def attributes
+    { :file => id, :original_filename => filename }
+  end
+
+  def to_xml(options = {})
+    { :file => attributes, :category_id => category_id }.to_xml(options)
+  end
+
+  def inspect
+    to_s
+  end
+
+  def save
+    response = Basecamp.connection.post('/upload', content, 'Content-Type' => 'application/octet-stream')
+
+    if response.code == '200'
+      self.id = Hash.from_xml(response.body)['upload']['id']
+      true
+    else
+      raise "Could not save attachment: #{response.message} (#{response.code})"
+    end
+  end
+end; end

data/lib/basecamp/resources/category.rb

@@ -0,0 +1,25 @@
+# == Creating different types of categories
+#
+# The type parameter is required when creating a category. For exampe, to
+# create an attachment category for a particular project:
+#
+#   c = Basecamp::Category.new(:project_id => 1037)
+#   c.type = 'attachment'
+#   c.name = 'Pictures'
+#   c.save # => true
+#
+module Basecamp; class Category < Basecamp::Resource
+  parent_resources :project
+
+  def self.all(project_id, options = {})
+    find(:all, :params => options.merge(:project_id => project_id))
+  end
+
+  def self.post_categories(project_id, options = {})
+    find(:all, :params => options.merge(:project_id => project_id, :type => 'post'))
+  end
+
+  def self.attachment_categories(project_id, options = {})
+    find(:all, :params => options.merge(:project_id => project_id, :type => 'attachment'))
+  end
+end; end

data/lib/basecamp/resources/comment.rb

@@ -0,0 +1,22 @@
+# == Creating comments for multiple resources
+#
+# Comments can be created for messages, milestones, and to-dos, identified
+# by the <tt>post_id</tt>, <tt>milestone_id</tt>, and <tt>todo_item_id</tt>
+# params respectively.
+#
+# For example, to create a comment on the message with id #8675309:
+#
+#   c = Basecamp::Comment.new(:post_id => 8675309)
+#   c.body = 'Great tune'
+#   c.save # => true
+#
+# Similarly, to create a comment on a milestone:
+#
+#   c = Basecamp::Comment.new(:milestone_id => 8473647)
+#   c.body = 'Is this done yet?'
+#   c.save # => true
+#
+
+module Basecamp; class Comment < Basecamp::Resource
+  parent_resources :post, :milestone, :todo_item
+end; end

data/lib/basecamp/resources/company.rb

@@ -0,0 +1,7 @@
+module Basecamp; class Company < Basecamp::Resource
+  parent_resources :project
+
+  def self.on_project(project_id, options = {})
+    find(:all, :params => options.merge(:project_id => project_id))
+  end
+end; end

data/lib/basecamp/resources/message.rb

@@ -0,0 +1,30 @@
+module Basecamp; class Message < Basecamp::Resource
+  parent_resources :project
+  set_element_name 'post'
+
+  # Returns the most recent 25 messages in the given project (and category,
+  # if specified). If you need to retrieve older messages, use the archive
+  # method instead. Example:
+  #
+  #   Basecamp::Message.recent(1037)
+  #   Basecamp::Message.recent(1037, :category_id => 7301)
+  #
+  def self.recent(project_id, options = {})
+    find(:all, :params => options.merge(:project_id => project_id))
+  end
+
+  # Returns a summary of all messages in the given project (and category, if
+  # specified). The summary is simply the title and category of the message,
+  # as well as the number of attachments (if any). Example:
+  #
+  #   Basecamp::Message.archive(1037)
+  #   Basecamp::Message.archive(1037, :category_id => 7301)
+  #
+  def self.archive(project_id, options = {})
+    find(:all, :params => options.merge(:project_id => project_id), :from => :archive)
+  end
+
+  def comments(options = {})
+    @comments ||= Comment.find(:all, :params => options.merge(:post_id => id))
+  end
+end; end

data/lib/basecamp/resources/milestone.rb

@@ -0,0 +1,45 @@
+module Basecamp; class Milestone
+  class << self
+    # Returns a list of all milestones for the given project, optionally filtered
+    # by whether they are completed, late, or upcoming.
+    def list(project_id, find = 'all')
+      Basecamp.records "milestone", "/projects/#{project_id}/milestones/list", :find => find
+    end
+
+    # Create a new milestone for the given project. +data+ must be hash of the
+    # values to set, including +title+, +deadline+, +responsible_party+, and
+    # +notify+.
+    def create(project_id, data)
+      create_milestones(project_id, [data]).first
+    end
+
+    # As #create_milestone, but can create multiple milestones in a single
+    # request. The +milestones+ parameter must be an array of milestone values as
+    # described in #create_milestone.
+    def create_milestones(project_id, milestones)
+      Basecamp.records "milestone", "/projects/#{project_id}/milestones/create", :milestone => milestones
+    end
+
+    # Updates an existing milestone.
+    def update(id, data, move = false, move_off_weekends = false)
+      Basecamp.record "/milestones/update/#{id}", :milestone => data,
+        :move_upcoming_milestones => move,
+        :move_upcoming_milestones_off_weekends => move_off_weekends
+    end
+
+    # Destroys the milestone with the given id.
+    def delete(id)
+      Basecamp.record "/milestones/delete/#{id}"
+    end
+
+    # Complete the milestone with the given id
+    def complete(id)
+      Basecamp.record "/milestones/complete/#{id}"
+    end
+
+    # Uncomplete the milestone with the given id
+    def uncomplete(id)
+      Basecamp.record "/milestones/uncomplete/#{id}"
+    end
+  end
+end; end

data/lib/basecamp/resources/person.rb

@@ -0,0 +1,8 @@
+module Basecamp; class Person < Basecamp::Resource
+  parent_resources :company, :projects
+
+  def self.me
+    hash = get(:me)
+    Basecamp::Person.new(hash)
+  end
+end; end

data/lib/basecamp/resources/project.rb

@@ -0,0 +1,5 @@
+module Basecamp; class Project < Basecamp::Resource
+  def time_entries(options = {})
+    @time_entries ||= TimeEntry.find(:all, :params => options.merge(:project_id => id))
+  end
+end; end

data/lib/basecamp/resources/time_entry.rb

@@ -0,0 +1,11 @@
+module Basecamp; class TimeEntry < Basecamp::Resource
+  parent_resources :project, :todo_item
+
+  def self.all(project_id, page = 0)
+    find(:all, :params => { :project_id => project_id, :page => page })
+  end
+
+  def self.report(options={})
+    find(:all, :from => :report, :params => options)
+  end
+end; end

data/lib/basecamp/resources/todo_item.rb

@@ -0,0 +1,25 @@
+module Basecamp; class TodoItem < Basecamp::Resource
+  def todo_list(options = {})
+    @todo_list ||= TodoList.find(todo_list_id, options)
+  end
+
+  def time_entries(options = {})
+    @time_entries ||= TimeEntry.find(:all, :params => options.merge(:todo_item_id => id))
+  end
+
+  def comments(options = {})
+    @comments ||= Comment.find(:all, :params => options.merge(:todo_item_id => id))
+  end
+
+  def complete!
+    put(:complete)
+  end
+
+  def uncomplete!
+    put(:uncomplete)
+  end
+
+  def prefix_options
+    { :todo_list_id => todo_list_id }
+  end
+end; end

data/lib/basecamp/resources/todo_list.rb

@@ -0,0 +1,26 @@
+module Basecamp; class TodoList < Basecamp::Resource
+  # Returns all lists for a project. If complete is true, only completed lists
+  # are returned. If complete is false, only uncompleted lists are returned.
+  def self.all(project_id, complete = nil)
+    filter = case complete
+      when nil   then "all"
+      when true  then "finished"
+      when false then "pending"
+      else raise ArgumentError, "invalid value for `complete'"
+    end
+
+    find(:all, :params => { :project_id => project_id, :filter => filter })
+  end
+
+  def project
+    @project ||= Project.find(project_id)
+  end
+
+  def todo_items(options = {})
+    @todo_items ||= TodoItem.find(:all, :params => options.merge(:todo_list_id => id))
+  end
+
+  def prefix_options
+    { :project_id => project_id }
+  end
+end; end

data/lib/basecamp/symbol.rb

@@ -0,0 +1,6 @@
+# A minor hack to let Xml-Simple serialize symbolic keys in hashes
+class Symbol
+  def [](*args)
+    to_s[*args]
+  end
+end

data/lib/basecamp.rb

@@ -0,0 +1,25 @@
+require 'net/https'
+require 'yaml'
+require 'date'
+require 'time'
+require 'active_resource'
+require 'xmlsimple'
+
+require 'basecamp/base'
+require 'basecamp/connection'
+require 'basecamp/active_resource'
+require 'basecamp/hash'
+require 'basecamp/record'
+require 'basecamp/resource'
+require 'basecamp/symbol'
+require 'basecamp/resources/attachment'
+require 'basecamp/resources/category'
+require 'basecamp/resources/comment'
+require 'basecamp/resources/company'
+require 'basecamp/resources/message'
+require 'basecamp/resources/milestone'
+require 'basecamp/resources/person'
+require 'basecamp/resources/project'
+require 'basecamp/resources/time_entry'
+require 'basecamp/resources/todo_item'
+require 'basecamp/resources/todo_list'

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification
+name: basecamp-classic
+version: !ruby/object:Gem::Version
+  version: 0.0.13
+platform: ruby
+authors:
+- Anibal Cucco
+- James A. Rosen
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-03-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: oauth2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: xml-simple
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activeresource
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.8
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.2
+description: Basecamp API wrapper.
+email: nobody@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.rdoc
+- lib/basecamp.rb
+- lib/basecamp/active_resource.rb
+- lib/basecamp/base.rb
+- lib/basecamp/connection.rb
+- lib/basecamp/hash.rb
+- lib/basecamp/record.rb
+- lib/basecamp/resource.rb
+- lib/basecamp/resources/attachment.rb
+- lib/basecamp/resources/category.rb
+- lib/basecamp/resources/comment.rb
+- lib/basecamp/resources/company.rb
+- lib/basecamp/resources/message.rb
+- lib/basecamp/resources/milestone.rb
+- lib/basecamp/resources/person.rb
+- lib/basecamp/resources/project.rb
+- lib/basecamp/resources/time_entry.rb
+- lib/basecamp/resources/todo_item.rb
+- lib/basecamp/resources/todo_list.rb
+- lib/basecamp/symbol.rb
+homepage: http://github.com/anibalcucco/basecamp-wrapper
+licenses: []
+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: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Basecamp API wrapper.
+test_files: []