jeanine 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8d88a21a82401395ddca515402a07e3155939eb0
+  data.tar.gz: e6edce8a4097864466149cf6769765332a868c76
+SHA512:
+  metadata.gz: 17f7d684adeefc7ec56e7244c6c53fddeafb9d037e4a1ee9aab94d8925193a39a95d0a079ba2aad85ae3f5a64b972315a7893f6ced6d07ba7e693923be9cc67e
+  data.tar.gz: 82082d64a1620c947e51aa84d9ada5701825c0525061cd930022b8ef68611338570fc64f20038a4605e48bf1d27578c668ff2923a0ef7d88bc3b55435792877d

data/lib/jeanine.rb

@@ -0,0 +1,26 @@
+require 'forwardable'
+require 'logger'
+
+require "jeanine/version"
+require 'jeanine/core_ext'
+require 'jeanine/router'
+require 'jeanine/app'
+require 'tilt'
+
+module Jeanine
+  def self.tilt_cache
+    @title_cache ||= Tilt::Cache.new
+  end
+
+  def self.logger
+    @logger ||= Logger.new(STDOUT)
+  end
+
+  def logger=(val)
+    @logger = val
+  end
+
+  def self.router
+    @router ||= Router.new
+  end
+end

data/lib/jeanine/app.rb

@@ -0,0 +1,68 @@
+require 'jeanine/callbacks'
+require 'jeanine/mimes'
+require 'jeanine/request'
+require 'jeanine/response'
+require 'jeanine/renderer'
+require 'jeanine/routing'
+
+module Jeanine
+  class App
+    include Routing::Evaluation
+    attr_reader :request, :response
+    class << self
+      include Routing::DSL
+      include Callbacks
+
+      alias :_new :new
+      def new(*args, &block)
+        initialize!
+        stack.run _new(*args, &block)
+        stack
+      end
+
+      def initialize!
+        Mimes.load!
+      end
+
+      def stack
+        @stack ||= Rack::Builder.new
+      end
+
+      def router
+        Jeanine.router
+      end
+
+      def call(env)
+        new.call env
+      end
+    end
+
+    def call(env)
+      @env = env
+      @request = Jeanine::Request.new(env)
+      @response = Jeanine::Response.new
+      catch(:halt) { route_eval }
+    end
+
+    private
+
+    def params
+      @params ||= if @request.format
+                    @request.params.merge({ format: @request.format })
+                  else
+                    @request.params
+                  end
+    end
+
+    def render(*args)
+      @response.action_variables = instance_variables_cache
+      Renderer.new(@response).render(*args)
+    end
+
+    def instance_variables_cache
+      instance_variables.each_with_object({}) do |var, obj|
+        obj[var] = instance_variable_get(var)
+      end
+    end
+  end
+end

data/lib/jeanine/callbacks.rb

@@ -0,0 +1,28 @@
+module Jeanine
+  module Callbacks
+    def _callbacks
+      @_callbacks ||= {
+          before: [],
+          after: [],
+          before_all: [],
+          after_all: []
+      }
+    end
+
+    def _register_callback(type, paths = [], &block)
+      if paths == []
+        _callbacks["#{type}_all".to_sym] << { block: block }
+      else
+        _callbacks[type] << { paths: paths, block: block }
+      end
+    end
+
+    def before(*paths, &block)
+      _register_callback(:before, paths, &block)
+    end
+
+    def after(*paths, &block)
+      _register_callback(:after, paths, &block)
+    end
+  end
+end

data/lib/jeanine/core_ext.rb

@@ -0,0 +1,4 @@
+require 'jeanine/core_ext/array'
+require 'jeanine/core_ext/hash'
+require 'jeanine/core_ext/nil_class'
+require 'jeanine/core_ext/string'

data/lib/jeanine/core_ext/array.rb

@@ -0,0 +1,5 @@
+class Array
+  def extract_options!
+    last.is_a?(::Hash) ? pop : {}
+  end
+end

data/lib/jeanine/core_ext/hash.rb

@@ -0,0 +1,8 @@
+class Hash
+  def reverse_merge(other_hash)
+    other_hash.merge(self)
+  end
+  def reverse_merge!(other_hash)
+    replace(reverse_merge(other_hash))
+  end
+end

data/lib/jeanine/core_ext/nil_class.rb

@@ -0,0 +1,5 @@
+class NilClass
+  def presence
+    nil
+  end
+end

data/lib/jeanine/core_ext/string.rb

@@ -0,0 +1,6 @@
+class String
+  def presence
+    return nil if self.empty?
+    self
+  end
+end

data/lib/jeanine/environment.rb

@@ -0,0 +1,18 @@
+module Broding
+  module Environment
+    def env
+      @_env ||= (ENV["RACK_ENV"].presence || "development")
+    end
+
+    def groups(*groups)
+      hash = groups.extract_options!
+      env = Jeanine.env
+      groups.unshift(:default, env)
+      groups.concat ENV["BRODY_GROUPS"].to_s.split(",")
+      groups.concat hash.map { |k, v| k if v.map(&:to_s).include?(env) }
+      groups.compact!
+      groups.uniq!
+      groups
+    end
+  end
+end

data/lib/jeanine/headers.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Jeanine
+  class Headers
+    CGI_VARIABLES = Set.new(%W[
+        AUTH_TYPE
+        CONTENT_LENGTH
+        CONTENT_TYPE
+        GATEWAY_INTERFACE
+        HTTPS
+        PATH_INFO
+        PATH_TRANSLATED
+        QUERY_STRING
+        REMOTE_ADDR
+        REMOTE_HOST
+        REMOTE_IDENT
+        REMOTE_USER
+        REQUEST_METHOD
+        SCRIPT_NAME
+        SERVER_NAME
+        SERVER_PORT
+        SERVER_PROTOCOL
+        SERVER_SOFTWARE
+      ]).freeze
+
+    HTTP_HEADER = /\A[A-Za-z0-9-]+\z/
+
+    include Enumerable
+
+    def initialize(request)
+      @req = request
+    end
+
+    def [](key)
+      @req.get_header env_name(key)
+    end
+
+    def key?(key)
+      @req.has_header? env_name(key)
+    end
+    alias :include? :key?
+
+    DEFAULT = Object.new
+
+    def fetch(key, default = DEFAULT)
+      @req.fetch_header(env_name(key)) do
+        return default unless default == DEFAULT
+        return yield if block_given?
+        raise KeyError, key
+      end
+    end
+
+    def each(&block)
+      @req.each_header(&block)
+    end
+
+    def to_h
+      obj = {}
+      each do |k,v|
+        obj[k] = v
+      end
+      obj
+    end
+
+    private
+
+    def env_name(key)
+      key = key.to_s
+      if HTTP_HEADER.match?(key)
+        key = key.upcase.tr("-", "_")
+        key = "HTTP_" + key unless CGI_VARIABLES.include?(key)
+      end
+      key
+    end
+  end
+end

data/lib/jeanine/mimes.rb

@@ -0,0 +1,33 @@
+module Jeanine
+  class Mimes
+    MimeTypeNotFound = Class.new(StandardError)
+    MIME_TYPES_INVERTED = Rack::Mime::MIME_TYPES.invert
+
+    def self.load!
+      register(:json, Rack::Mime::MIME_TYPES[".json"])
+      register(:html, Rack::Mime::MIME_TYPES[".html"])
+      register(:text, Rack::Mime::MIME_TYPES[".text"])
+      register(:plain, self.for(:text))
+    end
+
+    def self.register(type, header)
+      mime_types[type] = header
+    end
+
+    def self.for(type)
+      mime_types.fetch(type) do
+        raise(MimeTypeNotFound, "Mime #{type} not registered")
+      end
+    end
+
+    def self.mime_types
+      @mime_types ||= {}
+    end
+
+    private_class_method :mime_types
+
+    def initialize(*)
+      raise "Should not be initialiazed"
+    end
+  end
+end

data/lib/jeanine/path_proxy.rb

@@ -0,0 +1,73 @@
+module Jeanine
+  class PathProxy
+    def initialize(context, pathname, options = {})
+      @context = context
+      @pathname = pathname
+      @options = options
+    end
+
+    def get(path = nil, options = {}, &block)
+      @options.reverse_merge!(options)
+      @context.get(merged_path(path), options, &block)
+    end
+
+    def post(path = nil, options = {}, &block)
+      @options.reverse_merge!(options)
+      @context.post(merged_path(path), options, &block)
+    end
+
+    def patch(path = nil, options = {}, &block)
+      @options.reverse_merge!(options)
+      @context.patch(merged_path(path), options, &block)
+    end
+
+    def put(path = nil, options = {}, &block)
+      @options.reverse_merge!(options)
+      @context.put(merged_path(path), options, &block)
+    end
+
+    def options(path = nil, options = {}, &block)
+      @options.reverse_merge!(options)
+      @context.options(merged_path(path), options, &block)
+    end
+
+    def head(path = nil, options = {}, &block)
+      @options.reverse_merge!(options)
+      @context.head(merged_path(path), options, &block)
+    end
+
+    def delete(path = nil, options = {}, &block)
+      @options.reverse_merge!(options)
+      @context.delete(merged_path(path), options, &block)
+    end
+
+    def path(path = nil, options = {}, &block)
+      @options.reverse_merge!(options)
+      @context.path(merged_path(path), options, &block)
+    end
+
+    def match(path = nil, options = {}, &block)
+      @options.reverse_merge!(options)
+      @context.match(merged_path(path), options, &block)
+    end
+
+    def root(path = '/', options = {}, &block)
+      @options.reverse_merge!(options)
+      @context.root(merged_path(path), options, &block)
+    end
+
+    def before(*paths, &block)
+      @context.before(*paths, &block)
+    end
+
+    def after(*paths, &block)
+      @context.after(*paths, &block)
+    end
+
+    private
+
+    def merged_path(path)
+      [@pathname, path].join
+    end
+  end
+end

data/lib/jeanine/renderer.rb

@@ -0,0 +1,130 @@
+require 'jeanine/view'
+
+module Jeanine
+  class Renderer
+    def self._renderers
+      @_renderers ||= Set.new
+    end
+
+    def self.add(key, &block)
+      define_method(_render_with_renderer_method_name(key), &block)
+      _renderers << key.to_sym
+    end
+
+    def _render_with_renderer_method_name(key)
+      self.class._render_with_renderer_method_name(key)
+    end
+
+    def self._render_with_renderer_method_name(key)
+      "_render_with_renderer_#{key}"
+    end
+
+    def initialize(response)
+      @response = response
+    end
+
+    def render(*args)
+      options = _normalize_render(*args)
+      _render_to_body_with_renderer(options)
+    end
+
+    private
+
+    def _normalize_render(*args, &block)
+      options = _normalize_args(*args, &block)
+      _normalize_options(options)
+      options
+    end
+
+    def _normalize_args(action = nil, options = {})
+      if action.is_a?(Hash)
+        action
+      else
+        options
+      end
+    end
+
+    def _normalize_options(options)
+      options
+    end
+
+    def _render_to_body_with_renderer(options)
+      self.class._renderers.each do |name|
+        if options.key?(name)
+          _process_options(options)
+          method_name = _render_with_renderer_method_name(name)
+          return send(method_name, options.delete(name), options)
+        end
+      end
+      nil
+    end
+
+    def _process_options(options)
+      status, content_type, location = options.values_at(:status, :content_type, :location)
+      @response.status = status if status
+      @response.content_type = content_type if content_type
+      @response.headers["Location"] = location if location
+    end
+
+    add :json do |json, options|
+      json = json.to_json(options) unless json.is_a?(String)
+
+      if options[:callback]
+        "/**/#{options[:callback]}(#{json})"
+      else
+        @response.content_type = Mimes.for(:json)
+        json
+      end
+    end
+
+    def cache
+      Thread.current[:tilt_cache] ||= Tilt::Cache.new
+    end
+
+    def html(engine, template_name, options = {}, locals = {}, &block)
+      locals          = options.delete(:locals) || locals || {}
+      layout          = options[:layout]
+      scope           = options.delete(:scope) || self
+      options.delete(:layout)
+      options[:outvar] ||= '@_out_buf'
+      options[:default_encoding] ||= "UTF-8"
+      template        = compile_template(engine, template_name, options)
+      output          = template.render(scope, locals, &block)
+      if layout
+        unless layout.include?("layouts/")
+          layout = "layouts/#{layout}"
+        end
+        options = options.merge(layout: false, scope: scope)
+        catch(:layout_missing) { return html(engine, layout, options, locals) { output } }
+      end
+      output
+    end
+
+    def compile_template(engine, template_name, options)
+      Tilt::Cache.new.fetch engine, template_name, options do
+        template = Tilt[engine]
+        raise "Template engine not found: #{engine}" if template.nil?
+        template.new("views/#{template_name}", options)
+      end
+    end
+
+    add :template do |template, options|
+      view = Jeanine::View.new
+      @response.action_variables.each do |k,v|
+        view.instance_variable_set(k, v.dup)
+      end
+      options[:scope] = view
+      html(:erb, template, options)
+    end
+
+    add :text do |text, _options|
+      @response.content_type = Mimes.for(:text)
+      text
+    end
+
+    add :plain do |text, _options|
+      @response.content_type = Mimes.for(:plain)
+      text
+    end
+  end
+end

data/lib/jeanine/request.rb

@@ -0,0 +1,64 @@
+require 'rack/request'
+require 'jeanine/headers'
+
+module Jeanine
+  class Request < Rack::Request
+    FORMAT_REGEX = %r{\.(\w+)\z}
+
+    def initialize(env)
+      env['PATH_INFO'] = '/' if env['PATH_INFO'].empty?
+      if env['PATH_INFO'].include?(".")
+        format = env['PATH_INFO'].match(FORMAT_REGEX)
+        if format
+          @format = format.captures[0]
+          env['PATH_INFO'].gsub!(FORMAT_REGEX, '')
+        end
+      end
+      super
+    end
+
+    def headers
+      @headers ||= Jeanine::Headers.new(self)
+    end
+
+    def post?
+      request_method == 'POST'
+    end
+
+    def get?
+      request_method == 'GET'
+    end
+
+    def delete?
+      request_method == 'DELETE'
+    end
+
+    def put?
+      request_method == 'PUT'
+    end
+
+    def patch?
+      request_method == 'PATCH'
+    end
+
+    def options?
+      request_method == 'options'
+    end
+
+    def head?
+      request_method == 'head'
+    end
+
+    def json?
+      format == 'json'
+    end
+
+    def mime_type
+      @mime_type ||= Mimes::MIME_TYPES_INVERTED[content_type]
+    end
+
+    def format
+      @format || Rack::Mime::MIME_TYPES[content_type]
+    end
+  end
+end

data/lib/jeanine/response.rb

@@ -0,0 +1,49 @@
+require 'forwardable'
+require 'json'
+
+module Jeanine
+  class Response
+    attr_accessor :action_variables
+    attr_reader :headers, :body
+    attr_accessor :status
+
+    def initialize(body = [], status = 200, headers = { 'Content-Type' => 'text/html; charset=utf-8' })
+      @body = body
+      @status = status
+      @headers = headers
+      @length = 0
+
+      return if body == []
+      if body.respond_to? :to_str
+        write body.to_str
+      elsif body.respond_to? :each
+        body.each { |i| write i.to_s }
+      else
+        raise TypeError, 'body must #respond_to? #to_str or #each'
+      end
+    end
+
+    def complete!
+      unless (100..199).include?(status) || status == 204
+        headers['Content-Length'] = @length.to_s
+      end
+      [status, headers, body]
+    end
+
+    def content_type=(type)
+      headers['Content-Type'] = type
+    end
+
+    def redirect_to(target, status = 302)
+      self.status = status
+      headers['Location'] = target
+    end
+
+    def write(string)
+      s = string.to_s
+      @length += s.bytesize
+
+      body << s
+    end
+  end
+end

data/lib/jeanine/router.rb

@@ -0,0 +1,38 @@
+require 'forwardable'
+
+module Jeanine
+  class Router
+    extend Forwardable
+
+    def_delegators :@routes, :[]
+
+    attr_reader :routes
+    def initialize
+      @routes = {
+          GET: [],
+          POST: [],
+          PATCH: [],
+          PUT: [],
+          DELETE: [],
+          OPTIONS: [],
+          HEAD: [],
+      }
+    end
+
+    def add(verb, path, options = {}, &block)
+      routes[verb] << build_route("#{path}", options, &block)
+    end
+
+    private
+
+    def build_route(path, options = {}, &block)
+      route = { path: "#{path}", compiled_path: nil, params: [], block: block }
+      compiled_path = route[:path].gsub(/:\w+/) do |match|
+        route[:params] << match.tr(':', '').to_sym
+        '([^/?#]+)'
+      end
+      route[:compiled_path] = /^#{compiled_path}?$/
+      route
+    end
+  end
+end

data/lib/jeanine/routing.rb

@@ -0,0 +1,2 @@
+require 'jeanine/routing/dsl'
+require 'jeanine/routing/evaluation'

data/lib/jeanine/routing/dsl.rb

@@ -0,0 +1,60 @@
+require 'jeanine/path_proxy'
+
+module Jeanine
+  module Routing
+    module DSL
+      extend SingleForwardable
+
+      RouteError = Class.new(StandardError)
+
+      def_delegator :Jeanine, :router
+
+      def get(path = nil, options = {}, &block)
+        router.add(:GET, path, options, &block)
+      end
+
+      def post(path = nil, options = {}, &block)
+        router.add(:POST, path, options, &block)
+      end
+
+      def put(path = nil, options = {}, &block)
+        router.add(:PUT, path, options, &block)
+      end
+
+      def patch(path = nil, options = {}, &block)
+        router.add(:PATCH, path, options, &block)
+      end
+
+      def head(path = nil, options = {}, &block)
+        router.add(:HEAD, path, options, &block)
+      end
+
+      def options(path = nil, options = {}, &block)
+        router.add(:OPTIONS, path, options, &block)
+      end
+
+      def delete(path = nil, options = {}, &block)
+        router.add(:DELETE, path, options, &block)
+      end
+
+      def path(pathname, options = {}, &block)
+        option_merger = Jeanine::PathProxy.new(self, pathname, options)
+        option_merger.instance_eval(&block)
+      end
+
+      def root(path = "/", options = {}, &block)
+        router.add(:GET, path, options, &block)
+      end
+
+      def match(path = nil, options = {}, &block)
+        via = options.delete(:via)
+        unless via.is_a?(Array)
+          raise RouteError, "options[:via] must be an array of HTTP verbs"
+        end
+        via.each do |verb|
+          router.add(verb.upcase, path, options, &block)
+        end
+      end
+    end
+  end
+end

data/lib/jeanine/routing/evaluation.rb

@@ -0,0 +1,96 @@
+module Jeanine
+  module Routing
+    module Evaluation
+      IGNORED_INSTANCE_VARIABLES = [:@env]
+      def route_eval
+        before_find_route!
+        route = find_route
+
+        if route
+          before_evaluate_route!
+          result = instance_eval(&route[:block])
+          @response.write(result)
+          after_evaluate_route!
+        else
+          @response.status = 404
+        end
+        after_response!
+        @response.complete!
+      end
+
+      private
+
+      def find_route
+        matches = nil
+        route = Jeanine.router[@request.request_method.to_sym].detect do |r|
+          matches = r[:compiled_path].match(@request.path_info)
+          !matches.nil?
+        end
+
+        return nil if route.nil?
+        return route if route && route[:params].empty?
+
+        index = 0
+        while index < matches.captures.size
+          param = route[:params][index]
+          @request.params[param] = matches.captures[index]
+          if index == match.captures.size
+            @request.params[param].gsub!(@request.format)
+          end
+          index += 1
+        end
+
+        route
+      end
+
+      def before_find_route!
+        run_before_callbacks!(:before_all)
+      end
+
+      def before_evaluate_route!
+        run_before_callbacks!(:before)
+      end
+
+      def after_evaluate_route!
+        run_after_callbacks!(:after)
+      end
+
+      def after_response!
+        run_after_callbacks!(:after_all)
+      end
+
+      def run_before_callbacks!(type)
+        if type == :before_all
+          self.class._callbacks[type].each { |callback| eval_callback(&callback[:block]) }
+        else
+          matching_callbacks(type) do |callback|
+            eval_callback(&callback[:block])
+          end
+        end
+      end
+
+      def run_after_callbacks!(type)
+        if type == :after_all
+          self.class._callbacks[type].each { |callback| eval_callback(&callback[:block]) }
+        else
+          matching_callbacks(type) do |callback|
+            eval_callback(&callback[:block])
+          end
+        end
+      end
+
+      def matching_callbacks(type)
+        self.class._callbacks[type].select do |callback|
+          paths = callback[:paths]
+          if paths.detect { |path| path.match?(@request.path_info) }
+            yield callback
+          end
+        end
+      end
+
+      def eval_callback(*args, &callback)
+        instance_exec(*args, &callback)
+      end
+    end
+  end
+end

data/lib/jeanine/version.rb

@@ -0,0 +1,3 @@
+module Jeanine
+  VERSION = "0.1.0"
+end

data/lib/jeanine/view.rb

@@ -0,0 +1,4 @@
+module Jeanine
+  class View
+  end
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: jeanine
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Josh Brody
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-07-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tilt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A framework.
+email:
+- git@josh.mn
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/jeanine.rb
+- lib/jeanine/app.rb
+- lib/jeanine/callbacks.rb
+- lib/jeanine/core_ext.rb
+- lib/jeanine/core_ext/array.rb
+- lib/jeanine/core_ext/hash.rb
+- lib/jeanine/core_ext/nil_class.rb
+- lib/jeanine/core_ext/string.rb
+- lib/jeanine/environment.rb
+- lib/jeanine/headers.rb
+- lib/jeanine/mimes.rb
+- lib/jeanine/path_proxy.rb
+- lib/jeanine/renderer.rb
+- lib/jeanine/request.rb
+- lib/jeanine/response.rb
+- lib/jeanine/router.rb
+- lib/jeanine/routing.rb
+- lib/jeanine/routing/dsl.rb
+- lib/jeanine/routing/evaluation.rb
+- lib/jeanine/version.rb
+- lib/jeanine/view.rb
+homepage: https://github.com/joshmn/jeanine
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/joshmn/jeanine
+  source_code_uri: https://github.com/joshmn/jeanine
+  changelog_uri: https://github.com/joshmn/jeanine
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14.3
+signing_key: 
+specification_version: 4
+summary: A framework.
+test_files: []