leanweb 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f0437a01908da014f67d9ff669d421e9334233e4e30563ae4b3d77ebb8c7385c
+  data.tar.gz: f7e810131f740cc6357ec039b4b246c650169db78ee593a88f3377e7f594a342
+SHA512:
+  metadata.gz: b155fa1e345bac7b955a9c026c7a4eabab5166646fa59d731224234aa3fe2f702298de18d63eb37d8d7a8939857998c9465405002868b34909d04f690bd0c099
+  data.tar.gz: 76784d5a2b39cd6539bdd444ff57bbe346d0eb2a36c363dbf6e6349726aee0b0662e4300d6999790a92d8742d732426dfcec6b4505fe081daa8c73a6979995e5

data/bin/leanweb

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+
+# 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/>.
+
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'leanweb'
+
+# Script for building a new project.
+
+files = [
+  {
+    filename: 'Gemfile',
+    content: <<~RUBY
+      # frozen_string_literal: true
+
+      source 'https://rubygems.org'
+
+      gem 'leanweb', '~> #{LeanWeb::VERSION}'
+    RUBY
+  }, {
+    filename: 'config.ru',
+    content: <<~RUBY
+      # frozen_string_literal: true
+
+      require 'leanweb'
+
+      if ENV['RACK_ENV'] == 'development'
+        use(Rack::Reloader, 0)
+        use(Rack::Static, urls: [''], root: 'public', cascade: true)
+      end
+
+      app = LeanWeb::App.init
+      run app
+    RUBY
+  }, {
+    filename: 'routes.rb',
+    content: <<~RUBY
+      # frozen_string_literal: true
+
+      [{ path: '/' }]
+    RUBY
+  }, {
+    filename: 'Rakefile',
+    content: <<~RUBY
+      # frozen_string_literal: true
+
+      require 'leanweb'
+
+      task default: %w[build]
+
+      task :build do
+        LeanWeb::App.init.build_static
+      end
+    RUBY
+  }, {
+    filename: 'src/controllers/main.rb',
+    content: <<~RUBY
+      # frozen_string_literal: true
+
+      require 'leanweb'
+
+      # Main controller is the default controller
+      class MainController < LeanWeb::Controller
+        def index_get
+          render 'index.haml'
+        end
+      end
+    RUBY
+  }, {
+    filename: 'src/views/index.haml',
+    content: <<~HAML
+      !!!
+      %html
+        %head
+          %meta{charset: "utf-8"}
+          %meta{name: "viewport", content: "width=device-width, initial-scale=1"}
+          %title LeanWeb framework
+        %body
+          %h1 It works!
+    HAML
+  }
+]
+
+if !(1..2).include?(ARGV.size) || ARGV[0] != 'new'
+  puts 'Usage: leanweb new [directory]'
+  exit(1)
+end
+
+begin
+  path = ARGV[1] || '.'
+  FileUtils.mkdir_p(path)
+  FileUtils.cd(path)
+  FileUtils.mkdir_p(['public', 'src/controllers', 'src/views'])
+  files.each { |file| File.write(file[:filename], file[:content]) }
+  `git init`
+  puts("Project '#{File.basename(Dir.getwd)}' successfully created.")
+rescue # rubocop:disable Style/RescueStandardError
+  puts('Woops! Something went wrong.')
+  raise
+end

data/lib/leanweb/app.rb

@@ -0,0 +1,72 @@
+# 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/>.
+
+# frozen_string_literal: true
+
+require 'rack'
+
+module LeanWeb
+  # App resolves and builds static files from routes.
+  class App
+    attr_accessor :routes
+
+    # @param routes [Hash] Hash of routes with {Route} attributes.
+    def initialize(routes)
+      @routes = routes
+    end
+
+    # Entry point for dynamic routes (Rack).
+    # @param env [Hash] `env` for Rack.
+    def call(env)
+      request = Rack::Request.new(env)
+      route = @routes.find do |r|
+        (r[:method] || 'GET') == request.request_method && begin
+          r[:path] =~ request.path
+        rescue TypeError
+          r[:path] == request.path
+        end
+      end
+      return [404, {}, ['Not found']] unless route_exists?(route)
+
+      Route.new(**route).respond(request)
+    end
+
+    # Build static routes to files.
+    def build_static
+      @routes.each do |route|
+        route = Route.new(**route)
+        next unless route.static
+
+        begin
+          route.static.each { |seed| route.build(route.seed_path(seed)) }
+        rescue NoMethodError
+          route.build
+        end
+      end
+    end
+
+    # Initialize by evaluating the routes file.
+    # Do this here so users don't freak out for using eval and rubocop is happy
+    # on client side.
+    # @param file [String] Routes file.
+    def self.init(file = 'routes.rb')
+      new(eval(File.read(file))) # rubocop:disable Security/Eval
+    end
+
+    protected
+
+    # Check if route exists.
+    # If not on development environment, serve only dynamic routes.
+    # @param route [Hash]
+    def route_exists?(route)
+      return false if route.nil? \
+        || (ENV['RACK_ENV'] != 'development' && route[:static] != false)
+
+      true
+    end
+  end
+end

data/lib/leanweb/controller.rb

@@ -0,0 +1,89 @@
+# 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/>.
+
+# frozen_string_literal: true
+
+require 'rack'
+
+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.
+  #
+  # Even if you don't {render}, you can use the `.finish` method from
+  # `Rack::Response` on `@response` to return a proper `Rack` response.
+  class Controller
+    # @param route [Route]
+    # @param request [Rack::Request]
+    def initialize(route, request = nil)
+      @route = route
+      @request = request
+      @response = Rack::Response.new(nil, 200)
+    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`.
+    #
+    # @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 `~`.
+    # @param content_type [String] Defaults to the proper Content-Type for file
+    # extension, `text/plain` on unknown files.
+    #
+    # @return [Rack::Request#finish] A valid rack response.
+    def render(path, content_type = nil) # rubocop:disable Metrics/MethodLength
+      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
+    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
+    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
+    end
+  end
+end

data/lib/leanweb/route.rb

@@ -0,0 +1,164 @@
+# 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/>.
+
+# frozen_string_literal: true
+
+module LeanWeb
+  # Action for {Route#action}.
+  Action = Struct.new(:file, :controller, :action, keyword_init: true)
+
+  # A single route which routes with the {#respond} method. It can also {#build}
+  # an static file.
+  class Route
+    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.
+    # @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`.
+    #
+    # @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)
+      @path = path
+      @method = method
+      self.action = action
+      @static = static
+    end
+
+    # Last identifier on a path, returns `index` for `/`.
+    def path_basename
+      str_path[-1] == '/' ? 'index' : File.basename(str_path)
+    end
+
+    # @param request [Rack::Request]
+    # @return 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.
+    def str_path
+      @path.source.gsub(/[\^$]/, '')
+    rescue NoMethodError
+      @path
+    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) }
+      else
+        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' }
+        )
+      )
+      out_path = output_path(request_path, response[1]['Content-Type'] || nil)
+      FileUtils.mkdir_p(File.dirname(out_path))
+
+      File.write(out_path, response[2][0])
+    end
+
+    protected
+
+    # Assign value to `@action`.
+    def action=(value)
+      @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
+    #   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}"
+      value
+    end
+
+    # @param request [Rack::Request]
+    # @return a valid rack response.
+    def respond_method(request)
+      params = action_params(request.path)
+      require_relative("#{LeanWeb::CONTROLLER_PATH}/#{@action.file}")
+      controller = Object.const_get(@action.controller).new(self, request)
+      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.
+    def respond_proc(request)
+      params = action_params(request.path)
+      return @action.call(**params) if params.instance_of?(Hash)
+
+      @action.call(*params)
+    end
+
+    # @param request_path [String]
+    # @return [Array, Hash]
+    def action_params(request_path)
+      return nil unless @path.instance_of?(Regexp)
+
+      matches = @path.match(request_path)
+      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]}"
+    end
+  end
+end

data/lib/leanweb.rb

@@ -0,0 +1,30 @@
+# 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/>.
+
+# frozen_string_literal: true
+
+# LeanWeb is a minimal hybrid static / dynamic web framework.
+module LeanWeb
+  VERSION = '0.1.1'
+
+  ROOT_PATH = ENV['LEANWEB_ROOT_PATH'] || Dir.pwd
+  CONTROLLER_PATH = "#{ROOT_PATH}/src/controllers"
+  VIEW_PATH = "#{ROOT_PATH}/src/views"
+  PUBLIC_PATH = "#{ROOT_PATH}/public"
+
+  MEDIA_EXTENSIONS = {
+    nil => '.html',
+    'application/javascript' => '.js',
+    'application/json' => '.json',
+    'text/html' => '.html',
+    'text/plain' => '.txt'
+  }.freeze
+
+  autoload :Route, 'leanweb/route.rb'
+  autoload :Controller, 'leanweb/controller.rb'
+  autoload :App, 'leanweb/app.rb'
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: leanweb
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Felix Freeman
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-01-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: haml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+- libsys@hacktivista.org
+executables:
+- leanweb
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/leanweb
+- lib/leanweb.rb
+- lib/leanweb/app.rb
+- lib/leanweb/controller.rb
+- lib/leanweb/route.rb
+homepage: https://git.hacktivista.org/leanweb
+licenses:
+- LicenseRef-LICENSE
+metadata:
+  homepage_uri: https://git.hacktivista.org/leanweb
+  source_code_uri: https://git.hacktivista.org/leanweb
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: LeanWeb is a minimal hybrid static / dynamic web framework
+test_files: []