punk 0.0.1

data/lib/punk/framework/model.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'aasm'
+
+AASM::Configuration.hide_warnings = true
+
+module PUNK
+  Model = Class.new(Sequel::Model)
+  Model.def_Model(self)
+  class Model
+    include AASM
+    include Loggable
+
+    plugin :validation_helpers
+    plugin :timestamps, update_on_create: true
+    plugin :boolean_readers
+    plugin :uuid
+    plugin :update_or_create
+    plugin :defaults_setter
+    plugin :touch
+    plugin :many_through_many
+
+    plugin PUNK::Plugins::Validation
+
+    def validate; end
+
+    def inspect
+      id.present? ? "#{id}|#{self}" : to_s
+    end
+
+    def self.sample_dataset(count=1)
+      order(Sequel.lit('random()')).limit(count)
+    end
+
+    def self.sample(count=1)
+      query = sample_dataset(count)
+      count == 1 ? query.first : query.all
+    end
+
+    def self.symbolize(*names)
+      names.each do |name|
+        chain =
+          Module.new do
+            define_method(name) do |*args|
+              super(*args)&.to_sym
+            end
+          end
+        prepend chain
+      end
+    end
+  end
+end

data/lib/punk/framework/plugins/all.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'validation'

data/lib/punk/framework/plugins/validation.rb

@@ -0,0 +1,55 @@
+# frozen-string-literal: true
+
+require 'uri'
+require 'phony'
+
+module PUNK
+  module Plugins
+    module Validation
+      module InstanceMethods
+        def validates_url(atts, opts={})
+          default = { message: "is not a URL" }
+          validatable_attributes(atts, default.merge(opts)) do |_name, value, message|
+            message unless URI::DEFAULT_PARSER.make_regexp.match(value).to_a.compact.length > 2
+          end
+        end
+
+        def validates_email(atts, opts={})
+          default = { message: "is not an email address" }
+          validatable_attributes(atts, default.merge(opts)) do |_name, value, message|
+            message unless URI::MailTo::EMAIL_REGEXP.match(value)
+          end
+        end
+
+        def validates_phone(atts, opts={})
+          default = { message: "is not a phone number" }
+          validatable_attributes(atts, default.merge(opts)) do |_name, value, message|
+            message unless Phony.plausible?(value)
+          end
+        end
+
+        def validates_parse_id(atts, opts={})
+          default = { message: "is not a Parse ID" }
+          validatable_attributes(atts, default.merge(opts)) do |_name, value, message|
+            message unless /^[[:alnum:]]{10}$/.match(value)
+          end
+        end
+
+        def validates_subdomain(atts, opts={})
+          default = { message: "is not a subdomain" }
+          validatable_attributes(atts, default.merge(opts)) do |_name, value, message|
+            message unless /^[A-Za-z0-9](?:[A-Za-z0-9\-]{0,61}[A-Za-z0-9])?$/.match(value)
+          end
+        end
+
+        def validates_state(name, state)
+          errors.add(name, "is not in #{state} state") unless self[name].send("#{state}?")
+        end
+
+        def validates_event(name, event)
+          errors.add(name, "may not #{event}") unless self[name].send("may_#{event}?")
+        end
+      end
+    end
+  end
+end

data/lib/punk/framework/runnable.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module PUNK
+  class Runnable < Settings
+    include Validatable
+
+    def self.args(*args)
+      PUNK.store.runnable ||= {}
+      return PUNK.store.runnable[name] if PUNK.store.runnable.key?(name)
+      PUNK.store.runnable[name] = args
+    end
+
+    def method_missing(key, *args, &block)
+      val = super
+      val = val.to_h if val.class == self.class || val.class.instance_of?(self.class)
+      val
+    end
+
+    def respond_to_missing?(key, *args) # rubocop:disable Lint/UselessMethodDefinition
+      super
+    end
+
+    private
+
+    def _init_runnable(kwargs)
+      args = self.class.args || []
+      load(args.zip(Array.new(args.length, nil)).to_h)
+      load(kwargs.select { |k, _| args.include?(k) })
+    end
+  end
+end

data/lib/punk/framework/service.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'active_support/string_inquirer'
+
+module PUNK
+  class Service < Runnable
+    include Loggable
+    include Publishable
+
+    delegate :ready?, to: :_state
+    delegate :invalid?, to: :_state
+    delegate :success?, to: :_state
+    delegate :failure?, to: :_state
+
+    def self.run(**kwargs)
+      service = new
+      service.send(:_init, **kwargs)
+      service.send(:_run)
+      hijack = service.send(:_callbacks)
+      service.is_a?(View) && hijack.is_a?(View) ? hijack : service
+    end
+
+    def result
+      @_result
+    end
+
+    def process
+      raise NotImplemented, "view must provide process method"
+    end
+
+    protected
+
+    def _state
+      ActiveSupport::StringInquirer.new(@_state.to_s)
+    end
+
+    def on_success; end
+
+    def on_failure; end
+
+    private
+
+    def _init(**kwargs)
+      @_state = :ready
+      @_result = nil
+      _init_runnable(kwargs)
+    end
+
+    def _run
+      unless ready?
+        errors.add(:raised, e.message)
+        @_state = :failure
+        return
+      end
+      unless valid?
+        @_state = :invalid
+        return
+      end
+      @_result = process
+      @_state = :success
+    end
+
+    def _callbacks
+      success? ? on_success : on_failure
+    end
+  end
+end

data/lib/punk/framework/view.rb

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

data/lib/punk/framework/worker.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'sidekiq'
+
+module PUNK
+  class Worker < Runnable
+    include Sidekiq::Worker
+
+    def self.perform_now(**kwargs)
+      worker = new
+      worker.define_singleton_method :logger, -> { SemanticLogger['PUNK::SKQ'] }
+      worker.send(:perform, **kwargs)
+    end
+
+    def perform(kwargs={})
+      @_started = Time.now.utc
+      logger.info "Started #{self.class.name}", kwargs.sanitize.inspect
+      logger.push_tags(self.class.name)
+      _init_runnable(kwargs.deep_symbolize_keys)
+      raise BadRequest, "validation failed" unless valid?
+      process
+      nil
+    rescue BadRequest => e
+      logger.error e.message
+      logger.error errors.full_messages.to_sentence
+      raise
+    ensure
+      duration = 1000.0 * (Time.now.utc - @_started)
+      logger.pop_tags
+      logger.info message: "Completed #{self.class.name}", duration: duration
+      SemanticLogger.flush
+    end
+  end
+end

data/lib/punk/helpers/all.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+require_relative 'loggable'
+require_relative 'publishable'
+require_relative 'renderable'
+require_relative 'validatable'

data/lib/punk/helpers/loggable.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module PUNK
+  module Loggable
+    extend ActiveSupport::Concern
+
+    def logger
+      self.class.logger
+    end
+
+    def profile_info(name, **kwargs, &block)
+      self.class.profile_info(name, **kwargs, &block)
+    end
+
+    def profile_debug(name, **kwargs, &block)
+      self.class.profile_debug(name, **kwargs, &block)
+    end
+
+    def profile_trace(name, **kwargs, &block)
+      self.class.profile_trace(name, **kwargs, &block)
+    end
+
+    def exception(e, extra={})
+      if ENV.key?('SENTRY_DSN')
+        ::Raven.capture_exception(
+          e,
+          message: e.message,
+          extra: extra,
+          transaction: "Punk!"
+        )
+      end
+      _clean(e)
+      logger.error exception: e
+    end
+
+    private
+
+    IGNORE = Gem.path + $LOAD_PATH
+
+    def _clean(e, trim: false)
+      _clean(e.cause, trim: true) if e.cause
+      ignore = IGNORE.reject { |path| e.backtrace.first =~ /#{path}/ }
+      skip = false
+      e.backtrace.map! do |line|
+        if trim || ignore.any? { |path| line =~ /#{path}/ }
+          unless skip
+            skip = true
+            '...'
+          end
+        else
+          skip = false
+          line
+        end
+      end
+      e.backtrace.compact!
+    end
+
+    class_methods do
+      def logger
+        SemanticLogger[name]
+      end
+
+      def profile_info(name, **kwargs)
+        logger.info "Started #{name}", kwargs.sanitize.inspect
+        logger.measure_info("Completed #{name}") { logger.tagged(name) { yield } }
+      end
+
+      def profile_debug(name, **kwargs)
+        logger.debug "Started #{name}", kwargs.sanitize.inspect
+        logger.measure_debug("Completed #{name}") { logger.tagged(name) { yield } }
+      end
+
+      def profile_trace(name, **kwargs)
+        logger.trace "Started #{name}", kwargs.sanitize.inspect
+        logger.measure_trace("Completed #{name}") { logger.tagged(name) { yield } }
+      end
+    end
+  end
+end

data/lib/punk/helpers/publishable.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'wisper'
+
+module PUNK
+  module Publishable
+    include Wisper::Publisher
+  end
+end

data/lib/punk/helpers/renderable.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'tilt'
+
+module PUNK
+  module Renderable
+    FORMATS =
+      {
+        html: { renderer: :to_html, extension: 'slim' },
+        json: { renderer: :to_json, extension: 'jbuilder' },
+        csv: { renderer: :to_csv, extension: 'rcsv' },
+        xml: { renderer: :to_xml, extension: 'xml.slim' }
+      }.freeze
+
+    def template(name)
+      @template = name
+    end
+
+    def render(format)
+      raise NotFound, "unknown format '#{format}'" unless FORMATS.key?(format)
+      send(FORMATS[format][:renderer])
+    end
+
+    def to_html(options={})
+      _render(:html, options)
+    end
+
+    def to_json(options={})
+      _render(:json, options)
+    end
+
+    def to_csv(options={})
+      _render(:csv, options)
+    end
+
+    def to_xml(options={})
+      _render(:xml, options)
+    end
+
+    def to_s
+      to_json
+    end
+
+    def inspect
+      to_s
+    end
+
+    def to_h
+      ActiveSupport::JSON.decode(to_json).to_h.deep_symbolize_keys
+    end
+
+    protected
+
+    def _dir
+      File.join(PUNK.get.app.path, 'templates')
+    end
+
+    private
+
+    def _path(format)
+      raise InternalServerError, "No template given" unless @template
+      base = File.join(_dir, @template)
+      ext = FORMATS[format][:extension]
+      "#{base}.#{ext}"
+    end
+
+    def _render(format, options)
+      path = _path(format)
+      raise NotImplemented, "No path for template: #{@template}" unless path
+      Tilt.new(path).render(self, options)
+    rescue LoadError, Errno::ENOENT
+      raise NotFound, "Cannot load template: #{path}"
+    end
+  end
+end