jetra 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5b6d7a10300cb071943c84db41627c7dbc051e4c
+  data.tar.gz: f4c8b2ce7efaa9d93ccbe301eb70ee51b44b155f
+SHA512:
+  metadata.gz: 000a5c59fc536a6d0f95ffef0c50bee342da2843da07f2cc288f9c1d7245eb6fe0ee40712f96ccfdf8b7abe1e1d7036705c6f70fc210aaf7311fd6eb907555f6
+  data.tar.gz: d7c93df3cba8b1f6e734c01f6499c50457a02a4b2dbd1c87330fc6cb2585bb7d97fc618ede00926b1c62ad4f061cd19a13c8510f3421859c43e330da2825ab7b

data/lib/jetra.rb

@@ -0,0 +1,2 @@
+
+require "jetra/base"

data/lib/jetra/adapter/rack.rb

@@ -0,0 +1,66 @@
+
+require "set"
+require 'json'
+
+module Jetra
+
+  class RackAdapter
+
+    include Rack::Utils
+
+    def initialize(app)
+      @app = app
+
+      @routes = Set.new
+      @app.routes.each_key do |route|
+        @routes << route
+      end
+
+    end
+
+    def call(env)
+
+      request = Rack::Request.new(env)
+
+      route = request.path_info
+      route.chop! if (char=route[-1]) and char=='/' # ignore last '/' char
+      route[0] = '' if route[0]=="/" #remove first '/' char
+
+      sym_route = route.to_sym
+
+      if @routes.include?(sym_route)
+        params = indifferent_params(request.params)
+        res = @app.call(sym_route, params)
+      else
+        res = @app.call(:not_found, {route: route})
+      end
+
+      result = {}
+      result[:status] = res.status
+      result[:body] = res.body
+
+      ['200', {'Content-Type' => 'application/json;charset=utf-8'}, [result.to_json]]
+    end
+
+    # Enable string or symbol key access to the nested params hash.
+    def indifferent_params(object)
+      case object
+      when Hash
+        new_hash = indifferent_hash
+        object.each { |key, value| new_hash[key] = indifferent_params(value) }
+        new_hash
+      when Array
+        object.map { |item| indifferent_params(item) }
+      else
+        object
+      end
+    end
+
+    # Creates a Hash with indifferent access.
+    def indifferent_hash
+      Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
+    end
+
+  end
+
+end

data/lib/jetra/application.rb

@@ -0,0 +1,10 @@
+module Jetra
+
+  class Application
+
+  	def initialize(app)
+  		@app = app
+  	end
+
+  end
+end

data/lib/jetra/base.rb

@@ -0,0 +1,323 @@
+require "jetra/application"
+
+module Jetra
+
+  class NotFoundException < Exception ; end
+
+  class Halt ; end
+
+  class Request
+
+    attr_accessor :route, :params
+
+    def initialize(route, params)
+      @route = route || ""
+      @params = params || {}
+    end
+  end
+
+  class Response
+    
+    attr_accessor :status, :body
+
+    def initialize(status=0, body=nil)
+      @status = status.to_i
+      @body = body
+    end
+
+    def finish
+      self.freeze
+    end
+  end
+
+  class Base
+
+    attr_accessor :request, :response, :params
+
+    def call(route, params)
+      dup.call!(route, params)
+    end
+
+    def call!(route, params)
+
+      @request  = Request.new(route, params)
+      @response = Response.new
+
+      @params   = indifferentParams(@request.params)
+
+      invoke { dispatch! }
+
+      @response.finish
+    end
+
+    def currentClass
+      self.class
+    end
+
+    def indifferentParams(object)
+      case object
+      when Hash
+        newHash = indifferentHash
+        object.each { |key, value| newHash[key] = indifferentParams(value) }
+        newHash
+      when Array
+        object.map { |item| indifferentParams(item) }
+      else
+        object
+      end
+    end
+
+    def indifferentHash
+      Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
+    end
+
+    def invoke
+      res = catch(Halt) { yield }
+
+      if Array === res
+        res = res.dup
+        
+        if status = res.shift
+          response.status = status
+        end
+
+        if body = res.shift
+          response.body = body
+        end
+      else
+        if res
+          response.body = res
+        end
+      end
+      nil
+    end
+
+    def dispatch!
+      filter! :before
+      route!
+    rescue ::Exception => boom
+      gotError = true
+      handleException!(boom)
+    ensure
+      begin
+        filter! :after
+      rescue ::Exception => boom
+        handleException!(boom) unless gotError
+      end
+    end
+
+    def handleException!(boom)
+
+      response.status = 0
+
+      errorBlock!(boom.class, boom)
+
+      raise boom
+    end
+
+    def halt(*response)
+      response = response.first if response.length == 1
+      throw Halt, response
+    end
+
+    def filter!(type)
+      currentClass.filters[type].each do |args|
+        processRoute(*args)
+      end
+    end
+
+    def route!
+
+      if block = currentClass.routes[@request.route.to_sym]
+        processRoute do |*args|
+          routeEval { block[*args] }
+        end
+      end
+
+      routeMissing
+    end
+
+    def errorBlock!(errorClass, *blockParams)
+
+      if errorBlocks = currentClass.errors[errorClass]
+        errorBlocks.reverse_each do |errorBlock|
+          args = [errorBlock]
+          args += [blockParams]
+          resp = processRoute(*args)
+        end
+      end
+
+      if errorClass.respond_to? :superclass and errorClass.superclass <= Exception
+        errorBlock!(errorClass.superclass, *blockParams)
+      end
+    end
+
+    def routeEval
+      throw Halt, yield
+    end
+
+    def processRoute(block=nil,values=[])
+      block ? block[self,values] : yield(self,values)
+    end
+
+    def routeMissing
+      raise NotFoundException.new("route not found")
+    end
+
+    def successResponse(body, args = {status: 1})
+      status = args[:status]
+      raise "status code must >= 1 when using success" if status < 1
+
+      if body.class == String
+        body = {msg: body}
+      end
+
+      response.body = body
+      response.status = status
+      nil
+    end
+
+    def failureResponse(body, args = {status: -1})
+      status = args[:status]
+      raise "status code must <= -1 when using failure" if status > -1
+
+      if body.class == String
+        body = {msg: body}
+      end
+
+      response.body = body
+      response.status = status
+      nil
+    end
+
+    def haltSuccess(body, args = {status: 1})
+      halt successResponse(body, args)
+    end
+
+    def haltFailure(body, args ={status: -1})
+      halt failureResponse(body, args)
+    end
+
+    class << self
+
+      attr_accessor :routes, :filters, :errors
+
+      def prototype
+        @prototype ||= new
+      end
+
+      def call(route, params={})
+        prototype.call(route, params)
+      end
+
+      def before(&block)
+        addFilter(:before, &block)
+      end
+
+      def after(&block)
+        addFilter(:after, &block)
+      end
+
+      def addFilter(type, &block)
+        @filters[type] << compile!(&block)
+      end
+
+      def route(symbol, &block)
+        block ||= Proc.new { method(symbol).call }
+        @routes[symbol] = compile!(&block)
+      end
+
+      def error(*codes, &block)
+        codes = codes.map { |c| Array(c) }.flatten
+        codes << Exception if codes.empty?
+        codes.each { |c| (@errors[c] ||= []) << compile!(&block) }
+      end
+
+      def generateUnboundMethod(&block)
+        methodName = :id  #any symbol is ok.
+        define_method(methodName, &block)
+        method = instance_method methodName
+        remove_method methodName
+        method
+      end
+
+      def compile!(&block)
+
+        unboundMethod = generateUnboundMethod(&block)
+
+        block.arity != 0 ?
+          proc { |a,p| unboundMethod.bind(a).call(*p) } :
+          proc { |a,p| unboundMethod.bind(a).call }
+      end
+
+      def inherited(subclass)
+
+        subclass.routes = copyRoutes
+        subclass.filters = copyFilters
+        subclass.errors = copyErrors
+
+        super
+      end
+
+      def copyRoutes
+        newRoutes = {}
+        @routes.each do |key, value|
+          newRoutes[key] = value
+        end
+        newRoutes
+      end
+
+      def copyFilters
+        newFilters = {}
+        @filters.each do |key, values|
+          newValues = []
+          values.each do |value|
+            newValues << value
+          end
+          newFilters[key] = newValues
+        end
+        newFilters
+      end
+
+      def copyErrors
+        newErrors = {}
+        @errors.each do |key, values|
+          newValues = []
+          values.each do |value|
+            newValues << value
+          end
+          newErrors[key] = newValues
+        end
+        newErrors
+      end
+
+      def to_app
+
+        newApp = Jetra::Application.new(self)
+        @routes.each_key do |route|
+          eval("newApp.define_singleton_method(route) do |params={}| ; @app.call(route, params) ; end ")
+        end
+
+        eval("newApp.define_singleton_method(:method_missing) do |methodName, params={}| ; @app.call(methodName, params) ; end ")
+
+        newApp
+      end
+      
+    end
+
+    @routes         = {}
+    @filters        = {:before => [], :after => []}
+    @errors         = {}
+
+    error do |boom|
+      if boom.class == Jetra::NotFoundException
+        trace = []
+      else
+        trace = boom.backtrace
+      end
+      response.body = {msg: "#{boom.class} - #{boom.message}", class: boom.class.to_s, route: request.route, params: params, trace: trace}
+      halt
+    end
+
+  end
+end

data/lib/jetra/builder.rb

@@ -0,0 +1,51 @@
+require "jetra/application"
+
+module Jetra
+
+  class Builder
+
+    def initialize(&block)
+      @use = []
+      instance_eval(&block) if block_given?
+
+      @app = build_app
+    end
+
+    def call(route, params={})
+      @app.call(route, params)
+    end
+
+    def routes
+      @run.routes
+    end
+
+    def to_app
+
+      newApp = Jetra::Application.new(self)
+      routes.each_key do |route|
+        eval("newApp.define_singleton_method(route) do |params={}| ; @app.call(route, params) ; end ")
+      end
+
+      eval("newApp.define_singleton_method(:method_missing) do |methodName, params={}| ; @app.call(methodName, params) ; end ")
+
+      newApp
+    end
+
+    private 
+    
+    def use(middleware)
+      @use << proc { |app| middleware.new(app) }
+    end
+
+    def run(app)
+      @run = app
+    end
+
+    def build_app
+      app = @run
+      fail "missing run statement" unless app
+      app = @use.reverse.inject(app) { |a,e| e[a] }
+      app
+    end
+  end
+end

data/lib/jetra/combiner.rb

@@ -0,0 +1,53 @@
+require "jetra/application"
+
+module Jetra
+
+  class Combiner
+
+    def initialize(&block)
+
+      @leader = nil
+      @routes = {}
+
+      instance_eval(&block) if block_given?
+
+      fail "missing mount statement" unless @leader
+    end
+
+    def call(route, params={})
+      if app = @routes[route]
+        app.call(route, params)
+      else
+        @leader.call(route, params)
+      end
+    end
+
+    def routes
+      @routes
+    end
+
+    def to_app
+
+      newApp = Jetra::Application.new(self)
+      routes.each_key do |route|
+        eval("newApp.define_singleton_method(route) do |params={}| ; @app.call(route, params) ; end ")
+      end
+
+      eval("newApp.define_singleton_method(:method_missing) do |method_name, params={}| ; @app.call(method_name, params) ; end ")
+
+      newApp
+    end
+
+    private 
+    
+    def mount(app)
+
+      app.routes.each_key do |route|
+        @routes[route] ||= app
+      end
+
+      @leader ||= app
+    end
+
+  end
+end

data/lib/jetra/middleware/sample.rb

@@ -0,0 +1,30 @@
+module Jetra
+
+  module Middleware
+
+    #简单的中间件示例
+    class Sample
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(route, params)
+
+        #you can do something you like before call
+
+        #puts "sample middleware call start.."
+
+        response = @app.call(route, params)
+
+        #puts "sample middleware call finish.."
+
+        #you can do something you like after call
+
+        response
+      end
+
+    end
+
+  end
+end

data/lib/jetra/middleware/validater.rb

@@ -0,0 +1,37 @@
+module Jetra
+
+  module Middleware
+
+    #验证参数和返回值的基本类型
+    class Validater
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(route, params)
+
+        if !params.kind_of?(Hash)
+          response = Jetra::Response.new
+          response.status = 0
+          response.body = {msg: "Jetra::Middleware::Validater: params type miss match. excepted Hash, got #{params.class.to_s}"}
+        else
+          response = @app.call(route, params)
+          if !response.status.kind_of?(Integer)
+            response.status = 0
+            response.body = {msg: "Jetra::Middleware::Validater: response.status type miss match. excepted Integer, got #{response.status.class.to_s}"}
+          else
+            if !response.body.kind_of?(Hash)
+              response.status = 0
+              response.body = {msg: "Jetra::Middleware::Validater: response.body type miss match. excepted Hash, got #{response.body.class.to_s}"}
+            end
+          end
+        end
+
+        response
+      end
+
+    end
+
+  end
+end

data/lib/jetra/version.rb

@@ -0,0 +1,5 @@
+module Jetra
+
+  Version = "1.0.1"
+
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: jetra
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Jeffrey
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-04-20 00:00:00.000000000 Z
+dependencies: []
+description: micro DSL
+email:
+- jeffrey6052@163.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/jetra.rb
+- lib/jetra/adapter/rack.rb
+- lib/jetra/application.rb
+- lib/jetra/base.rb
+- lib/jetra/builder.rb
+- lib/jetra/combiner.rb
+- lib/jetra/middleware/sample.rb
+- lib/jetra/middleware/validater.rb
+- lib/jetra/version.rb
+homepage: 
+licenses:
+- MIT
+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.8
+signing_key: 
+specification_version: 4
+summary: make it easy to write micro service
+test_files: []