toycol 0.2.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1599308369b344cecc36881661fdf60b1ffa8866903939d5ea1380f87ca5e36b
-  data.tar.gz: b5a67a19b19a0357d13f3a55be989dd462f93a07981f5cb1d443cfd9af19be4c
+  metadata.gz: b1b8a58a4fd3f08fc0efe5c808ed00f1fdd78e66b8b0c5467f4deb314f504fde
+  data.tar.gz: 86c53cfa48a4331cde4e5888b92a28645bb88b81695b8996b0ef301958364575
 SHA512:
-  metadata.gz: 7b9c04a590c8df7f1abfb0ffb7029a3ec55e0a26b4bb4c2fe54dd7b662b792ec1837460c6ba6b21d452bc5c1c0ee8cf5eed3b55b340d594145c4d0996e7a60bb
-  data.tar.gz: 6be10814f2a7666b7a95ec77a6e737970db8c4f9f238fdb5f0accef6f03eb3cf1c9106401a47e81494fc17ad8393219d3c0f025e778576065f1b86b3eac5db51
+  metadata.gz: 6f98b7f6753378032835b787f2f46c1679d6d5df5b88188a1e8f4350ae486146cad37ea1b8f67ec2af0d6f91e8ed24015154a2048f5891d4fb89f662ae912aee
+  data.tar.gz: '054893839fdaea8dfb45701e1f2a0cca55c19287e03d18a9266f2547502bb4c18d4fe97b822960aeef208044660e30262bc89945d269a047f3c6398c954c99e8'

data/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,29 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: "[BUG]"
+labels: bug
+assignees: ''
+
+---
+
+## Describe the bug
+A clear and concise description of what the bug is.
+
+## To Reproduce
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+## Expected behavior
+A clear and concise description of what you expected to happen.
+
+## Environment
+- Ruby Version:
+- Rack Version:
+- Puma Version:
+
+## Additional context
+Add any other context about the problem here.

data/.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: "[FEATURE]"
+labels: enhancement
+assignees: ''
+
+---
+
+## Is your feature request related to a problem? Please describe.
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+## Describe the solution you'd like
+A clear and concise description of what you want to happen.
+
+## Describe alternatives you've considered
+A clear and concise description of any alternative solutions or features you've considered.
+
+## Additional context
+Add any other context or screenshots about the feature request here.

data/CHANGELOG.md

@@ -1,5 +1,18 @@
+# Changelog
+
+All notable changes to this project will be documented in this file. For info on how to format all future additions to this file please reference [Keep A Changelog](https://keepachangelog.com/en/1.0.0/).
+
 ## [Unreleased]
 
-## [0.0.1] - 2021-07-12
+## [1.0.0] - 2021-07-27
+
+The first major release of Toycol.The main features are:
 
-- Initial release
+- [Added] Toycol::Protocol - For defining orignal application protocol
+- [Added] Toycol::Proxy - For accepting requests and pass them to the background server
+- [Added] Toycol::Command - For user friendly CLI
+  - `$ toycol server` - For starting proxy & background server
+  - `$ toycol client` - For sending request message to server
+  - `$ toycol generate` - For generating skeletons of Protocolfile & application
+- [Added] Toycol::Server - As a built-in background server
+- [Added] Rack::Handler::Toycol - For running Rack compartible application & switching background server

data/README.md

@@ -1,13 +1,122 @@
 # Toycol
 
-Toy Application Protocol framework
+Toycol is a small framework for defining toy application protocols.
+
+You can define your own application protocol only by writing a parser in Toycol DSL for request messages.
+
+Since the server and client programs to run the protocol are built-in from the beginning, you only need to prepare the following two items to run your custom protocol.
+- A configuration file named like `Protocolfile`, `Protocolfile.protocol_name` and so on
+- A Rack compartible application(e.g. `config.ru`)
+
+In the real world, there is (yet) no full-fledged web server or browser in the world that runs on the custom protocol you devised.
+Therefore, the protocol defined by this framework is in fact a "toy".
+However, by using this framework, you will be able to experience and learn how the connection between the application layer and the transport layer is, and how the application protocol works on the transport layer.
+
+## Example(on original "Duck" protocol)
+
+In this protocol:
+  - Client would send message like: `"quack, quack /posts<3user_id=1"`
+  - Server would interpret client message: `"GET /posts?user_id=1"`
+
+You write your definition in Protocolfile
+
+```ruby
+# Protocolfile.duck (protocol file)
+
+Protocol.define(:duck) do
+  # [OPTIONAL] You can add your original request methods
+  add_request_methods "OTHER"
+
+  # [OPTIONAL] You can define your custom status codes
+  custom_status_codes(
+    600 => "I'm afraid you are not a duck..."
+  )
+
+  # [REQUIRED] Define how you parse request path from request message
+  request.path do |message|
+    %r{(?<path>\/\w*)}.match(message)[:path]
+  end
+
+  # [REQUIRED] Define how you parse query from request message
+  request.query do |message|
+    %r{\<3(?<query>.+)}.match(message) { |m| m[:query] }
+  end
+
+  # [REQUIRED] Define how you parse query from request message
+  request.http_method do |message|
+    case message.scan(/quack/).size
+    when 2 then "GET"
+    else "OTHER"
+    end
+  end
+end
+```
+
+Don't forget, you need to prepare your application as well.
+
+```ruby
+# config_duck.ru (Rack compartible application)
+
+require "rack"
+require "toycol"
+
+# Specify which protocol to use
+Toycol::Protocol.use(:duck)
+
+class App
+  def call(env)
+    case env["REQUEST_METHOD"]
+    when "GET"
+      [
+        200,
+        { "Content-Type" => "text/html" },
+        ["Quack, Quack! This app is running by Duck protocol."]
+      ]
+    when "OTHER"
+      [
+        600,
+        { "Content-Type" => "text/html" },
+        ["Sorry, this application is only for ducks...\n"]
+      ]
+    end
+  end
+end
+
+run App.new
+```
+
+Then you run server & client
+
+```
+# In terminal for server
+
+$ toycol server config_duck.ru
+Toycol starts build-in server, listening on unix:///tmp/toycol.socket
+Toycol is running on localhost:9292
+=> Use Ctrl-C to stop
+```
+
+```
+# In other terminal for client
+
+$ toycol client "quack, quack /posts<3user_id=1"
+[Toycol] Sent request message: quack, quack /posts<3user_id=1
+---
+[Toycol] Received response message:
+
+HTTP/1.1 200 OK
+Content-Type: text/html
+Content-Length: 32
+
+Quack, Quack! This app is running by Duck protocol.
+```
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'toycol'
+gem "toycol"
 ```
 
 And then execute:
@@ -20,7 +129,64 @@ Or install it yourself as:
 
 ## Usage
 
-WIP
+Toycol provides useful commands to define & run your protocol.
+
+#### `toycol generate` - To define your new protocol
+
+You can use `toycol generate` command to generate skeletons of Protocolfile and application.
+
+```
+$ toycol generate PROTOCOL_NAME
+```
+
+When you run this command, skeletons of `Protocolfile.PROTOCOL_NAME` and `config_PROTOCOL_NAME.ru` will be generated.
+If you only need one of them, you can specify the type by `-t` option.
+
+```
+$ toycol generate PROTOCOL_NAME -t protocol
+# or
+$ toycol generate PROTOCOL_NAME -t app
+```
+
+If `PROTOCOL_NAME` is not specified, Protocolfile and config.ru will simply be generated.
+
+```
+$ toycol generate
+```
+
+#### `toycol server` - To run server by your protocol
+
+After you prepare Protocolfile & application, you need to start server to run the application by `toycol server` command.
+
+```
+# Please specify application file name
+$ toycol server config_`PROTOCOL_NAME`.ru
+```
+
+Then the server will start.
+
+Normally, `toycol server` command will start the server built into toycol.
+However, if Puma is already installed in your environment, it will start Puma by default.
+
+If you want to explicitly specify which server to use, you can use the -u option.
+
+```
+$ toycol server config_`PROTOCOL_NAME`.ru -u puma
+# or
+$ toycol server config_`PROTOCOL_NAME`.ru -u buid_in
+```
+
+If you would like to check other options, run the command `toycol server -h`.
+
+#### `toycol client` - To send request message by your protocol
+
+When you would like to send the request message to the server, use `toycol client`.
+
+```
+$ toycol client "YOUR REQUEST MESSAGE"
+```
+
+If you would like to check other options, run the command `toycol client -h`.
 
 ## Development
 

data/examples/anonymous/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gem "toycol", path: "../../"

data/examples/anonymous/Protocolfile

@@ -0,0 +1,13 @@
+Toycol::Protocol.define do
+  request.path do |message|
+    %r{(?<path>\/\w*)}.match(message)[:path]
+  end
+
+  request.query do |message|
+    %r{\?(?<query>.+)}.match(message) { |m| m[:query] }
+  end
+
+  request.http_method do |message|
+    "GET"
+  end
+end

data/examples/anonymous/config.ru

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "rack"
+require "toycol"
+
+Toycol::Protocol.use
+
+class App
+  def call(env)
+    case env["REQUEST_METHOD"]
+    when "GET"
+      [
+        200,
+        { "Content-Type" => "text/html" },
+        ["This app has no protocol name\n"]
+      ]
+    end
+  end
+end
+
+run App.new

data/examples/duck/Protocolfile.duck

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 Toycol::Protocol.define(:duck) do
   custom_status_codes(
     600 => "I'm afraid you are not a duck..."
@@ -7,11 +5,11 @@ Toycol::Protocol.define(:duck) do
   additional_request_methods "OTHER"
 
   request.path do |message|
-    %r{(?<path>/\w*)}.match(message)[:path]
+    %r{(?<path>\/\w*)}.match(message)[:path]
   end
 
   request.query do |message|
-    /\?(?<query>.+)/.match(message) { |m| m[:query] }
+    %r{\<3(?<query>.+)}.match(message) { |m| m[:query] }
   end
 
   request.http_method do |message|

data/lib/rack/handler/toycol.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
-require "rack"
 require "rack/handler"
 
 module Rack
   module Handler
     class Toycol
+      extend ::Toycol::Helper
+
       class << self
         attr_writer :preferred_background_server, :host, :port
 
@@ -27,18 +28,20 @@ module Rack
         def select_background_server
           case @preferred_background_server
           when "puma"
-            return "puma" if puma_requireable?
+            return "puma" if try_require_puma_handler
 
-            puts "Puma is not installed in your environment."
-            raise LoadError
+            raise LoadError, "Puma is not installed in your environment."
           when nil
-            puma_requireable? ? "puma" : "build_in"
+            try_require_puma_handler ? "puma" : "builtin"
           else
-            "build_in"
+            "builtin"
           end
+        rescue LoadError
+          Process.kill(:INT, Process.ppid)
+          abort
         end
 
-        def puma_requireable?
+        def try_require_puma_handler
           require "rack/handler/puma"
           true
         rescue LoadError
@@ -48,10 +51,10 @@ module Rack
         def run_background_server
           case select_background_server
           when "puma"
-            puts "Toycol starts Puma in single mode, listening on unix://#{::Toycol::UNIX_SOCKET_PATH}"
+            logger "Start Puma in single mode, listening on unix://#{::Toycol::UNIX_SOCKET_PATH}"
             Rack::Handler::Puma.run(@app, **{ Host: ::Toycol::UNIX_SOCKET_PATH, Silent: true })
           else
-            puts "Toycol starts build-in server, listening on unix://#{::Toycol::UNIX_SOCKET_PATH}"
+            logger "Start built-in server, listening on unix://#{::Toycol::UNIX_SOCKET_PATH}"
             ::Toycol::Server.run(@app, **{ Path: ::Toycol::UNIX_SOCKET_PATH, Port: @port })
           end
         end

data/lib/toycol.rb

@@ -1,27 +1,33 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require "optparse"
+require "rack"
+require "socket"
+require "stringio"
 
 require_relative "toycol/const"
 require_relative "toycol/helper"
 require_relative "toycol/protocol"
 require_relative "toycol/proxy"
 require_relative "toycol/server"
-require_relative "rack/handler/toycol"
-
-Dir["#{FileUtils.pwd}/Protocolfile*"].sort.each { |f| load f }
-
+require_relative "toycol/client"
+require_relative "toycol/template_generator"
 require_relative "toycol/command"
 require_relative "toycol/version"
 
+require_relative "rack/handler/toycol"
+
 module Toycol
   class Error < StandardError; end
 
-  class UnauthorizedMethodError < Error; end
+  class UnauthorizeError < Error; end
 
-  class UnauthorizedRequestError < Error; end
+  class UndefinementError < Error; end
 
-  class UndefinedRequestMethodError < Error; end
+  class DuplicateProtocolError < Error; end
 
-  class UnknownStatusCodeError < Error; end
+  class HTTPError < Error; end
 end
+
+Dir["#{FileUtils.pwd}/Protocolfile*"].sort.each { |f| load f }

data/lib/toycol/client.rb

@@ -1,19 +1,20 @@
 # frozen_string_literal: true
 
-require "socket"
-
 module Toycol
   class Client
+    extend Helper
+
     @port = 9292
+    @host = "localhost"
     CHUNK_SIZE = 1024 * 16
 
     class << self
-      attr_writer :port
+      attr_writer :port, :host
 
       def execute!(request_message, &block)
-        socket = TCPSocket.new("localhost", @port)
+        socket = TCPSocket.new(@host, @port)
         socket.write(request_message)
-        puts "[Toycol] Sent request message: #{request_message}\n---"
+        logger "Sent request message: #{request_message}\n---"
 
         response_message = []
         response_message << socket.readpartial(CHUNK_SIZE) until socket.eof?
@@ -29,7 +30,7 @@ module Toycol
 
       def default_proc
         proc do |message|
-          puts "[Toycol] Received response message:\n\n"
+          logger "Received response message:\n\n"
           puts message
         end
       end

data/lib/toycol/command.rb

@@ -1,27 +1,26 @@
 # frozen_string_literal: true
 
-require "optparse"
-require_relative "./client"
-
 module Toycol
   class Command
     class Options
+      @options = {}
+
       class << self
         def parse!(argv)
-          options       = {}
           option_parser = create_option_parser
           sub_command_option_parser = create_sub_command_option_parser
 
           begin
             option_parser.order!(argv)
-            options[:command]         = argv.shift
-            options[:request_message] = argv.shift if %w[client c].include?(options[:command]) && argv.first != "-h"
-            sub_command_option_parser[options[:command]].parse!(argv)
+            @options[:command]         = argv.shift
+            @options[:request_message] = argv.shift if request_message?(argv.first)
+            @options[:protocol_name]   = argv.shift if protocol_name?(argv.first)
+            sub_command_option_parser[@options[:command]].parse!(argv)
           rescue OptionParser::MissingArgument, OptionParser::InvalidOption, ArgumentError => e
             abort e.message
           end
 
-          options
+          @options
         end
 
         def create_option_parser
@@ -45,26 +44,46 @@ module Toycol
 
         def create_sub_command_option_parser
           sub_command_parser = Hash.new { |_k, v| raise ArgumentError, "'#{v}' is not sub command" }
-          sub_command_parser["client"] = client_option_parser
-          sub_command_parser["c"]      = client_option_parser
-          sub_command_parser["server"] = server_option_parser
-          sub_command_parser["s"]      = server_option_parser
+          sub_command_parser["client"]   = client_option_parser
+          sub_command_parser["c"]        = client_option_parser
+          sub_command_parser["server"]   = server_option_parser
+          sub_command_parser["s"]        = server_option_parser
+          sub_command_parser["generate"] = generator_option_parser
+          sub_command_parser["g"]        = generator_option_parser
           sub_command_parser
         end
 
         private
 
+        def request_message?(arg)
+          %w[client c].include?(@options[:command]) \
+            && arg != "-p" \
+            && arg != "-h"
+        end
+
+        def protocol_name?(arg)
+          %w[geberate g].include?(@options[:command]) \
+            && arg != "-t" \
+            && arg != "-h"
+        end
+
         def sub_command_summaries
           [
             { name: "client REQUEST_MESSAGE -p PORT",  summary: "Send request message to server"    },
-            { name: "server -u SERVER_NAME",           summary: "Start proxy and background server" }
+            { name: "server -u SERVER_NAME",           summary: "Start proxy and background server" },
+            { name: "generate NAME -t TYPE",           summary: "Generate new protocol or Rack app" }
           ]
         end
 
         def client_option_parser
           OptionParser.new do |opt|
-            opt.on("-p PORT_NUMBER", "--port PORT_NUMBER", "listen on PORT (default: 9292)") do |port|
-              ::Toycol::Client.port = port
+            opt.banner = "Usage: #{opt.program_name} client [-h|--help] REQUEST_MESSAGE [arg...]"
+            opt.on("-o HOST", "--host HOST", "connect to HOST (default: localhost)") do |host|
+              Client.host = host
+            end
+
+            opt.on("-p PORT_NUMBER", "--port PORT_NUMBER", "connect to PORT (default: 9292)") do |port|
+              Client.port = port
             end
 
             opt.on_head("-h", "--help", "Show this message") { help_command(opt) }
@@ -73,6 +92,7 @@ module Toycol
 
         def server_option_parser
           OptionParser.new do |opt|
+            opt.banner = "Usage: #{opt.program_name} server [-h|--help] APPLICATION_PATH [arg...]"
             opt.on("-o HOST", "--host HOST", "bind to HOST (default: localhost)") do |host|
               ::Rack::Handler::Toycol.host = host
             end
@@ -81,7 +101,7 @@ module Toycol
               ::Rack::Handler::Toycol.port = port
             end
 
-            opt.on("-u SERVER_NAME", "--use SERVER_NAME", "switch using SERVER(puma/build_in)") do |server_name|
+            opt.on("-u SERVER_NAME", "--use SERVER_NAME", "switch using SERVER(puma/builtin)") do |server_name|
               ::Rack::Handler::Toycol.preferred_background_server = server_name
             end
 
@@ -89,16 +109,14 @@ module Toycol
           end
         end
 
-        def client_command_help_messages
-          [
-            { name: "client -p=PORT_NUMBER", summary: "Send request to server" }
-          ]
-        end
+        def generator_option_parser
+          OptionParser.new do |opt|
+            opt.on("-t TYPE", "--type TYPE", "generate TYPE of template (default: :all)") do |type|
+              @options[:template_type] = type
+            end
 
-        def server_command_help_messages
-          [
-            { name: "server -u=SERVER_NAME", summary: "Start proxy & background server" }
-          ]
+            opt.on_head("-h", "--help", "Show this message") { help_command(opt) }
+          end
         end
 
         def help_command(parser)
@@ -122,10 +140,13 @@ module Toycol
 
       case command
       when "client", "c"
-        ::Toycol::Client.execute!(options[:request_message])
+        Client.execute!(options[:request_message])
       when "server", "s"
         ARGV.push("-q", "-s", "toycol")
         Rack::Server.start
+      when "generate", "g"
+        type = options[:template_type] || "all"
+        TemplateGenerator.generate!(type: type, name: options[:protocol_name])
       end
     end
   end

data/lib/toycol/helper.rb

@@ -2,6 +2,10 @@
 
 module Toycol
   module Helper
+    def logger(message)
+      puts "[Toycol] #{message}"
+    end
+
     private
 
     def safe_execution!(&block)
@@ -10,8 +14,8 @@ module Toycol
 
     def safe_executionable_tp
       @safe_executionable_tp ||= TracePoint.new(:script_compiled) do |tp|
-        if tp.binding.receiver == Toycol::Protocol && tp.method_id.to_s.match?(unauthorized_methods_regex)
-          raise Toycol::UnauthorizedMethodError, <<~ERROR
+        if tp.binding.receiver == Protocol && tp.method_id.to_s.match?(unauthorized_methods_regex)
+          raise UnauthorizeError, <<~ERROR
             - Unauthorized method was called!
             You can't use methods that may cause injections in your protocol.
             Ex. Kernel.#eval, Kernel.#exec, Kernel.#require and so on.

data/lib/toycol/protocol.rb

@@ -5,23 +5,30 @@ module Toycol
   class Protocol
     @definements          = {}
     @protocol_name        = nil
-    @http_status_codes    = Toycol::DEFAULT_HTTP_STATUS_CODES.dup
-    @http_request_methods = Toycol::DEFAULT_HTTP_REQUEST_METHODS.dup
+    @http_status_codes    = DEFAULT_HTTP_STATUS_CODES.dup
+    @http_request_methods = DEFAULT_HTTP_REQUEST_METHODS.dup
     @custom_status_codes  = nil
     @additional_request_methods = nil
 
     class << self
-      # For protocol definition
-      def define(protocol_name = nil, &block)
+      attr_reader :protocol_name
+
+      # For Protocolfile to define new protocol
+      def define(protocol_name = :default, &block)
+        if @definements[protocol_name]
+          raise DuplicateProtocolError,
+                "#{protocol_name || "Anonymous"} protocol has already been defined"
+        end
+
         @definements[protocol_name] = block
       end
 
-      # For application which use the protocol
-      def use(protocol_name)
+      # For application to select which protocol to use
+      def use(protocol_name = :default)
         @protocol_name = protocol_name
       end
 
-      # For server which use the protocol
+      # For proxy server to interpret protocol definitions and parse messages
       def run!(message)
         @request_message = message.chomp
 
@@ -67,52 +74,54 @@ module Toycol
         end
       end
 
-      # For server: Get the request path
+      # For proxy server: Fetch the request path
       def request_path
         request_path = request.instance_variable_get("@path").call(request_message)
 
-        raise UnauthorizedRequestError, "This request path is too long" if request_path.size >= 2048
-
-        if request_path.scan(%r{[/\w\d\-_]}).size < request_path.size
-          raise UnauthorizedRequestError,
+        if request_path.size >= 2048
+          raise UnauthorizeError,
+                "This request path is too long"
+        elsif request_path.scan(%r{[/\w\d\-_]}).size < request_path.size
+          raise UnauthorizeError,
                 "This request path contains unauthorized character"
         end
 
         request_path
       end
 
-      # For server: Get the request method
+      # For proxy server: Fetch the request method
       def request_method
         @http_request_methods.concat @additional_request_methods if @additional_request_methods
         request_method = request.instance_variable_get("@http_method").call(request_message)
 
         unless @http_request_methods.include? request_method
-          raise UndefinedRequestMethodError, "This request method is undefined"
+          raise UndefinementError,
+                "This request method is undefined"
         end
 
         request_method
       end
 
-      # For server: Get the query string
+      # For proxy server: Fetch the query string
       def query
         return unless (parse_query_block = request.instance_variable_get("@query"))
 
         parse_query_block.call(request_message)
       end
 
-      # For server: Get the input body
+      # For proxy server: Fetch the input body
       def input
         return unless (parsed_input_block = request.instance_variable_get("@input"))
 
         parsed_input_block.call(request_message)
       end
 
-      # For server: Get the message of status code
+      # For proxy server: fetch the message of status code
       def status_message(status)
         @http_status_codes.merge!(@custom_status_codes) if @custom_status_codes
 
         unless (message = @http_status_codes[status])
-          raise UnknownStatusCodeError, "Application returns unknown status code"
+          raise HTTPError, "Application returns unknown status code"
         end
 
         message

data/lib/toycol/proxy.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "socket"
-
 module Toycol
   class Proxy
     include Helper
@@ -13,15 +11,15 @@ module Toycol
       @path           = nil
       @query          = nil
       @input          = nil
-      @protocol       = ::Toycol::Protocol
+      @protocol       = Protocol
       @proxy          = TCPServer.new(@host, @port)
     end
 
     CHUNK_SIZE = 1024 * 16
 
     def start
-      puts <<~MESSAGE
-        Toycol is running on #{@host}:#{@port}
+      logger <<~MESSAGE
+        Start proxy server on #{@protocol.protocol_name} protocol, listening on #{@host}:#{@port}
         => Use Ctrl-C to stop
       MESSAGE
 
@@ -33,13 +31,13 @@ module Toycol
         while !@client.closed? && !@client.eof?
           begin
             request = @client.readpartial(CHUNK_SIZE)
-            puts "[Toycol] Received message: #{request.inspect.chomp}"
+            logger "Received message: #{request.inspect.chomp}"
 
             safe_execution! { @protocol.run!(request) }
             assign_parsed_attributes!
 
             http_request_message = build_http_request_message
-            puts "[Toycol] Message has been translated to HTTP request message: #{http_request_message.inspect}"
+            logger "Message has been translated to HTTP request message: #{http_request_message.inspect}"
             transfer_to_server(http_request_message)
           rescue StandardError => e
             puts "#{e.class} #{e.message} - closing socket."
@@ -82,15 +80,15 @@ module Toycol
     end
 
     def transfer_to_server(request_message)
-      UNIXSocket.open(Toycol::UNIX_SOCKET_PATH) do |server|
+      UNIXSocket.open(UNIX_SOCKET_PATH) do |server|
         server.write request_message
         server.close_write
-        puts "[Toycol] Successed to Send HTTP request message to server"
+        logger "Successed to Send HTTP request message to server"
 
         response_message = []
         response_message << server.readpartial(CHUNK_SIZE) until server.eof?
         response_message = response_message.join
-        puts "[Toycol] Received response message from server: #{response_message.lines.first}"
+        logger "Received response message from server: #{response_message.lines.first}"
 
         response_line  = response_message.lines.first
         status_number  = response_line[9..11]
@@ -98,18 +96,18 @@ module Toycol
 
         if (custom_message = @protocol.status_message(status_number.to_i)) != status_message
           response_message = response_message.sub(status_message, custom_message)
-          puts "[Toycol] Status message has been translated to custom status message: #{custom_message}"
+          logger "Status message has been translated to custom status message: #{custom_message}"
         end
 
         @client.write response_message
         @client.close_write
-        puts "[Toycol] Finished to response to client"
+        logger "Finished to response to client"
         server.close
       end
     end
 
     def shutdown
-      puts "[Toycol] Catched SIGINT -> Stop to server"
+      logger "Caught SIGINT -> Stop to server"
       exit
     end
   end

data/lib/toycol/server.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "stringio"
-
 module Toycol
   class Server
     BACKLOG    = 1024
@@ -50,19 +48,19 @@ module Toycol
 
     def default_env
       {
-        ::Toycol::PATH_INFO         => "",
-        ::Toycol::QUERY_STRING      => "",
-        ::Toycol::REQUEST_METHOD    => "",
-        ::Toycol::SERVER_NAME       => "toycol_server",
-        ::Toycol::SERVER_PORT       => @port.to_s,
-        ::Toycol::CONTENT_LENGTH    => "0",
-        ::Toycol::RACK_VERSION      => Rack::VERSION,
-        ::Toycol::RACK_INPUT        => stringio(""),
-        ::Toycol::RACK_ERRORS       => $stderr,
-        ::Toycol::RACK_MULTITHREAD  => false,
-        ::Toycol::RACK_MULTIPROCESS => false,
-        ::Toycol::RACK_RUN_ONCE     => false,
-        ::Toycol::RACK_URL_SCHEME   => "http"
+        PATH_INFO         => "",
+        QUERY_STRING      => "",
+        REQUEST_METHOD    => "",
+        SERVER_NAME       => "toycol_server",
+        SERVER_PORT       => @port.to_s,
+        CONTENT_LENGTH    => "0",
+        RACK_VERSION      => Rack::VERSION,
+        RACK_INPUT        => stringio(""),
+        RACK_ERRORS       => $stderr,
+        RACK_MULTITHREAD  => false,
+        RACK_MULTIPROCESS => false,
+        RACK_RUN_ONCE     => false,
+        RACK_URL_SCHEME   => "http"
       }
     end
 
@@ -71,7 +69,7 @@ module Toycol
     end
 
     def response_status_code
-      "HTTP/1.1 #{@returned_status} #{::Toycol::DEFAULT_HTTP_STATUS_CODES[@returned_status.to_i] || "CUSTOM"}\r\n"
+      "HTTP/1.1 #{@returned_status} #{DEFAULT_HTTP_STATUS_CODES[@returned_status.to_i] || "CUSTOM"}\r\n"
     end
 
     def response_headers
@@ -108,17 +106,17 @@ module Toycol
       request_method, request_path, = request_line.split
       request_path, query_string    = request_path.split("?")
 
-      @env[::Toycol::REQUEST_METHOD] = request_method
-      @env[::Toycol::PATH_INFO]      = request_path
-      @env[::Toycol::QUERY_STRING]   = query_string || ""
-      @env[::Toycol::CONTENT_LENGTH]
+      @env[REQUEST_METHOD] = request_method
+      @env[PATH_INFO]      = request_path
+      @env[QUERY_STRING]   = query_string || ""
+      @env[CONTENT_LENGTH]
 
       request_headers.each do |request_header|
         k, v = request_header.split(":").map(&:strip)
-        @env["::Toycol::#{k.tr("-", "_").upcase}"] = v
+        @env[k.tr("-", "_").upcase.to_s] = v
       end
 
-      @env[::Toycol::RACK_INPUT] = stringio(request_body)
+      @env[RACK_INPUT] = stringio(request_body)
     end
   end
 end

data/lib/toycol/template_generator.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Toycol
+  class TemplateGenerator
+    include Helper
+
+    class << self
+      def generate!(type:, name:)
+        raise Error, "Unknown Type: This type of template can't be generated" unless valid? type
+
+        if type == "all"
+          new(name, "protocol").generate!
+          new(name, "app").generate!
+        else
+          new(name, type).generate!
+        end
+      end
+
+      private
+
+      def valid?(type)
+        %w[all app protocol].include? type
+      end
+    end
+
+    def initialize(name, type)
+      @name = name
+      @type = type
+    end
+
+    def generate!
+      raise Error, "#{filename} already exists" unless Dir.glob(filename).empty?
+
+      File.open(filename, "w") { |f| f.print template_text_for_new }
+      logger "Generate #{filename} in #{FileUtils.pwd}"
+    end
+
+    private
+
+    def filename
+      @filename ||= case @type
+                    when "protocol" then "Protocolfile#{@name ? ".#{@name}" : nil}"
+                    when "app"      then "config#{@name ? "_#{@name}" : nil}.ru"
+                    end
+    end
+
+    def template_text_for_new
+      if @name
+        template_text.sub(":PROTOCOL_NAME", ":#{@name}")
+      else
+        template_text.sub("\(:PROTOCOL_NAME\)", "")
+      end
+    end
+
+    def template_text
+      case @type
+      when "protocol" then File.open("#{__dir__}/templates/protocol.txt",    "r", &:read)
+      when "app"      then File.open("#{__dir__}/templates/application.txt", "r", &:read)
+      end
+    end
+  end
+end

data/lib/toycol/templates/application.txt

@@ -0,0 +1,27 @@
+require "rack"
+require "toycol"
+
+Toycol::Protocol.use(:PROTOCOL_NAME)
+
+class App
+  def call(env)
+    # Define your app on request method, request path, request query etc
+    # For example:
+    # case env["REQUEST_METHOD"]
+    # when "GET"
+    #   [
+    #     200,
+    #     { "Content-Type" => "text/html" },
+    #     ["Hello, This app is running by new protocol."]
+    #   ]
+    # when "OTHER"
+    #   [
+    #     600,
+    #     { "Content-Type" => "text/html" },
+    #     ["This is response message for additional request method"]
+    #   ]
+    # end
+  end
+end
+
+run App.new

data/lib/toycol/templates/protocol.txt

@@ -0,0 +1,39 @@
+Toycol::Protocol.define(:PROTOCOL_NAME) do
+  # For example
+  #   client would send:
+  #     quack, quack /posts<3user_id=1
+  #   server would interpret client message:
+  #     GET /posts?user_id=1
+
+
+  # [OPTIONAL] You can define your additional request methods:
+  # For example:
+  # additional_request_methods "OTHER"
+
+  # [OPTIONAL] You can define your own response status code:
+  # For example:
+  # custom_status_codes(
+  #   600 => "I'm afraid you are not a duck..."
+  # )
+
+  # [REQUIRED] Define how you parse request path from request message
+  request.path do |message|
+    # For example:
+    # %r{(?<path>\/\w*)}.match(message)[:path]
+  end
+
+  # [REQUIRED] Define how you parse query from request message
+  request.query do |message|
+    # For example:
+    # %r{\<3(?<query>.+)}.match(message) { |m| m[:query] }
+  end
+
+  # [REQUIRED] Define how you parse query from request message
+  request.http_method do |message|
+    # For example:
+    # case message.scan(/quack/).size
+    # when 2 then "GET"
+    # else "OTHER"
+    # end
+  end
+end

data/lib/toycol/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Toycol
-  VERSION = "0.2.1"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: toycol
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Misaki Shioi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-07-23 00:00:00.000000000 Z
+date: 2021-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -32,6 +32,8 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/ISSUE_TEMPLATE/bug_report.md"
+- ".github/ISSUE_TEMPLATE/feature_request.md"
 - ".github/dependabot.yml"
 - ".github/workflows/main.yml"
 - ".gitignore"
@@ -44,6 +46,9 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- examples/anonymous/Gemfile
+- examples/anonymous/Protocolfile
+- examples/anonymous/config.ru
 - examples/duck/Gemfile
 - examples/duck/Protocolfile.duck
 - examples/duck/config_duck.ru
@@ -71,6 +76,9 @@ files:
 - lib/toycol/protocol.rb
 - lib/toycol/proxy.rb
 - lib/toycol/server.rb
+- lib/toycol/template_generator.rb
+- lib/toycol/templates/application.txt
+- lib/toycol/templates/protocol.txt
 - lib/toycol/version.rb
 - toycol.gemspec
 homepage: https://github.com/shioimm/toycol