apical 0.1.4

data/examples/taco_truck/app.rb

@@ -0,0 +1,13 @@
+require 'sinatra'
+require 'json'
+
+get '/tacos.json' do
+  [
+    { meat: 'chicken', lettuce: true, tomatoes: true }
+  ]
+end
+
+post '/taco.json' do
+  JSON.generate(params)
+end
+

data/examples/taco_truck/taco_truck.apical

@@ -0,0 +1,18 @@
+require 'app'
+
+adapter :rack, app: Sinatra::Application
+name "Taco Truck"
+desc "Get some tacos, post some tacos!"
+
+accept :json
+content_type :json
+
+get "/tacos.json" do
+  desc "Get all your tacos"
+end
+
+post "/tacos.json" do
+  desc "Make a new taco!"
+  params { { meat: 'beef', lettuce: true } }
+end
+

data/lib/apical.rb

@@ -0,0 +1,30 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '.'))
+
+require 'thor'
+require 'mustache'
+require 'json'
+require 'kramdown'
+
+require 'apical/content_types'
+require 'apical/writers/console_writer'
+require 'apical/writers/html_writer'
+require 'apical/adapter'
+require 'apical/adapters/rack_adapter'
+require 'apical/adapters/http_adapter'
+require 'apical/resource'
+require 'apical/runner'
+require 'apical/resource'
+require 'apical/resource_types'
+require 'apical/cli'
+
+module Apical
+  VERSION = "0.1.0"
+
+  class << self
+    def new(&block)
+      Runner.new(&block)
+    end
+  end
+
+end
+

data/lib/apical/adapter.rb

@@ -0,0 +1,21 @@
+module Apical
+  
+  class Adapter
+
+    def self.[](identifier)
+      @@registry ||= {}
+      klass = @@registry[identifier]
+      raise "Adapter '#{identifier}' does not exist." unless klass
+
+      klass
+    end
+
+    def self.identifier(identifier)
+      @@registry ||= {}
+      @@registry[identifier] = self
+    end
+
+  end
+
+end
+

data/lib/apical/adapters/http_adapter.rb

@@ -0,0 +1,30 @@
+require 'httparty'
+
+module Apical
+
+  class HttpAdapter < Adapter
+    identifier :http
+    include HTTParty
+
+    def initialize(options={})
+      self.class.base_uri options[:base_uri]
+      @headers = {}
+    end
+
+    def header(name, value)
+      @headers[name] = value
+    end
+
+    def clear_headers!
+      @headers = {}
+    end
+
+    def method_missing(name, *args)
+      self.class.headers(@headers) unless @headers.empty?
+      response = self.class.send(name, *args)
+      clear_headers!
+      return response
+    end
+  end
+  
+end

data/lib/apical/adapters/rack_adapter.rb

@@ -0,0 +1,16 @@
+require 'rack/test'
+
+module Apical
+
+  class RackAdapter < Adapter
+    identifier :rack
+    include Rack::Test::Methods
+
+    def initialize(options={})
+      @app = options[:app] 
+    end
+
+    attr_reader :app
+  end
+
+end

data/lib/apical/cli.rb

@@ -0,0 +1,36 @@
+module Apical
+  class CLI < Thor
+    map '-v' => :version
+
+    desc "version", "print version information"
+    def version
+      puts Apical::VERSION
+    end
+
+    desc "compile", "compile the given input files"
+    method_option :output_path, aliases: '-o', desc: "Path to output file"
+    method_option :format, aliases: '-f', desc: "Format (either 'html' or 'text')"
+    def compile(*files)
+      files.each do |file|
+        $:.unshift File.dirname(file)
+        block = eval("Proc.new { #{File.read(file)} }")
+        doc = Apical.new(&block)
+
+        output = if options[:output_path]
+                   File.open(options[:output_path], 'w')
+                 else
+                   $stdout
+                 end
+
+
+        case options[:format]
+        when 'html'
+          HtmlWriter.new(doc).write(output)
+        else
+          ConsoleWriter.new(doc).write(output)
+        end
+      end
+    end
+  end
+end
+

data/lib/apical/content_types.rb

@@ -0,0 +1,62 @@
+module Apical
+
+  class ContentType
+
+    def self.[](format)
+      @@registry ||= {}
+      klass = @@registry[format]
+      raise "Content type '#{format}' does not exist." unless klass
+
+      klass.new
+    end
+
+    def self.format(format)
+      @format = format
+      @@registry ||= {}
+      @@registry[format] = self
+    end
+
+  end
+
+  class JsonContentType < ContentType
+    format :json
+
+    def header
+      'application/json'
+    end
+
+    def generate(obj)
+      JSON.pretty_generate(obj)
+    end
+
+    def parse(str)
+      JSON.parse(str)
+    end
+
+    def to_s
+      'json'
+    end
+  end
+
+  # TODO: Actually encode/decode urlencoded params
+  class FormContentType < ContentType
+    format :form
+
+    def header
+      'application/x-www-form-urlencoded'
+    end
+
+    def generate(str)
+      str
+    end
+
+    def parse(obj)
+      obj
+    end
+
+    def to_s
+      'form'
+    end
+  end
+end
+

data/lib/apical/resource.rb

@@ -0,0 +1,138 @@
+module Apical
+  class Resource
+    extend Forwardable
+
+    def initialize(runner, path, &block)
+      @runner = runner
+      @path = path
+      @params = nil
+      @before_blocks = []
+      @after_blocks = []
+      @custom_headers = {}
+      Blueprint.new self, &block
+    end
+
+    attr_accessor :path, :method, :params, :desc, :before_blocks, :after_blocks, :custom_headers
+    attr_writer :accept, :content_type
+
+    def_delegator :@runner, :adapter
+    def_delegators :adapter, :get, :put, :post, :delete, :options, :header
+
+    class Blueprint
+      def initialize(resource, &block)
+        @resource = resource
+        instance_eval &block
+      end
+
+      def desc(val)
+        @resource.desc = val
+      end
+
+      def accept(format)
+        @resource.accept = ContentType[format]
+      end
+
+      def content_type(format)
+        @resource.content_type = ContentType[format]
+      end
+
+      def header(name, value)
+        @resource.custom_headers[name] = value
+      end
+
+      def auth_header(token)
+        header 'Authorization', token
+      end
+
+      def params(&block)
+        @resource.params = block
+      end
+
+      def before(&block)
+        @resource.before_blocks << block
+      end
+
+      def after(&block)
+        @resource.after_blocks << block
+      end
+    end
+
+    def content_type
+      @content_type || @runner.content_type
+    end
+
+    def accept
+      @accept || @runner.accept
+    end
+
+    def auth_header
+      @auth_header || @runner.auth_header
+    end
+
+    def content_type_header
+      content_type.header
+    end
+
+    def accept_header
+      accept.header
+    end
+
+    def run
+      @before_blocks.each {|block| instance_eval &block }
+      @params = instance_eval(&@params) if @params.is_a?(Proc)
+      @response = make_request
+      @after_blocks.each {|block| instance_eval &block }
+    end
+
+    def filtered_params
+      params.reject {|k, v| path_captures.include?(k) or path_captures.include?(k.to_s)}
+    end
+
+    def formatted_params
+      return {} unless params
+      return filtered_params unless accept
+      accept.generate(filtered_params)
+    end
+
+    def formatted_response
+      return response_body unless content_type
+      content_type.generate(content_type.parse(response_body))
+    end
+
+    def response_body
+      @response.body
+    end
+
+    PATH_CAPTURE_REGEXP = /:[^\.\/]+/
+
+    def path_captures
+      @path.match(PATH_CAPTURE_REGEXP).to_a.map {|m| m.gsub(':', '').intern }
+    end
+
+    def interpolated_path
+      @path.gsub(PATH_CAPTURE_REGEXP) do |match|
+        params[match.gsub(':', '').intern]
+      end
+    end
+
+    def call_if_proc(proc_or_obj)
+      proc_or_obj.is_a?(Proc) ? instance_eval(&proc_or_obj) : proc_or_obj
+    end
+
+    def custom_header(name)
+      call_if_proc @custom_headers[name]
+    end
+
+    def make_request
+      @custom_headers.each do |name, value|
+        adapter.header name, custom_header(name)
+      end
+
+      adapter.header "Accept", accept_header              if accept_header
+      adapter.header "Content-Type", content_type_header  if content_type_header
+
+      adapter.send(@method.downcase.intern, interpolated_path, formatted_params)
+    end
+
+  end
+end

data/lib/apical/resource_types.rb

@@ -0,0 +1,36 @@
+module Apical
+  class PostResource < Resource
+    def initialize(runner, path, &block)
+      super runner, path, &block
+      @method = 'POST'
+    end
+  end
+
+  class GetResource < Resource
+    def initialize(runner, path, &block)
+      super runner, path, &block
+      @method = 'GET'
+    end
+  end
+
+  class PutResource < Resource
+    def initialize(runner, path, &block)
+      super runner, path, &block
+      @method = 'PUT'
+    end
+  end
+
+  class DeleteResource < Resource
+    def initialize(runner, path, &block)
+      super runner, path, &block
+      @method = 'DELETE'
+    end
+  end
+
+  class OptionsResource < Resource
+    def initialize(runner, path, &block)
+      super runner, path, &block
+      @method = 'OPTIONS'
+    end
+  end
+end

data/lib/apical/runner.rb

@@ -0,0 +1,104 @@
+module Apical
+  class Runner
+    def initialize(&block)
+      @resources          = []
+      @name               = "apical"
+      @desc               = ""
+      @accept             = ContentType[:form]
+      @content_type       = ContentType[:form]
+      @before_each_blocks = []
+      @before_all_blocks  = []
+      @after_each_blocks  = []
+      @after_all_blocks   = []
+      Blueprint.new self, &block
+    end
+
+    include Rack::Test::Methods
+
+    attr_accessor :resources, :accept, :name, :desc, :app, :content_type, :auth_header, :before_each_blocks, :before_all_blocks, :after_each_blocks, :after_all_blocks, :adapter
+
+    class Blueprint
+      def initialize(runner, &block)
+        @runner = runner
+        instance_eval &block
+      end
+
+      def adapter(identifier, options={})
+        @runner.adapter = Adapter[identifier].new(options)
+      end
+      
+      def accept(format)
+        @runner.accept = ContentType[format]
+      end
+
+      def content_type(format)
+        @runner.content_type = ContentType[format]
+      end
+
+      def auth_header(token)
+        @runner.auth_header = token
+      end
+
+      def name(name)
+        @runner.name = name
+      end
+      
+      def desc(desc)
+        @runner.desc = desc
+      end
+
+      def app(app)
+        @runner.app = app
+      end
+
+      def before(type=:each, &block)
+        case type
+        when :each
+          @runner.before_each_blocks << block
+        when :all
+          @runner.before_all_blocks << block
+        end
+      end
+
+      def after(type=:each, &block)
+        case type
+        when :each
+          @runner.after_each_blocks << block
+        when :all
+          @runner.after_all_blocks << block
+        end
+      end
+
+      def get(path, &block)
+        @runner.resources << GetResource.new(@runner, path, &block)
+      end
+
+      def post(path, &block)
+        @runner.resources << PostResource.new(@runner, path, &block)
+      end
+
+      def put(path, &block)
+        @runner.resources << PutResource.new(@runner, path, &block)
+      end
+
+      def delete(path, &block)
+        @runner.resources << DeleteResource.new(@runner, path, &block)
+      end
+
+      def options(path, &block)
+        @runner.resources << OptionsResource.new(@runner, path, &block)
+      end
+    end
+
+    def run
+      @before_all_blocks.each {|block| instance_eval &block }
+      @resources.each do |resource|
+        @before_each_blocks.each {|block| resource.instance_eval &block }
+        resource.run
+        @after_each_blocks.each {|block| resource.instance_eval &block }
+      end
+      @after_all_blocks.each {|block| instance_eval &block }
+      self
+    end
+  end
+end