shaf 1.6.0 → 3.0.0

data/{templates/config/settings.yml → lib/shaf/command/templates/config/settings.yml.erb}

@@ -1,27 +1,24 @@
 ---
 default: &default
-  public_folder: frontend/assets
-  views_folder: frontend/views
+  default_authentication_realm: api
   documents_dir: doc/api
-  migrations_dir: db/migrations
   fixtures_dir: spec/fixtures
-  paginate_per_page: 25
+  hostname: localhost
   http_cache: on
   http_cache_max_age_long: 86400 # 60 * 60 * 24 = 1 day
   http_cache_max_age_short: 3600 #      60 * 60 = 1 hour
-  hostname: localhost
+  migrations_dir: db/migrations
+  paginate_per_page: 25
+  port: <%= default_port %>
+  project_name: <%= project_name %>
   protocol: http
-  port: 3000
-  auth_token_header: X-Auth-Token
-  form_profile_name: shaf-form
-  form_profile_uri: https://gist.githubusercontent.com/sammyhenningsson/39c8aafeaf60192b082762cbf3e08d57/raw/shaf-form.md
-  error_profile_name: shaf-error
-  error_profile_uri: https://gist.githubusercontent.com/sammyhenningsson/049d10e2b8978059cde104fc5d6c2d52/raw/shaf-error.md
+  public_folder: frontend/assets
+  views_folder: frontend/views
 
 production:
   <<: *default
-  port: <%= ENV.fetch('PORT', 443) %>
   base_uri: https://my.public.shaf.api.com
+  port: <%= ENV.fetch('PORT', 443) %>
 
 development:
   <<: *default

data/lib/shaf/errors.rb

@@ -64,6 +64,17 @@ module Shaf
       end
     end
 
+    class NotAcceptableError < ServerError
+      def http_status
+        406
+      end
+
+      def initialize(msg = nil)
+        msg ||= 'Resource found, but a suitable representation could not be generated'
+        super(msg, code: 'NOT_ACCEPTABLE', title: 'Content negotiation failed')
+      end
+    end
+
     class ConflictError < ServerError
       def http_status
         409

data/lib/shaf/extensions/api_routes.rb

@@ -0,0 +1,60 @@
+require 'set'
+
+module Shaf
+  module ApiRoutes
+    class Registry
+      class << self
+        def register(controller, method, symbol)
+          routes[controller][symbol] << method.to_s.upcase
+        end
+
+        def controllers
+          routes.keys.sort_by(&:to_s)
+        end
+
+        def routes_for(controller)
+          sorted = routes[controller].keys.sort_by(&:to_s)
+          sorted.each do |symbol|
+            yield route_info(controller, symbol)
+          end
+        end
+
+        private
+
+        def routes
+          @routes ||= Hash.new do |hash, key|
+            # Group routes with conditionals together (`Set.new`). Like:
+            # get(:foobar_path, agent: /ios/) { "ios specific" }
+            # get(:foobar_path, agent: /android/) { "android specific" }
+            hash[key] = Hash.new { |h, k| h[k] = Set.new }
+          end
+        end
+
+        def route_info(controller, symbol)
+          methods = routes[controller][symbol].to_a
+          template_method = :"#{symbol}_template"
+
+          if controller.respond_to? template_method
+            template = controller.public_send(template_method)
+          else
+            template = symbol
+            symbol = '-'
+          end
+
+          [methods, template, symbol]
+        end
+      end
+    end
+
+    Shaf::SUPPORTED_HTTP_METHODS.each do |method|
+      define_method method do |path, **options, &block|
+        path_str = path.to_s
+        path_str.sub!(/_uri/, '_path')
+        path_str = "#{path_str}_path" unless path_str.end_with? '_path'
+        path_str.sub!(/_path/, '_collection_path') if options[:collection]
+        Registry.register(self, method, path_str.to_sym)
+        super(path, **options, &block)
+      end
+    end
+  end
+end

data/lib/shaf/extensions/authorize.rb

@@ -8,22 +8,25 @@ module Shaf
 
     attr_reader :policy_class
 
-    def authorize_with(policy_class)
-      @policy_class = policy_class
-    end
-
     def self.registered(app)
       app.helpers Helpers
     end
+
+    def authorize_with(policy_class)
+      @policy_class = policy_class
+    end
   end
 
   module Helpers
     def authorize(action, resource = nil)
-      policy(resource) or raise Authorize::NoPolicyError
+      policy = policy(resource)
+      raise Authorize::NoPolicyError unless policy
+
       method = __method_for(action)
-      return @policy.public_send(method) if @policy.respond_to? method
+      return policy.public_send(method) if policy.respond_to? method
+
       raise Authorize::MissingPolicyAction,
-        "#{@policy.class} does not implement method #{method}"
+        "#{policy.class} does not implement method #{method}"
     end
 
     def authorize!(action, resource = nil)
@@ -33,9 +36,8 @@ module Shaf
     private
 
     def policy(resource)
-      return @policy if defined?(@policy) && @policy
       user = current_user if respond_to? :current_user
-      @policy = self.class.policy_class&.new(user, resource)
+      self.class.policy_class&.new(user, resource)
     end
 
     def __method_for(action)

data/lib/shaf/extensions/log.rb

@@ -7,7 +7,7 @@ module Shaf
     end
 
     def log
-      $logger ||= Logger.new('/dev/nul')
+      Shaf.log
     end
   end
 

data/lib/shaf/extensions/resource_uris.rb

@@ -11,15 +11,25 @@ module Shaf
       end
     end
 
+    class << self
+      def resource_uris_for(name, **kwargs)
+        CreateUriMethods.new(name, **kwargs).call
+      end
+
+      def register_uri(name, uri)
+        MethodBuilder.new(name, uri).call
+      end
+    end
+
     def resource_uris_for(name, **kwargs)
-      result = CreateUriMethods.new(name, **kwargs).call
+      result = ResourceUris.resource_uris_for(name, **kwargs)
       UriHelperMethods.add_path_helpers(self, result)
 
       include UriHelper unless self < UriHelper
     end
 
     def register_uri(name, uri)
-      result = MethodBuilder.new(name, uri).call
+      result = ResourceUris.register_uri(name, uri)
       UriHelperMethods.add_path_helpers(self, result)
 
       include UriHelper unless self < UriHelper
@@ -39,23 +49,23 @@ module Shaf
       end
 
       def add_path_helpers(clazz, methods)
-        @path_helpers ||= {}
-        @path_helpers[clazz] ||= []
-        @path_helpers[clazz].concat Array(methods)
+        path_helpers[clazz].concat Array(methods)
       end
 
       def path_helpers_for(clazz = nil)
-        @path_helpers ||= {}
-        return @path_helpers unless clazz
-        return [] unless @path_helpers.key?(clazz)
-        @path_helpers[clazz] ||= []
+        return path_helpers unless clazz
+        path_helpers[clazz]
+      end
+
+      def path_helpers
+        @path_helpers ||= Hash.new { |hash, key| hash[key] = [] }
       end
 
       # For cleaning up after tests
       def remove_all
         helpers = instance_methods - [:path_helpers]
         remove_method(*helpers)
-        @path_helpers = {}
+        @path_helpers = Hash.new { |hash, key| hash[key] = [] }
       end
     end
 
@@ -96,22 +106,20 @@ module Shaf
   # edit_book_uri_template         => /books/:id/edit
   #
   class CreateUriMethods
-    def initialize(name, base: nil, plural_name: nil, only: nil, except: nil)
+    def initialize(name, plural_name: nil, base: nil, namespace: nil, only: nil, except: nil)
       @name = name.to_s
-      @base = base&.sub(%r(/\Z), '') || ''
       @plural_name = plural_name&.to_s || Utils::pluralize(name.to_s)
+      @base = base&.sub(%r(/\Z), '') || ''
+      @base = "/#{namespace}" if namespace && !base
+      @namespace = namespace
       @only = only
       @except = except
       @added_path_methods = []
     end
 
     def call
-      if plural_name == name
-        register_resource_helper_by_arg
-      else
-        register_collection_helper
-        register_resource_helper
-      end
+      register_collection_helper
+      register_resource_helper
       register_new_resource_helper
       register_edit_resource_helper
       @added_path_methods
@@ -119,48 +127,38 @@ module Shaf
 
     private
 
-    attr_reader :name, :base, :plural_name, :only, :except
+    attr_reader :name, :plural_name, :base, :namespace, :only, :except
 
     def register_collection_helper
       return if skip? :collection
 
+      method = method_name(plural_name, name == plural_name)
       template_uri = "#{base}/#{plural_name}".freeze
-      register(plural_name, template_uri)
+      register(method, template_uri)
     end
 
     def register_resource_helper
       return if skip? :resource
 
+      method = method_name(name)
       template_uri = "#{base}/#{plural_name}/:id".freeze
-      register(name, template_uri)
-    end
-
-    # If a resource has the same singular and plural names, then this method
-    # should be used. It will return the resource uri when a resource is given
-    # as argument and the resources uri when no arguments are provided.
-    def register_resource_helper_by_arg
-      return register_resource_helper if skip? :collection
-      return register_collection_helper if skip? :new
-
-      resource_template_uri =   "#{base}/#{plural_name}/:id"
-      collection_template_uri = "#{base}/#{plural_name}"
-
-      builder = MethodBuilder.new(name, resource_template_uri, alt_uri: collection_template_uri)
-      @added_path_methods << builder.call
+      register(method, template_uri)
     end
 
     def register_new_resource_helper
       return if skip? :new
 
+      method = method_name(name)
       template_uri = "#{base}/#{name}/form".freeze
-      register("new_#{name}", template_uri)
+      register("new_#{method}", template_uri)
     end
 
     def register_edit_resource_helper
       return if skip? :edit
 
+      method = method_name(name)
       template_uri = "#{base}/#{plural_name}/:id/edit".freeze
-      register("edit_#{name}", template_uri)
+      register("edit_#{method}", template_uri)
     end
 
     def register(name, template_uri)
@@ -177,35 +175,44 @@ module Shaf
         false
       end
     end
+
+    def method_name(name, collection = false)
+      collection_str = "collection" if collection
+      [namespace, name, collection_str].compact.join('_')
+    end
   end
 
   class MethodBuilder
     def self.query_string(query)
-      return "" unless query.any?
-      "?#{query.map { |key,value| "#{key}=#{value}" }.join("&")}"
+      return '' unless query&.any?
+
+      fragment_id = query.delete(:fragment_id)
+      fragment_str = "##{fragment_id}" if fragment_id
+
+      query_str = query.map { |a| a.join('=') }.join('&')
+      query_str = "?#{query_str}" unless query_str.empty?
+
+      [query_str, fragment_str].join
     end
 
-    def initialize(name, uri, alt_uri: nil)
+    def initialize(name, uri)
       @name = name
-      @uri = uri
-      @alt_uri = alt_uri
+      @uri = uri.dup.freeze
     end
 
     def call
       if UriHelper.respond_to? uri_method_name
         exception = ResourceUris::UriHelperMethodAlreadyExistError
-        raise exception.new(@name, uri_method_name)
+        raise exception.new(name, uri_method_name)
       end
 
-      if @alt_uri.nil?
-        build_methods
-      else
-        build_methods_with_optional_arg
-      end
+      build_methods
     end
 
     private
 
+    attr_reader :name, :uri
+
     def build_methods
       UriHelperMethods.eval_method uri_method_string
       UriHelperMethods.eval_method path_method_string
@@ -215,21 +222,12 @@ module Shaf
       path_method_name.to_sym
     end
 
-    def build_methods_with_optional_arg
-      UriHelperMethods.eval_method uri_method_with_optional_arg_string
-      UriHelperMethods.eval_method path_method_with_optional_arg_string
-      UriHelperMethods.register(template_method_name, &template_proc)
-      UriHelperMethods.register(legacy_template_method_name, &template_proc)
-      UriHelperMethods.register(path_matcher_name, &path_matcher_proc)
-      path_method_name.to_sym
-    end
-
     def uri_method_name
-      "#{@name}_uri".freeze
+      "#{name}_uri".freeze
     end
 
     def path_method_name
-      "#{@name}_path".freeze
+      "#{name}_path".freeze
     end
 
     def path_matcher_name
@@ -244,81 +242,45 @@ module Shaf
       "#{uri_method_name}_template".freeze
     end
 
-    def uri_signature(optional_args: 0)
-      signature(uri_method_name, optional_args: optional_args)
+    def uri_signature(uri: @uri, optional_args: 0)
+      signature(uri_method_name, uri, optional_args: optional_args)
     end
 
-    def path_signature(optional_args: 0)
-      signature(path_method_name, optional_args: optional_args)
+    def path_signature(uri: @uri, optional_args: 0)
+      signature(path_method_name, uri, optional_args: optional_args)
     end
 
-    def signature(method_name, optional_args: 0)
-      s = "#{method_name}("
+    def signature(method_name, uri, optional_args: 0)
+      args = extract_symbols(uri).size.times.map { |i| "arg#{i}" }
+      sym_count = args.size
 
-      symbols = extract_symbols.size.times.map { |i| "arg#{i}" }
-      sym_count = symbols.size
+      optional_args.times { |i| args << "arg#{sym_count + i} = nil" }
+      args << '**query'
 
-      args = []
-      symbols.each_with_index do |arg, i|
-        if i < sym_count - optional_args
-          args << "arg#{i}"
-        else
-          args << "arg#{i} = nil"
-        end
-      end
-      s << (args.empty? ? "**query)" : "#{args.join(', ')}, **query)")
+      "#{method_name}(#{args.join(', ')})"
     end
 
     def uri_method_string
       base_uri = UriHelper.base_uri
-      <<~Ruby
+      <<~RUBY
         def #{uri_signature}
           query_str = Shaf::MethodBuilder.query_string(query)
-          \"#{base_uri}#{interpolated_uri_string(@uri)}\#{query_str}\".freeze
+          \"#{base_uri}#{interpolated_uri_string(uri)}\#{query_str}\".freeze
         end
-      Ruby
+      RUBY
     end
 
     def path_method_string
-      <<~Ruby
+      <<~RUBY
         def #{path_signature}
           query_str = Shaf::MethodBuilder.query_string(query)
-          \"#{interpolated_uri_string(@uri)}\#{query_str}\".freeze
+          \"#{interpolated_uri_string(uri)}\#{query_str}\".freeze
         end
-      Ruby
-    end
-
-    def uri_method_with_optional_arg_string
-      base_uri = UriHelper.base_uri
-      arg_no = extract_symbols.size - 1
-      <<~Ruby
-        def #{uri_signature(optional_args: 1)}
-          query_str = Shaf::MethodBuilder.query_string(query)
-          if arg#{arg_no}.nil?
-            \"#{base_uri}#{interpolated_uri_string(@alt_uri)}\#{query_str}\".freeze
-          else
-            \"#{base_uri}#{interpolated_uri_string(@uri)}\#{query_str}\".freeze
-          end
-        end
-      Ruby
-    end
-
-    def path_method_with_optional_arg_string
-      arg_no = extract_symbols.size - 1
-      <<~Ruby
-        def #{path_signature(optional_args: 1)}
-          query_str = Shaf::MethodBuilder.query_string(query)
-          if arg#{arg_no}.nil?
-            \"#{interpolated_uri_string(@alt_uri)}\#{query_str}\".freeze
-          else
-            \"#{interpolated_uri_string(@uri)}\#{query_str}\".freeze
-          end
-        end
-      Ruby
+      RUBY
     end
 
     def extract_symbols(uri = @uri)
-      uri.split('/').grep(/:.*/).map { |t| t[1..-1].to_sym }
+      uri.split('/').grep(/\A:.+/).map { |t| t[1..-1].to_sym }
     end
 
     def transform_symbols(uri)
@@ -334,44 +296,40 @@ module Shaf
       return uri if uri == '/'
 
       transform_symbols(uri) do |segment, i|
-        sym = segment[1..-1]
-        "\#{arg#{i}.respond_to?(#{segment}) ? arg#{i}.#{sym} : arg#{i}}"
+        # if the uri is templated (starting with a '{'), then we need to
+        # exclude it from the interpolated string but add it back to the end of
+        # the segment.
+        last = (segment.index('{') || 0) - 1
+        sym = segment[1..last]
+        template = segment[(last + 1)..-1] unless last == -1
+        "\#{arg#{i}.respond_to?(:#{sym}) ? arg#{i}.#{sym} : arg#{i}}#{template}"
       end
     end
 
     def template_proc
-      uri, alt_uri = @uri, @alt_uri
-
-      if alt_uri.nil?
-        ->(_ = nil) { uri.freeze }
-      else
-        ->(collection = false) { collection ? alt_uri : uri }
-      end
+      uri = @uri
+      -> { uri }
     end
 
-    def path_mather_patterns
-      [
-        @uri.gsub(%r{:[^/]*}, '\w+'),
-        @alt_uri&.gsub(%r{:[^/]*}, '\w+')
-      ].compact.map { |str| Regexp.new("\\A#{str}\\Z") }
+    def path_mather_pattern
+      pattern = uri.gsub(%r{:[^/]*}, '\w+')
+      Regexp.new("\\A#{pattern}\\Z")
     end
 
     def path_matcher_proc
-      patterns = path_mather_patterns
+      pattern = path_mather_pattern
 
-      lambda do |path = nil, collection: false|
+      lambda do |path = nil|
         unless path
           r = request if respond_to? :request
-          path = r.path_info if r&.respond_to? :path_info
-
-          unless path
-            raise(
-              ArgumentError,
-              "Uri must be given (or #{self} should respond to :request)"
-            )
-          end
+          path = r.path_info if r.respond_to? :path_info
+
+          raise(
+            ArgumentError,
+            "Uri must be given (or #{self} should respond to :request)"
+          ) unless path
         end
-        pattern = collection ? patterns.last : patterns.first
+
         !!(pattern =~ path)
       end
     end

data/lib/shaf/extensions/symbolic_routes.rb

@@ -2,32 +2,22 @@ module Shaf
   module SymbolicRoutes
     class UriHelperNotRegisterdError < Error; end
 
-    SUPPORTED_METHODS = [
-      :get,
-      :put,
-      :post,
-      :patch,
-      :delete,
-      :head,
-      :options,
-      :link,
-      :unlink
-    ].freeze
-
-    SUPPORTED_METHODS.each do |m|
-      define_method m do |path, collection: false, &block|
-        super(rewrite_path(path, collection), &block)
+    Shaf::SUPPORTED_HTTP_METHODS.each do |m|
+      define_method m do |path, **options, &block|
+        path = rewrite_path(path, m)
+        super(path, **options, &block)
       end
     end
 
-    def rewrite_path(path, collection = nil)
+    def rewrite_path(path, method)
       return path unless path.is_a? Symbol
 
-      m = "#{path}_template"
-      return send(m, collection) if respond_to? m
+      ["#{path}_template", "#{path}_path_template"].each do |method|
+        return send(method) if respond_to? method
+      end
 
       raise UriHelperNotRegisterdError, <<~RUBY
-        Undefined method '#{m}'. Did you forget to register a uri helper for #{path}?
+        Undefined method '#{method}'. Did you forget to register a uri helper for #{path}?
       RUBY
     end
   end

data/lib/shaf/extensions.rb

@@ -1,9 +1,9 @@
 require 'shaf/extensions/log'
 require 'shaf/extensions/resource_uris'
 require 'shaf/extensions/controller_hooks'
-require 'shaf/extensions/current_user'
 require 'shaf/extensions/authorize'
 require 'shaf/extensions/symbolic_routes'
+require 'shaf/extensions/api_routes'
 
 module Shaf
   def self.extensions
@@ -11,9 +11,9 @@ module Shaf
       Log,
       ResourceUris,
       ControllerHooks,
-      CurrentUser,
       Authorize,
-      SymbolicRoutes
+      SymbolicRoutes,
+      ApiRoutes # This extension must be registered after `SymbolicRoutes`!
     ]
   end
 end