cabbage_doc 0.0.1

data/lib/cabbage_doc/processor.rb

@@ -0,0 +1,41 @@
+module CabbageDoc
+  class Processor
+    class << self
+      def inherited(klass)
+        all[klass.to_s.split('::').last.downcase.to_sym] = klass
+      end
+
+      def all
+        @_all ||= {}
+      end
+
+      def load!
+        Dir.glob(File.join(File.dirname(__FILE__), 'processors', '*.rb')).sort.each do |processor|
+          require(processor)
+        end
+      end
+    end
+
+    def perform
+      raise NotImplementedError
+    end
+
+    protected
+
+    def client
+      @_client ||= Client.new(auth)
+    end
+
+    def auth
+      @_auth ||= Authentication.new
+    end
+
+    def collection
+      @_collection ||= Collection.instance.tap do |collection|
+        collection.load!
+      end
+    end
+  end
+
+  Processor.load!
+end

data/lib/cabbage_doc/processors/contracts.rb

@@ -0,0 +1,12 @@
+module CabbageDoc
+  module Processors
+    class Contracts < Processor
+      include PactoHelper
+
+      def perform
+        # TODO: use "examples" to generate Pacto Contracts
+        # nop
+      end
+    end
+  end
+end

data/lib/cabbage_doc/processors/documentation.rb

@@ -0,0 +1,15 @@
+module CabbageDoc
+  module Processors 
+    class Documentation < Processor
+      def perform
+        collection.clear!
+
+        Configuration.instance.controllers.call.each do |filename|
+          collection.parse!(filename)
+        end
+
+        collection.save!
+      end
+    end
+  end
+end

data/lib/cabbage_doc/processors/rspec.rb

@@ -0,0 +1,11 @@
+module CabbageDoc
+  module Processors
+    class Rspec < Processor
+      def perform
+        # TODO: use "Examples" and generate a "controllers_spec.rb" that validates
+        # itself against the generated contracts via Pacto ...
+        # nop
+      end
+    end
+  end
+end

data/lib/cabbage_doc/request.rb

@@ -0,0 +1,70 @@
+module CabbageDoc
+  class Request
+    METHODS = %i[get post put delete].freeze
+
+    attr_reader :raw_request, :collection
+
+    def initialize(raw_request, collection)
+      @raw_request = raw_request
+      @collection = collection
+    end
+
+    def perform
+      Response.new(url, params, perform_request) if valid?
+    end
+
+    def valid?
+      action && method && METHODS.include?(method)
+    end
+
+    private
+
+    def perform_request
+      key = (method == :get) ? :query : :body
+      client.send(method, action, key => params.to_hash)
+    end
+
+    def url
+      @_url ||= [client.base_uri, action]
+    end
+
+    def action
+      @_action ||= compose_action(raw_request.params['action'])
+    end
+
+    def method
+      @_method ||= compose_method(raw_request.params['method'])
+    end
+
+    def compose_method(method)
+      method.downcase.to_sym if method
+    end
+
+    def compose_action(action)
+      return action unless action && action.include?(':')
+
+      action = action.dup
+
+      action.dup.scan(/\/:([^\/]+)/) do
+        value = params.delete($1)
+        return unless value
+
+        action.sub!(":#{$1}", value)
+      end
+
+      action
+    end
+
+    def params
+      @_params ||= Params.new(raw_request.params, collection)
+    end
+
+    def auth
+      @_auth ||= Authentication.new(raw_request)
+    end
+
+    def client
+      @_client ||= Client.new(auth)
+    end
+  end
+end

data/lib/cabbage_doc/response.rb

@@ -0,0 +1,37 @@
+module CabbageDoc
+  class Response
+    attr_reader :url, :headers, :params, :code, :body
+
+    def initialize(url, params, response)
+      @url = url
+      @params = params
+      @headers = convert_headers(response)
+      @code = response.code
+      @body = response.parsed_response
+    end
+
+    def to_json
+      { 
+        url: url,
+        query: params.to_query, 
+        code: code, 
+        headers: prettify(headers),
+        body: prettify(body) 
+      }.to_json
+    end
+
+    private
+
+    def prettify(hash)
+      JSON.pretty_generate(hash)
+    end
+
+    def convert_headers(response)
+      {}.tap do |hash|
+        response.headers.each do |k, v|
+          hash[k] = v
+        end
+      end
+    end
+  end
+end

data/lib/cabbage_doc/singleton.rb

@@ -0,0 +1,15 @@
+module CabbageDoc
+  module Singleton
+    class << self
+      def included(base)
+        base.extend(ClassMethods)
+      end
+    end
+
+    module ClassMethods
+      def instance
+        @_instance ||= new
+      end
+    end
+  end
+end

data/lib/cabbage_doc/task.rb

@@ -0,0 +1,72 @@
+require 'rake'
+require 'rake/tasklib'
+
+module CabbageDoc
+  class Task < Rake::TaskLib
+    attr_accessor :processors, :name
+
+    def self.define
+      new.tap do |instance|
+        yield instance if block_given?
+        instance.validate!
+        instance.define!
+      end
+    end
+
+    def initialize
+      @processors = [:documentation]
+      @name = :cabbagedoc
+    end
+
+    def contracts=(value)
+      if value
+        @processors.delete(:rspec) if @processors.include?(:rspec)
+        @processors << :contracts
+        @processors << :rspec
+      else
+        @processors.delete(:contracts)
+      end
+    end
+
+    def rspec=(value)
+      if value
+        @processors << :contracts unless @processors.include?(:contracts)
+        @processors << :rspec
+      else
+        @processors.delete(:rspec)
+      end
+    end
+
+    def define!
+      namespace name do
+        processors.each do |processor|
+          desc "Process #{processor}"
+          task processor.to_s => :environment do
+            Processor.all[processor].new.perform
+          end
+        end
+
+        desc "Customize Web"
+        task :customize => :environment do
+          Customizer.new.perform
+        end
+      end
+
+      desc "Run all processors"
+      task name => :environment do
+        processors.each do |name|
+          Processor.all[name].new.perform
+        end
+      end
+    end
+
+    def validate!
+      fail "Invalid 'name'" unless name.is_a?(Symbol)
+      fail "No 'processors' configured" unless processors.any?
+
+      processors.each do |processor|
+        fail "Invalid 'processor' #{processor}" unless Processor.all.has_key?(processor)
+      end
+    end
+  end
+end

data/lib/cabbage_doc/version.rb

@@ -0,0 +1,3 @@
+module CabbageDoc
+  VERSION = "0.0.1".freeze
+end

data/lib/cabbage_doc/web.rb

@@ -0,0 +1,39 @@
+require 'sinatra/base'
+require 'haml'
+require 'redcarpet'
+require 'json'
+require 'cgi'
+
+module CabbageDoc
+  class Web < Sinatra::Base
+    ROOT = File.expand_path("../../../web", __FILE__).freeze
+
+    set :root, proc {
+      dir = File.join(Configuration.instance.root, 'web')
+      if Dir.exists?(dir)
+        dir
+      else
+        ROOT
+      end
+    }
+    set :public_folder, proc { "#{root}/public" }
+    set :views, proc { "#{root}/views" }
+
+    helpers WebHelper
+
+    get '/' do
+      haml :index
+    end
+
+    post '/' do
+      response = Request.new(request, collection).perform
+
+      if response
+        content_type :json 
+        response.to_json
+      else
+        halt 500
+      end
+    end
+  end
+end

data/lib/cabbage_doc/web_helper.rb

@@ -0,0 +1,25 @@
+module CabbageDoc
+  module WebHelper
+    def config
+      Configuration.instance
+    end
+
+    def collection
+      @_collection ||= Collection.instance.tap do |collection|
+        collection.load!
+      end
+    end
+
+    def markdown
+      @_markdown ||= Redcarpet::Markdown.new(Redcarpet::Render::HTML.new)
+    end
+
+    def title
+      @_title ||= config.title
+    end
+
+    def auth
+      @_auth ||= Authentication.new(request)
+    end
+  end
+end

data/lib/cabbage_doc.rb

@@ -0,0 +1,34 @@
+module CabbageDoc
+  MARKER = ':cabbagedoc:'.freeze
+
+  autoload :Path,           'cabbage_doc/path'
+  autoload :Singleton,      'cabbage_doc/singleton'
+  autoload :Cloneable,      'cabbage_doc/cloneable'
+  autoload :PactoHelper,    'cabbage_doc/pacto_helper'
+  autoload :Parser,         'cabbage_doc/parser'
+  autoload :Client,         'cabbage_doc/client'
+  autoload :Request,        'cabbage_doc/request'
+  autoload :Response,       'cabbage_doc/response'
+  autoload :Params,         'cabbage_doc/params'
+  autoload :Example,        'cabbage_doc/example'
+  autoload :Configuration,  'cabbage_doc/configuration'
+  autoload :Authentication, 'cabbage_doc/authentication'
+  autoload :Parameter,      'cabbage_doc/parameter'
+  autoload :Action,         'cabbage_doc/action'
+  autoload :Controller,     'cabbage_doc/controller'
+  autoload :Collection,     'cabbage_doc/collection'
+  autoload :WebHelper,      'cabbage_doc/web_helper'
+  autoload :Web,            'cabbage_doc/web'
+  autoload :Processor,      'cabbage_doc/processor'
+  autoload :Customizer,     'cabbage_doc/customizer'
+  autoload :Task,           'cabbage_doc/task'
+
+  class << self
+    def configure
+      Configuration.instance.tap do |config|
+        yield config if block_given?
+        config.validate!
+      end
+    end
+  end
+end

data/web/public/css/application.css

@@ -0,0 +1,184 @@
+body
+{
+	margin: 0;
+	padding: 0;
+}
+
+pre, code, .authentication form
+{
+	font-family: monospace;
+	background-color: #fcf6db;
+	border: 1px solid #e5e0c6;
+	padding: 10px;
+}
+
+label, .required
+{
+  font-weight: bold;
+}
+
+input[type=text], select
+{
+  min-width: 200px;
+}
+
+input[type=button], input[type=submit]
+{
+  min-width: 98px;
+}
+
+a, a:active, a:visited, a:hover
+{
+	color: #000000;
+	text-decoration: none;
+	font-weight: bold;
+}
+
+a:hover
+{
+	text-decoration: underline;
+}
+
+.hidden
+{
+	display: none !important; 
+}
+
+.clear
+{
+	clear: both;
+}
+
+.application
+{
+	margin: 10px auto;
+	width: 1024px;
+}
+
+.welcome, .documentation, .authentication
+{
+	width: 100%;
+}
+
+.resource
+{
+	color: #999999;
+	padding: 10px 0 10px 0px;
+	font-size: 1.5em;
+	font-weight: bold;
+	border-bottom: 1px solid #dddddd;
+}
+
+.action
+{
+	margin-top: 10px;
+	padding: 10px;
+}
+
+.action.get
+{
+	background-color: #e7f0f7;
+	border: 1px solid #aecce4;
+}
+
+.action.post
+{
+	background-color: #ebf7f0;
+	border: 1px solid #c3e8d1;
+}
+
+.action.put
+{
+	background-color: #f9f2e9;
+	border: 1px solid #e9cead;
+}
+
+.action.delete
+{
+	background-color: #f5e8e8;
+	border: 1px solid #deb3b3;
+}
+
+.action .method
+{
+	color: #ffffff;
+	font-weight: bold;
+	width: 80px;
+	text-align: center;
+	padding: 5px;
+	float: left;
+	margin-right: 10px;
+}
+
+.action .method.get
+{
+	background-color: #0061ac;
+}
+
+.action .method.post
+{
+	background-color: #10a54a;
+}
+
+.action .method.put
+{
+	background-color: #b06300;
+}
+
+.action .method.delete
+{
+	background-color: #a20909;
+}
+
+.action .subresource
+{
+	float: left;
+	line-height: 31px;
+}
+
+.action form
+{
+	margin-top: 10px;
+	margin-bottom: 0;
+}
+
+.action form table
+{
+  border-collapse: collapse;
+  border-spacing: 0;
+  margin-bottom: 10px;
+  width: 100%;
+}
+
+.action form table th
+{
+  font-weight: bold;
+}
+
+.action form table th, .action form table td
+{
+  padding-bottom: 5px;
+  text-align: left;
+  border-bottom: 1px solid #000000;
+}
+
+.action form table td
+{
+  padding: 10px;
+}
+
+.action form table td input[type=text], .action form table td select
+{
+  display: block;
+  margin-bottom: 5px;
+}
+
+.action .response
+{
+  margin-top: 10px;
+}
+
+.action .description
+{
+  margin-bottom: 20px;
+}

data/web/public/js/application.js

@@ -0,0 +1,113 @@
+$(document).ready(function()
+{
+  $('.controller .resource a').click(function()
+  {
+    $(this).closest('.controller').find('.actions').toggleClass('hidden');
+  });
+
+  $('.controller .action .subresource a').click(function()
+  {
+    $(this).closest('.action').find('form').toggleClass('hidden');
+  });
+
+  $('.controller .action form .add').click(function(e)
+  {
+    var el = $(this);
+    var td = el.closest('td');
+
+    var input = td.find('input[type=text]:first');
+
+    if(input.length == 0) input = td.find('select:first');
+    if(input.length == 0) return;
+
+    var new_input = input.clone();
+
+    new_input.attr('disabled', false);
+    new_input.removeClass('hidden');
+
+    new_input.insertBefore(el);
+
+    td.find('.remove').removeClass('hidden');
+  });
+
+  $('.controller .action form .remove').click(function(e)
+  {
+    var el = $(this);
+    var td = el.closest('td');
+
+    td.find('input[type=text]:last').remove();
+    td.find('select:last').remove();
+
+    if(td.find('input[type=text]').length == 1 || td.find('select').length == 1)
+      el.addClass('hidden');
+  });
+
+  $('.controller .action form .clear').click(function(e)
+  {
+    var el = $(this);
+    var form = el.closest('form');
+ 
+    var response = form.find('.response');
+    response.addClass('hidden');
+
+    response.find('.url').html('');
+    response.find('.query').html('');
+    response.find('.code').html('');
+    response.find('.headers').html('');
+    response.find('.body').html('');
+
+    el.addClass('hidden');
+  });
+
+  $('.controller .action form input[type=submit]').click(function(e)
+  {
+    e.preventDefault();
+
+    var form = $(this).closest('form');
+
+    var data = $('.authentication form').serializeArray().concat(form.serializeArray());
+
+    data.push({'name': 'method', 'value': form.attr('method') || ''});
+    data.push({'name': 'action', 'value': form.attr('action') || ''});
+
+    data = $.grep(data, function(v, i)
+    {
+      if(v.name.match(/\[hash\]$/))
+      {
+          var kv = v.value.split('=');
+          if(kv.length == 2)
+          {
+            v.name = v.name.replace(/\[hash\]$/, '[' + $.trim(kv[0]) + ']');
+            v.value = $.trim(kv[1]);
+          }
+      }
+
+      return v.value.length > 0;
+    });
+
+    console.log(data);
+
+    $.ajax('/', {
+      data: $.param(data),
+      method: 'POST',
+      dataType: 'json',
+      complete: function(data)
+      {
+        var json = data.responseJSON || {};
+
+        var response = form.find('.response');
+        response.removeClass('hidden');
+
+        response.find('.url').html(json.url);
+        response.find('.query').html(json.query);
+        response.find('.code').html(json.code);
+        response.find('.headers').html(json.headers);
+        response.find('.body').html(json.body);
+
+        form.find('.clear').removeClass('hidden');
+      },
+    });
+
+    return false;
+  });
+});