shaf 0.1.0.beta

data/lib/shaf/generator/templates/api/controller.rb.erb

@@ -0,0 +1,62 @@
+require '<%= policy_file %>'
+
+class <%= controller_class_name %> < BaseController
+
+  resource_uris_for :<%= name %>
+
+  authorize_with <%= policy_class_name %>
+
+  get '/<%= plural_name %>/form' do
+    form = <%= model_class_name %>.create_form
+    form.self_link = new_<%= name %>_uri
+    form.href = <%= plural_name %>_uri
+    respond_with form
+  end
+
+  get '/<%= plural_name %>/:id/edit' do
+    form = <%= name %>.edit_form
+    form.self_link = edit_<%= name %>_uri(<%= name %>)
+    form.href = <%= name %>_uri(<%= name %>)
+    respond_with form
+  end
+
+  get '/<%= plural_name %>/:id' do
+    respond_with <%= name %>
+  end
+
+  put '/<%= plural_name %>/:id' do
+    authorize! :write
+    <%= name %>.update(<%= name %>_params)
+    respond_with <%= name %>
+  end
+
+  delete '/<%= plural_name %>/:id' do
+    authorize! :write
+    <%= name %>.destroy
+    status 204
+  end
+
+  get '/<%= plural_name %>' do
+    collection = paginate(<%= model_class_name %>.order(:created_at).reverse)
+    respond_with_collection collection, serializer: <%= serializer_class_name %>
+  end
+
+  post '/<%= plural_name %>' do
+    authorize! :write
+    <%= name %> = <%= model_class_name %>.create(<%= name %>_params)
+    headers({ "Location" => <%= name %>_uri(<%= name %>) })
+    respond_with <%= name %>, status: 201
+  end
+
+  def <%= name %>_params
+    # Generated method - TODO: Remove any params that should not be allowed!
+    safe_params(<%= params.map { |p| ":#{p[0]}" }.join(', ') %>)
+  end
+
+  def <%= name %>
+    <%= model_class_name %>[params['id']].tap do |<%= name %>|
+      raise NotFoundError.new(clazz: <%= model_class_name %>, id: params['id']) unless <%= name %>
+    end
+  end
+
+end

data/lib/shaf/generator/templates/api/model.rb.erb

@@ -0,0 +1,20 @@
+class <%= class_name %> < Sequel::Model
+  include Shaf::Formable
+
+<% if form_fields.any? %>
+  form do
+    <%= form_fields.join("\n    ") %>
+
+    create do
+      title 'Create <%= class_name %>'
+      name  'create-<%= model_name %>'
+    end
+
+    edit do
+      title 'Update <%= class_name %>'
+      name  'update-<%= model_name %>'
+    end
+  end
+<% end %>
+end
+

data/lib/shaf/generator/templates/api/policy.rb.erb

@@ -0,0 +1,26 @@
+class <%= policy_class_name %>
+  include HALPresenter::Policy::DSL
+
+  # Auto generated policy: Update this file to suite your API!
+ 
+  <%= attributes.join("\n  ") %>
+
+  link :up
+
+  link :edit, :'create-form', :'edit-form', :delete do
+    write?
+  end
+
+  embed :'create-form', :'edit-form' do
+    write?
+  end
+
+  def read?
+    true
+  end
+
+  def write?
+    # !!current_user
+    true
+  end
+end

data/lib/shaf/generator/templates/api/serializer.rb.erb

@@ -0,0 +1,24 @@
+require 'policies/<%= policy_name %>'
+
+class <%= class_name %>
+  extend HALPresenter
+  extend Shaf::UriHelper
+
+  model <%= model_class_name %>
+  policy <%= policy_class_name %>
+  <% attributes_with_doc.each do |attr| %>
+  <%= attr.join("\n  ") %>
+  <% end %>
+  <% curies_with_doc.each do |curie| %>
+  <%= curie.join("\n  ") %>
+  <% end %>
+  <% links_with_doc.each do |link| %>
+  <%= link.join("\n  ") %>
+  <% end %>
+  <% embeds_with_doc.each do |embed| %>
+  <%= embed.join("\n  ") %>
+  <% end %>
+  <% if collection_with_doc %>
+  <%= collection_with_doc.join("\n  ") %>
+  <% end %>
+end

data/lib/shaf/generator/templates/spec/integration_spec.rb.erb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe <%= model_class_name %>, type: :integration do
+
+  it "returns a <%= name %>" do
+    <%= name %> = <%= model_class_name %>.create
+    get <%= name %>_uri(<%= name %>)
+    status.must_equal 200
+    link_rels.must_include(:self)
+    links[:self][:href].must_equal <%= name %>_uri(<%= name %>)
+  end
+
+  it "lists all <%= plural_name %>" do
+    <%= model_class_name %>.create
+    <%= model_class_name %>.create
+
+    get <%= plural_name %>_uri
+    status.must_equal 200
+    link_rels.must_include(:self)
+    links[:self][:href].must_include <%= plural_name %>_uri
+    embedded :'<%= plural_name %>' do
+      <%= plural_name %> = last_payload
+      <%= plural_name %>.size.must_equal 2
+    end
+  end
+
+  it "can create <%= plural_name %>" do
+    get <%= plural_name %>_uri
+
+    embedded :'doc:create-form' do
+      links[:self][:href].must_equal new_<%= name %>_uri
+      attributes[:href].must_equal <%= plural_name %>_uri
+      attributes[:method].must_equal "POST"
+      attributes[:name].must_equal "create-<%= name %>"
+      attributes[:title].must_equal "Create <%= model_class_name %>"
+      attributes[:type].must_equal "application/json"
+      attributes[:fields].size.must_equal <%= params.size %>
+
+      payload = fill_form attributes[:fields]
+      post attributes[:href], payload
+      status.must_equal 201
+      link_rels.must_include(:self)
+      headers["Location"].must_equal links[:self][:href]
+    end
+
+    get <%= plural_name %>_uri
+    status.must_equal 200
+    links[:self][:href].must_include <%= plural_name %>_uri
+    embedded(:'<%= plural_name %>').size.must_equal 1
+
+    embedded :'<%= plural_name %>' do
+      <%= name %> = last_payload.first
+<% params.each do |param| -%>
+<% if param[1] == 'string' -%>
+      <%= name %>[:<%= param[0] %>].must_equal "value for <%= param[0] %>"
+<% elsif param[1] == 'integer' -%>
+      <%= name %>[:<%= param[0] %>].must_equal "<%= param[0] %>".size
+<% end -%>
+<% end -%>
+    end
+  end
+
+  it "<%= plural_name %> can be updated" do
+    <%= name %> = <%= model_class_name %>.create
+    get <%= name %>_uri(<%= name %>)
+    status.must_equal 200
+    link_rels.must_include(:'doc:edit-form')
+
+    embedded :'doc:edit-form' do
+      links[:self][:href].must_equal edit_<%= name %>_uri(<%= name %>)
+      attributes[:href].must_equal <%= name %>_uri(<%= name %>)
+      attributes[:method].must_equal "PUT"
+      attributes[:name].must_equal "update-<%= name %>"
+      attributes[:title].must_equal "Update <%= model_class_name %>"
+      attributes[:type].must_equal "application/json"
+      attributes[:fields].size.must_equal <%= params.size %>
+
+      payload = fill_form attributes[:fields]
+      put attributes[:href], payload
+      status.must_equal 200
+      link_rels.must_include(:self)
+    end
+  end
+
+  it "<%= plural_name %> can be deleted" do
+    <%= name %> = <%= model_class_name %>.create
+    get <%= name %>_uri(<%= name %>)
+    status.must_equal 200
+    link_rels.must_include(:'doc:delete')
+
+    follow_rel(:'doc:delete', method: :delete)
+    status.must_equal 204
+
+    get <%= name %>_uri(<%= name %>)
+    status.must_equal 404
+  end
+
+end

data/lib/shaf/generator/templates/spec/model.rb.erb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+module Model
+  class UserTest < TestCase
+    def setup
+      @user = User.create(
+        username: 'test_user',
+        password: 'hidden',
+        email: 'test@user.com',
+      )
+    end
+
+    def test_create
+      assert @user
+      assert_equal @user.username, 'test_user'
+      assert_equal @user.email, 'test@user.com'
+      created = @user.created_at
+      assert (created..(created + 30)).include? Time.now
+    end
+
+    def test_update_user
+      digest = @user.password_digest
+      @user.update(
+        username: 'test_User',
+        email: 'test@User.com',
+        password: 'hidden2'
+      )
+      assert @user.created_at < @user.updated_at
+      assert_equal 'test_User', @user.username
+      assert_equal 'test@User.com', @user.email
+      refute_equal digest, @user.password_digest
+    end
+
+    def test_delete_user
+      @user.destroy
+      assert_nil User.where(username: @user.username).first
+    end
+  end
+end
+

data/lib/shaf/generator/templates/spec/serializer_spec.rb.erb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe <%= class_name %> do
+
+  let(:resource) do
+    <%= model_class_name %>.new.
+      tap { |<%= name %>| <%= name %>.id = 5 }
+  end
+
+  describe "when current_user is nil" do
+    before do
+      set_payload HALPresenter.to_hal(resource)
+    end
+
+    it "serializes attributes" do
+<% attributes.each do |attr| -%>
+      attributes.keys.must_include(<%= attr %>)
+<% end -%>
+    end
+
+    it "serializes links" do
+<% ['self', 'doc:up'].each do |rel| -%>
+      link_rels.must_include(:'<%= rel %>')
+<% end -%>
+    end
+  end
+
+  describe "when current_user is present" do
+    before do
+      set_payload HALPresenter.to_hal(resource, current_user: "Bengt")
+    end
+
+    it "serializes attributes" do
+<% attributes.each do |attr| -%>
+      attributes.keys.must_include(<%= attr %>)
+<% end -%>
+    end
+
+    it "serializes links" do
+<% links.each do |rel| -%>
+      link_rels.must_include(:'<%= rel %>')
+<% end -%>
+    end
+  end
+end
+

data/lib/shaf/helpers.rb

@@ -0,0 +1,15 @@
+require 'shaf/helpers/payload'
+require 'shaf/helpers/json_html'
+require 'shaf/helpers/paginate'
+require 'shaf/helpers/session'
+
+module Shaf
+  def self.helpers
+    [
+      Payload,
+      JsonHtml,
+      Paginate,
+      Session,
+    ]
+  end
+end

data/lib/shaf/helpers/json_html.rb

@@ -0,0 +1,65 @@
+module Shaf
+  module JsonHtml
+
+    def json2html(json)
+      o = JSON.parse(json)
+      "<pre><code>#{to_html(o)}</code></pre>"
+    end
+
+    private
+
+    def to_html(obj, indent: 0, pre_indent: "")
+      case obj
+      when Array
+        html_array(obj, indent, pre_indent)
+      when Hash
+        html_hash(obj, indent, pre_indent)
+      else
+        html_scalar(obj, indent, pre_indent)
+      end
+    end
+
+    def html_array(a, indent, pre_indent)
+      array_of_strings = a.map do |e|
+        to_html(e, indent: indent + 1, pre_indent: indentation(indent + 1))
+      end
+
+      <<~EOS.chomp
+        #{pre_indent}<span>[</span>
+        #{array_of_strings.join(",\n")}
+        #{indentation(indent)}<span>]</span>
+      EOS
+    end
+
+    def html_hash(h, indent, pre_indent)
+      <<~EOS.chomp
+        #{pre_indent}<span>{</span>
+        #{h.map { |k,v| sub_hash(k,v, indent + 1) }.join(",\n")},
+        #{indentation(indent)}<span>}</span>
+      EOS
+    end
+
+    def html_scalar(s, indent, pre_indent)
+      q = around(s)
+      format "%s%s%s%s", pre_indent, q, s, q
+    end
+
+    def sub_hash(key, value, indent)
+      if key == 'href'
+        %Q(#{indentation(indent)}"#{key}"<span>:</span> <a href="#{value}">#{value}</a>)
+      else
+        "#{indentation(indent)}\"#{key}\"<span>:</span> #{to_html(value, indent: indent) }"
+      end
+    end
+
+    def indentation(i)
+      "  " * i
+    end
+
+    def around(obj)
+      return '"' if obj.is_a? String
+      ""
+    end
+
+  end
+end

data/lib/shaf/helpers/paginate.rb

@@ -0,0 +1,24 @@
+module Shaf
+  module Paginate
+
+    def current_page
+      page = (params[:page] || 1).to_i
+      page == 0 ? 1 : page
+    end
+
+    def paginate!(collection, per_page = PAGINATION_PER_PAGE)
+      unless collection.respond_to? :paginate
+        log.warning "Trying to paginate a collection that doesn't " \
+                    "support pagination: #{collection}"
+        return
+      end
+
+      per_page = params[:per_page].to_i if params[:per_page]
+      collection.paginate(current_page, per_page)
+    end
+
+    def paginate(collection, per_page = PAGINATION_PER_PAGE)
+      paginate!(collection.dup, per_page)
+    end
+  end
+end

data/lib/shaf/helpers/payload.rb

@@ -0,0 +1,115 @@
+module Shaf
+  module Payload
+    def supported_response_types(resource)
+      [
+        mime_type(:hal),
+        mime_type(:json),
+        mime_type(:html)
+      ]
+    end
+
+    def preferred_response_type(resource)
+      supported_types = supported_response_types(resource)
+      request.preferred_type(supported_types)
+    end
+
+    def prefer_html?
+      request.preferred_type.to_s == mime_type(:html)
+    end
+
+    private
+
+    def payload
+      @@request_id ||= nil
+      @@payload ||= nil
+
+      if @@request_id != request.env["REQUEST_ID"]
+        @@request_id = request.env["REQUEST_ID"]
+        @@payload = parse_payload
+      end
+      @@payload
+    end
+
+    def read_input
+      request.body.rewind unless request.body.pos == 0
+      request.body.read
+    ensure
+      request.body.rewind
+    end
+
+    def parse_payload
+      if request.env['CONTENT_TYPE'] == 'application/x-www-form-urlencoded'
+        return params.reject { |key,_| ['captures', 'splat'].include? key }
+      end
+
+      input = read_input
+      return {} if input.empty?
+
+      if request.env['CONTENT_TYPE'] =~ %r(\Aapplication/json)
+        JSON.parse(input)
+      else
+        raise ::UnsupportedMediaTypeError.new(request: request)
+      end
+    rescue StandardError
+      raise ::BadRequestError.new
+    end
+
+    def safe_params(*fields)
+      return {} unless payload
+      {}.tap do |allowed|
+        fields.each do |field|
+          f = field.to_s.downcase
+          allowed[f.to_sym] = payload[f] if payload[f]
+        end
+      end
+    end
+
+    def ignore_form_input?(name)
+      return name == '_method'
+    end
+
+    def respond_with_collection(resource, status: 200, serializer: nil)
+      respond_with(resource, status: status, serializer: serializer, collection: true)
+    end
+
+    def respond_with(resource, status: 200, serializer: nil, collection: false)
+      status(status)
+
+      preferred_response = preferred_response_type(resource)
+      serialized = serialize(resource, serializer, collection)
+
+      if preferred_response == mime_type(:html)
+        respond_with_html(resource, serialized)
+      else
+        respond_with_hal(resource, serialized)
+      end
+    end
+
+    def serialize(resource, serializer, collection)
+      serializer ||= HALPresenter
+      if collection
+        serializer.to_collection(resource, current_user: current_user)
+      else
+        serializer.to_hal(resource, current_user: current_user)
+      end
+    end
+
+    def respond_with_hal(resource, serialized)
+      log.debug "Response payload (#{resource.class}): #{serialized}"
+      content_type :hal
+      body serialized
+    end
+
+    def respond_with_html(resource, serialized)
+      log.debug "Responding with html. Output payload (#{resource.class}): #{serialized}"
+      content_type :html
+      case resource
+      when Shaf::Formable::Form
+        body erb(:form, locals: {form: resource, serialized: serialized})
+      else
+        body erb(:payload, locals: {serialized: serialized})
+      end
+    end
+
+  end
+end