yokunai 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c1274ce0c2f7dacdd99c1abc30bed8deab94fc7b
+  data.tar.gz: e7d4494b0ffd794ee6044c899b78cb3e5738ce48
+SHA512:
+  metadata.gz: 8c4886093c184821c2f726d584e6c56c3e76d7eafb7f5a276bef6d65363abe4bd71929e2c322a8426665a2dc0321d86931e194b25384dbac6d824526a99ef590
+  data.tar.gz: 8811bce56b21078bef89fb97dcdb7ac54557631635f38199a5b552700dd7065584443a988ed85d270eeb6b4031093cb31aa5014127f6864552518c5d778d9ad9

data/README.markdown

@@ -0,0 +1,72 @@
+# よくない
+
+It's not very good.
+
+Please don't actually use this.
+
+## How to use it
+
+Add the dependency:
+
+```ruby
+# Gemfile
+source "https://rubygems.org/"
+
+gem "yokunai"
+```
+
+Run `bundle`, of course. Then make a controller:
+
+```ruby
+# lib/my_app.rb
+require "yokunai"
+
+ROUTES = {
+  %r{^/$} => {class: "HomeController", methods: ["GET"]}
+}.freeze
+
+class HomeController < Yokunai::AbstractController
+  def get
+    respond body: "It works!"
+  end
+end
+```
+
+Add some configuration for where you want to keep things:
+
+```yml
+# config/development.yml
+---
+template_dir: web/views
+asset_dir: web/assets
+```
+
+Now just make a rackup config so we can run something:
+
+```ruby
+# config.ru
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "lib"))
+require "my_app"
+
+run Yokunai::Application.new(
+  route_map: ROUTES,
+  base_dir: File.dirname(__FILE__)
+)
+```
+
+Then just `bundle exec rackup` and you're gold, Ponyboy.
+
+## Assets
+
+You probably have frontend assets, if this is a web page. There's a controller
+built-in for that if you want it. Just point a path with a capture called `name`
+to `Yokunai::StaticController`.
+
+```ruby
+ROUTES = {
+  %r{^/assets/(?<name>.+)$} => {class: "Yokunai::StaticController", methods: ["GET"]}
+}
+```
+
+Now assets will be served out of the directory you set as your `asset_dir` in
+the YAML config.

data/lib/yokunai.rb

@@ -0,0 +1,16 @@
+# Dependencies
+require "mimemagic"
+require "ostruct"
+require "yaml"
+
+# Core
+require "yokunai/config"
+require "yokunai/application"
+require "yokunai/render_context"
+require "yokunai/template"
+require "yokunai/mime"
+
+# Controllers
+require "yokunai/abstract_controller"
+require "yokunai/errors_controller"
+require "yokunai/static_controller"

data/lib/yokunai/abstract_controller.rb

@@ -0,0 +1,79 @@
+module Yokunai
+  class AbstractController
+
+    # --------------------------------------------------------------------------
+    # Constants
+    # --------------------------------------------------------------------------
+
+    DEFAULT_HEADERS = {
+      "Content-Type" => "text/html",
+      "Server" => "yokunai/1.0"
+    }
+
+
+    # --------------------------------------------------------------------------
+    # Instance Methods
+    # --------------------------------------------------------------------------
+
+    # @param env [Rack::Env] The Rack ENV
+    # @param captures [MatchData] The named captures from the route regex
+    def initialize(env, captures=nil)
+      @env = env
+      @captures = captures
+      @templates = Yokunai::Template.new
+    end
+
+
+    # --------------------------------------------------------------------------
+    # Default HTTP method handlers
+    # --------------------------------------------------------------------------
+
+    def get
+      unsupported_method
+    end
+
+    def post
+      unsupported_method
+    end
+
+    def put
+      unsupported_method
+    end
+
+    def patch
+      unsupported_method
+    end
+
+    def delete
+      unsupported_method
+    end
+
+    def options
+      unsupported_method
+    end
+
+  private
+
+    def respond(code: 200, headers: {}, body: "", template: nil, context: {})
+      if template
+        return respond_error(:not_found) unless @templates.exist?(template)
+        body = @templates.render(template, context)
+      end
+
+      [
+        code,
+        DEFAULT_HEADERS.merge(headers),
+        [body]
+      ]
+    end
+
+    def respond_error(meth)
+      Yokunai::ErrorsController.new(@env).public_send(meth)
+    end
+
+    def unsupported_method
+      [405, {}, ["Error 405: Method not supported on this resource.\n"]]
+    end
+
+  end
+end

data/lib/yokunai/application.rb

@@ -0,0 +1,40 @@
+module Yokunai
+  # The Rack-compatible entrypoint class. Acts as the router, sending the
+  # request to the appropriate controller for handling.
+  class Application
+
+    # @param route_map [Hash] A hash with path regexes as keys, and hashes as values with the controller to send matching requests to.
+    # @param base_dir [String] The absolute base directory to use for various lookups.
+    def initialize(route_map:, base_dir:)
+      @routes = route_map
+      Yokunai::Config.base_dir = base_dir
+      Yokunai::Config.populate(ENV["YOKUNAI_ENV"] || "development")
+    end
+
+    # Route a request to the correct controller based on the given data.
+    #
+    # @param path [String] the domain-relative path being requested.
+    # @param env [Rack::Env] the full Rack environment
+    # @return [Array] a Rack-compatible response array.
+    def call(env)
+      route = @routes.map do |exp, meta|
+        next unless matches = env["PATH_INFO"].match(exp)
+        meta.merge({captures: matches})
+      end.compact.first
+
+      unless route
+        return Yokunai::ErrorsController.new(env).not_found
+      end
+
+      request_method = env["REQUEST_METHOD"]
+      if route[:methods].include?(request_method)
+        Object.const_get(route[:class])
+          .new(env, route[:captures])
+          .public_send(request_method.downcase)
+      else
+        Yokunai::ErrorsController.new(env).unsupported_method
+      end
+    end
+
+  end
+end

data/lib/yokunai/config.rb

@@ -0,0 +1,41 @@
+module Yokunai
+  # A centralized way to get configuration options. Reads values out of
+  # `config.yml` (or whatever name is passed to `populate`).
+  class Config
+
+    # Set the base directory path.
+    #
+    # @param base_dir [String]
+    # @return [String]
+    def self.base_dir=(dir)
+      @@base_dir = dir
+    end
+
+    # Get the base directory path.
+    #
+    # @return [String]
+    def self.base_dir
+      @@base_dir
+    end
+
+    # Loads the config into memory from disk. Called automatically on the first
+    # cold-get, but can be called manually to warm up.
+    #
+    # @param name [String] the name of the confg file to load. If not provided,
+    #                      will use the value of YOKUNAI_ENV.
+    def self.populate(name = nil)
+      name ||= ENV["YOKUNAI_ENV"]
+      @@config = YAML.load_file(File.join(@@base_dir, "config", "#{name}.yml"))
+    end
+
+    # Get the value of a config option
+    #
+    # @param key [String] the key to fetch
+    # @return [any] whatever key contains
+    def self.get(key)
+      populate unless class_variable_defined?(:@@config)
+      @@config[key]
+    end
+
+  end
+end

data/lib/yokunai/errors_controller.rb

@@ -0,0 +1,13 @@
+module Yokunai
+  class ErrorsController < AbstractController
+
+    def not_found
+      respond(code: 404, body: "Error 404: Could not locate resource.")
+    end
+
+    def unsupported_method
+      respond(code: 405, body: "Error 405: Unsupported HTTP method.")
+    end
+
+  end
+end

data/lib/yokunai/mime.rb

@@ -0,0 +1,15 @@
+module Yokunai
+  # Provides a light wrapper around MimeMagic to make it a little easier to use.
+  class Mime
+
+    # Detect the mime type from the given path string.
+    #
+    # @param path [String] the path
+    # @return [String] the mime type string
+    def self.detect_from_path(path, fallback = "text/plain")
+      mime = MimeMagic.by_path(path)
+      mime ? mime.type : fallback
+    end
+
+  end
+end

data/lib/yokunai/render_context.rb

@@ -0,0 +1,31 @@
+module Yokunai
+  # Provides a clean binding and basic API to add variables to it. Meant to be
+  # used only for template rendering.
+  class RenderContext
+
+    # Instantiate a new instance and create local variables for the key/value
+    # pairs in the given hash.
+    #
+    # @param context [Hash] variables to set on the local binding
+    # @return [Yokunai::RenderContext]
+    def initialize(context = {})
+      @binding = binding
+
+      context.each do |key, value|
+        @binding.local_variable_set(key, value)
+      end
+    end
+
+    # Returns the binding of this class, with the variables that have been set.
+    def get_binding
+      @binding
+    end
+
+    # Sort of a hack, since if a var doesn't exist it will try and call a method
+    # and so we'll end up here...
+    def method_missing(m, *args, &block)
+      nil
+    end
+
+  end
+end

data/lib/yokunai/static_controller.rb

@@ -0,0 +1,19 @@
+module Yokunai
+  class StaticController < AbstractController
+
+    def get
+      asset_dir = File.join(Yokunai::Config.base_dir, Yokunai::Config.get("asset_dir"))
+      asset_file = File.join(asset_dir, @captures[:name])
+
+      if File.exist?(asset_file)
+        mime = Yokunai::Mime.detect_from_path(asset_file)
+        asset_body = File.read(asset_file)
+
+        respond(body: asset_body, headers: {"Content-Type" => mime})
+      else
+        respond_error(:not_found)
+      end
+    end
+
+  end
+end

data/lib/yokunai/template.rb

@@ -0,0 +1,49 @@
+module Yokunai
+  # Renders ERB templates.
+  class Template
+
+    FALLBACK_EMPTY_LAYOUT = "<%= partial %>".freeze
+
+    def initialize(template_path: nil)
+      @template_path = template_path || File.join(Yokunai::Config.base_dir, Yokunai::Config.get("template_dir"))
+      @raw_layout = get_layout
+    end
+
+    # Render an ERB template with the given name, and cache the result for
+    # subsequent calls.
+    #
+    # @param template [String] the name of a template
+    # @param context [Hash] key/value pairs of variables to bind the template
+    # @return [String] the ERB render result
+    def render(template, context = {})
+      return nil unless exist?(template)
+
+      path = File.join(@template_path, template + ".erb")
+      layout_context = context.merge({
+        partial: ERB.new(File.read(path)).result(Yokunai::RenderContext.new(context).get_binding)
+      })
+
+      ERB.new(@raw_layout).result(Yokunai::RenderContext.new(layout_context).get_binding)
+    end
+
+    # Checks if a template exists. Useful for gating before rendering.
+    #
+    # @param template [String] the template name
+    # @return [Boolean]
+    def exist?(template)
+      File.exist?(File.join(@template_path, template + ".erb"))
+    end
+
+    private
+
+    def get_layout
+      layout_path = File.join(@template_path, "layout.erb")
+      if File.exist?(layout_path)
+        File.read(layout_path)
+      else
+        FALLBACK_EMPTY_LAYOUT
+      end
+    end
+
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: yokunai
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Alex Blackie
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-08-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: mimemagic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+description: '["Alex Blackie"]'
+email: alex@alexblackie.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.markdown
+- lib/yokunai.rb
+- lib/yokunai/abstract_controller.rb
+- lib/yokunai/application.rb
+- lib/yokunai/config.rb
+- lib/yokunai/errors_controller.rb
+- lib/yokunai/mime.rb
+- lib/yokunai/render_context.rb
+- lib/yokunai/static_controller.rb
+- lib/yokunai/template.rb
+homepage: https://github.com/alexblackie/yokunai
+licenses:
+- BSD-3-Clause
+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: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Helps you make really simple dynamic Internet Web Pages.
+test_files: []