stack_exchange 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

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

data/README.rdoc

@@ -0,0 +1,310 @@
+= stack_exchange
+
+A thin Ruby wrapper for the Stack Exchange API. Designed to match the API as closely as possible.
+
+== Examples:
+    
+    > s = StackExchange::Base.new
+    > s.questions(2877955, :answers)
+    > pp s.questions(2877955, :body => 'true')
+    
+    {
+      "total": 1,
+      "page": 1,
+      "pagesize": 30,
+      "questions": [
+        {
+          "tags": [
+            "java",
+            "concurrency"
+          ],
+          "answer_count": 5,
+          "answers": [
+            {
+              "answer_id": 2878021,
+              "accepted": false,
+              "answer_comments_url": "/answers/2878021/comments",
+              "question_id": 2877955,
+              "owner": {
+                "user_id": 142446,
+                "user_type": "registered",
+                "display_name": "bkail",
+                "reputation": 1268,
+                "email_hash": "0e8190d89907e24bf6b4438eaef71af4"
+              },
+              "creation_date": 1274391221,
+              "last_edit_date": 1274396565,
+              "last_activity_date": 1274396565,
+              "up_vote_count": 2,
+              "down_vote_count": 1,
+              "view_count": 80,
+              "score": 1,
+              "community_owned": false,
+              "title": "Controlling race condition at startup.",
+              "body": "<p>A <code>synchronized</code> block will automatically block other threads.  Just use a simple lock object + status variable:</p>\n\n<pre><code>public class MyClass {\n    private static boolean initialised;\n    private static final Object lockObject = new Object();\n\n    public void initialise() {\n        synchronized (lockObject) {\n            if (!initialised) {\n                initStuff();\n                initialised = true;\n            }\n        }\n    }\n\n    public void doStuff() {\n        initialise();\n        doOtherStuff();\n    }\n}\n</code></pre>\n"
+            },
+            {
+              "answer_id": 2878026,
+              "accepted": false,
+              "answer_comments_url": "/answers/2878026/comments",
+              "question_id": 2877955,
+              "owner": {
+                "user_id": 326480,
+                "user_type": "registered",
+                "display_name": "mdma",
+                "reputation": 4572,
+                "email_hash": "12778253a95d10ba54e696ffab85103d"
+              },
+              "creation_date": 1274391233,
+              "last_edit_date": 1274391655,
+              "last_activity_date": 1274391655,
+              "up_vote_count": 0,
+              "down_vote_count": 0,
+              "view_count": 80,
+              "score": 0,
+              "community_owned": false,
+              "title": "Controlling race condition at startup.",
+              "body": "<p>You're using <code>AtomicBoolean</code> always from inside a synchronized block. There's not much point to that since only one thread can access it. Atomic variables are intended for use in lock-free solutions - you can get and set the value as an uninterruptable unit.</p>\n\n<p>I guess you are looking for a lock free solution once the intiialization has happened:</p>\n\n<pre><code>public class MyClass {\n    private static final AtomicBoolean initialised = new AtomicBoolean(false);\n\n    public void initialise() {\n        if (!intialized.get())\n        {\n            synchornized (this)\n            {\n               if (!initialized.getAndSet(true))\n                  doInitialize();\n            }\n        }\n    }\n\n    public void doStuff() {\n        initialize();\n        doOtherStuff();\n    }\n</code></pre>\n\n<p>You could also do this with a simple <code>volatile boolean</code> which is actually a little more efficient than an AtomicBoolean.</p>\n"
+            },
+            {
+              "answer_id": 2878031,
+              "accepted": false,
+              "answer_comments_url": "/answers/2878031/comments",
+              "question_id": 2877955,
+              "owner": {
+                "user_id": 162273,
+                "user_type": "registered",
+                "display_name": "Jason",
+                "reputation": 855,
+                "email_hash": "ca27a5c424b2e8f1b9f9ea3747305751"
+              },
+              "creation_date": 1274391259,
+              "last_activity_date": 1274391259,
+              "up_vote_count": 0,
+              "down_vote_count": 0,
+              "view_count": 80,
+              "score": 0,
+              "community_owned": false,
+              "title": "Controlling race condition at startup.",
+              "body": "<p>It this is right at startup, why not wait to start the other threads until the initialization is complete?</p>\n\n<p>Also, you can do a thread-synchronized IsComplete boolean that is set to false until it is set to true by the initialization routine.</p>\n"
+            },
+            {
+              "answer_id": 2878040,
+              "accepted": true,
+              "answer_comments_url": "/answers/2878040/comments",
+              "question_id": 2877955,
+              "owner": {
+                "user_id": 3474,
+                "user_type": "registered",
+                "display_name": "erickson",
+                "reputation": 34431,
+                "email_hash": "ffbf4e85b8ffbae4e9039b9c0cf07bc8"
+              },
+              "creation_date": 1274391344,
+              "last_activity_date": 1274391344,
+              "up_vote_count": 4,
+              "down_vote_count": 0,
+              "view_count": 80,
+              "score": 4,
+              "community_owned": false,
+              "title": "Controlling race condition at startup.",
+              "body": "<p>That's a strange mix of library and built-in concurrency controls. Something like this is much cleaner:</p>\n\n<pre><code>public class MyClass {\n\n  private static final CountDownLatch latch = new CountDownLatch(1);\n\n  public void initialise() {\n    initStuff();\n    latch.countDown();\n  }\n\n  public void doStuff() {\n    try {\n      latch.await();\n    } catch (InterruptedException ex) {\n      throw new RuntimeException(\"Uh oh!\", ex);\n    }\n    doOtherStuff();\n  }\n\n}\n</code></pre>\n"
+            },
+            {
+              "answer_id": 2878440,
+              "accepted": false,
+              "answer_comments_url": "/answers/2878440/comments",
+              "question_id": 2877955,
+              "owner": {
+                "user_id": 115432,
+                "user_type": "registered",
+                "display_name": "Kathy Van Stone",
+                "reputation": 3675,
+                "email_hash": "eca023f50940b65931dfe75a03e6e00a"
+              },
+              "creation_date": 1274395987,
+              "last_activity_date": 1274395987,
+              "up_vote_count": 0,
+              "down_vote_count": 0,
+              "view_count": 80,
+              "score": 0,
+              "community_owned": false,
+              "title": "Controlling race condition at startup.",
+              "body": "<p>The best may be to use a static initializer (as mentioned by SB):</p>\n\n<pre><code>public class MyClass {\n\n    public static void doInitialize() {\n      ...\n    }\n\n    public void doStuff() {\n        doOtherStuff();\n    }\n\n    static {\n       doInitialize();\n    }\n}\n</code></pre>\n\n<p>This will get executed once before any other code is allowed to be called.  If you will always have to initialize anytime the class is used then there is no performance hit as the class will not be loaded until it is used.  See the answers to <a href=\"http://stackoverflow.com/questions/878577/are-java-static-initializers-thread-safe\">this question</a> for more details.</p>\n"
+            }
+          ],
+          "accepted_answer_id": 2878040,
+          "favorite_count": 3,
+          "question_timeline_url": "/questions/2877955/timeline",
+          "question_comments_url": "/questions/2877955/comments",
+          "question_answers_url": "/questions/2877955/answers",
+          "question_id": 2877955,
+          "owner": {
+            "user_id": 13663,
+            "user_type": "registered",
+            "display_name": "Will Hartung",
+            "reputation": 13650,
+            "email_hash": "92f0c7fe372960ea92560487665a8720"
+          },
+          "creation_date": 1274390502,
+          "last_edit_date": 1274393269,
+          "last_activity_date": 1274396565,
+          "up_vote_count": 3,
+          "down_vote_count": 0,
+          "view_count": 80,
+          "score": 3,
+          "community_owned": false,
+          "title": "Controlling race condition at startup.",
+          "body": "<p>I have some code that I want to have some one time initialisation performed. But this code doesn't have a definite lifecycle, so my logic can be potentially invoked by multiple threads before my initialisation is done. So, I want to basically ensure that my logic code \"waits\" until initialisation is done.</p>\n\n<p>This is my first cut.</p>\n\n<pre><code>public class MyClass {\n    private static final AtomicBoolean initialised = new AtomicBoolean(false);\n\n    public void initialise() {\n        synchronized(initialised) {\n            initStuff();\n            initialised.getAndSet(true);\n            initialised.notifyAll();\n        }\n    }\n\n    public void doStuff() {\n        synchronized(initialised) {\n            if (!initialised.get()) {\n                try {\n                    initialised.wait();\n                } catch (InterruptedException ex) {\n                    throw new RuntimeException(\"Uh oh!\", ex);\n                }\n            }\n        }\n\n        doOtherStuff();\n    }\n}\n</code></pre>\n\n<p>I basically want to make sure this is going to do what I think it's going to do -- block doStuff until the initialised is true, and that I'm not missing a race condition where doStuff might get stuck on a Object.wait() that will never arrive.</p>\n\n<p>Edit:</p>\n\n<p>I have no control over the threads. And I want to be able to control when all of the initialisation is done, which is why doStuff() can't call initialise().</p>\n\n<p>I used an AtomicBoolean as it was a combination of a value holder, and an object I could synchronize. I could have also simply had a \"public static final Object lock = new Object();\" and a simple boolean flag. AtomicBoolean conveniently gave me both. A Boolean can not be modified.</p>\n\n<p>The CountDownLatch is exactly what I was looking for. I also considered using a Sempahore with 0 permits. But the CountDownLatch is perfect for just this task.</p>\n"
+        }
+      ]
+    }
+    {"questions"=>
+      [{"question_id"=>2877955,
+        "up_vote_count"=>3,
+        "last_activity_date"=>1274396565,
+        "body"=>
+         "<p>I have some code that I want to have some one time initialisation performed. But this code doesn't have a definite lifecycle, so my logic can be potentially invoked by multiple threads before my initialisation is done. So, I want to basically ensure that my logic code \"waits\" until initialisation is done.</p>\n\n<p>This is my first cut.</p>\n\n<pre><code>public class MyClass {\n    private static final AtomicBoolean initialised = new AtomicBoolean(false);\n\n    public void initialise() {\n        synchronized(initialised) {\n            initStuff();\n            initialised.getAndSet(true);\n            initialised.notifyAll();\n        }\n    }\n\n    public void doStuff() {\n        synchronized(initialised) {\n            if (!initialised.get()) {\n                try {\n                    initialised.wait();\n                } catch (InterruptedException ex) {\n                    throw new RuntimeException(\"Uh oh!\", ex);\n                }\n            }\n        }\n\n        doOtherStuff();\n    }\n}\n</code></pre>\n\n<p>I basically want to make sure this is going to do what I think it's going to do -- block doStuff until the initialised is true, and that I'm not missing a race condition where doStuff might get stuck on a Object.wait() that will never arrive.</p>\n\n<p>Edit:</p>\n\n<p>I have no control over the threads. And I want to be able to control when all of the initialisation is done, which is why doStuff() can't call initialise().</p>\n\n<p>I used an AtomicBoolean as it was a combination of a value holder, and an object I could synchronize. I could have also simply had a \"public static final Object lock = new Object();\" and a simple boolean flag. AtomicBoolean conveniently gave me both. A Boolean can not be modified.</p>\n\n<p>The CountDownLatch is exactly what I was looking for. I also considered using a Sempahore with 0 permits. But the CountDownLatch is perfect for just this task.</p>\n",
+        "title"=>"Controlling race condition at startup.",
+        "down_vote_count"=>0,
+        "creation_date"=>1274390502,
+        "question_answers_url"=>"/questions/2877955/answers",
+        "favorite_count"=>3,
+        "answer_count"=>5,
+        "tags"=>["java", "concurrency"],
+        "last_edit_date"=>1274393269,
+        "accepted_answer_id"=>2878040,
+        "question_comments_url"=>"/questions/2877955/comments",
+        "community_owned"=>false,
+        "score"=>3,
+        "view_count"=>80,
+        "owner"=>
+         {"reputation"=>13650,
+          "user_type"=>"registered",
+          "email_hash"=>"92f0c7fe372960ea92560487665a8720",
+          "user_id"=>13663,
+          "display_name"=>"Will Hartung"},
+        "question_timeline_url"=>"/questions/2877955/timeline",
+        "answers"=>
+         [{"question_id"=>2877955,
+           "up_vote_count"=>2,
+           "last_activity_date"=>1274396565,
+           "body"=>
+            "<p>A <code>synchronized</code> block will automatically block other threads.  Just use a simple lock object + status variable:</p>\n\n<pre><code>public class MyClass {\n    private static boolean initialised;\n    private static final Object lockObject = new Object();\n\n    public void initialise() {\n        synchronized (lockObject) {\n            if (!initialised) {\n                initStuff();\n                initialised = true;\n            }\n        }\n    }\n\n    public void doStuff() {\n        initialise();\n        doOtherStuff();\n    }\n}\n</code></pre>\n",
+           "title"=>"Controlling race condition at startup.",
+           "down_vote_count"=>1,
+           "creation_date"=>1274391221,
+           "last_edit_date"=>1274396565,
+           "community_owned"=>false,
+           "answer_id"=>2878021,
+           "score"=>1,
+           "answer_comments_url"=>"/answers/2878021/comments",
+           "accepted"=>false,
+           "view_count"=>80,
+           "owner"=>
+            {"reputation"=>1268,
+             "user_type"=>"registered",
+             "email_hash"=>"0e8190d89907e24bf6b4438eaef71af4",
+             "user_id"=>142446,
+             "display_name"=>"bkail"}},
+          {"question_id"=>2877955,
+           "up_vote_count"=>0,
+           "last_activity_date"=>1274391655,
+           "body"=>
+            "<p>You're using <code>AtomicBoolean</code> always from inside a synchronized block. There's not much point to that since only one thread can access it. Atomic variables are intended for use in lock-free solutions - you can get and set the value as an uninterruptable unit.</p>\n\n<p>I guess you are looking for a lock free solution once the intiialization has happened:</p>\n\n<pre><code>public class MyClass {\n    private static final AtomicBoolean initialised = new AtomicBoolean(false);\n\n    public void initialise() {\n        if (!intialized.get())\n        {\n            synchornized (this)\n            {\n               if (!initialized.getAndSet(true))\n                  doInitialize();\n            }\n        }\n    }\n\n    public void doStuff() {\n        initialize();\n        doOtherStuff();\n    }\n</code></pre>\n\n<p>You could also do this with a simple <code>volatile boolean</code> which is actually a little more efficient than an AtomicBoolean.</p>\n",
+           "title"=>"Controlling race condition at startup.",
+           "down_vote_count"=>0,
+           "creation_date"=>1274391233,
+           "last_edit_date"=>1274391655,
+           "community_owned"=>false,
+           "answer_id"=>2878026,
+           "score"=>0,
+           "answer_comments_url"=>"/answers/2878026/comments",
+           "accepted"=>false,
+           "view_count"=>80,
+           "owner"=>
+            {"reputation"=>4572,
+             "user_type"=>"registered",
+             "email_hash"=>"12778253a95d10ba54e696ffab85103d",
+             "user_id"=>326480,
+             "display_name"=>"mdma"}},
+          {"question_id"=>2877955,
+           "up_vote_count"=>0,
+           "last_activity_date"=>1274391259,
+           "body"=>
+            "<p>It this is right at startup, why not wait to start the other threads until the initialization is complete?</p>\n\n<p>Also, you can do a thread-synchronized IsComplete boolean that is set to false until it is set to true by the initialization routine.</p>\n",
+           "title"=>"Controlling race condition at startup.",
+           "down_vote_count"=>0,
+           "creation_date"=>1274391259,
+           "community_owned"=>false,
+           "answer_id"=>2878031,
+           "score"=>0,
+           "answer_comments_url"=>"/answers/2878031/comments",
+           "accepted"=>false,
+           "view_count"=>80,
+           "owner"=>
+            {"reputation"=>855,
+             "user_type"=>"registered",
+             "email_hash"=>"ca27a5c424b2e8f1b9f9ea3747305751",
+             "user_id"=>162273,
+             "display_name"=>"Jason"}},
+          {"question_id"=>2877955,
+           "up_vote_count"=>4,
+           "last_activity_date"=>1274391344,
+           "body"=>
+            "<p>That's a strange mix of library and built-in concurrency controls. Something like this is much cleaner:</p>\n\n<pre><code>public class MyClass {\n\n  private static final CountDownLatch latch = new CountDownLatch(1);\n\n  public void initialise() {\n    initStuff();\n    latch.countDown();\n  }\n\n  public void doStuff() {\n    try {\n      latch.await();\n    } catch (InterruptedException ex) {\n      throw new RuntimeException(\"Uh oh!\", ex);\n    }\n    doOtherStuff();\n  }\n\n}\n</code></pre>\n",
+           "title"=>"Controlling race condition at startup.",
+           "down_vote_count"=>0,
+           "creation_date"=>1274391344,
+           "community_owned"=>false,
+           "answer_id"=>2878040,
+           "score"=>4,
+           "answer_comments_url"=>"/answers/2878040/comments",
+           "accepted"=>true,
+           "view_count"=>80,
+           "owner"=>
+            {"reputation"=>34431,
+             "user_type"=>"registered",
+             "email_hash"=>"ffbf4e85b8ffbae4e9039b9c0cf07bc8",
+             "user_id"=>3474,
+             "display_name"=>"erickson"}},
+          {"question_id"=>2877955,
+           "up_vote_count"=>0,
+           "last_activity_date"=>1274395987,
+           "body"=>
+            "<p>The best may be to use a static initializer (as mentioned by SB):</p>\n\n<pre><code>public class MyClass {\n\n    public static void doInitialize() {\n      ...\n    }\n\n    public void doStuff() {\n        doOtherStuff();\n    }\n\n    static {\n       doInitialize();\n    }\n}\n</code></pre>\n\n<p>This will get executed once before any other code is allowed to be called.  If you will always have to initialize anytime the class is used then there is no performance hit as the class will not be loaded until it is used.  See the answers to <a href=\"http://stackoverflow.com/questions/878577/are-java-static-initializers-thread-safe\">this question</a> for more details.</p>\n",
+           "title"=>"Controlling race condition at startup.",
+           "down_vote_count"=>0,
+           "creation_date"=>1274395987,
+           "community_owned"=>false,
+           "answer_id"=>2878440,
+           "score"=>0,
+           "answer_comments_url"=>"/answers/2878440/comments",
+           "accepted"=>false,
+           "view_count"=>80,
+           "owner"=>
+            {"reputation"=>3675,
+             "user_type"=>"registered",
+             "email_hash"=>"eca023f50940b65931dfe75a03e6e00a",
+             "user_id"=>115432,
+             "display_name"=>"Kathy Van Stone"}}]}],
+     "total"=>1,
+     "page"=>1,
+     "pagesize"=>30}
+
+
+
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Sam Coles. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,52 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "stack_exchange"
+    gem.summary = %Q{A Ruby interface to the Stack Exchange API}
+    gem.description = %Q{Access any Stack Exchange site (stackoverflow.com, ect.) from Ruby.}
+    gem.email = "sam@coredumplings.com"
+    gem.homepage = "http://github.com/coredumplings/stack_exchange"
+    gem.authors = ["Sam Coles"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+#task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "stack_exchange #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/stack_exchange.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'stack_exchange/base'
+
+module StackExchange
+  VERSION = '0.1'
+end

data/lib/stack_exchange/base.rb

@@ -0,0 +1,42 @@
+require 'open-uri'
+require 'uri'
+require 'json'
+require 'zlib'
+require 'stringio'
+
+module StackExchange
+  class Base
+    DEFAULT_OPTIONS = {
+      :site                       => 'stackoverflow.com',
+      :version                    => '0.8',
+      :http_basic_authentication  => nil,
+      'Accept-Encoding'           => 'gzip',
+      'User-Agent'                => "Ruby StackExchange Client/#{VERSION}"
+    }
+    
+    attr_reader :base_uri
+    attr_reader :http_options
+    
+    def initialize(opts={})
+      opts = DEFAULT_OPTIONS.merge(opts)
+      @base_uri = URI.parse("http://api.#{opts.delete(:site)}/#{opts.delete(:version)}/")
+      @http_options = opts
+    end
+    
+    def hash_to_querystring(hash)
+      hash.keys.inject('') do |query_string, key|
+        query_string << '&' unless key == hash.keys.first
+        query_string << "#{URI.encode(key.to_s)}=#{URI.encode(hash[key])}"
+      end
+    end
+    
+    def method_missing(method_name, *args)
+      query = hash_to_querystring(args.pop) if args && args.last.is_a?(Hash)
+      uri = base_uri + ([method_name.to_s] + args).join('/')
+      uri.query = query if defined?(query)
+      response = open( uri, http_options ).read
+      uncompressed_response = Zlib::GzipReader.new(StringIO.new( response )).read
+      JSON.parse( uncompressed_response )
+    end
+  end
+end

data/stack_exchange.gemspec

@@ -0,0 +1,52 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{stack_exchange}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Sam Coles"]
+  s.date = %q{2010-05-24}
+  s.description = %q{Access any Stack Exchange site (stackoverflow.com, ect.) from Ruby.}
+  s.email = %q{sam@coredumplings.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/stack_exchange.rb",
+     "lib/stack_exchange/base.rb",
+     "stack_exchange.gemspec",
+     "test/helper.rb",
+     "test/test_stack_exchange.rb"
+  ]
+  s.homepage = %q{http://github.com/coredumplings/stack_exchange}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{A Ruby interface to the Stack Exchange API}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_stack_exchange.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'stack_exchange'
+
+class Test::Unit::TestCase
+end

data/test/test_stack_exchange.rb

@@ -0,0 +1,9 @@
+require 'helper'
+
+class TestStackExchange < Test::Unit::TestCase
+  def test_uri_generation
+    answers = StackExchange::Base.new.questions(1, :answers)
+    puts(answers)
+    assert("http://api.stackoverflow.com/0.8/questions/1/answers", answers)
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: stack_exchange
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Sam Coles
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-24 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Access any Stack Exchange site (stackoverflow.com, ect.) from Ruby.
+email: sam@coredumplings.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/stack_exchange.rb
+- lib/stack_exchange/base.rb
+- stack_exchange.gemspec
+- test/helper.rb
+- test/test_stack_exchange.rb
+has_rdoc: true
+homepage: http://github.com/coredumplings/stack_exchange
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A Ruby interface to the Stack Exchange API
+test_files: 
+- test/helper.rb
+- test/test_stack_exchange.rb