apipony 0.0.9 → 1.0.0.rc1

data/app/views/apipony/application/_response.html.erb

@@ -1,30 +1,21 @@
 <div class="response">
-  <h4>Response: <%= response.status %></h4>
-  <% if response.example %>
+  <h4>Response: <%= response.data.status %></h4>
+  <% if response.data? %>
     <div class="response-example">
       <%# This is kind of fancy for no reason but whatever %>
-      <% if response.example.headers %>
-        <div class="title">Headers</div>
-        <pre class="code hljs json"><%= JSON.pretty_generate(response.example.headers) %></pre>
+      <% if response.data.headers %>
+        <div class="panel">
+          <div class="title">Headers</div>
+          <pre class="code hljs json"><%= JSON.pretty_generate(response.data.headers) %></pre>
+        </div>
       <% end %>
 
-      <% if response.example.body %>
+      <% if response.data.body %>
         <div class="panel">
           <div class="title">Body</div>
-          <pre class="code hljs json"><%= JSON.pretty_generate(response.example.body) %></pre>
+          <pre class="code hljs json"><%= JSON.pretty_generate(response.data.body) %></pre>
         </div>
       <% end %>
     </div>
   <% end %>
-
-  <% if response.attributes.size > 0 %>
-    <div class="panel">
-      <div class="title">Attributes</div>
-      <div class="table">
-        <div class="attributes">
-          <%= render partial: 'attribute', collection: response.attributes, as: :attribute %>
-        </div>
-      </div>
-    </div>
-  <% end %>
 </div>

data/app/views/apipony/application/index.html.erb

@@ -11,13 +11,18 @@
         <% @documentation.sections.each do |section| %>
           <div class="section">
             <h2 id="<%= section.title %>"><%= section.title %></h2>
+            <% if section.data.description %>
+              <div class="description">
+                <%= section.data.description %>
+              </div>
+            <% end %>
             <% section.endpoints.each do |endpoint| %>
               <div class="endpoint" id="<%= endpoint.id %>">
                 <h3><%= render "method", endpoint: endpoint %></h3>
 
-                <% if endpoint.description %>
+                <% if endpoint.data.description %>
                   <div class="description">
-                    <%= endpoint.description %>
+                    <%= endpoint.data.description %>
                   </div>
                 <% end %>
 
@@ -27,31 +32,13 @@
                   <% end %>
 
                   <% if endpoint.response %>
-                    <%= render "response", response: endpoint.response %> 
+                    <%= render "response", response: endpoint.response %>
                   <% end %>
                 <% end %>
               </div>
             <% end %>
           </div>
         <% end %>
-        
-        <div id="defined_subtypes">
-          <% @documentation.subtypes.each do |name, type| %>
-            <div class="subtype" id="subtype-<%= name %>">
-              <h4><%= name %></h4>
-              <div class="panel">
-                <div class="title">Attributes</div>
-                <div class="table">
-                  <div class="attributes">
-                    <%= render partial: "attribute", 
-                    collection: type.attributes, 
-                    as: :attribute %>
-                  </div>
-                </div>
-              </div>
-            </div>
-          <% end %>
-        </div>
       </div>
     </div>
   </div>

data/app/views/layouts/apipony/application.html.erb

@@ -4,7 +4,7 @@
     <meta charset="utf-8">
 
     <%# HTML Title %>
-    <title><%= @documentation.title %></title>
+    <title><%= @documentation.data.title %></title>
 
     <%# Viewport meta tag %>
     <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">

data/lib/apipony/documentation.rb

@@ -1,45 +1,41 @@
-##
-# Top-level class for the DSL 
-class Apipony::Documentation
-  class << self
-    attr_accessor :title, :base_url, :sections
+# Top-level class for the DSL
+module Apipony
+  class Documentation
+    class << self
+      attr_accessor :title, :base_url, :sections
 
-    def define(&block)
-      @sections = []
-      @title = 'API Documentation'
-      @base_url = ''
+      def define(&block)
+        @title = 'API Documentation'
+        @sections = []
 
-      instance_eval(&block)
-    end
-    ##
-    # @return [Hash<String, ApiPony::ResponseAttribute] a hash of each subype.
-    #   keys are the names of the subtype, values are the attribute object that
-    #   defines it
-    def subtypes
-      Apipony::ResponseAttribute.defined_subtypes
-    end
+        instance_eval(&block)
+      end
 
-    ##
-    # Start a new section.
-    # Sections are logically separated on the display page.
-    def section(title, &block)
-      @sections << Apipony::Section.new(title, &block)
-    end
+      # Start a new section.
+      # Sections are logically separated on the display page.
+      def section(title, &block)
+        @sections << Apipony::Section.new(title, &block)
+      end
 
-    ##
-    # Define a new subtype.
-    # A subtype describes a common object used in various places in your Api.
-    # Once defined, setting the `type` of an attribute to this given name will
-    # cause it to reference this subtype in a common location. 
-    # @param [String] name what to call this subtype
-    def subtype(name, **params, &block)
-      Apipony.define_attribute_type(name, **params, &block)
-    end
+      # Configure API pony with the DSL
+      def configure(&block)
+        instance_eval(&block)
+      end
+
+      def title(value)
+        @title = value
+      end
+
+      def base_url(value)
+        @base_url = value
+      end
 
-    ##
-    # Configure API pony with the DSL
-    def config(&block)
-      instance_eval(&block)
+      def data
+        OpenStruct.new(
+          title: @title,
+          base_url: @base_url
+        )
+      end
     end
   end
 end

data/lib/apipony/endpoint.rb

@@ -1,49 +1,56 @@
 ##
 # Model a response endpoint.
-class Apipony::Endpoint < Apipony::Base
-  ##
-  # What HTTP verb to use to access this endpoint
-  attr_accessor :method
-  ##
-  # The URl of this endpoint
-  attr_accessor :url
-
-  ##
-  # A short description of what this endpoint does and why it may be useful.
-  attr_accessor :description
-
-  ##
-  #:nodoc:
-  attr_accessor :response, :request
-
-  def initialize(method, url, &block)
-    @method = method
-    @url = set_base_url(url)
-
-    instance_eval(&block) if block_given?
-  end
+module Apipony
+  class Endpoint
+    include Apipony::Shared::Description
+    ##
+    # What HTTP verb to use to access this endpoint
+    attr_accessor :method
+    ##
+    # The URl of this endpoint
+    attr_accessor :url
+
+    attr_accessor :response, :request
+
+    def initialize(method, url, &block)
+      @method = method
+      @url = build_url(url)
+
+      instance_eval(&block) if block_given?
+    end
 
-  ##
-  # DSL method to start describing a response
-  def response_with(status, **params, &block)
-    @response = Apipony::Response.new(status, **params, &block)
-  end
+    ##
+    # DSL method to start describing a response
+    def response_with(&block)
+      @response = Apipony::Response.new(&block)
+    end
 
-  ##
-  # DSL method to start describind a request
-  def request_with(&block)
-    @request = Apipony::Request.new(&block)
-  end
+    ##
+    # DSL method to start describind a request
+    def request_with(&block)
+      @request = Apipony::Request.new(&block)
+    end
 
-  ##
-  # Create a unique identifier for this endpoint
-  def id
-    File.join(@method.to_s, @url)
-  end
+    ##
+    # Create a unique identifier for this endpoint
+    def id
+      File.join(@method.to_s, @url)
+    end
 
-  private
+    def data
+      OpenStruct.new(
+        description: @description
+      )
+    end
 
-    def set_base_url(url)
-      File.join(Apipony::Documentation.base_url, url)
+    def ==(other)
+      method == other.method && url == other.url
     end
+
+    private
+
+      def build_url(url)
+        File.join(Apipony::Documentation.data.base_url, url)
+      end
+  end
 end

data/lib/apipony/engine.rb

@@ -1,5 +1,4 @@
 module Apipony
-  ## 
   # Rails engine so you can just drop Apipony right into your application
   class Engine < ::Rails::Engine
     isolate_namespace Apipony

data/lib/apipony/parameter.rb

@@ -1,11 +1,23 @@
-class Apipony::Parameter < Apipony::Base
-  attr_accessor :name, :type, :example, :required, :description
-
-  def initialize(name, example, type, required, description)
-    @name = name
-    @example = example
-    @type = type
-    @required = required
-    @description = description
+module Apipony
+  class Parameter
+    OPTIONS = %i(name type example required description).freeze
+
+    attr_accessor(*OPTIONS)
+
+    def initialize(name, options = {})
+      @name = name
+      @example = options[:example]
+      @description = options[:description]
+      @type = options.fetch(:type, :string)
+      @required = options.fetch(:required, false)
+    end
+
+    alias required? required
+
+    def ==(other)
+      OPTIONS.all? do |option|
+        public_send(option) == other.public_send(option)
+      end
+    end
   end
 end

data/lib/apipony/request.rb

@@ -1,26 +1,33 @@
-##
 # Model a request that an API user can make.
 # Includes information about required parameters and required headers
-class Apipony::Request < Apipony::Base
-  ##
-  # :nodoc:
-  attr_accessor :params
-  ##
-  #:nodoc:
-  attr_accessor :headers
+module Apipony
+  class Request
+    include Apipony::Shared::Headers
 
-  def initialize(&block)
-    @params = []
+    attr_accessor :params
 
-    instance_eval(&block)
-  end
-  ##
-  # Construct a new parameter
-  def param(name, 
-            example: '', 
-            type: :string, 
-            required: false,
-            description: '')
-    @params << Apipony::Parameter.new(name, example, type, required, description)
+    def initialize(&block)
+      @params = []
+
+      instance_eval(&block) if block_given?
+    end
+
+    # Construct a new parameter
+    def param(name, *params)
+      @params << Apipony::Parameter.new(name, *params)
+    end
+
+    def data
+      OpenStruct.new(
+        headers: @headers,
+        params: params
+      )
+    end
+
+    private
+
+      def params
+        @params.sort_by { |e| e.required? ? -1 : 0 }
+      end
   end
 end

data/lib/apipony/response.rb

@@ -1,51 +1,33 @@
-class Apipony::Response
-  attr_accessor :example, :attributes, :status
-  def initialize(status, array: false, &block)
-    @status = status
-    @attributes = []
-    @array = array
-    instance_eval(&block) if block_given?
-  end
+module Apipony
+  class Response
+    include Apipony::Shared::Headers
 
-  def is_array?
-    !! @array
-  end
+    attr_accessor :status, :body
 
-  def example(&block)
-    if block_given?
-      @example = Apipony::ExampleResponse.new(&block)
-    else
-      find_example
+    def initialize(&block)
+      @status = 200
+
+      instance_eval(&block) if block_given?
     end
-  end
 
-  def attribute(name, **params, &block)
-    if params[:example]
-      @use_attribute_examples = true
+    def status(code)
+      @status = code if code
     end
-    @attributes << Apipony::ResponseAttribute.new(name, **params, &block)
-  end
-  private
-  def find_example
-    if @use_attribute_examples
-      build_example_from_attributes
+
+    def body
+      @body = yield if block_given?
     end
-    @example
-  end
 
-  def build_example_from_attributes
-    build = Hash.new
-    @attributes.each do |attr|
-      build[attr.name] = attr.example if attr.example
+    def data?
+      !(@status.nil? && @body.nil?)
     end
-    @example ||= Apipony::ExampleResponse.new
-    case @example.body
-    when Hash
-      @example.body.merge! build
-      @example.body = [@example.body] if is_array?
-    when NilClass
-      @example.body = (is_array? ? [build] : build)
+
+    def data
+      OpenStruct.new(
+        status: @status,
+        headers: @headers,
+        body: @body
+      )
     end
-    @example
   end
 end

data/lib/apipony/section.rb

@@ -1,23 +1,31 @@
-##
 # A section is a way to logically separate your endpoints. All endpoints in
-# a section should be related in some way. 
-class Apipony::Section
-  ##
-  # What to call this endpoint. This will show up on the generated page.
-  attr_accessor :title
-  ##
-  # :nodoc: 
-  # This contains an array of endpoints added with the `endpoint` method of the
-  # DSL
-  attr_accessor :endpoints
-  def initialize(title, &block)
-    @title = title
-    @endpoints = []
+# a section should be related in some way.
+module Apipony
+  class Section
+    include Apipony::Shared::Description
 
-    instance_eval(&block)
-  end
+    # What to call this endpoint. This will show up on the generated page.
+    attr_accessor :title
+
+    # This contains an array of endpoints added with the `endpoint`
+    # method of the DSL
+    attr_accessor :endpoints
+
+    def initialize(title, &block)
+      @title = title
+      @endpoints = []
+
+      instance_eval(&block) if block_given?
+    end
+
+    def endpoint(method, url, &block)
+      @endpoints << Apipony::Endpoint.new(method, url, &block)
+    end
 
-  def endpoint(method, url, &block)
-    @endpoints << Apipony::Endpoint.new(method, url, &block)
+    def data
+      OpenStruct.new(
+        description: @description
+      )
+    end
   end
 end

data/lib/apipony/shared/description.rb

@@ -0,0 +1,11 @@
+module Apipony
+  module Shared
+    module Description
+      attr_accessor :description
+
+      def description(value)
+        @description = value
+      end
+    end
+  end
+end

data/lib/apipony/shared/headers.rb

@@ -0,0 +1,11 @@
+module Apipony
+  module Shared
+    module Headers
+      attr_accessor :headers
+
+      def headers
+        @headers = yield if block_given?
+      end
+    end
+  end
+end

data/lib/apipony/version.rb

@@ -1,5 +1,3 @@
 module Apipony
-  ##
-  #:nodoc:
-  VERSION = '0.0.9'
+  VERSION = '1.0.0.rc1'.freeze
 end

data/lib/apipony.rb

@@ -1,31 +1,14 @@
 require 'apipony/engine'
 
-require 'apipony/base'
+require 'apipony/shared/headers'
+require 'apipony/shared/description'
+
 require 'apipony/documentation'
 require 'apipony/section'
 require 'apipony/endpoint'
 require 'apipony/response'
 require 'apipony/request'
 require 'apipony/parameter'
-require 'apipony/response_attribute'
-require 'apipony/example_response'
 
 module Apipony
-
-  ##
-  # This allows you to define a common sub-type of attributes.
-  # A typical example is something like a list of users. If you want to 
-  # display all users who created an image, who subscribe to a channel, or who
-  # are in a group, it may be useful if the information on those users is in a
-  # common format. This lets you define one common format, which you can then
-  # merge in to other attributes.
-  # = Example
-  #     Apipony.define_attribute_type :user_stub do
-  #       attribute :name
-  #       attribute :id
-  #     end
-  def self.define_attribute_type(name, **params, &block)
-    a = Apipony::ResponseAttribute.new("", **params, &block)
-    Apipony::ResponseAttribute.define_type(name, a)
-  end
 end