siresta 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9217dfe568d7730704e4e45843b624407d854749
+  data.tar.gz: 5f9e29a33a17aa6ea78a085b5d3aa27e64ef5cad
+SHA512:
+  metadata.gz: 362d5b662cdedb546d5df3a9601b0339139ad9900fc2bd8d67a003bcba464f17d9f9a342bb466c0a440449a281191550d289809b77cf3d87715f195acf8889c2
+  data.tar.gz: 70d5e0b4ecca360daf376dd9adcece4d0bae1dda08299a975ec0164ef1af0722ae4a2e87f55ef5ec92c51d1e87666b817d3e2bc2d18d27e4804ba120c04154e9

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown

data/README.md

@@ -0,0 +1,144 @@
+[]: {{{1
+
+    File        : README.md
+    Maintainer  : Felix C. Stegerman <flx@obfusk.net>
+    Date        : 2014-06-18
+
+    Copyright   : Copyright (C) 2014  Felix C. Stegerman
+    Version     : v0.0.2
+
+[]: }}}1
+
+[![Gem Version](https://badge.fury.io/rb/siresta.png)](https://badge.fury.io/rb/siresta)
+
+## Description
+[]: {{{1
+
+  siRESTa - declarative REST APIs
+
+  siRESTa is a DSL for declarative REST APIs.  It can generate a ruby
+  API (w/ sinatra [1]) and Client (w/ excon [2]) for you, based on a
+  YAML file.  Processing requests is done using a monad.
+
+  More documentation is underway.  For now, see `example/` and
+  `features/`.
+
+  ...
+
+[]: }}}1
+
+## Examples
+[]: {{{1
+
+  ```yaml
+  name:     FooBarBaz
+  version:  v1
+  request_formats:  [json, xml]
+  response_formats: [json, xml]
+  api:
+  - resource: foos
+    contains:
+    - desc: Gets foos
+      get:  get_foos
+    - post: create_foo
+    - resource: :foo_id
+      contains:
+      - desc:   Get a foo
+        get:    get_foo
+      - put:    create_foo
+      - delete: delete_foo
+      - resource: bars
+        contains:
+        - get: get_bars
+        # ...
+  - resource: baz
+    contains:
+    - get: get_baz
+    # ...
+  ```
+
+  ```ruby
+  require 'siresta'
+  API = Siresta.api file: 'config/api.yml'
+  class API
+    data :foos, []
+
+    handle :get_foos do |m, h, p, b|
+      m.get_data(:foos) { |foos| m.ok foos }
+    end
+
+    # ...
+  end
+  API.run!
+  ```
+
+  ```
+  GET     /foos
+  POST    /foos
+  GET     /foos/:foo_id
+  PUT     /foos/:foo_id
+  DELETE  /foos/:foo_id
+  GET     /foos/:foo_id/bars
+  GET     /baz
+  ...
+  ```
+
+  ```ruby
+  require 'siresta'
+  Client = Siresta.client
+  c = Client.new 'http://localhost:4567'
+
+  c.foos.get
+  c.foos.post headers: { 'Content-Type' => 'foo/bar' }
+  c.foos[some_foo_id].get query: { foo: 'bar' }
+  c.foos[some_foo_id].put
+  c.foos[some_foo_id].delete
+  c.foos[some_foo_id].bars.get
+  c.baz.get
+  ```
+
+  ```ruby
+  require 'siresta'
+  Siresta.routes
+  # => [["GET",     "/foos",              "Gets foos" ],
+  #     ["POST",    "/foos",              nil         ],
+  #     ["GET",     "/foos/:foo_id",      "Get a foo" ],
+  #     ["PUT",     "/foos/:foo_id",      nil         ],
+  #     ["DELETE",  "/foos/:foo_id",      nil         ],
+  #     ["GET",     "/foos/:foo_id/bars", nil         ],
+  #     ["GET",     "/baz",               nil         ]]
+  ```
+
+[]: }}}1
+
+## Specs & Docs
+
+```bash
+$ rake cuke
+$ rake docs
+```
+
+## TODO
+
+  * finish monad, api
+  * specs
+  * docs
+  * authorization?
+  * authentication?
+
+## License
+
+  LGPLv3+ [3].
+
+## References
+
+  [1] Sinatra
+  --- http://www.sinatrarb.com
+
+  [2] Excon
+  --- https://github.com/excon/excon
+
+  [3] GNU Lesser General Public License, version 3
+  --- http://www.gnu.org/licenses/lgpl-3.0.html
+
+[]: ! ( vim: set tw=70 sw=2 sts=2 et fdm=marker : )

data/Rakefile

@@ -0,0 +1,63 @@
+cuke = ENV['CUKE']
+
+desc 'Run cucumber'
+task :cuke do
+  sh "cucumber -fprogress #{cuke}"
+end
+
+desc 'Run cucumber strictly'
+task 'cuke:strict' do
+  sh "cucumber -fprogress -S #{cuke}"
+end
+
+desc 'Run cucumber verbosely'
+task 'cuke:verbose' do
+  sh "cucumber #{cuke}"
+end
+
+desc 'Run cucumber verbosely, view w/ less'
+task 'cuke:less' do
+  sh "cucumber -c #{cuke} | less -R"
+end
+
+desc 'Cucumber step defs'
+task 'cuke:steps' do
+  sh 'cucumber -c -fstepdefs | less -R'
+end
+
+
+desc 'Check for warnings'
+task :warn do
+  sh 'ruby -w -I lib -r siresta -e ""'  # TODO
+end
+
+
+desc 'Generate docs'
+task :docs do
+  sh 'yardoc | cat'
+end
+
+desc 'List undocumented objects'
+task 'docs:undoc' do
+  sh 'yard stats --list-undoc'
+end
+
+
+desc 'Cleanup'
+task :clean do
+  sh 'rm -rf .yardoc/ doc/ *.gem examples/*/db/*.sqlite3'
+end
+
+
+desc 'Build SNAPSHOT gem'
+task :snapshot do
+  v = Time.new.strftime '%Y%m%d%H%M%S'
+  f = 'lib/siresta/version.rb'
+  sh "sed -ri~ 's!(SNAPSHOT)!\\1.#{v}!' #{f}"
+  sh 'gem build siresta.gemspec'
+end
+
+desc 'Undo SNAPSHOT gem'
+task 'snapshot:undo' do
+  sh 'git checkout -- lib/siresta/version.rb'
+end

data/lib/siresta.rb

@@ -0,0 +1,5 @@
+require 'siresta/api'
+require 'siresta/client'
+require 'siresta/env'
+require 'siresta/routes'
+require 'siresta/version'

data/lib/siresta/api.rb

@@ -0,0 +1,190 @@
+# --                                                            ; {{{1
+#
+# File        : siresta/api.rb
+# Maintainer  : Felix C. Stegerman <flx@obfusk.net>
+# Date        : 2014-06-17
+#
+# Copyright   : Copyright (C) 2014  Felix C. Stegerman
+# Licence     : LGPLv3+
+#
+# --                                                            ; }}}1
+
+require 'json'
+require 'obfusk/atom'
+require 'sinatra/base'
+require 'siresta/response'
+require 'siresta/spec'
+
+module Siresta
+  module API
+    # handle request for generated route
+    def _handle_request(meth, path, formats, pipe, handler)
+      b   = method handler
+      r   = Response
+      fs  = []  # TODO
+
+      fs << r.choose_request_format(handler, formats) \
+        unless formats[:request].empty?
+      fs << r.get
+      fs << -> s { b[r, s.request.headers, s.request.params, s.request.body] }
+      fs << r.choose_response_format(handler, formats) \
+        unless formats[:response].empty?
+
+      x   = r.pipeline(r.return(nil), *fs)
+      s   = x.exec _begin_state
+
+      # TODO
+      if s.status.is_a? r::ResponseError
+        [500, s.status.message]
+      elsif s.response.data.is_a? r::ResponseBody
+        [s.response.status, s.response.headers, s.response.data.data]
+      else
+        raise 'OOPS'  # TODO
+      end
+    end
+
+    # begin state for Response monad
+    def _begin_state
+      r = Response
+      r.ResponseState(
+        r.RequestData(
+          {}, # TODO: headers
+          request.body.read, params
+        ),
+        r.ResponseInfo(nil, {}, r.ResponseEmpty()),
+        r.ResponseContinue(), self
+      )
+    end
+
+    # preferred formats
+    def preferred_formats(formats)
+      @preferred_formats ||= {}
+      return @preferred_formats[formats] if @preferred_formats[formats]
+      fmts  = formats[:request] | formats[:response]
+      m2f   = Hash[fmts.map { |x| [mime_type(x), x] }]
+      f_in  = m2f[request.content_type] || formats[:request].first
+      f_out = m2f[request.preferred_type m2f.keys]
+      @preferred_formats[formats] = [f_in, f_out]
+    end
+
+    # convert from preferred format
+    def convert_from(handler, formats, body)
+      f_in, f_out = preferred_formats formats
+      ss          = settings.siresta[:convert_from][f_in] || {}
+      f           = ss[handler] || ss[:__all__]
+      f ? f[body] : raise('OOPS')   # TODO
+    end
+
+    # convert to preferred format
+    def convert_to(handler, formats, body)
+      f_in, f_out = preferred_formats formats
+      ss          = settings.siresta[:convert_to][f_out] || {}
+      f           = ss[handler] || ss[:__all__]
+      f ? f[body] : raise('OOPS')   # TODO
+    end
+
+    # atoms
+    def data
+      settings.siresta[:data]
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      # generate route
+      def _gen_route(meth, path, formats, pipe, handler)
+        send(meth, path) do
+          _handle_request meth, path, formats, pipe, handler
+        end
+      end
+
+      # named handler
+      def handle(name, &b)
+        define_method name, &b
+      end
+
+      # declare data (atom)
+      def data(k, v)
+        settings.siresta[:data][k] = Obfusk.atom v
+      end
+
+      # handle authorization
+      def to_authorize(handler, &b)
+        settings.siresta[:authorize][handler] = b
+      end
+
+      # convert body from format
+      def to_convert_from(format, handler = :__all__, &b)
+        (settings.siresta[:convert_from][format] ||= {})[handler] = b
+      end
+
+      # convert params
+      def to_convert_params(handler, &b)
+        settings.siresta[:convert_params][handler] = b
+      end
+
+      # convert body to format
+      def to_convert_to(format, handler = :__all__, &b)
+        (settings.siresta[:convert_to][format] ||= {})[handler] = b
+      end
+
+      # validate body
+      def to_validate_body(handler, &b)
+        settings.siresta[:validate_body][handler] = b
+      end
+
+      # validate params
+      def to_validate_params(handler, &b)
+        settings.siresta[:validate_params][handler] = b
+      end
+    end
+  end
+
+  class ApiBase < Sinatra::Base
+    include Siresta::API
+
+    set :siresta, { data: {}, authorize: {}, convert_from: {},
+                    convert_params: {}, convert_to: {},
+                    validate_body: {}, validate_params: {} }
+
+    to_convert_from :json do |body|
+      body.empty? ? nil : JSON.parse(body)
+    end
+
+    to_convert_to :json do |data|
+      data.to_json
+    end
+  end
+
+  # generate an API (Sinatra::Base subclass) based on a YAML
+  # description
+  def self.api(opts = {})
+    api = Class.new ApiBase
+    Spec.walk api_spec(opts), {
+      root: -> (info) {
+        api.class_eval do
+          enable :sessions if info[:sessions]   # TODO
+          set :name   , info[:name]
+          set :version, info[:version]
+        end
+        api
+      },
+      resource: -> (info) {
+        api.class_eval do
+          info[:methods].each do |m|
+            formats = info[:specs][m][:formats]
+            symfmts = Hash[formats.map { |k,v| [k,v.map(&:to_sym)] }]
+            _gen_route m.to_sym, info[:path], symfmts,
+              info[:specs][m]['pipeline'], info[:specs][m][m].to_sym
+          end
+        end
+        nil
+      },
+      subresource: -> (_) {}, parametrized_subresource: -> (_) {},
+    }
+  end
+end
+
+# vim: set tw=70 sw=2 sts=2 et fdm=marker :

data/lib/siresta/client.rb

@@ -0,0 +1,71 @@
+# --                                                            ; {{{1
+#
+# File        : siresta/client.rb
+# Maintainer  : Felix C. Stegerman <flx@obfusk.net>
+# Date        : 2014-06-17
+#
+# Copyright   : Copyright (C) 2014  Felix C. Stegerman
+# Licence     : LGPLv3+
+#
+# --                                                            ; }}}1
+
+require 'excon'
+require 'siresta/spec'
+
+module Siresta
+  module Client
+    # (sub)resource: wraps url, gets extendes as-needed w/ `.post`,
+    # `.get`, `.put`, `.delete`, `.some_resource`, `[some_param]` etc.
+    # Route methods take the same arguments as Excon's.
+    class Resource
+      attr_reader :url
+      def initialize(url, *path)
+        @url = ([url]+path)*'/'
+      end
+    end
+  end
+
+  # generate a client (Excon wrapper) based on a YAML description
+  def self.client(opts = {})
+    opts_       = opts.dup
+    http_client = opts_.delete(:http_client) || Excon
+    Spec.walk api_spec(opts_), {
+      root: -> (info) {
+        info[:res].class_eval do
+          define_method(:name)    { info[:name]     }
+          define_method(:version) { info[:version]  }
+        end
+        info[:res]
+      },
+      resource: -> (info) {
+        res = Class.new Client::Resource
+        res.class_eval do
+          info[:methods].map(&:to_sym).each do |m|
+            # resource.{get,post,put,delete}
+            define_method(m) do |*params, &b|
+              # TODO: quoting
+              http_client.send m, url, *params, &b
+            end
+          end
+        end
+        res
+      },
+      subresource: -> (info) {
+        info[:res].class_eval do
+          # resource.some_route
+          define_method(info[:route].to_sym) do
+            info[:sub].new url, info[:route]
+          end
+        end
+      },
+      parametrized_subresource: -> (info) {
+        info[:res].class_eval do
+          # resource[some_param]
+          define_method(:[]) { |param| info[:sub].new url, param }
+        end
+      },
+    }
+  end
+end
+
+# vim: set tw=70 sw=2 sts=2 et fdm=marker :

data/lib/siresta/env.rb

@@ -0,0 +1,6 @@
+module Siresta
+  # environment
+  def self.env
+    ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
+  end
+end

data/lib/siresta/response.rb

@@ -0,0 +1,176 @@
+# --                                                            ; {{{1
+#
+# File        : siresta/response.rb
+# Maintainer  : Felix C. Stegerman <flx@obfusk.net>
+# Date        : 2014-06-17
+#
+# Copyright   : Copyright (C) 2014  Felix C. Stegerman
+# Licence     : LGPLv3+
+#
+# --                                                            ; }}}1
+
+require 'obfusk/adt'
+require 'obfusk/monads'
+
+module Siresta
+  class Response < Obfusk::Monads::State
+    class ResponseState
+      include Obfusk::ADT
+      constructor :ResponseState,
+        :request, :response, :status, :api_obj
+    end
+
+    class RequestData
+      include Obfusk::ADT
+      constructor :RequestData, :headers, :body, :params # ...
+    end
+
+    class ResponseInfo
+      include Obfusk::ADT
+      constructor :ResponseInfo, :status, :headers, :data
+    end
+
+    class ResponseData
+      include Obfusk::ADT
+      constructor :ResponseEmpty
+      constructor :ResponseBody,    :data
+      constructor :ResponseStream,  :handle
+    end
+
+    class ResponseStatus
+      include Obfusk::ADT
+      constructor :ResponseContinue
+      constructor :ResponseDone
+      constructor :ResponseError, :message
+    end
+
+    [ ResponseState, RequestData, ResponseInfo ] \
+      .each { |x| x.import_constructors self, false }
+
+    [ ResponseData, ResponseStatus ] \
+      .each { |x| x.import_constructors self }
+
+    # -- constructor helpers --
+
+    # add error to state
+    def self._error(s, msg)
+      s.clone(status: ResponseError(msg))
+    end
+
+    # call block with state if error (to short-circuit)
+    def self._on_error(s, &b)
+      b[s] if s.status.is_a? ResponseError
+    end
+
+    # call block with error state if done
+    def self._on_done(s, &b)
+      b[_error(s, 'cannot continue when done')] \
+        if s.status.is_a? ResponseDone
+    end
+
+    # call block with error state if empty
+    def self._on_empty(s, &b)
+      b[_error(s, 'cannot use empty body')] \
+        if s.response.data.is_a? ResponseEmpty
+    end
+
+    # call block with error state if stream
+    def self._on_stream(s, &b)
+      b[_error(s, 'cannot use body response')] \
+        if s.response.data.is_a? ResponseStream
+    end
+
+    # -- constructors --
+
+    # everything ok
+    def self.ok(body, headers = {}, status = 200)
+      modify -> s {
+        _on_error(s)  { |t| return t }
+        _on_done(s)   { |t| return t }
+        _on_stream(s) { |t| return t }
+        s.clone(
+          response: s.response.clone(
+            status: status, headers: s.response.headers.merge(headers),
+            data: ResponseBody(body)
+          ),
+          status: ResponseContinue()
+        )
+      }
+    end
+
+    # everyting ok, stream data
+    def self.stream(data, headers = {}, status = 200)
+      # TODO
+    end
+
+    # everything ok, stream data (keep open)
+    def self.stream_keep_open
+      # TODO
+    end
+
+    # error!
+    def self.error(msg)
+      modify { |s| _error s, msg }
+    end
+
+    # ...
+
+    # -- helpers --
+
+    # get atom data
+    def self.get_data(k, &b)
+      x = get >> -> s { mreturn s.api_obj.data[k]._ }; b ? x >> b : x
+    end
+
+    # set atom data
+    def self.set_data(k, v)
+      get >> -> s { s.api_obj.data[k].swap! { |_| v }; mreturn nil }
+    end
+
+    # authorization
+    def self.authorize(handler)
+      # TODO
+    end
+
+    # convert parameters
+    def self.convert_params(handler)
+      # TODO
+    end
+
+    # validate body
+    def self.validate_body(handler)
+      # TODO
+    end
+
+    # validate parameters
+    def self.validate_params(handler)
+      # TODO
+    end
+
+    # -- formats --
+
+    # convert request body from appropriate format
+    def self.choose_request_format(handler, formats)
+      modify -> s {
+        _on_error(s)  { |t| return t }
+        _on_done(s)   { |t| return t }
+        b = s.api_obj.convert_from(handler, formats, s.request.body)
+        s.clone(request: s.request.clone(body: b))
+      }
+    end
+
+    # convert response body to appropriate format
+    def self.choose_response_format(handler, formats)
+      modify -> s {
+        _on_error(s)  { |t| return t }
+        _on_done(s)   { |t| return t }
+        _on_empty(s)  { |t| return t }
+        _on_stream(s) { |t| return t }
+        b = s.api_obj.convert_to(handler, formats, s.response.data.data)
+        s.clone(response: s.response.clone(data: ResponseBody(b)))
+      }
+    end
+  end
+end
+
+# vim: set tw=70 sw=2 sts=2 et fdm=marker :

data/lib/siresta/routes.rb

@@ -0,0 +1,32 @@
+# --                                                            ; {{{1
+#
+# File        : siresta/routes.rb
+# Maintainer  : Felix C. Stegerman <flx@obfusk.net>
+# Date        : 2014-06-13
+#
+# Copyright   : Copyright (C) 2014  Felix C. Stegerman
+# Licence     : LGPLv3+
+#
+# --                                                            ; }}}1
+
+require 'siresta/spec'
+
+module Siresta
+  # get routes from YAML description
+  def self.routes(opts = {})
+    routes = []
+    Spec.walk api_spec(opts), {
+      resource: -> (info) {
+        info[:methods].each do |m|
+          routes << [m.upcase, info[:path], info[:specs][m]['desc']]
+        end
+        nil
+      },
+      root: -> (_) {}, subresource: -> (_) {},
+      parametrized_subresource: -> (_) {},
+    }
+    routes
+  end
+end
+
+# vim: set tw=70 sw=2 sts=2 et fdm=marker :

data/lib/siresta/spec.rb

@@ -0,0 +1,79 @@
+# --                                                            ; {{{1
+#
+# File        : siresta/spec.rb
+# Maintainer  : Felix C. Stegerman <flx@obfusk.net>
+# Date        : 2014-06-17
+#
+# Copyright   : Copyright (C) 2014  Felix C. Stegerman
+# Licence     : LGPLv3+
+#
+# --                                                            ; }}}1
+
+require 'yaml'
+
+module Siresta
+  DEFAULT_API_YAML = 'config/api.yml'
+
+  module Spec
+    METHODS = %w{ post get put delete }
+
+    # walk spec
+    def self.walk(spec, opts)
+      name      = spec['name']
+      version   = spec['version']
+      sessions  = spec['sessions']
+      formats   = { request:  spec['request_formats']   || [],
+                    response: spec['response_formats']  || [] }
+      res       = walk_resource spec['api'], '/', opts, formats
+      opts[:root][{
+        res: res, name: name, version: version, sessions: sessions
+      }]
+    end
+
+    # process resource when walking spec
+    def self.walk_resource(specs, path, opts, formats)
+      ms, ss = specs.inject([[],{}]) do |(ms,ss), spec|
+        chs = formats.merge({ request: spec['request_formats'],
+                              response: spec['response_formats'] }
+                            .reject { |k,v| !v })
+        (m = (METHODS & spec.keys).first) ?
+          [ms + [m], ss.merge(m => spec.merge(formats: chs))] : [ms,ss]
+      end
+      opts[:resource][{ methods: ms, specs: ss, path: path }] \
+        .tap { |res| walk_subresources res, specs, path, opts, formats }
+    end
+
+    # process subresources when walking spec
+    def self.walk_subresources(res, specs, path, opts, formats)
+      specs.each do |spec|
+        if (r = spec['resource'])
+          r_s = (p = Symbol === r) ? ":#{r}" : r
+          chs = formats.merge({ request: spec['request_formats'],
+                                response: spec['response_formats'] }
+                              .reject { |k,v| !v })
+          pth = (path == '/' ? '' : path) + '/' + r_s
+          sub = walk_resource spec['contains'], pth, opts, chs
+          opts[p ? :parametrized_subresource : :subresource][
+            { res: res, sub: sub, parametrized: p, route: r,
+              route_s: r_s, path: path }
+          ]
+        end
+      end
+    end
+  end
+
+  # get (cached) API spec
+  # @param [Hash] opts            options
+  # @option opts [String] :data   YAML data, or:
+  # @option opts [String] :file   file name
+  def self.api_spec(opts = {})
+    if opts[:data]
+      YAML.load opts[:data]
+    else
+      file = opts[:file] || DEFAULT_API_YAML
+      (@api_spec ||= {})[file] ||= api_spec data: File.read(file)
+    end
+  end
+end
+
+# vim: set tw=70 sw=2 sts=2 et fdm=marker :

data/lib/siresta/version.rb

@@ -0,0 +1,4 @@
+module Siresta
+  VERSION = '0.0.2'
+  DATE    = '2014-06-18'
+end

data/lib/siresta/xml.rb

@@ -0,0 +1,72 @@
+# --                                                            ; {{{1
+#
+# File        : siresta/xml.rb
+# Maintainer  : Felix C. Stegerman <flx@obfusk.net>
+# Date        : 2014-06-13
+#
+# Copyright   : Copyright (C) 2014  Felix C. Stegerman
+# Licence     : LGPLv3+
+#
+# --                                                            ; }}}1
+
+# TODO: move to separate lib
+
+require 'ox'
+
+module Siresta
+  module XML
+    # parse XML
+    #
+    # ```ruby
+    # Siresta::XML.parse '<foo><bar id="99">hi!</bar></foo>'
+    # # =>  { tag: 'foo', attrs: {}, contents: [
+    # #       { tag: 'bar', attrs: { id: 99 }, contents: ['hi!'] }
+    # #     ] }
+    # ```
+    def self.parse(xml)
+      ox_elem = Ox.parse xml
+      _parse Ox::Document === ox_elem ? ox_elem.root : ox_elem
+    end
+
+    def self._parse(ox_elem)
+      if String === ox_elem
+        ox_elem
+      else
+        contents = ox_elem.nodes.map { |n| _parse n }
+        { tag: ox_elem.name, attrs: ox_elem.attributes, contents: contents }
+      end
+    end
+
+    # emit XML
+    #
+    # ```ruby
+    # puts Siresta::XML.emit(
+    #   { tag: 'foo', attrs: {}, contents: [
+    #     { tag: 'bar', attrs: { id: 99 }, contents: ['hi!'] }
+    #   ] }
+    # )
+    # # <?xml version="1.0"?>
+    # # <foo>
+    # #   <bar id="99">hi!</bar>
+    # # </foo>
+    # ```
+    def self.emit(elem, opts = {})
+      ox_doc = Ox::Document.new version: '1.0'
+      _emit ox_doc, elem
+      Ox.dump ox_doc, { with_xml: true }.merge(opts)
+    end
+
+    def self._emit(ox_doc, elem)
+      if String === elem
+        ox_doc << elem
+      else
+        ox_elem = Ox::Element.new elem[:tag]
+        elem[:attrs].each_pair { |k,v| ox_elem[k] = v }
+        ox_doc << ox_elem
+        elem[:contents].each { |e| _emit ox_elem, e }
+      end
+    end
+  end
+end
+
+# vim: set tw=70 sw=2 sts=2 et fdm=marker :

data/siresta.gemspec

@@ -0,0 +1,36 @@
+require File.expand_path('../lib/siresta/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = 'siresta'
+  s.homepage    = 'https://github.com/obfusk/siresta'
+  s.summary     = 'siRESTa - declarative REST APIs'
+
+  s.description = <<-END.gsub(/^ {4}/, '')
+    siRESTa is a DSL for declarative REST APIs.  It can generate a
+    ruby API (w/ sinatra) and Client (w/ excon) for you, based on a
+    YAML file.  Processing requests is done using a monad.
+  END
+
+  s.version     = Siresta::VERSION
+  s.date        = Siresta::DATE
+
+  s.authors     = [ 'Felix C. Stegerman' ]
+  s.email       = %w{ flx@obfusk.net }
+
+  s.licenses    = %w{ LGPLv3+ }
+
+  s.files       = %w{ .yardopts README.md Rakefile siresta.gemspec } \
+                + Dir['lib/**/*.rb']
+
+  s.add_runtime_dependency 'excon'
+# s.add_runtime_dependency 'hashie'
+  s.add_runtime_dependency 'obfusk', '>= 0.1.1'
+  s.add_runtime_dependency 'ox'
+  s.add_runtime_dependency 'sinatra'
+
+  s.add_development_dependency 'cucumber'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'yard'
+
+  s.required_ruby_version = '>= 1.9.1'
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: siresta
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Felix C. Stegerman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: excon
+  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: obfusk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+- !ruby/object:Gem::Dependency
+  name: ox
+  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: sinatra
+  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: cucumber
+  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: 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: yard
+  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'
+description: |
+  siRESTa is a DSL for declarative REST APIs.  It can generate a
+  ruby API (w/ sinatra) and Client (w/ excon) for you, based on a
+  YAML file.  Processing requests is done using a monad.
+email:
+- flx@obfusk.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".yardopts"
+- README.md
+- Rakefile
+- lib/siresta.rb
+- lib/siresta/api.rb
+- lib/siresta/client.rb
+- lib/siresta/env.rb
+- lib/siresta/response.rb
+- lib/siresta/routes.rb
+- lib/siresta/spec.rb
+- lib/siresta/version.rb
+- lib/siresta/xml.rb
+- siresta.gemspec
+homepage: https://github.com/obfusk/siresta
+licenses:
+- LGPLv3+
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: siRESTa - declarative REST APIs
+test_files: []
+has_rdoc: