simple-httpd 0.3.0 → 0.3.1

data/examples/services/example_service.rb

@@ -1,25 +0,0 @@
-# rubocop:disable Naming/UncommunicativeMethodParamName, Lint/UnusedMethodArgument
-
-module Example; end
-module Example::Service
-  include ::Simple::Service
-
-  def test(a:, b:)
-    # "this is a test; a is #{a.inspect}, b is #{b.inspect}"
-    "hello from ExampleService#test"
-  end
-
-  def echo(one, two, a:, b:)
-    "one: [#{one}]/two: [#{two}]/a: [#{a}]/b: [#{b}]"
-  end
-
-  def echo_context
-    ::Simple::Service.context.inspect
-  end
-
-  def this_is_a_helper!; end
-
-  private
-
-  def this_is_a_private_helper; end
-end

data/lib/simple/httpd/mount_spec.rb

@@ -1,106 +0,0 @@
-# rubocop:disable Metrics/AbcSize, Style/ParallelAssignment
-
-require "simple-service"
-require_relative "./rack"
-
-class Simple::Httpd::MountSpec
-  def self.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)
-
-    ServiceMountSpec.build(mount_point, service: entity) ||
-      PathMountSpec.build(mount_point, path: entity) ||
-      raise(ArgumentError, "#{mount_point}: don't know how to mount #{entity.inspect}")
-  end
-
-  def self.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
-
-  attr_reader :mount_point
-
-  class PathMountSpec < ::Simple::Httpd::MountSpec
-    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_spec" 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 build_rack_apps
-      [
-        Rack::DynamicMount.build(mount_point, path),
-        Rack::StaticMount.build(mount_point, path)
-      ].compact
-    end
-  end
-
-  class ServiceMountSpec < ::Simple::Httpd::MountSpec
-    H = ::Simple::Httpd::Helpers
-
-    attr_reader :service
-
-    def self.build(mount_point, service:)
-      service = ::Simple::Service.resolve(service)
-      return unless service
-
-      new(mount_point, service)
-    end
-
-    def initialize(mount_point, service)
-      @mount_point, @service = mount_point, service
-    end
-
-    def build_rack_apps
-      [build_controller]
-    end
-
-    private
-
-    # wraps all helpers into a Simple::Httpd::BaseController subclass
-    def build_controller
-      controller = H.subclass(::Simple::Httpd::BaseController)
-      setup_action_routes! controller
-      controller
-    end
-
-    def setup_action_routes!(controller)
-      action_names = service.actions.keys
-
-      controller.mount_service(service) do |service|
-        action_names.each do |action_name|
-          ::Simple::Httpd.logger.debug "#{mount_point}/#{action_name} -> #{service.name}##{action_name}"
-          controller.post "/#{action_name}" => action_name
-        end
-      end
-
-      ::Simple::Httpd.logger.info do
-        "#{mount_point}: mounting #{action_names.count} actions(s) from #{service.name} service"
-      end
-    end
-  end
-end

data/lib/simple/httpd/service.rb

@@ -1,70 +0,0 @@
-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/service.rb

@@ -1,69 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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/spec/simple/httpd/services/service_spec.rb

@@ -1,34 +0,0 @@
-require "spec_helper"
-
-describe "service file" do
-  # mounting not at root level
-  it "returns value from mapped function" do
-    http.post "/service/example/test?a=1&b=2"
-    expect_response("hello from ExampleService#test")
-  end
-
-  it "properly extracts arguments and parameters" do
-    http.post "/service/example/echo?a=1&b=2", { one: "foo", two: "bar" }
-    expect_response "one: [foo]/two: [bar]/a: [1]/b: [2]"
-  end
-
-  it "ignores extra body arguments and extra parameters" do
-    http.post "/service/example/echo?a=1&b=2&c=3", { one: "foo", two: "bar", three: "baz" }
-    expect_response "one: [foo]/two: [bar]/a: [1]/b: [2]"
-  end
-
-  it "complains on missing body arguments" do
-    http.post "/service/example/echo?a=1&b=2&c=3", { two: "bar" }
-    expect_response 422
-  end
-
-  it "ignores missing parameters arguments" do
-    http.post "/service/example/echo?b=2", { one: "foo", two: "bar" }
-    expect_response "one: [foo]/two: [bar]/a: []/b: [2]"
-  end
-
-  it "properly extracts arguments and parameters" do
-    http.post "/service/example/echo_context"
-    expect_response /Simple::Service::Context/
-  end
-end