apiary 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+.bundle
+pkg

data/Gemfile

@@ -0,0 +1,10 @@
+source :rubygems
+
+gem 'callsite'
+gem 'method-args'
+gem 'thin'
+gem 'http_router'
+gem 'rack'
+gem 'rake'
+gem 'em-http-request'
+gem 'minitest', '~> 2.0.0'

data/Gemfile.lock

@@ -0,0 +1,45 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.2.2)
+    callsite (0.0.4)
+    daemons (1.1.0)
+    em-http-request (0.2.12)
+      addressable (>= 2.0.0)
+      eventmachine (>= 0.12.9)
+    eventmachine (0.12.10)
+    http_router (0.5.0)
+      rack (>= 1.0.0)
+      url_mount (~> 0.2.1)
+    method-args (0.1.0)
+      ruby2ruby (~> 1.2.4)
+      ruby_parser (~> 2.0)
+      sexp_processor (~> 3.0.4)
+    minitest (2.0.2)
+    rack (1.2.1)
+    rake (0.8.7)
+    ruby2ruby (1.2.5)
+      ruby_parser (~> 2.0)
+      sexp_processor (~> 3.0)
+    ruby_parser (2.0.5)
+      sexp_processor (~> 3.0)
+    sexp_processor (3.0.5)
+    thin (1.2.7)
+      daemons (>= 1.0.9)
+      eventmachine (>= 0.12.6)
+      rack (>= 1.0.0)
+    url_mount (0.2.1)
+      rack
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  callsite
+  em-http-request
+  http_router
+  method-args
+  minitest (~> 2.0.0)
+  rack
+  rake
+  thin

data/README.markdown

@@ -0,0 +1,34 @@
+# Apiary
+
+Stand up simple APIs for consumption.
+
+## Usage
+
+Apiary let's you use any existing class and turn it into an API. For instance, say you have a class like this.
+
+    class Temperature
+      def c2f(val)
+        Float(val) * 9 / 5 + 32
+      end
+    end
+    
+You can convert this to an API by annotating this class with three lines.
+
+    class Temperature
+      include Apiary              # Include Apiary as a module in your class
+
+      version '1.0'               # Specifies a version prefix for your api
+
+      get                         # Marks this method as accessible from GET
+      def c2f(val)                # This is now available at /1.0/c2f/:val
+        Float(val) * 9 / 5 + 32
+      end
+    end
+
+Now, your API is complete! You can run this with `Temperature.run`. This will create a server on port 3000. You can hit it with
+
+    curl http://localhost:3000/1.0/c2f/23.45
+
+And you'll get back
+
+    74.21

data/Rakefile

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'bundler'
+
+desc "Run tests"
+task :test do
+  $: << 'lib'
+  require 'apiary'
+  require 'test/helper'
+  Dir['test/**/test_*.rb'].each { |test| require test }
+end
+
+require 'rake/rdoctask'
+desc "Generate documentation"
+Rake::RDocTask.new do |rd|
+  rd.main = "README.markdown"
+  rd.rdoc_files.include("README.markdown", "lib/**/*.rb")
+  rd.rdoc_dir = 'rdoc'
+end
+
+Bundler::GemHelper.install_tasks

data/apiary.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "apiary/version"
+
+Gem::Specification.new do |s|
+  s.name        = "apiary"
+  s.version     = Apiary::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Joshua Hull"]
+  s.email       = ["joshbuddy@gmail.com"]
+  s.homepage    = "https://github.com/joshbuddy/apiary"
+  s.summary     = %q{Convert your existing class into an EM-based API}
+  s.description = %q{Convert your existing class into an EM-based API.}
+
+  s.rubyforge_project = "apiary"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/apiary.rb

@@ -0,0 +1,74 @@
+require 'method_args'
+require 'callsite'
+require 'http_router'
+require 'thin'
+require 'rack'
+require 'apiary/version'
+
+module Apiary
+  ApiMethod = Struct.new(:method, :http_method, :path)
+  
+  module ClassMethods
+
+    def get(path = nil)
+      __set_routing(:get, path)
+    end
+
+    def post(path = nil)
+      __set_routing(:get, path)
+    end
+
+    def version(number)
+      @version = number
+    end
+
+    def __set_routing(method, path)
+      @http_method, @path = method, path
+    end
+
+    def method_added(m)
+      if @http_method
+        MethodArgs.register(Callsite.parse(caller.first).filename)
+        @cmds ||= []
+        @cmds << ApiMethod.new(m, @http_method, @path)
+        @http_method = nil
+        @path = nil
+      end
+    end
+
+    def default_path(m)
+      instance_method(m).args.inject(m.to_s) do |path, arg|
+        path << case arg.type
+        when :required then "/:#{arg.name}"
+        when :optional then "/(:#{arg.name})"
+        when :splat    then "/*#{arg.name}"
+        end
+      end
+    end
+
+    def __as_app(&blk)
+      router = HttpRouter.new
+      @cmds.each do |cmd|
+        path = "#{@version}/#{cmd.path || default_path(cmd.method)}".squeeze('/')
+        route = router.add(path)
+        route.send(cmd.http_method) if cmd.http_method
+        route.to { |env| 
+          Rack::Response.new((blk ? blk.call : new).send(cmd.method, *env['router.response'].param_values).to_s).finish
+        }
+      end
+      router
+    end
+
+    def run(port = 3000, &blk)
+      api = self
+      raise "No version specified" unless @version
+      Thin::Server.new('0.0.0.0', port) {
+        run api.__as_app(&blk)
+      }.start
+    end
+  end
+
+  def self.included(cls)
+    cls.instance_eval "class << self; include ClassMethods; end"
+  end
+end

data/lib/apiary/version.rb

@@ -0,0 +1,3 @@
+module Apiary
+  VERSION = '0.0.1'
+end

data/test/fixtures/basic.rb

@@ -0,0 +1,19 @@
+class Basic
+  include Apiary
+
+  version '1.0'
+
+  def initialize(var = nil)
+    @var = var
+  end
+
+  get
+  def ping
+    'ping'
+  end
+
+  get
+  def var
+    @var
+  end
+end

data/test/helper.rb

@@ -0,0 +1,23 @@
+require 'minitest/autorun'
+require 'em-http'
+require 'test/fixtures/basic'
+
+class MiniTest::Unit::TestCase
+  def run_with(cls, optional_blk = nil, &blk)
+    EM.run do
+      optional_blk ? cls.run(&optional_blk) : cls.run
+      EM.add_timer(0.5) { assert false, "Stopped EM server because you didn't call done, or reach your done"; EM.stop }
+      EM.next_tick(&blk)
+    end
+  end
+
+  def request(path, method = :get, opts = {}, &blk)
+    raise "you need to be running inside a request" unless EM.reactor_running?
+    http = EventMachine::HttpRequest.new("http://127.0.0.1:3000#{path}").__send__(method, opts)
+    http.callback { EM.next_tick { blk.call(http) } }
+  end
+
+  def done
+    EM.stop
+  end
+end

data/test/test_basic.rb

@@ -0,0 +1,30 @@
+class TestBasic < MiniTest::Unit::TestCase
+  def test_simple
+    run_with(Basic) do
+      request('/1.0/ping') do |http|
+        assert_equal 200, http.response_header.status
+        assert_equal 'ping', http.response
+        done
+      end
+    end
+  end
+
+  def test_not_found
+    run_with(Basic) do
+      request('/1.0/something_else') do |http|
+        assert_equal 404, http.response_header.status
+        done
+      end
+    end
+  end
+
+  def test_custom_initializer
+    run_with(Basic, proc{ Basic.new('hi there')}) do
+      request('/1.0/var') do |http|
+        assert_equal 200, http.response_header.status
+        assert_equal 'hi there', http.response
+        done
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: apiary
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Joshua Hull
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-16 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Convert your existing class into an EM-based API.
+email: 
+- joshbuddy@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.markdown
+- Rakefile
+- apiary.gemspec
+- lib/apiary.rb
+- lib/apiary/version.rb
+- test/fixtures/basic.rb
+- test/helper.rb
+- test/test_basic.rb
+has_rdoc: true
+homepage: https://github.com/joshbuddy/apiary
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+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: apiary
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Convert your existing class into an EM-based API
+test_files: 
+- test/fixtures/basic.rb
+- test/helper.rb
+- test/test_basic.rb