shaf 0.8.0 → 1.0.0

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

@@ -5,16 +5,14 @@ class <%= class_name %> < BaseSerializer
 
   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 %>
-  <% if collection_with_doc %>
-  <%= collection_with_doc.join("\n  ") %>
-  <% end %>
+
+  <%= print_nested(attributes_with_doc) %>
+
+  <%= print_nested(curies_with_doc) %>
+
+  <%= print_nested(links_with_doc) %>
+
+  <%- if collection_with_doc %>
+  <%= print(collection_with_doc) %>
+  <%- end -%>
 end

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

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'ostruct'
 
 describe <%= class_name %> do
 
@@ -6,10 +7,11 @@ describe <%= class_name %> do
     <%= model_class_name %>.new.
       tap { |<%= name %>| <%= name %>.id = 5 }
   end
+  let(:user) { OpenStruct.new(id: 5, name: 'Bengt') }
 
   describe "when current_user is nil" do
     before do
-      set_payload HALPresenter.to_hal(resource)
+      serialize resource
     end
 
     it "serializes attributes" do
@@ -27,7 +29,7 @@ describe <%= class_name %> do
 
   describe "when current_user is present" do
     before do
-      set_payload HALPresenter.to_hal(resource, current_user: "Bengt")
+      serialize resource, current_user: user
     end
 
     it "serializes attributes" do

data/lib/shaf/helpers.rb

@@ -2,6 +2,7 @@ require 'shaf/helpers/cache_control'
 require 'shaf/helpers/json_html'
 require 'shaf/helpers/paginate'
 require 'shaf/helpers/payload'
+require 'shaf/helpers/http_header'
 
 module Shaf
   def self.helpers
@@ -10,6 +11,7 @@ module Shaf
       JsonHtml,
       Paginate,
       Payload,
+      HttpHeader,
     ]
   end
 end

data/lib/shaf/helpers/http_header.rb

@@ -0,0 +1,26 @@
+require 'shaf/errors'
+
+module Shaf
+  module HttpHeader
+    def request_headers
+      unless respond_to? :request
+        log.error <<~ERROR
+
+
+          Classes including the HttpHeader module must respond to #request
+          HttpHeader#request_headers called from #{self}.
+        ERROR
+        raise Errors::ServerError, 'Server bug'
+      end
+
+      request.env.each_with_object({}) do |(key, value), headers|
+        next unless key =~ /^HTTP_/
+        headers[key[5..-1].tr('_', '-')] = value
+      end
+    end
+
+    def request_header(header)
+      request_headers[header.to_s.upcase]
+    end
+  end
+end

data/lib/shaf/helpers/paginate.rb

@@ -1,3 +1,5 @@
+require 'shaf/settings'
+
 module Shaf
   module Paginate
 
@@ -6,7 +8,7 @@ module Shaf
       page == 0 ? 1 : page
     end
 
-    def paginate!(collection, per_page = PAGINATION_PER_PAGE)
+    def paginate!(collection, per_page = Shaf::Settings.paginate_per_page)
       unless collection.respond_to? :paginate
         log.warn "Trying to paginate a collection that doesn't " \
                     "support pagination: #{collection}"
@@ -17,7 +19,7 @@ module Shaf
       collection.paginate(current_page, per_page)
     end
 
-    def paginate(collection, per_page = PAGINATION_PER_PAGE)
+    def paginate(collection, per_page = Shaf::Settings.paginate_per_page)
       paginate!(collection.dup, per_page)
     end
   end

data/lib/shaf/helpers/payload.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require 'set'
+
 module Shaf
   module Payload
     EXCLUDED_FORM_PARAMS = ['captures', 'splat'].freeze
@@ -48,22 +52,24 @@ module Shaf
       return {} if input.empty?
 
       if request.env['CONTENT_TYPE'] =~ %r(\Aapplication/(hal\+)?json)
-        JSON.parse(input)
+        JSON.parse(input, symbolize_names: true)
       else
-        raise ::UnsupportedMediaTypeError.new(request: request)
+        raise Errors::UnsupportedMediaTypeError.new(request: request)
       end
     rescue StandardError
-      raise ::BadRequestError.new
+      raise Errors::BadRequestError.new
     end
 
     def safe_params(*fields)
       return {} unless payload
-      field_strings = fields.map { |f| f.to_s.downcase }
-      field_strings << 'id' unless field_strings.include? 'id'
+
+      fields = fields.map { |f| f.to_sym.downcase }.to_set
+      fields << :id
 
       {}.tap do |allowed|
-        field_strings.each do |f|
-          allowed[f.to_sym] = payload[f] if payload[f]
+        fields.each do |f|
+          allowed[f] = payload[f] if payload.key? f
+          allowed[f] ||= payload[f.to_s] if payload.key? f.to_s
         end
       end
     end
@@ -72,6 +78,11 @@ module Shaf
       return name == '_method'
     end
 
+    def profile(value = nil)
+      return @profile unless value
+      @profile = value
+    end
+
     def respond_with_collection(resource, status: 200, serializer: nil, **kwargs)
       respond_with(
         resource,
@@ -111,7 +122,7 @@ module Shaf
 
     def respond_with_hal(resource, serialized)
       log.debug "Response payload (#{resource.class}): #{serialized}"
-      content_type :hal
+      content_type :hal, content_type_params(resource)
       body serialized
     end
 
@@ -132,5 +143,19 @@ module Shaf
       sha1 = Digest::SHA1.hexdigest payload
       etag sha1, :weak # Weak or Strong??
     end
+
+    def content_type_params(resource)
+      return {profile: profile} if profile
+
+      name =
+        case resource
+        when Formable::Form
+          Shaf::Settings.form_profile_name
+        when Errors::ServerError
+          Shaf::Settings.error_profile_name
+        end
+
+      {profile: name}.compact
+    end
   end
 end

data/lib/shaf/middleware/request_id.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'securerandom'
 
 module Shaf
@@ -8,7 +10,7 @@ module Shaf
       end
 
       def call(env)
-        env["REQUEST_ID"] = SecureRandom.uuid
+        env['REQUEST_ID'] = SecureRandom.uuid
         @app.call(env)
       end
     end

data/lib/shaf/rake/db.rb

@@ -22,10 +22,10 @@ end
 Shaf::DbTask.new(:migrate, description: "Run migrations", args: [:version]) do |t, args|
   if args[:version]
     puts "Migrating to version #{args[:version]}"
-    Sequel::Migrator.run(DB, MIGRATIONS_DIR, target: args[:version].to_i)
+    Sequel::Migrator.run(DB, Shaf::Settings.migrations_dir, target: args[:version].to_i)
   else
     puts "Migrating to latest"
-    Sequel::Migrator.run(DB, MIGRATIONS_DIR)
+    Sequel::Migrator.run(DB, Shaf::Settings.migrations_dir)
   end
 end
 
@@ -46,7 +46,7 @@ Shaf::DbTask.new(
     puts "This would migrate the Database to version: #{version}. Continue [N/y]?"
     next unless /\Ay/i =~ STDIN.gets.chomp&.downcase
   end
-  Sequel::Migrator.run(DB, MIGRATIONS_DIR, target: version.to_i)
+  Sequel::Migrator.run(DB, Shaf::Settings.migrations_dir, target: version.to_i)
 end
 
 Rake::Task["db:migrate"].enhance do
@@ -59,8 +59,8 @@ end
 
 Shaf::DbTask.new(:reset, description: "Reset the database by deleting all rows in all columns") do
   version = 0
-  Sequel::Migrator.run(DB, MIGRATIONS_DIR, target: version)
-  Sequel::Migrator.run(DB, MIGRATIONS_DIR)
+  Sequel::Migrator.run(DB, Shaf::Settings.migrations_dir, target: version)
+  Sequel::Migrator.run(DB, Shaf::Settings.migrations_dir)
 end
 
 Shaf::DbTask.new(:seed, description: "Seed the Database") do

data/lib/shaf/rake/test.rb

@@ -1,32 +1,5 @@
 require 'shaf/tasks'
 
-namespace :test do |ns|
-  Shaf::TestTask.new(:integration) do |t|
-    t.pattern = "spec/integration/**/*_spec.rb"
-  end
-
-  Shaf::TestTask.new(:models) do |t|
-    t.pattern = "spec/models/**/*_spec.rb"
-  end
-
-  Shaf::TestTask.new(:serializers) do |t|
-    t.pattern = "spec/serializers/**/*_spec.rb"
-  end
-
-  Shaf::TestTask.new(:lib) do |t|
-    t.pattern = "spec/lib/**/*_spec.rb"
-  end
-
-  Shaf::TestTask.new(:all) do |t|
-    t.pattern = [
-      "spec/lib/**/*_spec.rb",
-      "spec/models/**/*_spec.rb",
-      "spec/serializers/**/*_spec.rb",
-      "spec/integration/**/*_spec.rb"
-    ]
-  end
-end
-
 desc "Run all tests"
 task test: 'test:all'
 

data/lib/shaf/router.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'shaf/middleware'
+require 'set'
+
+module Shaf
+  class Router
+    class << self
+      def mount(controller, default: false)
+        @default_controller = controller if default
+        @controllers ||= []
+        @controllers << controller
+      end
+
+      def routes
+        init_routes unless defined? @routes
+        @routes
+      end
+
+      # This controller will be used when no other can handle the request
+      # (E.g. returning 404 Not Found)
+      def default_controller
+        @default_controller ||= nil
+      end
+
+      private
+
+      attr_reader :controllers
+
+      def init_routes
+        @routes = {}
+        controllers.each { |controller| init_routes_for(controller) }
+      end
+
+      def init_routes_for(controller)
+        controller.routes.each do |method, controller_routes|
+          routes[method] ||= Hash.new { |hash, key| hash[key] = [] }
+          routes[method][controller] += controller_routes.map(&:first)
+        end
+      end
+    end
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      http_method, path = http_details(env)
+
+      result = nil
+
+      controllers_for(http_method, path) do |controller|
+        result = controller.call(env)
+        break unless cascade? result
+      end
+
+      result
+    end
+
+    private
+
+    def http_details(env)
+      [env['REQUEST_METHOD'], env['PATH_INFO']]
+    end
+
+    def controllers_for(http_method, path)
+      find_cached(http_method, path).each { |ctrlr| yield ctrlr }
+
+      if controller = find(http_method, path)
+        yield controller
+      end
+
+      find_all(http_method, path).each do |ctrlr|
+        yield ctrlr unless ctrlr == controller
+      end
+
+      yield default_controller
+    end
+
+    def default_controller
+      self.class.default_controller || @app || raise('No default controller')
+    end
+
+    def routes
+      self.class.routes
+    end
+
+    def find(http_method, path)
+      routes[http_method].each do |controller, patterns|
+        next unless patterns.any? { |pattern| pattern.match(path) }
+        add_cache(controller, http_method, path)
+        return controller
+      end
+
+      nil
+    end
+
+    def find_all(http_method, path)
+      Set.new.tap do |controllers|
+        routes[http_method].each do |ctrlr, patterns|
+          next unless patterns.any? { |pattern| pattern.match(path) }
+          add_cache(ctrlr, http_method, path)
+          controllers << ctrlr
+        end
+      end
+    end
+
+    def cascade?(result)
+      result.dig(1, 'X-Cascade') == 'pass'
+    end
+
+    def cache
+      @cache ||= Hash.new { |hash, key| hash[key] = Set.new }
+    end
+
+    def add_cache(controller, http_method, path)
+      key = cache_key(http_method, path)
+      cache[key] << controller
+    end
+
+    def find_cached(http_method, path)
+      key = cache_key(http_method, path)
+      cache[key]
+    end
+
+    def cache_key(http_method, path)
+      path[1..-1].split('/').inject("#{http_method}_") do |key, segment|
+        segment = ':id' if segment =~ /\A\d+\z/
+        "#{key}/#{segment}"
+      end
+    end
+  end
+end

data/lib/shaf/settings.rb

@@ -1,24 +1,50 @@
-require 'yaml'
+# frozen_string_literal: true
 
+require 'yaml'
 
 module Shaf
   class Settings
     SETTINGS_FILE = 'config/settings.yml'
+    DEFAULTS = {
+      public_folder: 'frontend/assets',
+      views_folder: 'frontend/views',
+      documents_dir: 'doc/api',
+      migrations_dir: 'db/migrations',
+      fixtures_dir: 'spec/fixtures',
+      auth_token_header: 'X-Auth-Token',
+      paginate_per_page: 25
+    }.freeze
 
     class << self
       def load
-        @settings = File.exist?(SETTINGS_FILE) ?
-          YAML.load(File.read(SETTINGS_FILE)) : {}
+        @settings = DEFAULTS.dup
+        config = read_config(SETTINGS_FILE)
+        @settings.merge! config.fetch(env, {})
+      end
+
+      def read_config(file)
+        return {} unless File.exist? file
+
+        yaml = File.read(file)
+        if RUBY_VERSION < '2.5.0'
+          YAML.safe_load(yaml, [], [], true).each_with_object({}) do |(k, v), hash|
+            hash[k.to_sym] = v
+          end
+        elsif RUBY_VERSION < '2.6.0'
+          YAML.safe_load(yaml, [], [], true).transform_keys(&:to_sym)
+        else
+          YAML.safe_load(yaml, aliases: true, symbolize_names: true)
+        end
       end
 
       def env
-        @env ||= (ENV['APP_ENV'] || ENV['RACK_ENV'] || :development).to_sym
+        (ENV['APP_ENV'] || ENV['RACK_ENV'] || 'development').to_sym
       end
 
       def method_missing(method, *args)
         load unless defined? @settings
 
-        if method.to_s.end_with? "="
+        if method.to_s.end_with? '='
           define_setter(method)
           public_send(method, args.first)
         else
@@ -27,21 +53,20 @@ module Shaf
         end
       end
 
-      def respond_to_missing?(method, include_private = false)
-        return true
+      def respond_to_missing?(_method, _include_private = false)
+        true
       end
 
       def define_getter(method)
         define_singleton_method(method) do
-          @settings.dig(env.to_s, method.to_s)
+          @settings[method]
         end
       end
 
       def define_setter(method)
+        key = method[0..-2].to_sym
         define_singleton_method(method) do |arg|
-          key = method[0..-2]
-          @settings[env.to_s] ||= {}
-          @settings[env.to_s][key] = arg
+          @settings[key] = arg
         end
       end
     end