zleb 0.1.6

data/lib/zleb/plugins/params_snake_keys.rb

@@ -0,0 +1,33 @@
+#转换为snake
+require 'plissken'
+
+
+class Roda
+  module RodaPlugins
+
+    def self.load_dependencies(app)
+      app.plugin :request_headers
+      app.plugin :json_parser
+    end
+    module ParamsSnakeKeys
+
+      def self.configure(config)
+
+      end
+
+      module RequestMethods
+        def params
+          super_params = super
+          if headers['X-Convert-Key'] == 'true'
+            super_params.to_snake_keys
+          else
+            super_params
+          end
+        end
+      end
+
+    end
+
+    register_plugin(:params_snake_keys, ParamsSnakeKeys)
+  end
+end

data/lib/zleb/plugins/render_static.rb

@@ -0,0 +1,142 @@
+# frozen-string-literal: true
+
+require 'uri'
+
+begin
+  require 'rack/files'
+rescue LoadError
+  require 'rack/file'
+end
+
+#
+class Roda
+  module RodaPlugins
+    # The public plugin adds a +r.public+ routing method to serve static files
+    # from a directory.
+    #
+    # The public plugin recognizes the application's :root option, and defaults to
+    # using the +public+ subfolder of the application's +:root+ option.  If the application's
+    # :root option is not set, it defaults to the +public+ folder in the working
+    # directory.  Additionally, if a relative path is provided as the +:root+
+    # option to the plugin, it will be considered relative to the application's
+    # +:root+ option.
+    #
+    # Examples:
+    #
+    #   # Use public folder as location of files
+    #   plugin :public
+    #
+    #   # Use /path/to/app/static as location of files
+    #   opts[:root] = '/path/to/app'
+    #   plugin :public, root: 'static'
+    #
+    #   # Assuming public is the location of files
+    #   r.route do
+    #     # Make GET /images/foo.png look for public/images/foo.png 
+    #     r.public
+    #
+    #     # Make GET /static/images/foo.png look for public/images/foo.png
+    #     r.on(:static) do
+    #       r.public
+    #     end
+    #   end
+    module RenderStatic
+      SPLIT = Regexp.union(*[File::SEPARATOR, File::ALT_SEPARATOR].compact)
+      PARSER = URI::DEFAULT_PARSER
+
+      RACK_FILES = defined?(Rack::Files) ? Rack::Files : Rack::File
+      # Use options given to setup a Rack::File instance for serving files. Options:
+      # :default_mime :: The default mime type to use if the mime type is not recognized.
+      # :gzip :: Whether to serve already gzipped files with a .gz extension for clients
+      #          supporting gzipped transfer encoding.
+      # :headers :: A hash of headers to use for statically served files
+      # :root :: Use this option for the root of the public directory (default: "public")
+      def self.configure(app, opts={})
+        if opts[:root]
+          app.opts[:public_root] = app.expand_path(opts[:root])
+        elsif !app.opts[:public_root]
+          app.opts[:public_root] = app.expand_path("public")
+        end
+        app.opts[:public_server] = RACK_FILES.new(app.opts[:public_root], opts[:headers]||{}, opts[:default_mime] || 'text/plain')
+        app.opts[:public_gzip] = opts[:gzip]
+      end
+
+      module RequestMethods
+        # Serve files from the public directory if the file exists and this is a GET request.
+        def render_static(render_path)
+          if is_get?
+            path = PARSER.unescape(render_path)
+            return if path.include?("\0")
+
+            roda_opts = roda_class.opts
+            server = roda_opts[:public_server]
+            path = ::File.join(server.root, *public_path_segments(path))
+
+            if roda_opts[:public_gzip] && env['HTTP_ACCEPT_ENCODING'] =~ /\bgzip\b/
+              gzip_path = path + '.gz'
+
+              if public_file_readable?(gzip_path)
+                res = public_serve(server, gzip_path)
+                headers = res[1]
+
+                unless res[0] == 304
+                  if mime_type = ::Rack::Mime.mime_type(::File.extname(path), 'text/plain')
+                    headers['Content-Type'] = mime_type
+                  end
+                  headers['Content-Encoding'] = 'gzip'
+                end
+
+                halt res
+              end
+            end
+
+            if public_file_readable?(path)
+              halt public_serve(server, path)
+            end
+          end
+        end
+
+        private
+
+        # Return an array of segments for the given path, handling ..
+        # and . components
+        def public_path_segments(path)
+          segments = []
+            
+          path.split(SPLIT).each do |seg|
+            next if seg.empty? || seg == '.'
+            seg == '..' ? segments.pop : segments << seg
+          end
+            
+          segments
+        end
+
+        # Return whether the given path is a readable regular file.
+        def public_file_readable?(path)
+          ::File.file?(path) && ::File.readable?(path)
+        rescue SystemCallError
+          # :nocov:
+          false
+          # :nocov:
+        end
+
+        if ::Rack.release > '2'
+          # Serve the given path using the given Rack::File server.
+          def public_serve(server, path)
+            server.serving(self, path)
+          end
+        else
+          # :nocov:
+          def public_serve(server, path)
+            server = server.dup
+            server.path = path
+            server.serving(env)
+          end
+          # :nocov:
+        end
+      end
+    end
+
+    register_plugin(:render_static, RenderStatic)
+  end
+end

data/lib/zleb/plugins/schema_compiler.rb

@@ -0,0 +1,293 @@
+
+#dry schema enhance
+require_relative "dry_schema_enhance.rb"
+
+module DrySchemaExtend
+  class DrySchemaExendError < Exception
+  end
+
+  class SchemaInfoCompiler
+    EMPTY_HASH = {}
+    PREDICATE_TO_TYPE = {
+      array?: "array",
+      bool?: "bool",
+      date?: "date",
+      date_time?: "date_time",
+      decimal?: "decimal",
+      float?: "float",
+      hash?: "hash",
+      int?: "integer",
+      nil?: "nil",
+      str?: "string",
+      time?: "time",
+    }.freeze
+  
+    # @api private
+    attr_reader :keys
+  
+    # @api private
+    def initialize(schema)
+      @keys = EMPTY_HASH.dup
+      @schema = schema
+    end
+  
+    # @api private
+    def to_h
+      { children: @keys, type: "hash" }
+    end
+  
+    # @api private
+    def call
+      visit(@schema.to_ast)
+    end
+  
+    # @api private
+    def visit(node, opts = EMPTY_HASH)
+      meth, rest = node
+      public_send(:"visit_#{meth}", rest, opts)
+    end
+  
+    # @api private
+    def visit_set(node, opts = EMPTY_HASH)
+      target = (key = opts[:key]) ? self.class.new(@schema) : self
+  
+      node.map { |child| target.visit(child, opts) }
+  
+      return unless key
+  
+      target_info = opts[:member] ? { member: target.to_h } : target.to_h
+      type = opts[:member] ? "array" : "hash"
+  
+      keys.update(key => { **keys[key], type: type, **target_info })
+    end
+  
+    # @api private
+    def visit_and(node, opts = EMPTY_HASH)
+      left, right = node
+  
+      visit(left, opts)
+      visit(right, opts)
+    end
+  
+    # @api private
+    def visit_implication(node, opts = EMPTY_HASH)
+      node.each do |el|
+        # p "--------------"
+        # p el
+        if el[0] == :predicate and el[1][0] == :key?
+          visit(el, opts.merge(required: false))
+        else
+          visit(el, opts)
+        end
+      end
+    end
+  
+    def visit_not(node, opts= EMPTY_HASH)
+      visit(node, opts.merge(not: true))
+    end
+  
+    # @api private
+    def visit_each(node, opts = EMPTY_HASH)
+      visit(node, opts.merge(member: true))
+    end
+  
+    # @api private
+    def visit_key(node, opts = EMPTY_HASH)
+      
+      name, rest = node
+      # puts "visit_key is ### #{name}"
+      visit(rest, opts.merge(key: name, required: true, member: false)) # modified by zhanghz
+    end
+  
+    # @api private
+    def visit_predicate(node, opts = EMPTY_HASH)
+      name, rest = node
+  
+      key = opts[:key]
+  
+      if name.equal?(:key?)
+        # p "---key is #{rest[0][1]} #{opts}"
+        keys[rest[0][1]] = { required: opts.fetch(:required, true) }
+      else
+        type = PREDICATE_TO_TYPE[name]
+        # p opts
+        # p "rest predicate key is #{key} content is #{name}| #{rest}"
+
+        # modified by zhanghz
+        if opts[:member] == true
+          keys[key][:member] ||= {}
+          if type
+            if type == 'nil' and opts[:not] == true
+              keys[key][:member][:maybe] = type
+            else
+              keys[key][:member][:type] = type
+            end
+            keys[key][:type] = "array"
+          else
+            keys[key][:member][:validations] = [] unless keys[key][:member][:validations]
+            keys[key][:member][:validations] << predicate_message(key, name, rest)
+          end
+
+        else
+          if type
+            if type == 'nil' and opts[:not] == true
+              keys[key][:maybe] = type
+            else
+              keys[key][:type] = type
+            end
+          else
+            keys[key][:validations] = [] unless keys[key][:validations]
+            keys[key][:validations] << predicate_message(key, name, rest)
+          end
+        end
+      end
+    end
+  
+    def predicate_message(key, name, rest)
+      result = nil
+      if rest.count == 2
+        param_name = rest[0][0]
+        param_value = rest[0][1]
+        
+        result = @schema.message_compiler.messages.get_message_for_key(name,{:path=> key, :arg_type => param_value.class})
+        if param_value.class == Range
+          result = result[:text].gsub("%{#{param_name}_left}", param_value.first.to_s).gsub("%{#{param_name}_right}", param_value.last.to_s)
+        else
+          result = result[:text].gsub("%{#{param_name}}", param_value.to_s)
+        end
+      else
+        result = @schema.message_compiler.messages.get_message_for_key(name,{:path=> key})
+        result = result[:text]
+      end
+      result
+    end
+  end
+
+
+  class SchemaExtendEdInfo
+
+    def self.define(&block)
+      desc = self.new
+      desc.instance_eval(&block)
+      desc
+    end
+  
+    def initialize()
+      @schema_desc = {}
+      @current_field_name = nil
+    end
+  
+  
+    def required(field_name)
+      key(:required, field_name)
+    end
+  
+    def optional(field_name)
+      key(:optional, field_name)
+    end
+
+    def hash(&block)
+      instance_eval(&block)
+      self
+    end
+
+
+    def get_desc
+      @schema_desc.transform_values do |field|
+        field.get_desc
+      end
+    end
+  
+  
+  
+  
+    private
+    def key(type, name)
+      if @schema_desc.key?(name)
+        raise DrySchemaExendError.new("the key: #{name} already exists")
+      end
+      field_desc = FieldExtendedInfo.new(name)
+      @schema_desc[name] = field_desc
+      @current_field_name = name
+      field_desc
+    end
+  
+  
+  end
+  
+  
+  class FieldExtendedInfo
+  
+    def initialize(field_name)
+      @field_name = field_name
+      @desc = nil
+    end
+  
+    def desc(**info)
+      @desc = info
+      self
+    end
+
+
+    def get_desc
+      result = {}
+      if @children
+        if @is_member
+          result[:member] = {}
+          result[:member][:children] = @children.get_desc
+        else
+          result[:children] = @children.get_desc
+        end
+      end
+      result[:desc] = @desc if @desc
+      result
+    end
+  
+    def method_missing(method_name, *args, &block)
+      rest_method(method_name, *args, &block)
+    end
+
+    def hash(*arg, &block)
+      rest_method(:hash, *arg, &block)
+    end
+  
+  
+    private
+    def rest_method(method_name, *args, &block)
+      if block_given?
+        sub_schema_desc = SchemaExtendEdInfo.new
+        sub_schema_desc.instance_eval(&block)
+        @children = sub_schema_desc
+        if method_name == :array or method_name == :each
+          @is_member = true
+        end
+      end
+
+      if args[0].class == SchemaExtendEdInfo
+        @children = args[0]
+      end
+      self
+    end
+  end
+end
+
+
+
+module Dry
+  module Schema
+    module Macros
+      # Macro specialization used within the DSL
+      #
+      # @api public
+      class DSL
+        def desc(*args)
+          self
+        end
+      end
+    end
+  end
+end
+
+
+
+

data/lib/zleb/plugins/uni_logger.rb

@@ -0,0 +1,18 @@
+require 'semantic_logger'
+
+class Roda
+  module RodaPlugins
+    module UniLogger
+      
+      module InstanceMethods
+        include SemanticLogger::Loggable
+      end
+
+      module ClassMethods
+        include SemanticLogger::Loggable
+      end
+    end
+
+    register_plugin(:uni_logger, UniLogger)
+  end
+end

data/lib/zleb/symbolize_helper.rb

@@ -0,0 +1,19 @@
+module SymbolizeHelper
+  extend self
+  def symbolize_recursive(hash)
+    {}.tap do |h|
+      hash.each { |key, value| h[key.to_sym] = map_value(value) }
+    end
+  end
+
+  def map_value(thing)
+    case thing
+    when Hash
+      symbolize_recursive(thing)
+    when Array
+      thing.map { |v| map_value(v) }
+    else
+      thing
+    end
+  end
+end

data/lib/zleb/version.rb

@@ -0,0 +1,3 @@
+module Zleb
+  VERSION = "0.1.6"
+end

data/lib/zleb.rb

@@ -0,0 +1,133 @@
+require "zleb/version"
+require "zleb/symbolize_helper"
+require "zleb/controller"
+
+require 'roda'
+
+# for logging
+require 'semantic_logger'
+
+if ENV['RACK_ENV'] == 'development'
+  SemanticLogger.default_level = :trace  # :trace
+  # SemanticLogger.backtrace_level = :trace
+  # SemanticLogger.add_appender(io: $stderr, level: :error)
+  SemanticLogger.add_appender(io: $stdout, formatter: :color)
+end
+
+# add logger to Object
+class Object
+  include SemanticLogger::Loggable
+end
+
+require 'roda/session_middleware'
+
+require 'zleb/plugins/params_check'
+require 'zleb/plugins/render_static'
+require 'zleb/plugins/uni_logger'
+require 'zleb/plugins/params_snake_keys'
+require 'zleb/plugins/basic_restful_action'
+require 'zleb/plugins/api_route'
+require 'zleb/plugins/method_route'
+require 'zleb/plugins/http_auth'
+
+
+#转换为驼峰
+require 'awrence'
+#转换为snake
+require 'plissken'
+
+module Zleb
+  class Error < StandardError; end
+
+
+  module Config
+    def self.prefix
+      @prefix || 'api'
+    end
+
+    def self.prefix=(pre)
+      @prefix = pre
+    end
+
+    def self.controller_module
+      @controller_module
+    end
+
+    def self.controller_module=(c)
+      @controller_module = c
+    end
+
+    def self.set_global_check(&block)
+      @global_check = block
+    end
+
+    def self.global_check=(c)
+      @global_check = c
+    end
+
+    def self.global_check
+      @global_check
+    end
+  end
+
+
+  class BaseApp < Roda
+
+    plugin :empty_root
+    plugin :all_verbs
+
+    json_serializer =  proc do |res, req|
+      if req.headers['X-Convert-Key'] == 'true'
+        res.to_camelback_keys.to_json
+      else
+        res.to_json
+      end
+    end
+
+    plugin :request_headers
+    plugin :json, include_request: true, classes: [Array, Hash], serializer: json_serializer
+    plugin :params_snake_keys
+
+    plugin :json_parser #, parser: proc{|req| JSON.parse(req).to_snake_keys}
+    plugin :hash_routes
+    plugin :public
+    plugin :params_check
+    plugin :basic_restful_action
+    plugin :render_static
+
+    plugin :uni_logger
+    plugin :cookies
+    plugin :symbolized_params
+
+
+    plugin :api_route
+    # plugin :error_handler, classes: [Mongoid::Errors::DocumentNotFound] do |e|
+    #   response.status = 406
+    #   { error: "object is not existed" }
+    # end
+
+    # plugin :not_found do |r|
+    #   r.render_static(File.join(Prefix, 'index.html'))
+    #   # {error: "not found #{r.path}"}
+    # end
+
+    secret = ENV.delete('SESSION_SECRET') || SecureRandom.random_bytes(64)
+    use RodaSessionMiddleware, secret: secret
+  end
+
+  class App < BaseApp
+    plugin :method_route
+
+    GlobalCheck =
+
+    route do |r|
+      r.public
+      r.on Config.prefix do
+        instance_eval(&Config.global_check) if Config.global_check
+        r.method_to Config.controller_module if Config.controller_module
+        r.hash_routes(:api)
+      end
+    end
+
+  end
+end

data/push.sh

@@ -0,0 +1,3 @@
+# curl -d '_method=DELETE' -X POST http://192.168.1.132:9571/gems/zleb-0.1.0.gem
+
+gem inabox pkg/zleb-0.1.6.gem --host http://localhost:8081/repository/groupgems/

data/zleb.gemspec

@@ -0,0 +1,43 @@
+require_relative 'lib/zleb/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "zleb"
+  spec.version       = Zleb::VERSION
+  spec.authors       = ["saidev"]
+  spec.email         = ["saidev@163.com"]
+
+  spec.summary       = %q{a more convenient web framework}
+  spec.description   = %q{a more convenient web framework}
+  spec.homepage      = "https://github.com/bluesaiz/zleb"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "roda", '~> 3.52'
+  spec.add_dependency "roda-symbolized_params", '~> 0.0.2'
+  spec.add_dependency "dry-validation", '~> 1.6'
+  spec.add_dependency 'puma', '~> 6.4'
+  spec.add_dependency "semantic_logger", "~> 4.7", ">= 4.7.4"
+
+  spec.add_dependency "awrence", "~> 1.2", ">= 1.2.1"
+  spec.add_dependency "plissken", "~> 1.4", ">= 1.4.1"
+  spec.add_dependency "concurrent-ruby"
+
+  spec.add_dependency "dry-schema", "= 1.13.3"
+  spec.add_dependency "dry-container", "~> 0.7"
+
+  spec.add_development_dependency 'rack-test'
+
+end