simple-httpd 0.3.0 → 0.3.1

data/lib/simple/httpd/cli.rb

@@ -1,5 +1,3 @@
-# rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-
 module Simple
   class Httpd
     class << self
@@ -11,9 +9,13 @@ end
 module Simple::Httpd::CLI
   include Simple::CLI
 
+  def logger
+    ::Simple::CLI.logger
+  end
+
   # Runs a simple httpd server
   #
-  # A mount_spec is either the location of a directory, which would then be mounted
+  # A mount is either the location of a directory, which would then be mounted
   # at the "/" HTTP location, or a directory followed by a colon and where to mount
   # the directory.
   #
@@ -22,7 +24,9 @@ module Simple::Httpd::CLI
   #
   # Examples:
   #
-  #   simple-httpd --port=8080 httpd/root --service=src/to/service.rb MyService:/ httpd/assets:assets
+  #   PORT=8080 simple-httpd start httpd/root --service=src/to/service.rb \
+  #                                           MyService:/
+  #                                           httpd/assets:assets
   #
   # serves the content of ./httpd/root on http://0.0.0.0/ and the content of httpd/assets
   # on http://0.0.0.0/assets.
@@ -30,7 +34,8 @@ module Simple::Httpd::CLI
   # Options:
   #
   #   --environment=ENV         ... the environment setting, which adjusts configuration.
-  #   --services=<path>,<path>  ... load these ruby file during startup. Used to define service objects.
+  #   --services=<path>,<path>  ... load these ruby files or directories during startup. This
+  #                                 can be used to define service objects.
   #
   # simple-httpd respects the HOST and PORT environment values to determine the interface
   # and port to listen to. Default values are "127.0.0.1" and 8181.
@@ -40,40 +45,76 @@ module Simple::Httpd::CLI
   # - a mount_point <tt>[ mount_point, path ]</tt>, e.g. <tt>[ "path/to/root", "/"]</tt>
   # - a string denoting a mount_point, e.g. "path/to/root:/")
   # - a string denoting a "/" mount_point (e.g. "path", which is shorthand for "path:/")
-  def main(*mount_specs, environment: "development", services: nil)
-    ::Simple::Httpd.env = environment
+  def start(*mounts, environment: "development", services: nil)
+    host = ENV["HOST"] || "127.0.0.1"
+    port = Integer(ENV["PORT"] || 8181)
 
-    start_simplecov if environment == "test"
+    prepare_environment!(environment: environment)
+
+    app = build_app!(mounts: mounts, services: services)
+    logger.info "start to listen on #{mounts.inspect}"
+    ::Simple::Httpd.listen!(app, environment: environment,
+                                 host: host,
+                                 port: port)
+  end
 
-    mount_specs << "." if mount_specs.empty?
+  def routes(*mounts, environment: "development", services: nil)
+    prepare_environment!(environment: environment)
+    app = build_app!(mounts: mounts, services: services)
+    routes = app.route_descriptions
 
-    host = ENV["HOST"] || "127.0.0.1"
-    port = Integer(ENV["PORT"] || 8181)
+    logger.info "Found #{routes.count} routes"
+
+    max_verb_len = routes.map(&:verb).map(&:length).max
+    max_path_len = routes.map(&:path).map(&:length).max
+
+    routes.
+      sort_by { |route| [route.path, route.verb] }.
+      each { |route|
+        puts format("%#{max_verb_len}s %-#{max_path_len}s %s", route.verb, route.path, route.source_location_str)
+      }
+  end
+
+  private
+
+  def prepare_environment!(environment:)
+    ::Simple::Httpd.env = environment
+    start_simplecov if environment == "test"
 
     # late loading simple/httpd, for simplecov support
     require "simple/httpd"
-    helpers = ::Simple::Httpd::Helpers
-
-    services&.split(",")&.each do |service_path|
-      paths = if Dir.exist?(service_path)
-                Dir.glob("#{service_path}/**/*.rb").sort
-              else
-                [service_path]
-              end
-
-      paths.each do |path|
-        logger.info "Loading service(s) from #{helpers.shorten_path path}"
-        load path
-      end
-    end
+  end
 
-    ::Simple::Httpd.listen!(*mount_specs, environment: environment,
-                                          host: host,
-                                          port: port,
-                                          logger: logger)
+  def build_app!(mounts:, services:)
+    mounts << "." if mounts.empty?
+    logger.info "building server on #{mounts.inspect}"
+
+    load_services! services if services
+    app = ::Simple::Httpd.build(*mounts)
+    app.rack # builds the rack application
+    app
   end
 
-  private
+  def load_services!(paths)
+    expect! paths => String
+
+    resolve_service_path(paths).each do |path|
+      logger.info "Loading service(s) from #{::Simple::Httpd::Helpers.shorten_path path}"
+      load path
+    end
+  end
+
+  def resolve_service_path(paths)
+    # each service_path either denotes the path to a file or to a directory
+    # of files.
+    paths.split(",").each_with_object([]) do |service_path, ary|
+      if Dir.exist?(service_path)
+        ary.concat Dir.glob("#{service_path}/**/*.rb").sort
+      else
+        ary << service_path
+      end
+    end
+  end
 
   def stderr_logger
     logger = ::Logger.new STDERR

data/lib/simple/httpd/helpers.rb

@@ -37,8 +37,10 @@ module Simple::Httpd::Helpers
   end
 
   # instance_eval zero or more paths in the context of obj
-  def instance_eval_paths(obj, *paths)
-    paths.each do |path|
+  def instance_eval_paths(obj, paths:)
+    return obj unless paths
+
+    Array(paths).each do |path|
       # STDERR.puts "Loading #{path}"
       obj.instance_eval File.read(path), path, 1
     end
@@ -46,9 +48,39 @@ module Simple::Httpd::Helpers
   end
 
   # subclass a klass with an optional description
-  def subclass(klass, description: nil)
+  def subclass(klass, paths: nil, description: nil)
+    raise "Missing description" unless description
+
     subclass = Class.new(klass)
     subclass.define_method(:inspect) { description } if description
+    instance_eval_paths subclass, paths: paths if paths
     subclass
   end
+
+  def filter_stacktrace_entry?(line)
+    return true if line =~ /\.rvm\b/
+
+    false
+  end
+
+  # Receives a stacktrace (like, for example, from Kernel#callers or
+  # from Exception#backtrace), and removes all lines that point to
+  # ".rvm". It also removes the working directory from the file paths.
+  #
+  # returns the cleaned array
+  def filtered_stacktrace(stacktrace, count: 20)
+    lines = []
+
+    stacktrace[0..count].inject(false) do |filtered_last_line, line|
+      if filter_stacktrace_entry?(line)
+        lines << "... (lines removed) ..." unless filtered_last_line
+        true
+      else
+        lines << shorten_path(line)
+        false
+      end
+    end
+
+    lines
+  end
 end

data/lib/simple/httpd/mount.rb

@@ -0,0 +1,66 @@
+require "simple-service"
+require_relative "./rack"
+
+module Simple::Httpd::Mount
+  extend self
+
+  def build(arg, at:)
+    if at
+      entity, mount_point = arg, at
+    else
+      # The regexp below uses negative lookbehind and negative lookahead to
+      # only match single colons, but not double (or more) colons. See
+      # `ri Regexp` for details.
+      entity, mount_point = *arg.split(/(?<!:):(?!:)/, 2)
+    end
+
+    mount_point = normalize_and_verify_mount_point(mount_point)
+
+    PathMount.build(mount_point, path: entity) ||
+      raise(ArgumentError, "#{mount_point}: don't know how to mount #{entity.inspect}")
+  end
+
+  private
+
+  def normalize_and_verify_mount_point(mount_point)
+    mount_point ||= "/"                           # fall back to "/"
+    mount_point = File.join("/", mount_point)     # make sure we start at "/"
+
+    canary_url = "http://0.0.0.0#{mount_point}"   # verify mount_point: can it be used to build a URL?
+    URI.parse canary_url
+
+    mount_point
+  end
+
+  class PathMount
+    Rack = ::Simple::Httpd::Rack
+
+    attr_reader :path, :mount_point
+
+    def self.build(mount_point, path:)
+      path = path.gsub(/\/$/, "") # remove trailing "/"
+
+      raise ArgumentError, "You probably don't want to mount your root directory, check mount" if path == ""
+      return unless Dir.exist?(path)
+
+      new(mount_point, path)
+    end
+
+    def initialize(mount_point, path)
+      @mount_point, @path = mount_point, path
+    end
+
+    def route_descriptions
+      build_rack_apps.inject([]) do |ary, app|
+        ary.concat app.route_descriptions
+      end
+    end
+
+    def build_rack_apps
+      dynamic_mount = Rack::DynamicMount.build(mount_point, path)
+      static_mount = Rack::StaticMount.build(mount_point, path)
+
+      [dynamic_mount, static_mount].compact
+    end
+  end
+end

data/lib/simple/httpd/rack/dynamic_mount.rb

@@ -7,12 +7,13 @@ class Simple::Httpd::Rack::DynamicMount
   H = ::Simple::Httpd::Helpers
   Rack = ::Simple::Httpd::Rack
 
-  def self.build(mount_point, path)
-    expect! path => String
+  extend Forwardable
 
-    url_map = new(mount_point, path).build_url_map
+  delegate :call => :@rack_app # rubocop:disable Style/HashSyntax
 
-    ::Rack::URLMap.new(url_map)
+  def self.build(mount_point, path)
+    expect! path => String
+    new(mount_point, path)
   end
 
   attr_reader :path
@@ -20,47 +21,66 @@ class Simple::Httpd::Rack::DynamicMount
 
   def initialize(mount_point, path)
     @mount_point = mount_point
-    @path = path
+    @path = path.gsub(/\/\z/, "") # remove trailing "/"
 
-    # determine source_paths and controller_paths
-    source_paths = Dir.glob("#{path}/**/*.rb")
-    helper_paths, @controller_paths = source_paths.partition { |str| /_helpers\.rb$/ =~ str }
+    setup_paths!
+    load_service_files!
+    @root_controller = build_root_controller # also loads helpers
+    @url_map = build_url_map
 
-    # build root_controller
-    @root_controller = build_root_controller(helper_paths)
+    @rack_app = ::Rack::URLMap.new(@url_map)
   end
 
-  # rubocop:disable Metrics/AbcSize
-  def build_url_map
-    @controller_paths.sort.each_with_object({}) do |absolute_path, url_map|
-      relative_path = absolute_path[(path.length)..-1]
+  # RouteDescriptions are being built during build_url_map
+  include ::Simple::Httpd::RouteDescriptions
 
-      relative_mount_point = relative_path == "/root.rb" ? "/" : relative_path.gsub(/\.rb$/, "")
-      controller_class = load_controller absolute_path
+  private
 
-      ::Simple::Httpd.logger.info do
-        absolute_mount_point = File.join(mount_point, relative_mount_point)
-        routes_count = controller_class.routes.reject { |verb, _| verb == "HEAD" }.values.sum(&:count)
+  def logger
+    ::Simple::Httpd.logger
+  end
 
-        "#{absolute_mount_point}: mounting #{routes_count} route(s) from #{H.shorten_path absolute_path}"
-      end
+  def setup_paths!
+    @source_paths = Dir.glob("#{path}/**/*.rb")
+    @helper_paths, @controller_paths = @source_paths.partition { |str| /_helper(s?)\.rb$/ =~ str }
+
+    logger.info "#{path}: found #{@source_paths.count} sources, #{@helper_paths.count} helpers"
+  end
 
-      url_map.update relative_mount_point => controller_class
+  def load_service_files!
+    return if path == "." # i.e. mounting current directory
+
+    service_path = "#{path}.services"
+    service_files = Dir.glob("#{service_path}/**/*.rb")
+    return if service_files.empty?
+
+    logger.info "#{service_path}: loading #{service_files.count} service file(s)"
+    service_files.sort.each do |path|
+      logger.debug "Loading service file #{path.inspect}"
+      load path
     end
   end
 
   # wraps all helpers into a Simple::Httpd::BaseController subclass
-  def build_root_controller(helper_paths)
-    klass = H.subclass ::Simple::Httpd::BaseController,
-                       description: "root controller at #{path} w/#{helper_paths.count} helpers"
-
-    H.instance_eval_paths klass, *helper_paths.sort
-    klass
+  def build_root_controller
+    H.subclass ::Simple::Httpd::BaseController,
+               paths: @helper_paths.sort,
+               description: "root controller at #{path} w/#{@helper_paths.count} helpers"
   end
 
-  # wraps the source file in path into a root_controller
-  def load_controller(path)
-    klass = H.subclass @root_controller, description: "controller at #{path}"
-    H.instance_eval_paths klass, path
+  def build_url_map
+    @controller_paths.sort.each_with_object({}) do |absolute_path, hsh|
+      relative_path = absolute_path[(path.length)..-1]
+
+      relative_mount_point = relative_path == "/root.rb" ? "/" : relative_path.gsub(/\.rb$/, "")
+      controller_class = H.subclass @root_controller, description: "controller at #{absolute_path}", paths: absolute_path
+
+      controller_class.route_descriptions.each do |route|
+        route = route.prefix(@mount_point, relative_mount_point)
+        describe_route! route
+      end
+
+      hsh.update relative_mount_point => controller_class
+    end
   end
 end

data/lib/simple/httpd/rack/static_mount.rb

@@ -1,48 +1,54 @@
 # A simple file server middleware
 class Simple::Httpd::Rack::StaticMount
+  H = ::Simple::Httpd::Helpers
   Rack = ::Simple::Httpd::Rack
 
   EXTENSIONS = %w(.txt .md .js .css .png .jpeg .jpg)
+  GLOB_PATTERN = "**/*.{#{EXTENSIONS.map { |s| s[1..-1] }.join(",")}}"
 
   def self.build(mount_point, path)
-    static_files = static_files(path)
+    static_files = Dir.chdir(path) { Dir.glob(GLOB_PATTERN) }
+
     return nil if static_files.empty?
 
     ::Simple::Httpd.logger.info do
       "#{mount_point}: serving #{static_files.count} static file(s)"
     end
 
-    new(path, static_files)
-  end
-
-  def self.static_files(path)
-    Dir.chdir(path) do
-      pattern = "**/*{" + EXTENSIONS.join(",") + "}"
-      Dir.glob(pattern)
-    end
+    new(mount_point, path, static_files)
   end
 
   attr_reader :mount_point, :path
 
-  def initialize(path, static_files)
+  private
+
+  def initialize(mount_point, path, static_files)
+    @mount_point = mount_point
     @path = path
     @static_files = Set.new(static_files)
+    @file_server = ::Rack::File.new(path)
+
+    describe_route! verb: "GET",
+                    path: File.join(mount_point, GLOB_PATTERN),
+                    source_location: File.join(H.shorten_path(path), GLOB_PATTERN)
   end
 
+  include ::Simple::Httpd::RouteDescriptions
+
+  public
+
   def call(env)
     request_path = env["PATH_INFO"]
     if serve_file?(request_path)
       file_path = request_path[1..-1]
       env["PATH_INFO"] = file_path
-      file_server.call(env)
+      @file_server.call(env)
     else
       Rack.error 404, "No such file"
     end
   end
 
-  def file_server
-    @file_server ||= ::Rack::File.new(path)
-  end
+  private
 
   def serve_file?(request_path)
     @static_files.include?(request_path[1..-1])

data/lib/simple/httpd/route.rb

@@ -0,0 +1,79 @@
+class Simple::Httpd::Route
+  H = ::Simple::Httpd::Helpers
+  SELF = self
+
+  attr_reader :verb, :path, :source_location
+
+  def self.build(route)
+    expect! route => [
+      ::Simple::Httpd::Route,
+      {
+        verb: %w(GET POST PUT DELETE HEAD OPTIONS),
+        path: String,
+        source_location: [nil, Array, String]
+      }
+    ]
+
+    return route if route.is_a?(self)
+
+    ::Simple::Httpd::Route.new(*route.values_at(:verb, :path, :source_location))
+  end
+
+  private
+
+  def initialize(verb, path, source_location)
+    @verb = verb
+    @path = path
+    @source_location = source_location
+  end
+
+  public
+
+  def to_s
+    parts = [verb, path, source_location_str]
+    parts.compact.join " "
+  end
+
+  def inspect
+    "<#{SELF.name}: #{self}>"
+  end
+
+  def prefix(*prefixes)
+    SELF.new(verb, File.join(*prefixes, path), source_location)
+  end
+
+  def source_location_str
+    case source_location
+    when Array
+      path, lineno = *source_location
+      path = H.shorten_path(path)
+      "#{path}:#{lineno}"
+    when String, nil
+      source_location
+    else
+      source_location.inspect
+    end
+  end
+end
+
+module Simple::Httpd::RouteDescriptions
+  # returns a list of route desc entries.
+  #
+  # When building a simple-httpd application we also collect all routes defined
+  # via get, put, etc., including their source location (which, for example,
+  # might point to a service's method or to a controller source file).
+  #
+  # (see <tt>Simple::Httpd::Route</tt>).
+  def route_descriptions
+    @route_descriptions ||= []
+  end
+
+  # Adds a route description.
+  #
+  # The argument must either be a Route, or an argument acceptable to Route.build.
+  #
+  # (see <tt>Simple::Httpd::Route</tt>).
+  def describe_route!(route)
+    route_descriptions << ::Simple::Httpd::Route.build(route)
+  end
+end