leanweb 0.1.3 → 0.3.0

data/lib/leanweb/controller.rb

@@ -2,19 +2,20 @@
 
 # Copyright 2022 Felix Freeman <libsys@hacktivista.org>
 #
-# This file is part of "LeanWeb" and licensed under the terms of the Hacktivista
-# General Public License version 0.1 or (at your option) any later version. You
-# should have received a copy of this license along with the software. If not,
-# see <https://hacktivista.org/licenses/>.
+# This file is part of "LeanWeb" and licensed under the terms of the GNU Affero
+# General Public License version 3 with permissions for compatibility with the
+# Hacktivista General Public License. You should have received a copy of this
+# license along with the software. If not, see <https://gnu.org/licenses/>.
 
 require 'rack'
+require 'tilt'
 
 module LeanWeb
   # Controller is a base controller with `@route`, `@request` and `@response`
-  # private attributes that will be shared with your views when you {render}
-  # Haml documents.
+  # private attributes that will be shared with your views when you
+  # {#render_response}.
   #
-  # Even if you don't {render}, you can use the `.finish` method from
+  # Even if you don't {#render_response}, you can use the `.finish` method from
   # `Rack::Response` on `@response` to return a proper `Rack` response.
   class Controller
     # @param route [Route]
@@ -23,67 +24,68 @@ module LeanWeb
       @route = route
       @request = request
       @response = Rack::Response.new(nil, 200)
+      @content_for = {}
     end
 
-    # Render magic. Supports dynamic (and static) Haml documents, other
-    # documents don't support dynamic data.
-    #
-    # Depending on {Route#path} and {render} `path` you will render different
-    # documents:
-    #
-    # - {Route#path} `/a/b/c` and `render('d')` will render `src/views/a/b/d`
-    # - {Route#path} `/a/b/c/` and `render('d')` will render `src/views/a/b/c/d`
-    # - `render('~/custom')` will render `src/views/custom`.
-    # - `render('/custom')` will render `/custom`.
+    # Render magic. Supports every file extension that Tilt supports. Defaults
+    # to ERB when file extension is unknown.
     #
     # @param path [String] Might be an absolute path or a relative path to
-    #   `src/views/` + the parent path of the last non-capture-group on
-    #   `@route.path`. You can also make it relative to {LeanWeb::VIEW_PATH} by
-    #   prepending `~`.
+    #   `src/views/`.
     # @param content_type [String] Defaults to the proper Content-Type for file
     #   extension, `text/plain` on unknown files.
+    # @yield Optionally pass a block for nested rendering.
+    # @return [Rack::Request#finish] A valid Rack response.
+    def render_response(path, content_type = nil, &block)
+      template = create_template(path)
+      @response.set_header(
+        'Content-Type',
+        content_type || template.class.metadata[:mime_type] || 'text/plain'
+      )
+      @response.write(template.render(self){ block.call if block_given? })
+      @response.finish
+    end
+
+    # Template rendering engine. Useful for partials / nested views.
     #
-    # @return [Rack::Request#finish] A valid rack response.
-    def render(path, content_type = nil) # rubocop:disable Metrics/MethodLength
+    # @param path [String] Same as on {#render_response}.
+    # @param options [Hash] Options for Tilt, defaults to
+    #   template_defaults[extension].
+    # @return [String] Rendered `path`.
+    def create_template(path, options = nil)
       path = absolute_view_path(path)
-      content = File.read(path)
-      case File.extname(path)
-      when '.haml'
-        require('haml')
-        @response.write(Haml::Engine.new(content).render(binding))
-        @response.set_header('Content-Type', content_type || 'text/html')
-      else
-        require('erb')
-        @response.write(ERB.new(content).result(binding))
-        @response.set_header('Content-Type', content_type || 'text/plain')
-      end
-      @response.finish
+      ext = File.extname(path)[1..] || ''
+      ext = 'erb' unless Tilt.registered?(ext)
+      Tilt[ext].new(path, 1, options || template_defaults[ext] || {})
+    end
+
+    # Relative route to path from public directory considering current route.
+    #
+    # @param path [String] path from public directory, never begins with `/`.
+    def base_url(path = '.')
+      @base_url ||= @route.str_path[1..]
+        .sub(%r{[^/]*$}, '')
+        .gsub(%r{[^/]+}, '..')
+
+      @base_url + path
+    end
+
+    # Request params.
+    def params
+      @request.params
     end
 
     protected
 
-    # @param relative_path [String]
-    # @return [String] Full path.
-    def absolute_view_path(relative_path)
-      case relative_path[0]
-      when '/'
-        relative_path
-      when '~'
-        relative_path.sub('~', LeanWeb::VIEW_PATH)
-      else
-        "#{view_path_by_route_path}/#{relative_path}"
-      end
+    # Set default options for Tilt in the format 'extension' => { options }.
+    def template_defaults
+      {}
     end
 
-    def view_path_by_route_path
-      LeanWeb::VIEW_PATH +
-        if @route.path.instance_of?(Regexp)
-          File.dirname(@route.str_path.sub(%r{/?\(.*}, ''))
-        elsif @route.path[-1] != '/'
-          File.dirname(@route.path)
-        else
-          @route.path.chomp('/')
-        end
+    # @param path [String]
+    # @return [String] Full path.
+    def absolute_view_path(path)
+      path[0] == '/' ? path : "#{LeanWeb::VIEW_PATH}/#{path}"
     end
   end
 end

data/lib/leanweb/helpers.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Copyright 2022 Felix Freeman <libsys@hacktivista.org>
+#
+# This file is part of "LeanWeb" and licensed under the terms of the GNU Affero
+# General Public License version 3 with permissions for compatibility with the
+# Hacktivista General Public License. You should have received a copy of this
+# license along with the software. If not, see <https://gnu.org/licenses/>.
+
+
+module LeanWeb
+  # String refinements.
+  module StringRefinements
+    refine ::String do
+      # String to PascalCase.
+      def pascalize
+        camelize(pascal: true)
+      end
+
+      # String to camelCase.
+      # @param pascal [Boolean] If true first letter is uppercase.
+      def camelize(pascal: false)
+        str = gsub(/[-_\s]+(.?)/){ |match| match[1].upcase }
+        str[0] = pascal ? str[0].upcase : str[0].downcase
+        str
+      end
+
+      # String to snake_case
+      def snakeize
+        gsub(/[[:upper:]]/){ |match| "_#{match.downcase}" }.delete_prefix('_')
+      end
+    end
+  end
+end

data/lib/leanweb/route.rb

@@ -2,47 +2,60 @@
 
 # Copyright 2022 Felix Freeman <libsys@hacktivista.org>
 #
-# This file is part of "LeanWeb" and licensed under the terms of the Hacktivista
-# General Public License version 0.1 or (at your option) any later version. You
-# should have received a copy of this license along with the software. If not,
-# see <https://hacktivista.org/licenses/>.
+# This file is part of "LeanWeb" and licensed under the terms of the GNU Affero
+# General Public License version 3 with permissions for compatibility with the
+# Hacktivista General Public License. You should have received a copy of this
+# license along with the software. If not, see <https://gnu.org/licenses/>.
 
+require 'rack/mock'
 
 module LeanWeb
   # Action for {Route#action}.
-  Action = Struct.new(:file, :controller, :action, keyword_init: true)
+  Action = Struct.new(:controller, :action, keyword_init: true)
 
-  # A single route which routes with the {respond} method. It can also {build}
+  # A single route which routes with the {#respond} method. It can also {#build}
   # an static file.
   class Route
+    using StringRefinements
+
     attr_reader :path, :method, :action, :static
 
     # A new instance of Route.
     #
     # @param path [String, Regexp] Path matcher, can be an String or Regexp with
     #   positional or named capture groups, `@action` will receive these as
-    #   positional or named arguments.
+    #   positional or named arguments. Always begins with `/`.
     # @param method [String, nil] Must be an HTTP verb such as `GET` or `POST`.
     # @param action [Proc, Hash, String, nil] References a Method/Proc to be
     #   triggered. It can be:
     #
-    #   - A full hash `{ file: 'val', controller: 'val', action: 'val' }`.
-    #   - A hash with `{ 'file' => 'action' }` only (which has a controller
-    #     class name `{File}Controller`).
-    #   - A simple string (which will consider file `main.rb` and controller
-    #     `MainController`). Defaults to "{path_basename}_{method}", (ex:
-    #     `index_get`).
-    #   - It can also be a `Proc`.
+    #   - Nothing, defaults to :"{#path_basename}_{#method}" (such as
+    #     `:index_get`) on `:MainController`.
+    #   - A full hash `{ controller: 'val', action: 'val' }`.
+    #   - A hash with `{ Controller: :action }` only.
+    #   - A simple string for an action on `:MainController`.
+    #   - It can also be a `Proc`. Will be executed in a `:MainController`
+    #     instance context.
     #
-    # @param static [Boolean|Array] Defines a route as static. Set to `false` to
-    #   say it can only work dynamically. You can also supply an array of arrays
-    #   or hashes to generate static files based on that positional or keyword
-    #   params.
-    def initialize(path:, method: 'GET', action: nil, static: true)
+    # @param static [Boolean|Array] Defines a route as static. Defaults true for
+    #   GET method, false otherwise. Set to `false` to say it can only work
+    #   dynamically. You can also supply an array of arrays or hashes to
+    #   generate static files based on that positional or keyword params.
+    def initialize(path:, method: 'GET', action: nil, static: nil)
       @path = path
       @method = method
       self.action = action
-      @static = static
+      @static = static.nil? ? @method == 'GET' : static
+    end
+
+    # Check if route is available.
+    #
+    # If on production environment (not `development`), should serve only
+    # dynamic (not `static`) routes.
+    def available?
+      return @static == false if ENV['RACK_ENV'] != 'development'
+
+      true
     end
 
     # Last identifier on a path, returns `index` for `/`.
@@ -51,14 +64,14 @@ module LeanWeb
     end
 
     # @param request [Rack::Request]
-    # @return a valid rack response.
+    # @return [Array] a valid rack response.
     def respond(request)
       return respond_proc(request) if @action.instance_of?(Proc)
 
       respond_method(request)
     end
 
-    # String path, independent if {path} is Regexp or String.
+    # String path, independent if {#path} is Regexp or String.
     def str_path
       @path.source.gsub(/[\^$]/, '')
     rescue NoMethodError
@@ -66,26 +79,26 @@ module LeanWeb
     end
 
     # On Regexp paths, return a string valid for making a request to this route.
+    #
     # @param seed [Array, Hash] Seeds to use as replacement on capture groups.
     # @return [String] sown path.
     def seed_path(seed)
       sown_path = str_path
       if seed.instance_of?(Hash)
-        seed.each { |key, val| sown_path.sub!(/\(\?<#{key}>[^)]+\)/, val) }
+        seed.each{ |key, val| sown_path.sub!(/\(\?<#{key}>[^)]+\)/, val) }
       else
-        seed.each { |val| sown_path.sub!(/\([^)]+\)/, val) }
+        seed.each{ |val| sown_path.sub!(/\([^)]+\)/, val) }
       end
       sown_path
     end
 
     # Build this route as an static file and place it relative to
     #   {LeanWeb::PUBLIC_PATH}.
+    #
     # @param request_path [String] Request path for dynamic (regex) routes.
     def build(request_path = @path)
       response = respond(
-        Rack::Request.new(
-          { 'PATH_INFO' => request_path, 'REQUEST_METHOD' => 'GET' }
-        )
+        Rack::Request.new(Rack::MockRequest.env_for(request_path))
       )
       out_path = output_path(request_path, response[1]['Content-Type'] || nil)
       FileUtils.mkdir_p(File.dirname(out_path))
@@ -97,48 +110,62 @@ module LeanWeb
 
     # Assign value to `@action`.
     def action=(value)
-      @action = if value.instance_of?(Proc)
-                  value
-                else
-                  Action.new(**prepare_action_hash(value))
-                end
+      @action =
+        if value.instance_of?(Proc)
+          value
+        else
+          Action.new(**prepare_action_hash(value))
+        end
     end
 
-    # @param value [Hash, String, nil] Check {initialize} action param for
+    # @param src_value [Hash, String, nil] Check {#initialize} action param for
     #   valid input.
     # @return [Hash] valid hash for {Action}.
-    def prepare_action_hash(value)
-      begin
-        value[:file], value[:action] = value.first \
-          unless %i[file controller action].include?(value.keys.first)
-      rescue NoMethodError
-        value = { action: value }
-      end
-      value[:file] ||= 'main'
-      value[:controller] ||= "#{value[:file].capitalize}Controller"
-      value[:action] ||= "#{path_basename}_#{@method.downcase}"
+    def prepare_action_hash(src_value)
+      value = prepare_prepare_action_hash(src_value)
+      value[:controller] = value[:controller]&.to_sym || DEFAULT_CONTROLLER
+      value[:action] = value[:action]&.to_sym || default_action_action
       value
     end
 
+    def prepare_prepare_action_hash(src_value)
+      if %i[controller action].include?(src_value.keys.first)
+        src_value
+      else
+        value = {}
+        value[:controller], value[:action] = src_value.first
+        value
+      end
+    rescue NoMethodError
+      { action: src_value }
+    end
+
+    def default_action_action
+      "#{path_basename.gsub('-', '_')}_#{@method.downcase}".to_sym
+    end
+
     # @param request [Rack::Request]
-    # @return a valid rack response.
+    # @return [Array] a valid Rack response.
     def respond_method(request)
       params = action_params(request.path)
-      require_relative("#{LeanWeb::CONTROLLER_PATH}/#{@action.file}")
+      require_relative("#{CONTROLLER_PATH}/#{@action.controller.to_s.snakeize}")
       controller = Object.const_get(@action.controller).new(self, request)
-      return controller.public_send(@action.action, **params)\
+      return controller.public_send(@action.action, **params) \
         if params.instance_of?(Hash)
 
       controller.public_send(@action.action, *params)
     end
 
     # @param request [Rack::Request]
-    # @return a valid rack response.
+    # @return [Array] a valid Rack response.
     def respond_proc(request)
       params = action_params(request.path)
-      return @action.call(**params) if params.instance_of?(Hash)
+      require_relative("#{CONTROLLER_PATH}/#{DEFAULT_CONTROLLER.to_s.snakeize}")
+      controller = Object.const_get(DEFAULT_CONTROLLER).new(self, request)
+      return controller.instance_exec(**params, &@action) \
+        if params.instance_of?(Hash)
 
-      @action.call(*params)
+      controller.instance_exec(*params, &@action)
     end
 
     # @param request_path [String]
@@ -147,19 +174,30 @@ module LeanWeb
       return nil unless @path.instance_of?(Regexp)
 
       matches = @path.match(request_path)
-      return matches.named_captures.transform_keys(&:to_sym)\
+      return matches.named_captures.transform_keys(&:to_sym) \
         if matches.named_captures != {}
 
       matches.captures
     end
 
     # Output path for public file.
+    #
     # @param path [String]
     # @param content_type [String]
     # @return [String] absolute route to path + extension based on content_type.
     def output_path(path, content_type)
-      path += 'index' if path[-1] == '/'
-      "#{LeanWeb::PUBLIC_PATH}#{path}#{LeanWeb::MEDIA_EXTENSIONS[content_type]}"
+      out_path =
+        if path[-1] == '/'
+          String.new("#{PUBLIC_PATH}#{path}/index")
+        else
+          String.new("#{PUBLIC_PATH}#{path}")
+        end
+
+      unless path.end_with?(MEDIA_EXTENSIONS[content_type])
+        out_path << MEDIA_EXTENSIONS[content_type]
+      end
+
+      out_path
     end
   end
 end

data/lib/leanweb/version.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Copyright 2022 Felix Freeman <libsys@hacktivista.org>
+#
+# This file is part of "LeanWeb" and licensed under the terms of the GNU Affero
+# General Public License version 3 with permissions for compatibility with the
+# Hacktivista General Public License. You should have received a copy of this
+# license along with the software. If not, see <https://gnu.org/licenses/>.
+
+
+module LeanWeb
+  VERSION = '0.3.0'
+end

data/lib/leanweb.rb

@@ -2,16 +2,16 @@
 
 # Copyright 2022 Felix Freeman <libsys@hacktivista.org>
 #
-# This file is part of "LeanWeb" and licensed under the terms of the Hacktivista
-# General Public License version 0.1 or (at your option) any later version. You
-# should have received a copy of this license along with the software. If not,
-# see <https://hacktivista.org/licenses/>.
+# This file is part of "LeanWeb" and licensed under the terms of the GNU Affero
+# General Public License version 3 with permissions for compatibility with the
+# Hacktivista General Public License. You should have received a copy of this
+# license along with the software. If not, see <https://gnu.org/licenses/>.
 
 # LeanWeb is a minimal hybrid static / dynamic web framework.
 module LeanWeb
-  VERSION = '0.1.3'
+  require_relative 'leanweb/version'
 
-  ROOT_PATH = ENV['LEANWEB_ROOT_PATH'] || Dir.pwd
+  ROOT_PATH = ENV.fetch('LEANWEB_ROOT_PATH', Dir.pwd)
   CONTROLLER_PATH = "#{ROOT_PATH}/src/controllers"
   VIEW_PATH = "#{ROOT_PATH}/src/views"
   PUBLIC_PATH = "#{ROOT_PATH}/public"
@@ -21,10 +21,16 @@ module LeanWeb
     'application/javascript' => '.js',
     'application/json' => '.json',
     'text/html' => '.html',
-    'text/plain' => '.txt'
+    'text/plain' => '.txt',
+    'text/css' => '.css',
+    'text/csv' => '.csv'
   }.freeze
 
+  DEFAULT_CONTROLLER = :MainController
+
   autoload :Route, 'leanweb/route.rb'
   autoload :Controller, 'leanweb/controller.rb'
   autoload :App, 'leanweb/app.rb'
 end
+
+require_relative 'leanweb/helpers'