landline 0.9.2

data/lib/landline/util/multipart.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: false
+
+require 'uri'
+require 'stringio'
+require 'tempfile'
+require_relative 'parseutils'
+require_relative 'parsesorting'
+require_relative 'html'
+
+module Landline
+  module Util
+    # Valid element of form data with headers
+    # @!attribute headers [Hash] headers recevied from form data
+    # @!attribute name [String] name of the form part
+    # @!attribute data [String,nil] Data received in the field through form data
+    # @!attribute filename [String,nil] Original name of the sent file
+    # @!attribute filetype [String,nil] MIME-type of the file
+    # @!attribute tempfile [File,nil] Temporary file for storing sent file data.
+    FormPart = Struct.new(:data, :name, :filename,
+                          :filetype, :tempfile, :headers) do
+      # Is this form part a file or plain data?
+      # @return [Boolean]
+      def file?
+        !tempfile.nil?
+      end
+
+      # Decode charset parameter
+      def decode(data)
+        data = Landline::Util.unescape_html(data)
+        return data unless self.headers['charset']
+
+        data.force_encoding(self.headers['charset']).encode("UTF-8")
+      end
+
+      # If FormPart is not a file, simplify to string.
+      # @return [FormPart, String]
+      def simplify
+        file? ? self : decode(self.data)
+      end
+    end
+
+    # A very naive implementation of a Multipart form parser.
+    class MultipartParser
+      include Landline::Util::ParserSorting
+      def initialize(io, boundary)
+        @input = io.is_a?(String) ? StringIO.new(io) : io
+        @boundary = boundary
+        @state = :idle
+        @data = []
+      end
+
+      # lord forgive me for what i'm about to do
+      # TODO: replace the god method with a state machine object
+      # rubocop:disable Metrics/*
+
+      # Parse multipart formdata
+      # @return [Array<FormPart, FormFile>]
+      def parse
+        return @data unless @data.empty?
+
+        while (line = @input.gets)
+          case @state
+          when :idle # waiting for valid boundary
+            if line == "--#{@boundary}\r\n"
+              # transition to :headers on valid boundary
+              @state = :headers
+              @data.append(FormPart.new(*([nil] * 5), {}))
+            end
+          when :headers # after valid boundary - checking for headers
+            if line == "\r\n"
+              # prepare form field and transition to :data or :file
+              @state = file?(@data[-1].headers) ? :file : :data
+              if @state == :data
+                setup_data_meta(@data[-1])
+              else
+                setup_file_meta(@data[-1])
+              end
+              next
+            end
+            push_header(line, @data[-1].headers)
+          when :data, :file # after headers - processing form data
+            if @data[-1].headers.empty?
+              # transition to :idle on empty headers
+              @state = :idle
+              next
+            end
+            if ["--#{@boundary}\r\n", "--#{@boundary}--\r\n"].include? line
+              # finalize and transition to either :headers or :idle
+              if @state == :file
+                @data[-1].tempfile.truncate(@data[-1].tempfile.size - 2)
+                @data[-1].tempfile.close
+              else
+                @data[-1].data.delete_suffix! "\r\n"
+              end
+              @state = line == "--#{@boundary}\r\n" ? :headers : :idle
+              @data.append(FormPart.new(*([nil] * 5), {}))
+              next
+            end
+            if @state == :data
+              @data[-1].data ||= ""
+              @data[-1].data << line
+            else
+              @data[-1].tempfile << line
+            end
+          end
+        end
+        @state = :idle
+        @data.pop
+        @data.freeze
+      end
+      # rubocop:enable Metrics/*
+
+      # Return a hash of current form.
+      # (equivalent to Query.parse but for multipart/form-data)
+      # @return [Hash]
+      def to_h
+        flatten(sort(gen_hash(parse)))
+      end
+
+      private
+
+      def gen_hash(array)
+        hash = {}
+        array.each do |formpart|
+          key = formpart.name.to_s
+          if key.match?(/.*\[\d*\]\Z/)
+            new_key, index = key.match(/(.*)\[(\d*)\]\Z/).to_a[1..]
+            hash[new_key] = [] unless hash[new_key]
+            hash[new_key].append([index, formpart.simplify])
+          else
+            hash[key] = formpart.simplify
+          end
+        end
+        hash
+      end
+
+      # Setup file metadata
+      # @part part [FormPart]
+      def setup_file_meta(part)
+        part.name = part.headers.dig("content-disposition", 1, "name")
+        part.filename = part.headers.dig("content-disposition", 1, "filename")
+        part.filetype = part.headers["content-type"]
+        part.tempfile = Tempfile.new
+      end
+
+      # Setup plain metadata
+      # @part part [FormPart]
+      def setup_data_meta(part)
+        part.name = part.headers.dig("content-disposition", 1, "name")
+      end
+
+      # Analyze headers to check if current data part is a file.
+      # @param headers_hash [Hash]
+      # @return [Boolean]
+      def file?(headers_hash)
+        if headers_hash.dig("content-disposition", 1, "filename") and
+           headers_hash['content-type']
+          return true
+        end
+
+        false
+      end
+
+      # Parse a header and append it to headers_hash
+      # @param line [String]
+      # @param headers_hash [Hash]
+      def push_header(line, headers_hash)
+        return unless line.match(/^[\w!#$%&'*+-.^_`|~]+:.*\r\n$/)
+
+        k, v = line.match(/^([\w!#$%&'*+-.^_`|~]+):(.*)\r\n$/).to_a[1..]
+        headers_hash[k.downcase] = Landline::Util::ParserCommon.parse_value(v)
+      end
+    end
+  end
+end

data/lib/landline/util/parsesorting.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Landline
+  module Util
+    # Internal library for generating form hashes
+    module ParserSorting
+      private
+
+      # Sort key-value pair arrays
+      def sort(hash)
+        hash.filter { |_, v| v.is_a? Array }.each do |_, value|
+          value.sort_by! { |array| array[0].to_i }
+        end
+        hash
+      end
+
+      # Flatten key-value pair arrays
+      def flatten(hash)
+        hash.transform_values do |value|
+          if value.is_a? Array
+            new_array = []
+            value.each do |k, v|
+              if k.match?(/\d+/) and k.to_i < new_array.size
+                new_array[k.to_i] = v
+              else
+                new_array.append(v)
+              end
+            end
+            new_array
+          else
+            value
+          end
+        end.to_h
+      end
+    end
+  end
+end

data/lib/landline/util/parseutils.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'uri'
+require_relative 'errors'
+
+module Landline
+  module Util
+    # (not exactly precise) Regular expressions for some RFC definitions
+    module HeaderRegexp
+      # Matches the RFC2616 definiton of token
+      TOKEN = /[!-~&&[^()<>@,;:\\"\/\[\]?={}\t]]+/.freeze
+      # Matches the RFC2616 definition of quoted-string
+      QUOTED = /"[\x0-\x7E&&[^\x1-\x8\xb-\x1f]]*(?<!\\)"/.freeze
+      # Matches any CHAR except CTLs
+      PRINTCHAR = /[\x2-\x7E]/.freeze
+      # Matches 1 or more CHARs excluding CTLs
+      PRINTABLE = /#{PRINTCHAR}+/o.freeze
+      # Matches the RFC6265 definition of a cookie-octet
+      COOKIE_OCTET = /[\x21-\x7E&&[^",;\\]]*/.freeze
+      COOKIE_VALUE = /(?:#{QUOTED}|#{COOKIE_OCTET})/o.freeze
+      COOKIE_NAME = TOKEN
+      # Matches the RFC6265 definition of cookie-pair.
+      # Captures name (1) and value (2).
+      COOKIE_PAIR = /\A(#{COOKIE_NAME})=(#{COOKIE_VALUE})\Z/o.freeze
+      # Matches a very abstract definition of a quoted header paramter.
+      # Captures name (1) and value (2).
+      PARAM_QUOTED = /\A(#{TOKEN})=?(#{QUOTED}|#{PRINTCHAR}*)\Z/o.freeze
+      # Matches a very abstract definition of a header parameter.
+      # Captures name (1) and value (2).
+      PARAM = /\A(#{TOKEN})=?(#{PRINTCHAR}*)\Z/o.freeze
+      # Specifically matches cookie parameters
+      COOKIE_PARAM = /\A(#{TOKEN})=?(#{QUOTED}|#{COOKIE_OCTET})\Z/o.freeze
+    end
+
+    # Module for all things related to parsing HTTP and related syntax.
+    module ParserCommon
+      # #strftime parameter to return a correct RFC 1123 date.
+      RFC1123_DATE = "%a, %d %b %Y %H:%M:%S GMT"
+
+      # rubocop:disable Metrics/MethodLength
+
+      # Parse parametrized header values.
+      # This method will try the best attempt at decoding parameters.
+      # However, it does no decoding on the first argument.
+      # @param input [String]
+      # @param sep [String, Regexp]
+      # @param unquote [Boolean] interpret params as possibly quoted
+      # @param regexp [Regexp,nil] override param matching regexp
+      # @return [Array(String, Hash)]
+      def self.parse_value(input, sep: ";", unquote: false, regexp: nil)
+        parts = input.split(sep).map { |x| URI.decode_uri_component(x).strip }
+        base = parts.shift
+        opts = parts.map do |raw|
+          key, value = raw.match(if regexp
+                                   regexp
+                                 elsif unquote
+                                   HeaderRegexp::PARAM_QUOTED
+                                 else
+                                   HeaderRegexp::PARAM
+                                 end).to_a[1..]
+          value = case value
+                  when "" then true
+                  when /\A".*"\z/ then value.undump
+                  else value
+                  end
+          [key, value]
+        end.to_h
+        [base, opts]
+      end
+
+      # rubocop:enable Metrics/MethodLength
+
+      # Construct a parametrized header value.
+      # Does some input sanitization during construction
+      # @param input [String]
+      # @param opts [Hash]
+      # @return [String]
+      # @raise [Landline::ParsingError]
+      def self.make_value(input, opts, sep = ";")
+        output = input
+        unless input.match? HeaderRegexp::PRINTABLE
+          raise Landline::ParsingError, "input is not ascii printable"
+        end
+        
+        opts.each do |key, value|
+          check_param(key, value)
+          newparam = if [String, Integer].include? value.class
+                       "#{sep} #{key}=#{value}"
+                     elsif value
+                       "#{sep} #{key}"
+                     end
+          output += newparam if newparam
+        end
+        output
+      end
+
+      # Checks if key and value are valid for constructing a parameter.
+      # Raises an error if that is not possible.
+      def self.check_param(key, value)
+        unless key.match? HeaderRegexp::TOKEN
+          raise Landline::ParsingError, "key #{key} is not an RFC2616 token"
+        end
+
+        if value.is_a?(String) and value.match? HeaderRegexp::PARAM_QUOTED
+          raise Landline::ParsingError, "quoted param value #{value} is invalid"
+        end
+      end
+      private_class_method :check_param
+    end
+  end
+end

data/lib/landline/util/query.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'uri'
+require_relative 'parsesorting'
+
+module Landline
+  module Util
+    # Query string parser
+    class Query
+      include Landline::Util::ParserSorting
+      # @param query [String]
+      def initialize(query)
+        @query = query
+      end
+
+      # Shallow query parser (does not do PHP-like array keys)
+      # @return [Hash]
+      def parse_shallow
+        URI.decode_www_form(@query)
+           .sort_by { |array| array[0] }
+           .to_h
+      end
+
+      # Better(tm) query parser.
+      # Returns a hash with arrays.
+      # Key semantics:
+      #
+      # - `key=value` creates a key value pair
+      # - `key[]=value` appends `value` to an array named `key`
+      # - `key[index]=value` sets `value` at `index` of array named `key`
+      # @return [Hash]
+      def parse
+        construct_deep_hash(URI.decode_www_form(@query))
+      end
+
+      # Get key from query.
+      # @param key [String]
+      # @return [String,Array]
+      def [](key)
+        (@cache ||= parse)[key]
+      end
+
+      private
+
+      # Construct a hash with array support
+      def construct_deep_hash(array)
+        flatten(sort(group(array)))
+      end
+
+      # Assign values to keys in a new hash and group arrayable keys
+      def group(array)
+        hash = {}
+        array.each do |key, value|
+          if key.match?(/.*\[\d*\]\Z/)
+            new_key, index = key.match(/(.*)\[(\d*)\]\Z/).to_a[1..]
+            hash[new_key] = [] unless hash[new_key]
+            hash[new_key].append([index, value])
+          else
+            hash[key] = value
+          end
+        end
+        hash
+      end
+    end
+  end
+end

data/lib/landline.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'landline/server'
+require_relative 'landline/path'
+require_relative 'landline/probe'
+require_relative 'landline/request'
+require_relative 'landline/response'
+require_relative 'landline/template'
+
+# Landline is a hideously simple ruby web framework
+module Landline
+  # Landline version
+  VERSION = '0.9 "Moonsong" (beta/rewrite)'
+
+  # Landline branding and version
+  VLINE = "Landline/#{Landline::VERSION} (Ruby/#{RUBY_VERSION}/#{RUBY_RELEASE_DATE})\n"
+
+  # Landline copyright
+  COPYRIGHT = "Copyright 2023 Yessiest"
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: landline
+version: !ruby/object:Gem::Version
+  version: 0.9.2
+platform: ruby
+authors:
+- Yessiest
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-09-22 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Landline is a no-hard-dependencies HTTP routing DSL that was made entirely for fun.
+  It runs on any HTTP server that supports the Rack 3.0 protocol.
+  It is usable for many menial tasks, and as long as it continues to be fun, it will keep growing.
+email: yessiest@text.512mb.org
+executables: []
+extensions: []
+extra_rdoc_files:
+- HACKING.md
+- LAYOUT.md
+- LICENSE.md
+- README.md
+files:
+- HACKING.md
+- LAYOUT.md
+- LICENSE.md
+- README.md
+- lib/landline.rb
+- lib/landline/dsl/constructors_path.rb
+- lib/landline/dsl/constructors_probe.rb
+- lib/landline/dsl/methods_common.rb
+- lib/landline/dsl/methods_path.rb
+- lib/landline/dsl/methods_probe.rb
+- lib/landline/dsl/methods_template.rb
+- lib/landline/node.rb
+- lib/landline/path.rb
+- lib/landline/pattern_matching.rb
+- lib/landline/pattern_matching/glob.rb
+- lib/landline/pattern_matching/rematch.rb
+- lib/landline/pattern_matching/util.rb
+- lib/landline/probe.rb
+- lib/landline/probe/handler.rb
+- lib/landline/probe/http_method.rb
+- lib/landline/probe/serve_handler.rb
+- lib/landline/request.rb
+- lib/landline/response.rb
+- lib/landline/server.rb
+- lib/landline/template.rb
+- lib/landline/template/erb.rb
+- lib/landline/template/erubi.rb
+- lib/landline/util/cookie.rb
+- lib/landline/util/errors.rb
+- lib/landline/util/html.rb
+- lib/landline/util/lookup.rb
+- lib/landline/util/mime.rb
+- lib/landline/util/multipart.rb
+- lib/landline/util/parsesorting.rb
+- lib/landline/util/parseutils.rb
+- lib/landline/util/query.rb
+homepage: https://adastra7.net/git/Yessiest/landline
+licenses:
+- AGPL-3.0
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.25
+signing_key:
+specification_version: 4
+summary: Elegant HTTP DSL
+test_files: []