punk 0.0.1

data/lib/punk/core/error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module PUNK
+  class BadRequest < StandardError; end
+  class Unauthorized < StandardError; end # rubocop:disable Layout/EmptyLineBetweenDefs
+  class Forbidden < StandardError; end # rubocop:disable Layout/EmptyLineBetweenDefs
+  class NotFound < StandardError; end # rubocop:disable Layout/EmptyLineBetweenDefs
+  class InternalServerError < StandardError; end # rubocop:disable Layout/EmptyLineBetweenDefs
+  class NotImplemented < StandardError; end # rubocop:disable Layout/EmptyLineBetweenDefs
+end

data/lib/punk/core/exec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module PUNK
+  def self.require_all(path)
+    path = File.expand_path(path)
+    PUNK.profile_debug("require_all", path: path) do
+      if PUNK.get.app.reloadable?
+        PUNK.loader.require(path)
+      else
+        Dir.glob(File.join(path, '**/*.rb')).sort.each { |file| require(file) }
+      end
+    end
+  end
+end
+
+PUNK::Interface.register(:loader) do
+  require 'rack/unreloader'
+  raise PUNK::InternalServerError, "App is not reloadable" unless PUNK.get.app.reloadable?
+  retval = Rack::Unreloader.new { PUNK::App }
+  require_relative './monkey_unreloader'
+  retval
+end
+
+PUNK::Interface.register(:app) do
+  require_relative 'app'
+  PUNK.require_all(File.join(PUNK.get.app.path, 'routes'))
+  retval = PUNK.get.app.reloadable ? PUNK.loader : PUNK::App.freeze.app
+  SemanticLogger.flush
+  retval
+end
+
+PUNK.inject :loader, :app
+
+['actions', 'models', 'views', 'services', 'workers'].each do |dir|
+  PUNK.require_all(File.join(PUNK.get.app.path, dir))
+end
+
+PUNK.store[:state] = :started

data/lib/punk/core/interface.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'active_support/dependencies/autoload'
+require 'active_support/core_ext'
+require 'active_support/json'
+
+require 'oj'
+Oj.optimize_rails
+
+require 'forwardable'
+require 'dim'
+
+require_relative 'version'
+require_relative 'error'
+require_relative 'monkey'
+
+module PUNK
+  extend SingleForwardable
+
+  def_single_delegators :store, :state
+
+  def self.inject(*methods)
+    def_single_delegators :'PUNK::Interface', *methods
+  end
+
+  Interface = Dim::Container.new
+end
+
+PUNK::Interface.register(:store) do
+  require 'ostruct'
+  store = OpenStruct.new
+  store.state = :included
+  Thread.current[:rr] = store
+end
+
+PUNK::Interface.register(:bootstrap) do
+  raise PUNK::InternalServerError, 'Must call PUNK.init first!' if PUNK.state != :initialised
+  require_relative 'settings'
+  require_relative 'logger'
+end
+
+PUNK::Interface.register(:config) do |c|
+  c.bootstrap
+  PUNK.profile_trace('config') do
+    require_relative 'env'
+    PUNK.get.load!
+    require_relative 'commands'
+  end
+end
+
+PUNK::Interface.register(:boot) do |c|
+  c.config
+  retval = PUNK.profile_trace('boot') { require_relative 'boot' }
+  PUNK.logger.info "Punk! v#{PUNK.version}"
+  PUNK.db.fetch("SELECT version(), timeofday()") do |row|
+    row.each_value { |value| PUNK.logger.info value }
+  end
+  retval
+end
+
+PUNK::Interface.register(:load) do |c|
+  c.boot
+  PUNK.profile_debug('load') { require_relative 'load' }
+end
+
+PUNK::Interface.register(:exec) do |c|
+  c.load
+  retval = PUNK.profile_debug('exec') { require_relative 'exec' }
+  PUNK.logger.tagged(PUNK.env, PUNK.task) do
+    PUNK.logger.info PUNK.get.app.name
+  end
+  SemanticLogger.flush
+  retval
+end
+
+PUNK.inject :store, :config, :boot, :load, :exec

data/lib/punk/core/load.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+PUNK.db
+
+require_relative '../helpers/all'
+require_relative '../framework/all'
+require_relative '../views/all'
+
+PUNK.store[:state] = :loaded

data/lib/punk/core/logger.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'semantic_logger'
+
+module PUNK
+  include SemanticLogger::Loggable
+
+  def self.profile_info(name, **kwargs)
+    logger.info "Started #{name}", kwargs.sanitize.inspect
+    logger.measure_info("Completed #{name}") { logger.tagged(name) { yield } }
+  end
+
+  def self.profile_debug(name, **kwargs)
+    logger.debug "Started #{name}", kwargs.sanitize.inspect
+    logger.measure_debug("Completed #{name}") { logger.tagged(name) { yield } }
+  end
+
+  def self.profile_trace(name, **kwargs)
+    logger.trace "Started #{name}", kwargs.sanitize.inspect
+    logger.measure_trace("Completed #{name}") { logger.tagged(name) { yield } }
+  end
+
+  SemanticLogger.default_level =
+    case PUNK.store.args.task
+    when 'console', 'script'
+      :info
+    when 'spec'
+      :debug
+    else
+      :trace
+    end
+  SemanticLogger.add_appender(io: $stdout, formatter: :color)
+end

data/lib/punk/core/monkey.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Hash
+  def sanitize
+    merge(slice(:password, :secret, 'password', 'secret').transform_values { "***" })
+  end
+end

data/lib/punk/core/monkey_unreloader.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# fixes https://github.com/jeremyevans/rack-unreloader/issues/9
+module Rack
+  class Unreloader
+    class Reloader
+      private
+
+      def all_classes
+        rs = Set.new
+        ::ObjectSpace.each_object(Module).each do |mod|
+          rs << mod if !mod.to_s.empty? && monitored_module?(mod)
+        end
+        rs
+      end
+    end
+  end
+end

data/lib/punk/core/pry.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+def perform(action_class, **kwargs)
+  raise PUNK::InternalServerError, "Not an action: #{action_class}" unless action_class < PUNK::Action
+  action_class.perform(**kwargs)
+ensure
+  SemanticLogger.flush
+end
+
+def present(view_class, **kwargs)
+  raise PUNK::InternalServerError, "Not a view: #{view_class}" unless view_class < PUNK::View
+  view_class.present(**kwargs)
+ensure
+  SemanticLogger.flush
+end
+
+def run(service_class, **kwargs)
+  raise PUNK::InternalServerError, "Not a service: #{service_class}" unless service_class.superclass == PUNK::Service
+  service_class.run(**kwargs).result
+ensure
+  SemanticLogger.flush
+end
+
+def reload!
+  ['actions', 'models', 'views', 'services', 'workers'].each do |dir|
+    path = File.join(PUNK.get.app.path, dir)
+    Dir.glob(File.join(path, '**/*.rb')).each { |file| load(file) }
+  end
+  "Reloaded all actions, models, views, services and workers."
+ensure
+  SemanticLogger.flush
+end
+
+Pry.config.print =
+  proc do |output, value|
+    SemanticLogger.flush
+    output.puts "=> #{value.inspect}"
+  end
+Pry.config.prompt_name = "🎤 "

data/lib/punk/core/settings.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'dot_hash'
+
+module PUNK
+  class Settings < DotHash::Settings
+    alias key? has_key?
+
+    delegate :inspect, to: :_inspect_hash
+
+    def method_missing(key, *args, &block)
+      match = /^(.*)([!?])$/.match(key)
+      if match && key?(match[1]) && !key?(key)
+        value = execute(match[1], *args, &block)
+        case match[2]
+        when '?'
+          return value if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+        when '!'
+          raise InternalServerError, "Value is nil: #{key}" if value.nil?
+          return value
+        end
+      end
+      super
+    end
+
+    def respond_to_missing?(key, *args)
+      match = /^(.*)([!?])$/.match(key)
+      key = match[1] if match && !key?(key)
+      super
+    end
+
+    private
+
+    def _inspect_hash
+      to_h.inspect
+    end
+  end
+end

data/lib/punk/core/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module PUNK
+  def self.version
+    File.read(File.join(__dir__, '..', '..', '..', 'VERSION'))
+  end
+end

data/lib/punk/core/worker.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative '../../punk'
+require 'sidekiq'
+require 'sidekiq-cron'
+
+PUNK.init(task: 'worker', config: { app: { name: 'Norma' } }).exec
+
+Sidekiq.logger = SemanticLogger['PUNK::SKQ']
+Sidekiq.logger.class.alias_method(:with_context, :tagged)
+
+path = File.expand_path(File.join(PUNK.get.app.path, '..', 'config', 'schedule.yml'))
+Sidekiq::Cron::Job.load_from_hash(YAML.load_file(path))

data/lib/punk/framework/action.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module PUNK
+  class Action < Service
+    def self.perform(**kwargs)
+      action = profile_info("perform", kwargs) { run(**kwargs) }
+      action.result
+    end
+
+    def process
+      raise NotImplemented, "action must provide process method"
+    end
+
+    def present(view_class, **kwargs)
+      raise InternalServerError, "not a view: #{view_class}" unless view_class < View
+      view_class.run(**kwargs)
+    end
+
+    protected
+
+    def on_success
+      raise InternalServerError, "not a view: #{result}" unless result.is_a?(View)
+    end
+
+    def on_failure
+      @_result = Fail.run(message: "action failed: #{self.class}", error_messages: errors.full_messages, status: invalid? ? 400 : 500)
+    end
+  end
+end

data/lib/punk/framework/all.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'plugins/all'
+require_relative 'model'
+require_relative 'runnable'
+require_relative 'service'
+require_relative 'worker'
+require_relative 'action'
+require_relative 'view'
+require_relative 'command'

data/lib/punk/framework/command.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module SpecHelpers
+end
+
+module PUNK
+  class Command
+    attr_accessor :args, :opts
+
+    def self.create(name, &block)
+      command = new
+      command.send(:_init, name)
+      PUNK.store.commands ||= {}
+      PUNK.store.commands[name] = command
+      command.instance_eval(&block)
+    end
+
+    def shortcut(name)
+      instance_variable_set(:@shortcut, name)
+    end
+
+    def description(text)
+      instance_variable_set(:@description, text)
+    end
+
+    def option(name:, description:, shortcut: nil, type: String)
+      @options[name] = {
+        name: name,
+        description: description,
+        shortcut: shortcut,
+        type: type
+      }
+    end
+
+    def self.pry
+      PUNK.store.commands.each_value do |command|
+        command.send(:_pry)
+      end
+    end
+
+    def self.commander
+      PUNK.store.commands.each_value do |command|
+        command.send(:_commander)
+      end
+    end
+
+    def self.spec(scope)
+      PUNK.store.commands.each_value do |command|
+        command.send(:_spec, scope)
+      end
+    end
+
+    def process
+      raise NotImplemented, "command must provide process method"
+    end
+
+    private
+
+    def _init(name)
+      @name = name
+      @shortcut = nil
+      @description = nil
+      @options = {}
+    end
+
+    def _pry
+      command = Pry::Commands.create_command(@name) {} # rubocop:disable Lint/EmptyBlock
+      command.description = @description
+      command.instance_variable_set(:@group, "punk")
+      command.class_eval do
+        define_method(:options) do |opt|
+          punk_command = PUNK.store.commands[match]
+          punk_command.instance_variable_get(:@options).each_value do |option|
+            opt.on option[:shortcut], option[:name], option[:description], argument: true, as: option[:type]
+          end
+        end
+        define_method(:process) do
+          punk_command = PUNK.store.commands[match]
+          punk_command.instance_variable_set(:@args, args)
+          punk_command.instance_variable_set(:@opts, opts.to_h)
+          result = punk_command.process
+          SemanticLogger.flush
+          output.puts result
+        end
+      end
+    end
+
+    def _commander
+      command @name do |c|
+        c.description = @description
+        @options.each_value do |option|
+          c.option "-#{option[:shortcut]}", option[:description], "--#{option[:name]} #{option[:type].to_s.upcase}", option[:type]
+        end
+        c.action do |args, opts|
+          @args = args
+          @opts = opts.__hash__
+          PUNK.exec
+          result = process
+          SemanticLogger.flush
+          puts result # rubocop:disable Rails/Output
+        end
+      end
+      return unless @shortcut
+      alias_command @shortcut, @name
+    end
+
+    def _spec(scope)
+      this = self
+      SpecHelpers.send(:define_method, "command_#{@name}") do |*args, **kwargs|
+        this.instance_variable_set(:@args, args)
+        this.instance_variable_set(:@opts, kwargs)
+        this.process
+      end
+      scope.include SpecHelpers
+    end
+  end
+end