rest-core 2.0.0 → 2.0.1

data/.gitignore

@@ -1,7 +1,2 @@
 pkg
-rdoc
 *.rbc
-.bundle
-.yardoc
-Gemfile.lock
-task

data/CHANGES.md

@@ -1,6 +1,19 @@
 # CHANGES
 
-## rest-core 2.0.0
+## rest-core 2.0.1 -- 2013-01-08
+
+### Bugs fixes
+
+* Don't walk into parent's constants in `RC.eagerload`.
+* Also rescue `NameError` in `RC.eagerload`.
+
+### Enhancement
+
+* Remove unnecessary `future.wrap` in `EmHttpRequest`.
+* Introduce Future#callback_in_async.
+* We would never double resume the fiber, so no need to rescue `FiberError`.
+
+## rest-core 2.0.0 -- 2012-10-31
 
 This is a major release which introduces some incompatible changes.
 This is intended to cleanup some internal implementation and introduce

data/README.md

@@ -83,6 +83,8 @@ YourClient = RC::Builder.client do
 end
 ```
 
+### Basic Usage:
+
 And use it with per-instance basis (clients could have different
 configuration, e.g. different cache time or timeout time):
 
@@ -96,17 +98,71 @@ client.get('cardinalblue') # cache miss
 client.get('cardinalblue') # cache hit
 ```
 
+### Concurrent Requests with Futures:
+
 You can also make concurrent requests easily:
 (see "Advanced Concurrent HTTP Requests -- Embrace the Future" for detail)
 
 ``` ruby
-a = [client.get('cardinalblue')['name'], client.get('godfat')['name']]
+a = [client.get('cardinalblue'), client.get('godfat')]
 puts "It's not blocking... but doing concurrent requests underneath"
-p a # here we want the values, so it blocks here
+p a.map{ |r| r['name'] } # here we want the values, so it blocks here
 puts "DONE"
 ```
 
-Callback mode also available:
+### Exception Handling for Futures:
+
+Note that since the API call would only block whenever you're looking at
+the response, it won't raise any exception at the time the API was called.
+So if you want to block and handle the exception at the time API was called,
+you would do something like this:
+
+``` ruby
+begin
+  response = client.get('bad-user').tap{} # .tap{} is the point
+  do_the_work(response)
+rescue => e
+  puts "Got an exception: #{e}"
+end
+```
+
+The trick here is forcing the future immediately give you the exact response,
+so that rest-core could see the response and raise the exception. You can
+call whatever methods on the future to force this behaviour, but since `tap{}`
+is a method from `Kernel` (which is included in `Object`), it's always
+available and would return the original value, so it is the easiest method
+to be remembered and used.
+
+If you know the response must be a string, then you can also use `to_s`.
+Like this:
+
+``` ruby
+begin
+  response = client.get('bad-user').to_s
+  do_the_work(response)
+rescue => e
+  puts "Got an exception: #{e}"
+end
+```
+
+Or you can also do this:
+
+``` ruby
+begin
+  response = client.get('bad-user')
+  response.class # simply force it to load
+  do_the_work(response)
+rescue => e
+  puts "Got an exception: #{e}"
+end
+```
+
+The point is simply making a method call to force it load, whatever method
+should work.
+
+### Concurrent Requests with Callbacks:
+
+On the other hand, callback mode also available:
 
 ``` ruby
 client.get('cardinalblue'){ |v| p v }
@@ -115,6 +171,53 @@ client.wait # we block here to wait for the request done
 puts "DONE"
 ```
 
+### Exception Handling for Callbacks:
+
+What about exception handling in callback mode? You know that we cannot
+raise any exception in the case of using a callback. So rest-core would
+pass the exception object into your callback. You can handle the exception
+like this:
+
+``` ruby
+client.get('bad-user') do |response|
+  if response.kind_of?(Exception)
+    puts "Got an exception: #{response}"
+  else
+    do_the_work(response)
+  end
+end
+puts "It's not blocking... but doing concurrent requests underneath"
+client.wait # we block here to wait for the request done
+puts "DONE"
+```
+
+### More Control with `request_full`:
+
+You can also use `request_full` to retrieve everything including response
+status, response headers, and also other rest-core options. But since using
+this interface is like using Rack directly, you have to build the env
+manually. To help you build the env manually, everything has a default,
+including the path.
+
+``` ruby
+client.request_full({})[RC::RESPONSE_BODY] # {"message"=>"Not Found"}
+# This would print something like this:
+# RestCore: Auto   picked: RestCore::RestClient
+# RestCore: Future picked: RestCore::Future::FutureThread
+# RestCore: spent 1.135713 Requested GET https://api.github.com/users//
+
+client.request_full(RC::REQUEST_PATH => 'cardinalblue')[RC::RESPONSE_STATUS]
+client.request_full(RC::REQUEST_PATH => 'cardinalblue')[RC::RESPONSE_HEADERS]
+# Headers are normalized with all upper cases and
+# dashes are replaced by underscores.
+
+# To make POST (or any other request methods) request:
+client.request_full(RC::REQUEST_PATH   => 'cardinalblue',
+                    RC::REQUEST_METHOD => :post)[RC::RESPONSE_STATUS] # 404
+```
+
+### Examples:
+
 Runnable example is at: [example/simple.rb][]. Please see [rest-more][]
 for more complex examples to build clients, and [slides][] from
 [rubyconf.tw/2011][rubyconf.tw] for concepts.
@@ -124,6 +227,74 @@ for more complex examples to build clients, and [slides][] from
 [slides]: http://www.godfat.org/slide/2011-08-27-rest-core.html
 [rubyconf.tw]: http://rubyconf.tw/2011/#6
 
+## Playing Around:
+
+You can also play around with `RC::Universal` client, which has installed
+_all_ reasonable middlewares built-in rest-core. So the above example could
+also be achieved by:
+
+``` ruby
+require 'rest-core'
+client = RC::Universal.new(:site          => 'https://api.github.com/users/',
+                           :json_response => true,
+                           :log_method    => method(:puts))
+client.get('cardinalblue')
+```
+
+`RC::Universal` is defined as:
+
+``` ruby
+module RestCore
+  Universal = Builder.client do
+    use Timeout       , 0
+
+    use DefaultSite   , nil
+    use DefaultHeaders, {}
+    use DefaultQuery  , {}
+    use DefaultPayload, {}
+    use JsonRequest   , false
+    use AuthBasic     , nil, nil
+
+    use FollowRedirect, 10
+    use CommonLogger  , method(:puts)
+    use Cache         ,  {}, 600 do
+      use ErrorHandler, nil
+      use ErrorDetectorHttp
+      use JsonResponse, false
+    end
+  end
+end
+```
+
+If you have both [rib][] and [rest-more][] installed, you can also play
+around with an interactive shell, like this:
+
+``` shell
+rib rest-core
+```
+
+And you will be entering a rib shell, which `self` is an instance of
+`RC::Universal` you can play:
+
+    rest-core>> get 'https://api.github.com/users/cardinalblue'
+
+will print out the response from Github. You can also do this to make
+calling Github easier:
+
+    rest-core>> self.site = 'https://api.github.com/users/'
+    rest-core>> self.json_response = true
+
+Then it would do exactly like the original example:
+
+    rest-core>> get 'cardinalblue' # you get a nice parsed hash
+
+This is mostly for fun and experimenting, so it's only included in
+[rest-more][] and [rib][]. Please make sure you have both of them
+installed before trying this.
+
+[rib]: https://github.com/godfat/rib
+[rest-more]: https://github.com/cardinalblue/rest-more
+
 ## List of built-in Middlewares:
 
 * `RC::AuthBasic`
@@ -177,9 +348,9 @@ end
 
 client = YourClient.new
 puts "rest-client with threads doing concurrent requests"
-a = [client.get('cardinalblue')['name'], client.get('godfat')['name']]
+a = [client.get('cardinalblue'), client.get('godfat')]
 puts "It's not blocking... but doing concurrent requests underneath"
-p a # here we want the values, so it blocks here
+p a.map{ |r| r['name'] } # here we want the values, so it blocks here
 puts "DONE"
 ```
 
@@ -237,7 +408,8 @@ client = YourClient.new
 puts "eventmachine with threads doing concurrent requests"
 EM.run{
   Thread.new{
-    p [client.get('cardinalblue')['name'], client.get('godfat')['name']]
+    a = [client.get('cardinalblue'), client.get('godfat')]
+    p a.map{ |r| r['name'] } # here we want the values, so it blocks here
     puts "DONE"
     EM.stop
   }
@@ -261,7 +433,8 @@ client = YourClient.new
 puts "eventmachine with fibers doing concurrent requests"
 EM.run{
   Fiber.new{
-    p [client.get('cardinalblue')['name'], client.get('godfat')['name']]
+    a = [client.get('cardinalblue'), client.get('godfat')]
+    p a.map{ |r| r['name'] } # here we want the values, so it blocks here
     puts "DONE"
     EM.stop
   }

data/example/multi.rb

@@ -12,9 +12,9 @@ end
 
 client = YourClient.new
 puts "rest-client with threads doing concurrent requests"
-a = [client.get('cardinalblue')['name'], client.get('godfat')['name']]
+a = [client.get('cardinalblue'), client.get('godfat')]
 puts "It's not blocking... but doing concurrent requests underneath"
-p a # here we want the values, so it blocks here
+p a.map{ |r| r['name'] } # here we want the values, so it blocks here
 puts "DONE"
 
 puts; puts
@@ -22,7 +22,8 @@ puts; puts
 puts "eventmachine with threads doing concurrent requests"
 EM.run{
   Thread.new{
-    p [client.get('cardinalblue')['name'], client.get('godfat')['name']]
+    a = [client.get('cardinalblue'), client.get('godfat')]
+    p a.map{ |r| r['name'] } # here we want the values, so it blocks here
     puts "DONE"
     EM.stop
   }
@@ -34,7 +35,8 @@ puts; puts
 puts "eventmachine with fibers doing concurrent requests"
 EM.run{
   Fiber.new{
-    p [client.get('cardinalblue')['name'], client.get('godfat')['name']]
+    a = [client.get('cardinalblue'), client.get('godfat')]
+    p a.map{ |r| r['name'] } # here we want the values, so it blocks here
     puts "DONE"
     EM.stop
   }.resume

data/example/simple.rb

@@ -16,9 +16,9 @@ p client.get('cardinalblue') # cache hit
 client.cache = false
 
 puts "concurrent requests"
-a = [client.get('cardinalblue')['name'], client.get('godfat')['name']]
+a = [client.get('cardinalblue'), client.get('godfat')]
 puts "It's not blocking... but doing concurrent requests underneath"
-p a # here we want the values, so it blocks here
+p a.map{ |r| r['name'] } # here we want the values, so it blocks here
 puts "DONE"
 
 puts "callback"

data/example/use-cases.rb

@@ -66,12 +66,16 @@ def_use_case 'pure_ruby_nested_concurrent_requests' do
   %w[rubytaiwan godfat].each{ |user|
     c.get("/users/#{user}/repos", :per_page => 100){ |repos|
       rs = repos.reject{ |r| r['fork'] }
+      rs = [{}] if rs.size == 1 # out of API limit :(
       most_watched = rs.max_by{ |r| r['watchers'] }['name']
       most_size    = rs.max_by{ |r| r['size']     }['name']
 
       watch_contri = c.get("/repos/#{user}/#{most_watched}/contributors")
        size_contri = c.get("/repos/#{user}/#{most_size}/contributors")
 
+      watch_contri = [{}] if watch_contri.size == 1 # out of API limit :(
+       size_contri = [{}] if  size_contri.size == 1 # out of API limit :(
+
       most_watched_most_contri = watch_contri.max_by{ |c| c['contributions'] }
       most_size_most_contri    =  size_contri.max_by{ |c| c['contributions'] }
 

data/lib/rest-core.rb

@@ -71,10 +71,10 @@ module RestCore
   def self.eagerload const=self, loaded={}
     return if loaded[const.name]
     loaded[const.name] = true
-    const.constants.each{ |n|
+    const.constants(false).each{ |n|
       begin
         c = const.const_get(n)
-      rescue LoadError => e
+      rescue LoadError, NameError => e
         warn "RestCore: WARN: #{e} for #{const}\n" \
              "  from #{e.backtrace.grep(/top.+required/).first}"
       end

data/lib/rest-core/engine/em-http-request.rb

@@ -17,18 +17,17 @@ class RestCore::EmHttpRequest
                                                merge(env[REQUEST_HEADERS]))
 
     client.callback{
-      future.wrap{ # callbacks are run in main thread, so we need to wrap it
-        future.on_load(client.response,
-                       client.response_header.status,
-                       client.response_header)}}
+      future.on_load(client.response,
+                     client.response_header.status,
+                     client.response_header)}
 
-    client.errback{future.wrap{ future.on_error(client.error) }}
+    client.errback{future.on_error(client.error) }
 
     env[TIMER].on_timeout{
       (client.instance_variable_get(:@callbacks)||[]).clear
       (client.instance_variable_get(:@errbacks )||[]).clear
       client.close
-      future.wrap{ future.on_error(env[TIMER].error) }
+      future.on_error(env[TIMER].error)
     } if env[TIMER]
 
     env.merge(RESPONSE_BODY    => future.proxy_body,

data/lib/rest-core/engine/future/future.rb

@@ -58,21 +58,22 @@ class RestCore::Future
                                       ["Future picked: #{self.class}"]))
   end
 
+  def callback_in_async
+    callback
+  rescue Exception => e
+    # nothing we can do here for an asynchronous exception,
+    # so we just log the error
+    logger = method(:warn) # TODO: add error_log_method
+    logger.call "RestCore: ERROR: #{e}\n  from #{e.backtrace.inspect}"
+  end
+
   def on_load body, status, headers
     env[TIMER].cancel if env[TIMER]
     synchronize{
       self.body, self.status, self.headers = body, status, headers
-      begin
-        # under ASYNC callback, should call immediate
-        next_tick{ callback } if immediate
-      rescue Exception => e
-        # nothing we can do here for an asynchronous exception,
-        # so we just log the error
-        logger = method(:warn) # TODO: add error_log_method
-        logger.call "RestCore: ERROR: #{e}\n" \
-                    "  from #{e.backtrace.inspect}"
-      end
     }
+    # under ASYNC callback, should call immediately
+    next_tick{ callback_in_async } if immediate
     resume # client or response might be waiting
   end
 

data/lib/rest-core/engine/future/future_fiber.rb

@@ -22,14 +22,7 @@ class RestCore::Future::FutureFiber < RestCore::Future
     fibers.clear
     current_fibers.each{ |f|
       next unless f.alive?
-      next_tick{
-        begin
-          f.resume
-        rescue FiberError
-          # whenever timeout, it would be already resumed,
-          # and we have no way to tell if it's already resumed or not!
-        end
-      }
+      next_tick{ f.resume }
     }
     resume
   end

data/lib/rest-core/version.rb

@@ -1,4 +1,4 @@
 
 module RestCore
-  VERSION = '2.0.0'
+  VERSION = '2.0.1'
 end

data/rest-core.gemspec

@@ -2,13 +2,13 @@
 
 Gem::Specification.new do |s|
   s.name = "rest-core"
-  s.version = "2.0.0"
+  s.version = "2.0.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = [
   "Cardinal Blue",
   "Lin Jen-Shin (godfat)"]
-  s.date = "2012-10-31"
+  s.date = "2013-01-08"
   s.description = "Modular Ruby clients interface for REST APIs\n\nThere has been an explosion in the number of REST APIs available today.\nTo address the need for a way to access these APIs easily and elegantly,\nwe have developed rest-core, which consists of composable middleware\nthat allows you to build a REST client for any REST API. Or in the case of\ncommon APIs such as Facebook, Github, and Twitter, you can simply use the\ndedicated clients provided by [rest-more][].\n\n[rest-more]: https://github.com/cardinalblue/rest-more"
   s.email = ["dev (XD) cardinalblue.com"]
   s.files = [
@@ -71,6 +71,8 @@ Gem::Specification.new do |s|
   "lib/rest-core/version.rb",
   "lib/rest-core/wrapper.rb",
   "rest-core.gemspec",
+  "task/.gitignore",
+  "task/gemgem.rb",
   "test/test_auth_basic.rb",
   "test/test_builder.rb",
   "test/test_cache.rb",
@@ -92,7 +94,7 @@ Gem::Specification.new do |s|
   "test/test_wrapper.rb"]
   s.homepage = "https://github.com/cardinalblue/rest-core"
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.24"
+  s.rubygems_version = "1.8.23"
   s.summary = "Modular Ruby clients interface for REST APIs"
   s.test_files = [
   "test/test_auth_basic.rb",

data/task/.gitignore

@@ -0,0 +1 @@
+*.rbc

data/task/gemgem.rb

@@ -0,0 +1,267 @@
+
+require 'pathname'
+
+module Gemgem
+  class << self
+    attr_accessor :dir, :spec
+  end
+
+  module_function
+  def create
+    yield(spec = Gem::Specification.new{ |s|
+      s.authors     = ['Lin Jen-Shin (godfat)']
+      s.email       = ['godfat (XD) godfat.org']
+
+      s.description = description.join
+      s.summary     = description.first
+
+      s.rubygems_version = Gem::VERSION
+      s.date             = Time.now.strftime('%Y-%m-%d')
+      s.files            = gem_files
+      s.test_files       = gem_files.grep(%r{^test/(.+?/)*test_.+?\.rb$})
+      s.executables      = Dir['bin/*'].map{ |f| File.basename(f) }
+      s.require_paths    = %w[lib]
+    })
+    spec.homepage ||= "https://github.com/godfat/#{spec.name}"
+    spec
+  end
+
+  def readme
+    path = %w[README.md README].find{ |name|
+      File.exist?("#{Gemgem.dir}/#{name}")
+    }
+    @readme ||=
+      if path
+        ps = "##{File.read(path)}".
+             scan(/((#+)[^\n]+\n\n.+?(?=\n\n\2[^#\n]+\n))/m).map(&:first)
+        ps.inject({'HEADER' => ps.first}){ |r, s, i|
+          r[s[/\w+/]] = s
+          r
+        }
+      else
+        {}
+      end
+  end
+
+  def description
+    @description ||= (readme['DESCRIPTION']||'').sub(/.+\n\n/, '').lines.to_a
+  end
+
+  def changes
+    path = %w[CHANGES.md CHANGES].find{ |name|
+      File.exist?("#{Gemgem.dir}/#{name}")
+    }
+    @changes ||=
+      if path
+        date = '\d+{4}\-\d+{2}\-\d{2}'
+        File.read(path).match(
+          /([^\n]+#{date}\n\n(.+?))(?=\n\n[^\n]+#{date}\n|\Z)/m)[1]
+      else
+        ''
+      end
+  end
+
+  def ann_md
+     "#{readme['HEADER'].sub(/([\w\-]+)/, "[\\1](#{spec.homepage})")}\n\n" \
+    "##{readme['DESCRIPTION'][/[^\n]+\n\n[^\n]+/]}\n\n"                    \
+    "### CHANGES:\n\n"                                                     \
+    "###{changes}\n\n"                                                     \
+    "##{readme['INSTALLATION']}\n\n"                                       +
+    if readme['SYNOPSIS'] then "##{readme['SYNOPSIS'][/[^\n]+\n\n[^\n]+/]}"
+    else '' end
+  end
+
+  def ann_html
+    gem 'nokogiri'
+    gem 'kramdown'
+
+    IO.popen('kramdown', 'r+') do |md|
+      md.puts Gemgem.ann_md
+      md.close_write
+      require 'nokogiri'
+      html = Nokogiri::XML.parse("<gemgem>#{md.read}</gemgem>")
+      html.css('*').each{ |n| n.delete('id') }
+      html.root.children.to_html
+    end
+  end
+
+  def ann_email
+    "#{readme['HEADER'].sub(/([\w\-]+)/, "\\1 <#{spec.homepage}>")}\n\n" \
+    "#{readme['DESCRIPTION']}\n\n"                                       \
+    "#{readme['INSTALLATION']}\n\n"                                      +
+    if readme['SYNOPSIS'] then "##{readme['SYNOPSIS']}\n\n" else '' end  +
+    "## CHANGES:\n\n"                                                    \
+    "##{changes}\n\n"
+  end
+
+  def gem_tag
+    "#{spec.name}-#{spec.version}"
+  end
+
+  def write
+    File.open("#{dir}/#{spec.name}.gemspec", 'w'){ |f|
+      f << split_lines(spec.to_ruby) }
+  end
+
+  def split_lines ruby
+    ruby.gsub(/(.+?)\[(.+?)\]/){ |s|
+      if $2.index(',')
+        "#{$1}[\n  #{$2.split(',').map(&:strip).join(",\n  ")}]"
+      else
+        s
+      end
+    }
+  end
+
+  def all_files
+    @all_files ||= find_files(Pathname.new(dir)).map{ |file|
+      if file.to_s =~ %r{\.git/|\.git$}
+        nil
+      else
+        file.to_s
+      end
+    }.compact.sort
+  end
+
+  def gem_files
+    @gem_files ||= all_files - ignored_files
+  end
+
+  def ignored_files
+    @ignored_file ||= all_files.select{ |path| ignore_patterns.find{ |ignore|
+      path =~ ignore && !git_files.include?(path)}}
+  end
+
+  def git_files
+    @git_files ||= if File.exist?("#{dir}/.git")
+                     `git ls-files`.split("\n")
+                   else
+                     []
+                   end
+  end
+
+  # protected
+  def find_files path
+    path.children.select(&:file?).map{|file| file.to_s[(dir.size+1)..-1]} +
+    path.children.select(&:directory?).map{|dir| find_files(dir)}.flatten
+  end
+
+  def ignore_patterns
+    @ignore_files ||= expand_patterns(
+      gitignore.split("\n").reject{ |pattern|
+        pattern.strip == ''
+      }).map{ |pattern| %r{^([^/]+/)*?#{Regexp.escape(pattern)}(/[^/]+)*?$} }
+  end
+
+  def expand_patterns pathes
+    pathes.map{ |path|
+      if path !~ /\*/
+        path
+      else
+        expand_patterns(
+          Dir[path] +
+          Pathname.new(File.dirname(path)).children.select(&:directory?).
+            map{ |prefix| "#{prefix}/#{File.basename(path)}" })
+      end
+    }.flatten
+  end
+
+  def gitignore
+    if File.exist?(path = "#{dir}/.gitignore")
+      File.read(path)
+    else
+      ''
+    end
+  end
+end
+
+namespace :gem do
+
+desc 'Install gem'
+task :install => [:build] do
+  sh("#{Gem.ruby} -S gem install pkg/#{Gemgem.gem_tag}")
+end
+
+desc 'Build gem'
+task :build => [:spec] do
+  sh("#{Gem.ruby} -S gem build #{Gemgem.spec.name}.gemspec")
+  sh("mkdir -p pkg")
+  sh("mv #{Gemgem.gem_tag}.gem pkg/")
+end
+
+desc 'Release gem'
+task :release => [:spec, :check, :build] do
+  sh("git tag #{Gemgem.gem_tag}")
+  sh("git push")
+  sh("git push --tags")
+  sh("#{Gem.ruby} -S gem push pkg/#{Gemgem.gem_tag}.gem")
+end
+
+task :check do
+  ver = Gemgem.spec.version.to_s
+
+  if ENV['VERSION'].nil?
+    puts("\e[35mExpected "                                  \
+         "\e[33mVERSION\e[35m=\e[33m#{ver}\e[0m")
+    exit(1)
+
+  elsif ENV['VERSION'] != ver
+    puts("\e[35mExpected \e[33mVERSION\e[35m=\e[33m#{ver} " \
+         "\e[35mbut got\n         "                         \
+         "\e[33mVERSION\e[35m=\e[33m#{ENV['VERSION']}\e[0m")
+    exit(2)
+  end
+end
+
+end # of gem namespace
+
+desc 'Run tests in memory'
+task :test do
+  require 'bacon'
+  Bacon.extend(Bacon::TestUnitOutput)
+  Bacon.summary_on_exit
+  $LOAD_PATH.unshift('lib')
+  Dir['./test/**/test_*.rb'].each{ |file| require file[0..-4] }
+end
+
+desc 'Run tests with shell'
+task 'test:shell', :RUBY_OPTS do |t, args|
+  files = Dir['test/**/test_*.rb'].join(' ')
+
+  cmd = [Gem.ruby, args[:RUBY_OPTS],
+         '-I', 'lib', '-S', 'bacon', '--quiet', files]
+
+  sh(cmd.compact.join(' '))
+end
+
+desc 'Generate ann markdown'
+task 'ann:md' => ['gem:spec'] do
+  puts Gemgem.ann_md
+end
+
+desc 'Generate ann html'
+task 'ann:html' => ['gem:spec'] do
+  puts Gemgem.ann_html
+end
+
+desc 'Generate ann email'
+task 'ann:email' => ['gem:spec'] do
+  puts Gemgem.ann_email
+end
+
+desc 'Generate rdoc'
+task :doc => ['gem:spec'] do
+  sh("yardoc -o rdoc --main README.md" \
+     " --files #{Gemgem.spec.extra_rdoc_files.join(',')}")
+end
+
+desc 'Remove ignored files'
+task :clean => ['gem:spec'] do
+  trash = "~/.Trash/#{Gemgem.spec.name}/"
+  sh "mkdir -p #{trash}" unless File.exist?(File.expand_path(trash))
+  Gemgem.ignored_files.each{ |file| sh "mv #{file} #{trash}" }
+end
+
+task :default do
+  puts `#{Gem.ruby} -S #{$PROGRAM_NAME} -T`
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rest-core
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-31 00:00:00.000000000 Z
+date: 2013-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -110,6 +110,8 @@ files:
 - lib/rest-core/version.rb
 - lib/rest-core/wrapper.rb
 - rest-core.gemspec
+- task/.gitignore
+- task/gemgem.rb
 - test/test_auth_basic.rb
 - test/test_builder.rb
 - test/test_cache.rb
@@ -149,7 +151,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Modular Ruby clients interface for REST APIs
@@ -173,4 +175,3 @@ test_files:
 - test/test_timeout.rb
 - test/test_universal.rb
 - test/test_wrapper.rb
-has_rdoc: