punk 0.0.1

data/lib/punk/config/script/defaults.json

@@ -0,0 +1,5 @@
+{
+  "log": {
+    "level": "info"
+  }
+}

data/lib/punk/config/server/development.json

@@ -0,0 +1,9 @@
+{
+  "app": {
+    "reloadable": true,
+    "client": "http://localhost:4000"
+  },
+  "log": {
+    "type": "file"
+  }
+}

data/lib/punk/config/spec/defaults.json

@@ -0,0 +1,5 @@
+{
+  "log": {
+    "level": "info"
+  }
+}

data/lib/punk/core/app.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require 'roda'
+require 'sidekiq/web'
+require 'sidekiq/cron/web'
+require 'rack/protection'
+
+require_relative '../plugins/all'
+
+# don't use rack session for sidekiq (we do our own auth when routing)
+Sidekiq::Web.set(:sessions, false)
+# TODO: need custom roda route csrf in sidekiq web forms
+Sidekiq::Web.use(::Rack::Protection, use: :none, logging: true, logger: SemanticLogger['PUNK::RPT'])
+
+module PUNK
+  def self.route(name, &block)
+    PUNK.profile_info("route", path: name) do
+      PUNK::App.route(name) do |r|
+        r.scope.instance_exec(&block)
+      end
+    end
+  end
+
+  ROUTES = Tempfile.new("routes.json").path
+  PUNK.profile_info("generate", path: ROUTES) do
+    system "roda-parse_routes -f #{ROUTES} #{File.expand_path(File.join(PUNK.get.app.path, 'routes', '*'))}"
+  end
+
+  class App < Roda
+    include Loggable
+
+    PUBLIC = File.join(PUNK.get.app.path, '..', 'www')
+    INDEX = File.read(File.join(PUBLIC, 'index.html'))
+    REMOTE = PUNK.env.staging? || PUNK.env.production?
+
+    plugin :sessions, secret: [PUNK.get.cookie.secret].pack('H*'),
+                      key: PUNK.get.cookie.key,
+                      max_seconds: 1.year.to_i,
+                      max_idle_sessions: 1.month.to_i,
+                      cookie_options: {
+                        same_site: REMOTE ? :strict : :lax,
+                        secure: REMOTE,
+                        max_age: 1.year.to_i
+                      }
+    plugin :ssl if REMOTE
+    plugin :cors, PUNK.get.app.client
+    # plugin :route_csrf
+    plugin :all_verbs
+    plugin :class_level_routing
+    plugin :delegate
+    plugin :indifferent_params
+    plugin :json_parser
+    plugin :path_rewriter
+    plugin :slash_path_empty
+    plugin :multi_route
+    plugin :type_routing, types: { csv: 'text/csv' }, default_type: :json
+    plugin :route_list, file: ROUTES
+    plugin :disallow_file_uploads
+    plugin :public, root: PUBLIC
+
+    plugin :default_headers, 'Content-Type' => 'text/html', 'Content-Security-Policy' => "default-src 'self';img-src *", 'Strict-Transport-Security' => 'max-age=16070400;', 'X-Frame-Options' => 'deny', 'X-Content-Type-Options' => 'nosniff', 'X-XSS-Protection' => '1; mode=block'
+
+    plugin :error_handler
+    plugin :not_found
+    plugin :hooks
+
+    request_delegate :root, :on, :is, :get, :post, :redirect, :patch, :delete
+
+    rewrite_path(/\A\/?\z/, '/index.html')
+    rewrite_path(/\A\/api\/?\z/, '/api/index.html')
+
+    def require_session!
+      begin
+        # TODO
+        @_current_session = nil #Session[request.session['session_id']]
+        if @_current_session&.active?
+          @_current_session.touch
+        else
+          clear_session
+          @_current_session = nil
+        end
+      rescue StandardError => e
+        exception(e)
+        raise Unauthorized, e.message
+      end
+      raise Unauthorized, 'Session does not exist' if @_current_session.nil?
+      PUNK.logger.info "require_session!", { current_session: current_session.inspect, current_identity: current_identity.inspect, current_user: current_user.inspect }.inspect
+    end
+
+    def require_anonymous!
+      raise BadRequest, "Session already exists" if request.session.present?
+      PUNK.logger.info "require_anonymous!"
+    end
+
+    def require_tenant!
+      raise Unauthorized, 'Session does not exist' if @_current_session.nil?
+      @_current_tenant = current_user.tenants_dataset[id: params[:tenant_id]]
+      PUNK.logger.info "require_tenant!", { current_tenant: @_current_tenant.inspect }.inspect
+    end
+
+    def args
+      params.transform_keys(&:to_sym)
+    end
+
+    def current_session
+      @_current_session
+    end
+
+    def current_identity
+      @_current_session&.identity
+    end
+
+    def current_user
+      @_current_session&.user
+    end
+
+    def current_tenant
+      @_current_tenant
+    end
+
+    def perform(action_class, **kwargs)
+      raise InternalServerError, "Not an action: #{action_class}" unless action_class < Action
+      render action_class.perform(**kwargs)
+    end
+
+    def present(view_class, **kwargs)
+      raise InternalServerError, "Not a view: #{view_class}" unless view_class < View
+      render view_class.present(**kwargs)
+    end
+
+    PUNK_CONTENT_TYPE_LOOKUP = {
+      csv: 'text/csv',
+      html: 'text/html',
+      json: 'application/json',
+      xml: 'application/xml'
+    }.freeze
+    def render(view)
+      raise InternalServerError, "Not a view: #{view}" unless view.is_a?(View)
+      format = request.requested_type
+      view.profile_info("render", format: format) do
+        response.status = view.status if view.is_a?(Fail)
+        response['Content-Type'] = PUNK_CONTENT_TYPE_LOOKUP[format]
+        view.render(format)
+      end
+    end
+
+    error do |e|
+      exception(e, current_user: current_user)
+      case e
+      when BadRequest
+        present Fail, message: 'Bad Request', error_messages: [e.message], status: 400
+      when Unauthorized
+        present Fail, message: "Unauthorized", error_messages: [e.message], status: 401
+      when Forbidden
+        present Fail, message: "Forbidden", error_messages: [e.message], status: 403
+      when NotFound
+        present Fail, message: "Not Found", error_messages: [e.message], status: 404
+      when NotImplemented
+        present Fail, message: "Not Implemented", error_messages: [e.message], status: 501
+      when InternalServerError
+        present Fail, message: "Internal Server Error", error_messages: [e.message], status: 500
+      else
+        present Fail, message: "Unknown Failure", error_messages: [e.message], status: 500
+      end
+    end
+
+    not_found do
+      raise NotFound, "Cannot serve #{request.path}" unless request.is_get?
+      response.status = 200
+      INDEX
+    end
+
+    before do
+      @_started = Time.now.utc
+      name = "#{request.request_method} #{request.path}"
+      logger.info "Started #{name} for #{request.ip}", params.deep_symbolize_keys.sanitize.inspect
+      logger.trace request.env['HTTP_USER_AGENT']
+      # TODO
+#     logger.info "Started #{name} for #{request.ip || Session.default_values[:remote_addr].to_s}", params.deep_symbolize_keys.sanitize.inspect
+#     logger.trace request.env['HTTP_USER_AGENT'] || Session.default_values[:user_agent]
+      logger.trace request.env['HTTP_COOKIE']
+      logger.push_tags(name)
+      _set_cookie(request.env)
+    end
+
+    after do |response|
+      status, headers, _body = response
+      name = logger.pop_tags(1).join
+      duration = 1000.0 * (Time.now.utc - @_started)
+      logger.pop_tags
+      logger.trace((headers.present? ? headers['Set-Cookie'] : nil) || "(no cookie set)")
+      logger.info message: "Completed #{name} status #{status}", duration: duration
+      _store_cookie(headers)
+    end
+
+    route do |r|
+      r.public
+      r.on 'jobs' do
+        require_session!
+        r.run Sidekiq::Web
+      end
+      r.multi_route
+    end
+
+    private
+
+    def _set_cookie(headers)
+      return if REMOTE
+      return if headers.blank?
+      return if headers['HTTP_USER_AGENT'].present?
+      return if headers['HTTP_COOKIE'].present?
+      cookie_file = 'tmp/.cookie-jar'
+      cookie_file += '-test' if PUNK.env.test?
+      cookie = File.read(cookie_file) if File.exist?(cookie_file)
+      return if cookie.blank?
+      headers['HTTP_COOKIE'] = cookie
+    end
+
+    def _store_cookie(headers)
+      return if REMOTE
+      return if headers.blank?
+      cookie = headers['Set-Cookie']
+      return if cookie.blank?
+      cookie_file = 'tmp/.cookie-jar'
+      cookie_file += '-test' if PUNK.env.test?
+      if cookie =~ /max-age=0/
+        File.delete(cookie_file)
+      else
+        File.open(cookie_file, 'w') { |file| file << cookie }
+      end
+    end
+  end
+end

data/lib/punk/core/boot.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative '../startup/logger'
+require_relative '../startup/environment'
+require_relative '../startup/task'
+require_relative '../startup/database'
+require_relative '../startup/cache'
+
+PUNK.store[:state] = :booted

data/lib/punk/core/cli.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative '../../punk'
+
+require 'highline/import'
+
+PUNK.init(task: 'console', config: { app: { name: 'Punk!' } }).exec
+
+PUNK.commands(:pry)
+
+say HighLine.color('Commands: "reload!", "perform [action]", "present [view]", "run [service]".  Type "help punk" for more.', :green, :bold)
+
+PUNK.db.loggers.first.level = :debug

data/lib/punk/core/commander.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+command :test do |c|
+  c.description = 'Run rubocop and rspec'
+  c.action do
+    say('Running tests...')
+    warn('!!! PUNK_ENV should be test !!!') unless ENV['PUNK_ENV'] == 'test'
+    ENV.delete_if { |name, _value| name =~ /^PUNK_/ }
+    system('rubocop') &&
+      system('quasar build -m pwa') &&
+      system('PUNK_ENV=test rspec')
+    exit $CHILD_STATUS.exitstatus # rubocop:disable Rails/Exit
+  end
+end
+
+command :console do |c|
+  c.description = 'Launch the console'
+  c.action do
+    say(HighLine.color('🤘 Are you ready to rock?', :green, :bold))
+    path = File.join(__dir__, 'cli.rb')
+    exec "pry -r #{path}"
+  end
+end
+alias_command :c, :console
+
+command :server do |c|
+  c.description = 'Start the server'
+  c.action do
+    say('Starting server...')
+    exec 'puma -C ./config/puma.rb'
+  end
+end
+alias_command :s, :server
+
+command :worker do |c|
+  c.description = 'Start the worker'
+  c.action do
+    say('Starting worker...')
+    path = File.join(__dir__, 'worker.rb')
+    exec "sidekiq -r #{path} -C ./config/sidekiq.yml"
+  end
+end
+alias_command :w, :worker
+
+command 'env dump' do |c|
+  c.description = 'Display the environment'
+  c.action do
+    say('Dumping env...')
+    ap PUNK.get # rubocop:disable Rails/Output
+  end
+end
+
+command 'db create' do |c|
+  c.description = 'Create the database (dropping it first if necessary)'
+  c.action do
+    say('Creating db...')
+    require 'sequel'
+    database = File.basename(PUNK.get.db.url)
+    server = PUNK.get.db.url.gsub(/[^\/]+$/, 'postgres')
+    pg = Sequel.connect(server)
+    pg.execute "DROP DATABASE IF EXISTS #{database}"
+    pg.execute "CREATE DATABASE #{database}"
+    pg.disconnect
+  end
+end
+
+command 'db migrate' do |c|
+  c.description = 'Run database migrations'
+  c.option '-r', 'Number of versions to migrate, +ve for up and -ve for down', '--relative NUMBER', Integer
+  c.action do |_args, options|
+    say('Migrating db...')
+    PUNK.boot
+    Sequel.extension :migration
+    if options.relative.nil?
+      Sequel::Migrator.run(PUNK.db, File.join(PUNK.get.app.path, 'migrations'))
+    else
+      Sequel::Migrator.run(PUNK.db, File.join(PUNK.get.app.path, 'migrations'), relative: options.relative)
+    end
+    database = File.basename(PUNK.get.db.url)
+    `pg_dump #{database} --schema-only > schema.psql`
+  end
+end

data/lib/punk/core/commands.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../framework/command'
+
+module PUNK
+  def self.commands(target, scope=nil)
+    path = File.expand_path(File.join(__dir__, '..', 'commands'))
+    PUNK.profile_debug("commands", path: path) do
+      Dir.glob(File.join(path, '**/*.rb')).sort.each { |file| require(file) }
+    end
+    path = File.expand_path(File.join(PUNK.get.app.path, 'commands'))
+    PUNK.profile_debug("commands", path: path) do
+      Dir.glob(File.join(path, '**/*.rb')).sort.each { |file| require(file) }
+    end
+    case target
+    when :commander
+      require_relative 'commander'
+      Command.commander
+    when :pry
+      require_relative 'pry'
+      Command.pry
+    when :spec
+      Command.spec(scope)
+    end
+  end
+end

data/lib/punk/core/env.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+require 'active_support/string_inquirer'
+
+require 'date'
+require 'fileutils'
+require 'dotenv'
+
+module PUNK
+  class Env < Settings
+    def logger
+      SemanticLogger['PUNK::Env']
+    end
+
+    def initialize(*args)
+      super(*args)
+      return unless args.empty?
+      @loaded = false
+      parent_methods = Module.new do
+        def to_s
+          raise InternalServerError, "Environment not yet loaded" unless @loaded
+          env.to_s
+        end
+
+        def to_sym
+          raise InternalServerError, "Environment not yet loaded" unless @loaded
+          env.to_sym
+        end
+
+        def env
+          ActiveSupport::StringInquirer.new(self[:env].to_s)
+        end
+
+        def task
+          ActiveSupport::StringInquirer.new(self[:task].to_s)
+        end
+
+        def load!
+          return if @loaded
+          _load
+          @loaded = true
+        end
+      end
+      extend(parent_methods)
+    end
+
+    private
+
+    def _load
+      _load_environment(File.join(PUNK.store.args.path, '..', 'env'), ENV.fetch('PUNK_ENV'), PUNK.store.args.task)
+      @schema = {}
+      _load_schemas(File.join(__dir__, '..', 'config'), ENV.fetch('PUNK_ENV'), PUNK.store.args.task)
+      _load_schemas(File.join(PUNK.store.args.path, 'config'), ENV.fetch('PUNK_ENV'), PUNK.store.args.task)
+      @values = @schema.keys.zip(Array.new(@schema.length, nil)).to_h
+      _add_config(
+        task: PUNK.store.args.task,
+        app: {
+          path: PUNK.store.args.path
+        }
+      )
+      _load_configs(File.join(__dir__, '..', 'config'), ENV.fetch('PUNK_ENV'), PUNK.store.args.task)
+      _load_configs(File.join(PUNK.store.args.path, 'config'), ENV.fetch('PUNK_ENV'), PUNK.store.args.task)
+      _add_environment
+      _add_arguments
+      _validate
+      load(_unflatten(@values))
+      @loaded = true
+    end
+
+    def _flatten(data)
+      results = []
+      data.each do |key, value|
+        if value.is_a?(Hash)
+          _flatten(value).each do |k, v|
+            results << [[key.to_sym, k].flatten, v]
+          end
+        else
+          results << [[key.to_sym], value]
+        end
+      end
+      results.to_h
+    end
+
+    def _unflatten(data)
+      results = {}
+      data.each do |key, value|
+        name = key.join('.')
+        search = results
+        while key.length > 1
+          item = key.shift
+          search[item] ||= {}
+          unless search[item].is_a?(Hash)
+            logger.warn "Skipping #{name} due to conflicted nesting"
+            next
+          end
+          search = search[item]
+        end
+        search[key[0]] = value
+      end
+      results
+    end
+
+    def _load_schema(path)
+      return unless File.exist?(path)
+      logger.trace "Loading schema #{path}..."
+      _flatten(ActiveSupport::JSON.decode(File.read(path))).each do |key, value|
+        override = true
+        required = false
+        key.map! do |name|
+          match = /^(_?)([a-z_]+)(!?)$/.match(name)
+          raise InternalServerError, "Invalid schema key: #{key.join('.')}" if match.nil?
+          override &&= match[1] != '_'
+          required ||= match[3] == '!'
+          match[2].to_sym
+        end
+        raise InternalServerError, "Duplicate schema key: #{key.join('.')}" if @schema.key?(key)
+        @schema[key] = {
+          required: required,
+          override: override,
+          validate: value
+        }
+      end
+    end
+
+    def _load_schemas(base, name=nil, dir=nil)
+      base = File.expand_path(base)
+      _load_schema(File.join(base, 'schema.json'))
+      _load_schema(File.join(base, "schema_#{name}.json")) unless name.nil?
+      _load_schemas(File.join(base, dir), name) unless dir.nil?
+    end
+
+    def _validate
+      @schema.each do |key, value|
+        next unless value[:required]
+        current_value = @values[key]
+        raise InternalServerError, "Missing required configuration value: #{key.join('.')}" if current_value.nil?
+      end
+    end
+
+    def _typecast(key, value, validation, required)
+      valid = false
+      match = /^\$([A-Z][A-Z_]+[A-Z])$/.match(value) if value.is_a?(String)
+      if match
+        value = ENV.fetch(match[1], nil)
+        raise InternalServerError, "Env var does not exist: #{match[1]}" if value.nil? && required
+      end
+      value =
+        case validation
+        when /^Enum\((.*)\)$/
+          values = Regexp.last_match(1).split(/ *, */)
+          valid = values.include?(value)
+          value.to_sym
+        when /^Symbol\(\/(.*)\/\)$/
+          regexp = Regexp.last_match(1)
+          valid = value =~ /#{regexp}/
+          value.to_sym
+        when /^Symbol$/
+          valid = true
+          value.to_sym
+        when /^String\(\/(.*)\/\)$/
+          regexp = Regexp.last_match(1)
+          valid = value =~ /#{regexp}/
+          value.to_s
+        when /^String$/
+          valid = true
+          value.to_s
+        when /^Dir\(\/(.*)\/\)$/
+          regexp = Regexp.last_match(1)
+          valid = value =~ /#{regexp}/
+          FileUtils.mkdir_p(value)
+          valid &&= Dir.exist?(value)
+          value
+        when /^Dir$/
+          FileUtils.mkdir_p(value)
+          valid = Dir.exist?(value)
+          value
+        when /^File\(\/(.*)\/\)$/
+          regexp = Regexp.last_match(1)
+          valid = value =~ /#{regexp}/
+          dir = File.dirname(value)
+          FileUtils.mkdir_p(dir)
+          FileUtils.touch(value)
+          valid &&= File.file?(value)
+          value
+        when /^File$/
+          dir = File.dirname(value)
+          FileUtils.mkdir_p(dir)
+          FileUtils.touch(value)
+          valid = File.file?(value)
+          value
+        when /^Flag$/
+          valid = value.is_a?(TrueClass) || value.is_a?(FalseClass)
+          value
+        when /^Integer$/
+          valid = value.is_a?(Integer)
+          value
+        when /^Float$/
+          valid = value.is_a?(Float) || value.is_a?(Integer)
+          value.to_f
+        when /^Date$/
+          valid = Date.parse(value)
+          value
+        when /^Email$/
+          valid = value =~ /^[^@]+@[^@]+$/
+          value
+        when /^URI$/
+          valid = value =~ /^[a-z]+:\/\/[^ ]+$/
+          value
+        when /^Array$/
+          valid = value.is_a?(Array)
+          value
+        else
+          raise InternalServerError, "Unknown validation: #{validation}"
+        end
+      raise InternalServerError, "#{value} is invalid for #{key.join('.')}: #{validation}" unless valid
+      value
+    end
+
+    def _add_value(key, value)
+      schema = @schema[key]
+      raise InternalServerError, "Configuration not found in schema: #{key.join('.')}" if schema.nil?
+      unless schema[:override]
+        current_value = @values[key]
+        raise InternalServerError, "Cannot override configuration value: #{key.join('.')}" unless current_value.nil?
+      end
+      @values[key] = _typecast(key, value, schema[:validate], schema[:required])
+    end
+
+    def _add_config(data)
+      _flatten(data).each do |key, value|
+        _add_value(key, value)
+      end
+    end
+
+    def _load_config(path)
+      return unless File.exist?(path)
+      logger.trace "Loading config #{path}..."
+      _add_config(ActiveSupport::JSON.decode(File.read(path)))
+    end
+
+    def _load_configs(base, name=nil, dir=nil)
+      base = File.expand_path(base)
+      _load_config(File.join(base, 'defaults.json'))
+      _load_config(File.join(base, "#{name}.json")) unless name.nil?
+      _load_configs(File.join(base, dir), name) unless dir.nil?
+    end
+
+    def _load_dotenv(path)
+      return unless File.exist?(path)
+      logger.trace "Loading dotenv #{path}..."
+      Dotenv.load(path)
+    end
+
+    def _load_environment(base, name=nil, dir=nil)
+      base = File.expand_path(base)
+      _load_environment(File.join(base, dir), name) unless dir.nil?
+      _load_dotenv(File.join(base, 'locals.sh'))
+      _load_dotenv(File.join(base, "#{name}.sh"))
+      _load_dotenv(File.join(base, 'defaults.sh'))
+    end
+
+    def _add_environment
+      ENV.each do |key, value|
+        key = key.downcase
+        match = /^punk_(.*)$/.match(key)
+        next unless match
+        key = match[1].split('_').reject(&:empty?).map(&:to_sym)
+        _add_value(key, value)
+      end
+    end
+
+    def _add_arguments
+      _add_config(PUNK.store.args.config)
+    end
+  end
+
+  def self.env
+    PUNK.get.env
+  end
+
+  def self.task
+    PUNK.get.task
+  end
+end
+
+PUNK::Interface.register(:get) do
+  PUNK::Env.new
+end
+
+PUNK.inject :get