simple-httpd 0.0.4 → 0.3.0

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

@@ -0,0 +1,28 @@
+# A simple file server middleware
+class Simple::Httpd::Rack::Merger
+  Rack = Simple::Httpd::Rack
+
+  # returns an app that merges other apps
+  def self.build(apps)
+    return apps.first if apps.length == 1
+
+    new(apps)
+  end
+
+  private
+
+  def initialize(apps)
+    @apps = apps
+  end
+
+  public
+
+  def call(env)
+    @apps.each do |app|
+      status, body, headers = app.call(env)
+      return [status, body, headers] unless status == 404
+    end
+
+    Rack.error 404, "No such action"
+  end
+end

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

@@ -0,0 +1,50 @@
+# A simple file server middleware
+class Simple::Httpd::Rack::StaticMount
+  Rack = ::Simple::Httpd::Rack
+
+  EXTENSIONS = %w(.txt .md .js .css .png .jpeg .jpg)
+
+  def self.build(mount_point, path)
+    static_files = static_files(path)
+    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
+  end
+
+  attr_reader :mount_point, :path
+
+  def initialize(path, static_files)
+    @path = path
+    @static_files = Set.new(static_files)
+  end
+
+  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)
+    else
+      Rack.error 404, "No such file"
+    end
+  end
+
+  def file_server
+    @file_server ||= ::Rack::File.new(path)
+  end
+
+  def serve_file?(request_path)
+    @static_files.include?(request_path[1..-1])
+  end
+end

data/lib/simple/httpd/server.rb

@@ -0,0 +1,69 @@
+class Simple::Httpd
+  module Server
+    extend self
+
+    module NullLogger # :nodoc:
+      extend self
+
+      def <<(msg); end
+    end
+
+    def listen!(app, environment: "development", host: nil, port:, logger: nil)
+      expect! app != nil
+
+      host ||= "127.0.0.1"
+      URI("http://#{host}:#{port}") # validate host and port
+
+      logger ||= ::Simple::Httpd.logger
+
+      prepare_logger!(logger)
+      logger.info "Starting httpd server on http://#{host}:#{port}/"
+
+      app = ::Rack::Lint.new(app) if environment != "production"
+
+      # re/AccessLog: the AccessLog setting points WEBrick's access logging to the
+      # NullLogger object.
+      #
+      # Instead we'll use a combination of Rack::CommonLogger (see Simple::Httpd.app),
+      # and sinatra's logger (see Simple::Httpd::BaseController).
+      ::Rack::Server.start app: app,
+                           Host: host,
+                           Port: port,
+                           environment: environment,
+                           Logger: logger,
+                           AccessLog: [[NullLogger, ""]]
+    end
+
+    private
+
+    # When Webrick is being shut down via SIGTERM - which we do at least during
+    # rspec-httpd triggered runs - it sends a fatal message to the logger. We catch
+    # it - to "downgrade" it to INFO - but we still abort.
+    def prepare_logger!(logger)
+      def logger.fatal(msg, &block)
+        if msg.is_a?(SignalException) && msg.signo == ::Signal.list["TERM"]
+          if %w(test development).include?(::Simple::Httpd.env)
+            info "Received SIGTERM: hard killing server (due to running in #{::Simple::Httpd.env.inspect} environment)"
+            Simple::Httpd::Server.exit!
+          else
+            info "Received SIGTERM: shutting down server..."
+            exit 1
+          end
+        end
+
+        super
+      end
+    end
+
+    public
+
+    def exit!(exit_status = 1)
+      # Run SimpleCov if exists, and if this is the PID that started SimpleCov in the first place.
+      if defined?(SimpleCov) && SimpleCov.pid == Process.pid
+        SimpleCov.process_result(SimpleCov.result, 0)
+      end
+
+      Kernel.exit! exit_status
+    end
+  end
+end

data/lib/simple/httpd/service.rb

@@ -0,0 +1,70 @@
+require "simple-service"
+
+class Simple::Httpd::Service
+  module ControllerAdapter
+    def mount_service(service)
+      @service = service
+
+      instance_eval do
+        yield(service)
+      end
+    ensure
+      @service = nil
+    end
+
+    def get(path, opts = {}, &block)
+      service_route?("GET", path, opts, &block) || super
+    end
+
+    def post(path, opts = {}, &block)
+      service_route?("POST", path, opts, &block) || super
+    end
+
+    def put(path, opts = {}, &block)
+      service_route?("PUT", path, opts, &block) || super
+    end
+
+    def delete(path, opts = {}, &block)
+      service_route?("DELETE", path, opts, &block) || super
+    end
+
+    def head(path, opts = {}, &block)
+      service_route?("HEAD", path, opts, &block) || super
+    end
+
+    private
+
+    def service_route?(verb, path, opts, &block)
+      return false unless @service
+      return false if block
+      return false unless opts.empty?
+      return false unless path.is_a?(Hash) && path.size == 1
+
+      path, action_name = *path.first
+
+      # Verify existence of this action.
+      @service.fetch_action(action_name)
+
+      # get service reference into binding, to make it available for the route
+      # definition.
+      service = @service
+
+      # define sinatra route.
+      route(verb, path) do
+        result = service.call(action_name, parsed_body, params, context: context)
+        json(result)
+      end
+
+      true
+    end
+  end
+
+  module Helpers
+    def context
+      @context ||= ::Simple::Service::Context.new
+    end
+  end
+
+  ::Simple::Httpd::BaseController.extend(ControllerAdapter)
+  ::Simple::Httpd::BaseController.helpers(Helpers)
+end

data/lib/simple/httpd/version.rb

@@ -1,4 +1,4 @@
-module Simple::Httpd
+class Simple::Httpd
   module GemHelper
     extend self
 

data/lib/simple/service.rb

@@ -0,0 +1,69 @@
+module Simple::Service
+  class ArgumentError < ::ArgumentError
+  end
+end
+
+require_relative "service/action"
+require_relative "service/context"
+
+module Simple::Service
+  def self.included(klass)
+    klass.extend ClassMethods
+  end
+
+  def self.context
+    Thread.current[:"Simple::Service.context"]
+  end
+
+  def self.with_context(ctx)
+    old_ctx = Thread.current[:"Simple::Service.context"]
+    Thread.current[:"Simple::Service.context"] = ctx
+    yield
+  ensure
+    Thread.current[:"Simple::Service.context"] = old_ctx
+  end
+
+  module ClassMethods
+    def actions
+      @actions ||= Action.build_all(service_module: self)
+    end
+
+    def build_service_instance
+      service_instance = Object.new
+      service_instance.extend self
+      service_instance
+    end
+
+    def fetch_action(action_name)
+      actions.fetch(action_name) do
+        informal = "service #{self} has these actions: #{actions.keys.sort.map(&:inspect).join(", ")}"
+        raise "No such action #{action_name.inspect}; #{informal}"
+      end
+    end
+
+    def call(action_name, arguments, params, context: nil)
+      ::Simple::Service.with_context(context) do
+        fetch_action(action_name).invoke(arguments, params)
+      end
+    end
+  end
+
+  # Resolves a service by name. Returns nil if the name does not refer to a service,
+  # or the service module otherwise.
+  def self.resolve(str)
+    return unless str =~ /^[A-Z][A-Za-z0-9_]*(::[A-Z][A-Za-z0-9_]*)*$/
+
+    service = resolve_constant(str)
+
+    return unless service.is_a?(Module)
+    return unless service.include?(::Simple::Service)
+
+    service
+  end
+
+  def self.resolve_constant(str)
+    const_get(str)
+  rescue NameError
+    nil
+  end
+end

data/lib/simple/service/action.rb

@@ -0,0 +1,78 @@
+module Simple::Service
+  class Action
+    ArgumentError = ::Simple::Service::ArgumentError
+
+    IDENTIFIER_PATTERN = "[a-z][a-z0-9_]*"
+    IDENTIFIER_REGEXP = Regexp.compile("\\A#{IDENTIFIER_PATTERN}\\z")
+
+    def self.build_all(service_module:)
+      service_module.public_instance_methods(false)
+                    .grep(IDENTIFIER_REGEXP)
+                    .inject({}) { |hsh, name| hsh.update name => Action.new(service_module, name) }
+    end
+
+    attr_reader :service
+    attr_reader :name
+    attr_reader :arguments
+    attr_reader :parameters
+
+    def initialize(service, name)
+      instance_method = service.instance_method(name)
+
+      @service = service
+      @name = name
+      @arguments = []
+      @parameters = []
+
+      instance_method.parameters.each do |kind, parameter_name|
+        case kind
+        when :req, :opt then @arguments << parameter_name
+        when :keyreq, :key then @parameters << parameter_name
+        else
+          raise ArgumentError, "#{full_name}: no support for #{kind.inspect} arguments, w/parameter #{parameter_name}"
+        end
+      end
+    end
+
+    # build a service_instance and run the action, with arguments constructed from
+    # args_hsh and params_hsh
+    def invoke(args_hsh, params_hsh)
+      args_hsh ||= {}
+      params_hsh ||= {}
+
+      # build arguments array
+      args = extract_arguments(args_hsh)
+      args << extract_parameters(params_hsh) unless parameters.empty?
+
+      # run the action. Note: public_send is only
+      # an extra safeguard; since actions are already built off public methods
+      # there should be no way to call a private service method.
+      service_instance = service.build_service_instance
+      service_instance.public_send(@name, *args)
+    end
+
+    private
+
+    def extract_arguments(args_hsh)
+      arguments.map do |name|
+        args_hsh.fetch(name.to_s) { raise ArgumentError, "Missing argument in request body: #{name}" }
+      end
+    end
+
+    def extract_parameters(params_hsh)
+      # Note: in contrast to arguments that are being read from the body parameters that
+      # are not submitted are being ignored (and filled in by +nil+).
+      #
+      # Note 2: The parameter names **must** be Symbols, not Strings, otherwise
+      # the service_instance.send invocation later would not fill in keyword
+      # arguments from the parameters hash.
+      parameters.inject({}) do |hsh, parameter|
+        hsh.update parameter => params_hsh.fetch(parameter, nil)
+      end
+    end
+
+    def full_name
+      "#{service}##{name}"
+    end
+  end
+end

data/lib/simple/service/context.rb

@@ -0,0 +1,46 @@
+module Simple::Service
+  class Context
+    def initialize
+      @hsh = {}
+    end
+
+    IDENTIFIER_PATTERN = "[a-z][a-z0-9_]*"
+    IDENTIFIER_REGEXP = Regexp.compile("\\A#{IDENTIFIER_PATTERN}\\z")
+    ASSIGNMENT_REGEXP = Regexp.compile("\\A(#{IDENTIFIER_PATTERN})=\\z")
+
+    def [](key)
+      key = key.to_sym
+      @hsh[key]
+    end
+
+    def []=(key, value)
+      key = key.to_sym
+      existing_value = @hsh[key]
+
+      unless existing_value.nil? || existing_value == value
+        raise "Cannot overwrite existing context setting #{key.inspect}"
+      end
+
+      @hsh[key] = value
+    end
+
+    def method_missing(sym, *args, &block)
+      if block
+        super
+      elsif args.count == 0 && sym =~ IDENTIFIER_REGEXP
+        self[sym]
+      elsif args.count == 1 && sym =~ ASSIGNMENT_REGEXP
+        self[$1.to_sym] = args.first
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(sym, include_private = false)
+      return true if IDENTIFIER_REGEXP.maptch?(sym)
+      return true if ASSIGNMENT_REGEXP.maptch?(sym)
+
+      super
+    end
+  end
+end

data/scripts/release

@@ -0,0 +1,2 @@
+#!/bin/bash
+$0.rb "$@"

data/scripts/release.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+
+# -- helpers ------------------------------------------------------------------
+
+def sys(cmd)
+  STDERR.puts "> #{cmd}"
+  system cmd
+  return true if $?.success?
+
+  STDERR.puts "> #{cmd} returned with exitstatus #{$?.exitstatus}"
+  $?.success?
+end
+
+def sys!(cmd, error: nil)
+  return true if sys(cmd)
+  STDERR.puts error if error
+  exit 1
+end
+
+def die!(msg)
+  STDERR.puts msg
+  exit 1
+end
+
+ROOT = File.expand_path("#{File.dirname(__FILE__)}/..")
+
+GEMSPEC = Dir.glob("*.gemspec").first || die!("Missing gemspec file.")
+
+# -- Version reading and bumping ----------------------------------------------
+
+module Version
+  extend self
+
+  VERSION_FILE = "#{Dir.getwd}/VERSION"
+
+  def read_version
+    version = File.exist?(VERSION_FILE) ? File.read(VERSION_FILE) : "0.0.1"
+    version.chomp!
+    raise "Invalid version number in #{VERSION_FILE}" unless version =~ /^\d+\.\d+\.\d+$/
+    version
+  end
+
+  def auto_version_bump
+    old_version_number = read_version
+    old = old_version_number.split('.')
+
+    current = old[0..-2] << old[-1].next
+    current.join('.')
+  end
+
+  def bump_version
+    next_version = ENV["VERSION"] || auto_version_bump
+    File.open(VERSION_FILE, "w") { |io| io.write next_version }
+  end
+end
+
+# -- check, bump, release a new gem version -----------------------------------
+
+Dir.chdir ROOT
+$BASE_BRANCH = ENV['BRANCH'] || 'master'
+
+# ENV["BUNDLE_GEMFILE"] = "#{Dir.getwd}/Gemfile"
+# sys! "bundle install"
+
+sys! "git diff --exit-code > /dev/null", error: 'There are unstaged changes in your working directory'
+sys! "git diff --cached --exit-code > /dev/null", error: 'There are staged but uncommitted changes'
+
+sys! "git checkout #{$BASE_BRANCH}"
+sys! "git pull"
+
+Version.bump_version
+version = Version.read_version
+
+sys! "git add VERSION"
+sys! "git commit -m \"bump gem to v#{version}\""
+sys! "git tag -a v#{version} -m \"Tag #{version}\""
+
+sys! "gem build #{GEMSPEC}"
+
+sys! "git push origin #{$BASE_BRANCH}"
+sys! 'git push --tags --force'
+sys! "gem push #{Dir.glob('*.gem').first}"
+
+sys! "mkdir -p pkg"
+sys! "mv *.gem pkg"
+
+STDERR.puts <<-MSG
+================================================================================
+Thank you for releasing a new gem version. You made my day.
+================================================================================
+    MSG