shaf 2.1.0 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2dc76b4b8ddbc8c627a2f03eb3f3f889771a21cc950de357fc6d3d50a7ba3008
-  data.tar.gz: 5c6ab688fa85a69650e6741933b9ddbad4dd6d40693ce0998d9fb88b14e212ef
+  metadata.gz: c508aa7154d738ed2009c18256326f590917af8c24d60bfacfd5bb91613c4270
+  data.tar.gz: 49e9fec1c522764bb1a722623cfb49cf8de3d6d7e026355a09310a6099828711
 SHA512:
-  metadata.gz: 154deb196fe2f4583599024524bd21b06fadc039fb99971ed2360acffb65b1339c79c8b61edebbf230df558473ef9f11cc0baa54c79b52df0989c60d60e7debf
-  data.tar.gz: 49d240389e58f852e4445ccd321f83bb501d803bb957c328816d470ac5bb64c648e293be26b5dbda07e57649fe1987b339e4dc458e4d5f27c3b56e120f14adbe
+  metadata.gz: d1d2ddda76cb3e76470f4cbc0297e72ef3c3b9c6119a12d101d999a50bc0aab37a442067ddd0cb4fdd3e698d0446982e65d199e633e46d875175e087f3bc9a61
+  data.tar.gz: 3d2c97ed1362ac58addf9c282e37d8754adad5a994c421d72779e4576dd91c8cbd1bbfc67689d20bf51bc20410270f61752383d36b11eb9dcbe28883c6552440

data/lib/shaf/app.rb

@@ -1,25 +1,43 @@
-require 'shaf/middleware'
+require 'sinatra'
 
 module Shaf
   class App
     class << self
       # Either call `Shaf::App.run!`
       def run!
-        app.run!
+        instance.run!
       end
 
       # Or `run Shaf::App` (in config.ru)
       def call(*args)
-        app.call(*args)
+        instance.call(*args)
       end
 
+      def instance
+        # This works since Sinatra includes Sinatra::Delegator into
+        # Rack::Builder, which means that Rack::Builder#set will be delegated
+        # to Sinatra::Application
+        @instance ||= Rack::Builder.new(app) do
+          set :port, Settings.port || 3000
+        end
+      end
+
+      def use(middleware, *args, **kwargs, &block)
+        if args.empty? && kwargs.empty?
+          instance.use middleware, &block
+        elsif kwargs.empty?
+          instance.use middleware, *args, &block
+        elsif args.empty?
+          instance.use middleware, **kwargs, &block
+        else
+          instance.use middleware, *args, **kwargs, &block
+        end
+      end
+
+      private
+
       def app
-        @app ||=
-          Sinatra.new.tap do |app|
-            app.set :port, Settings.port || 3000
-            app.use Middleware::RequestId
-            app.use Router
-          end
+        Router.new
       end
     end
   end

data/lib/shaf/command/base.rb

@@ -23,6 +23,10 @@ module Shaf
           @usage = str || block
         end
 
+        def identified_by
+          @identifiers
+        end
+
         def exit_with_error(msg, status)
           STDERR.puts msg
           exit status

data/lib/shaf/command/new.rb

@@ -47,8 +47,12 @@ module Shaf
         settings_file = 'config/settings.yml'
         template_file = File.expand_path("../templates/#{settings_file}.erb", __FILE__)
         content = File.read(template_file)
+        locals = {
+          project_name: project_name.capitalize,
+          default_port: "<%= ENV.fetch('PORT', 3000) %>"
+        }
         File.write settings_file,
-                   erb(content, project_name: project_name.capitalize)
+                   erb(content, locals)
       end
 
       def erb(content, locals = {})

data/lib/shaf/command/server.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require 'rack'
 
 module Shaf
   module Command
@@ -16,7 +17,10 @@ module Shaf
       def call
         Settings.port = options[:port] if options[:port]
         bootstrap
-        App.run!
+        Rack::Server.start(
+          app: App,
+          Port: Settings.port
+        )
       end
     end
   end

data/lib/shaf/command/templates/config/settings.yml.erb

@@ -1,23 +1,24 @@
 ---
 default: &default
-  project_name: <%= project_name %>
-  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
+  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/extensions/resource_uris.rb

@@ -106,26 +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
-        # Deprecated code path
-        # Remove this branch and only keep the `else` behavior when dropping
-        # support for this
-        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
@@ -133,51 +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
-      method_name = plural_name
-      method_name = "#{name}_collection" if name == @plural_name
-      register(method_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
-      register_collection_helper
-      return 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)
@@ -194,11 +175,14 @@ 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
-    NO_GIVEN_VALUE = Object.new
-
     def self.query_string(query)
       return '' unless query&.any?
 
@@ -211,10 +195,9 @@ module Shaf
       [query_str, fragment_str].join
     end
 
-    def initialize(name, uri, alt_uri: nil)
+    def initialize(name, uri)
       @name = name
       @uri = uri.dup.freeze
-      @alt_uri = alt_uri.dup.freeze
     end
 
     def call
@@ -223,16 +206,12 @@ module Shaf
         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, :alt_uri
+    attr_reader :name, :uri
 
     def build_methods
       UriHelperMethods.eval_method uri_method_string
@@ -243,15 +222,6 @@ 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
     end
@@ -309,53 +279,6 @@ module Shaf
       RUBY
     end
 
-    def uri_method_with_optional_arg_string
-      base_uri = UriHelper.base_uri
-      arg_no = extract_symbols(alt_uri).size
-      <<~RUBY
-        def #{uri_signature(uri: alt_uri, optional_args: 1)}
-          query_str = Shaf::MethodBuilder.query_string(query)
-          if arg#{arg_no}.nil?
-            warn <<~DEPRECATION
-
-              Deprecated use of collection uri helper:
-              To get the collection uri use ##{name}_collection_uri instead of ##{uri_method_name}.
-              Or pass an argument to ##{uri_method_name} to get the uri to a resource.
-                \#{caller.find { |s| !s.match? %r{lib/shaf/extensions/resource_uris.rb} }}
-
-            DEPRECATION
-
-            \"#{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(alt_uri).size
-      <<~RUBY
-        def #{path_signature(uri: alt_uri, optional_args: 1)}
-          query_str = Shaf::MethodBuilder.query_string(query)
-          if arg#{arg_no}.nil?
-            warn <<~DEPRECATION
-
-              Deprecated use of collection path helper:
-              To get the collection path use ##{name}_collection_path instead of ##{path_method_name}.
-              Or pass an argument to ##{path_method_name} to get the path to a resource.
-                \#{caller.find { |s| !s.match? %r{lib/shaf/extensions} }}
-
-            DEPRECATION
-
-            \"#{interpolated_uri_string(alt_uri)}\#{query_str}\".freeze
-          else
-            \"#{interpolated_uri_string(uri)}\#{query_str}\".freeze
-          end
-        end
-      RUBY
-    end
-
     def extract_symbols(uri = @uri)
       uri.split('/').grep(/\A:.+/).map { |t| t[1..-1].to_sym }
     end
@@ -384,70 +307,29 @@ module Shaf
     end
 
     def template_proc
-      uri, alt_uri = @uri, @alt_uri
-
-      if alt_uri.nil?
-        -> { uri }
-      else
-        deprecated_method = template_method_name
-        replacing_method = "#{name}_collection_path_template"
-
-        lambda do |collection = NO_GIVEN_VALUE|
-          if collection != NO_GIVEN_VALUE
-            warn <<~DEPRECATION
-
-              Deprecated use of uri template helper with `collection` argument:
-              Use #{replacing_method} instead of #{deprecated_method}"
-                #{caller.find { |s| !s.match? %r{lib/shaf/extensions} }}
-
-            DEPRECATION
-          else
-            collection = false
-          end
-
-          collection ? alt_uri : uri
-        end
-      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
-
-      deprecated_method = path_matcher_name
-      replacing_method = "#{name}_collection_path?"
-
-      lambda do |path = nil, collection: NO_GIVEN_VALUE|
-        if collection != NO_GIVEN_VALUE
-          warn <<~DEPRECATION
-
-            Deprecated use of uri predicate helper with `collection` argument:
-            Use #{replacing_method} instead of #{deprecated_method}(collection: true)
-              #{caller.find { |s| !s.match? %r{lib/shaf/extensions} }}
-
-          DEPRECATION
-        else
-          collection = false
-        end
+      pattern = path_mather_pattern
 
+      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

@@ -4,30 +4,17 @@ module Shaf
 
     Shaf::SUPPORTED_HTTP_METHODS.each do |m|
       define_method m do |path, **options, &block|
-        collection = options.delete(:collection)
-        path = rewrite_path(path, collection, m)
+        path = rewrite_path(path, m)
         super(path, **options, &block)
       end
     end
 
-    def rewrite_path(path, collection, method)
+    def rewrite_path(path, method)
       return path unless path.is_a? Symbol
 
-      warn <<~DEPRECATION unless collection.nil?
-        Deprecated use of declaring route with collection keyword argument:
-        Use `#{method} :#{path.to_s.sub(/_(path|uri)/, '_collection_path')} do`
-        instead of `#{method} :#{path}, collection: #{collection} do`
-        #{caller.find { |s| s.match?(/_controller.rb/) }}
-
-      DEPRECATION
-
-      method = "#{path}_template"
-      send_args = [method]
-      send_args << collection unless collection.nil?
-      return send(*send_args) if respond_to? method
-
-      method = "#{path}_path_template"
-      return send(*send_args) if respond_to? method
+      ["#{path}_template", "#{path}_path_template"].each do |method|
+        return send(method) if respond_to? method
+      end
 
       raise UriHelperNotRegisterdError, <<~RUBY
         Undefined method '#{method}'. Did you forget to register a uri helper for #{path}?

data/lib/shaf/formable/builder.rb

@@ -1,11 +1,56 @@
+require 'forwardable'
 require 'shaf/formable/form'
+require 'shaf/immutable_attr'
 
 module Shaf
   module Formable
     class Builder
-      InstanceAccessorType = Struct.new(:prefill?)
       DELEGATES = %i[title name action method type submit fields].freeze
 
+      class FormWrapper
+        extend Forwardable
+        extend Shaf::ImmutableAttr
+
+        attr_accessor :instance_accessor
+        immutable_reader :form
+
+        WRITER_DELEGATES = DELEGATES.map { |method| :"#{method}=" }
+        def_delegators :@form, :add_field, *WRITER_DELEGATES
+
+        def initialize(form, method_name: nil, instance_accessor: nil)
+          @form = form&.dup || Formable::Form.new
+          @method_name = method_name
+          @form.action = action_from(method_name) unless @form.action
+          @instance_accessor = instance_accessor
+        end
+
+        def action_from(method_name)
+          return unless method_name
+
+          (method_name.to_s.delete_suffix('_form')).to_sym
+        end
+
+        def method_name
+          name = @method_name || form.action
+
+          if name.nil?
+            nil
+          elsif name.to_s.end_with? '_form'
+            name.to_sym
+          else
+            :"#{name}_form"
+          end
+        end
+
+        def instance_accessor?
+          [:empty, :prefill].include? instance_accessor
+        end
+
+        def prefill?
+          instance_accessor == :prefill
+        end
+      end
+
       attr_reader :forms
 
       def initialize(&block)
@@ -15,48 +60,42 @@ module Shaf
         exec_with_form(block)
       end
 
-      def instance_accessor_for(form)
-        @instance_accessors[form.action]
-      end
-
       private
 
-      attr_reader :form
+      attr_reader :current
 
-      def exec_with_form(block, action: nil)
-        current, @form = form, new_form
-        form.action = action if action
+      def exec_with_form(block, method_name: nil)
+        prev, @current = current, new_form(method_name)
         instance_exec(&block)
       ensure
-        @form = current
+        @current = prev
       end
 
-      def new_form
-        (form&.dup || Formable::Form.new).tap { |f| @forms << f }
+      def new_form(method_name)
+        FormWrapper.new(current&.form, method_name: method_name).tap { |f| @forms <<  f }
       end
 
       def instance_accessor(prefill: true)
-        acc = InstanceAccessorType.new(prefill)
-        @instance_accessors[form.action] = acc
+        current.instance_accessor = prefill ? :prefill : :empty
       end
 
       DELEGATES.each do |name|
         define_method(name) do |arg|
-          form.send(:"#{name}=", arg)
+          current.send(:"#{name}=", arg)
         end
       end
 
       def field(name, opts = {})
-        form.add_field(name, opts)
+        current.add_field(name, opts)
       end
 
       def method_missing(method, *args, &block)
         return super unless args.empty? && block
-        exec_with_form(block, action: method)
+        exec_with_form(block, method_name: method)
       end
 
-      def respond_to_missing?(*)
-        true
+      def respond_to_missing?(method, _include_private = false)
+        method.to_s.end_with?('_form') ? true : super
       end
     end
   end

data/lib/shaf/formable/form.rb

@@ -12,14 +12,15 @@ module Shaf
       DEFAULT_SUBMIT = 'save'.freeze
 
       attr_accessor :resource
-      immutable_accessor :title, :name, :href, :type, :submit, :self_link
-      immutable_reader :fields, :action
+      attr_writer :name, :action
+      immutable_accessor :title, :href, :type, :submit, :self_link
+      immutable_reader :fields
 
       def initialize(params = {})
         @title = params[:title]
         @action = params[:action]
-        @name = params[:name]&.to_sym || name_from(@action)
-        @method = params[:method] ||= http_method_from(@action)
+        @name = params[:name]
+        @method = params[:method]
         @type = params[:type] || DEFAULT_TYPE
         @submit = params[:submit] || DEFAULT_SUBMIT
         @fields = (params[:fields] || {}).map do |name, args|
@@ -27,23 +28,25 @@ module Shaf
         end
       end
 
+      def name
+        (@name || name_from(action))&.to_sym
+      end
+
       def method=(http_method)
         @method = http_method.to_s.upcase
       end
 
       def method
-        return unless @method
-        @method.to_s.upcase
+        _method = @method || http_method_from(action)
+        _method.to_s.upcase if _method
       end
 
       def fields=(fields)
         @fields = fields.map { |name, args| Field.new(name, args) }
       end
 
-      def action=(action)
-        @action = action
-        @name ||= name_from action
-        @method ||= http_method_from action
+      def action
+        @action&.to_sym
       end
 
       def add_field(name, opts)