cafe_car 0.1.0 → 0.1.2

data/lib/cafe_car/component.rb

@@ -0,0 +1,155 @@
+module CafeCar
+  class Component
+    concerning :Macros do
+      included do
+        class_attribute :option_defaults, default: {}
+        class_attribute :attribute_defaults, default: {}
+      end
+
+      def extract_options!(options)
+        @options = options.extract!(*option_defaults.keys).with_defaults!(option_defaults)
+      end
+
+      class_methods do
+        def inherited(subclass)
+          super
+          subclass.option_defaults = option_defaults.deep_dup
+          subclass.attribute_defaults = attribute_defaults.deep_dup
+        end
+
+        def component(*names, **, &)
+          names.each do |name|
+            define_class(name, CafeCar[:Component], **, &)
+          end
+        end
+
+        def flag(flag)
+          include Module.new do
+            define_method(flag) { |v| @options[flag] = v.nil? ? true : v }
+          end
+        end
+
+        def option(name, default: nil, accessor: true, reader: accessor, writer: accessor, presence: accessor, macro: accessor)
+          option_defaults[name] = default
+          define_singleton_method(name) { |v| option_defaults[name] = v } if macro
+          include Module.new {
+            define_method(name) { options[name] } if reader
+            define_method("#{name}=") { |v| options[name] = v } if writer
+            define_method("#{name}?") { options[name].present? } if presence
+          }
+        end
+      end
+    end
+
+    def self.method_missing(name, v)
+      attribute_defaults[name] = v
+    end
+
+    attr_reader :flags, :options, :attributes
+
+    delegate :render, :capture, :safe_join, :ui_class, :context?, to: :@template
+
+    option :tag, default: :div
+    option :class, accessor: false
+    option :data, default: {}
+    option :href
+    option :tip
+
+    def initialize(template, name, *args, **attributes, &block)
+      @template   = template
+      @names      = [ *name ].map(&:underscore)
+      @flags      = args.extract! { _1.is_a? Symbol }
+      @args       = args.flatten.compact_blank
+      @attributes = attributes.with_defaults!(attribute_defaults)
+      @children   = attributes.extract_if! { _1 =~ /^[A-Z]\w*$/ }
+      @block      = block
+      extract_options!(@attributes)
+    end
+
+    def name     = @names.last
+    def tag      = href? ? :a : super
+    def href?    = super && !context?(:a) && !current_href?
+
+    def href
+      @template.href_for(super) if href?
+    end
+
+    def current_href? = options[:href]&.then { @template.current_href?(_1, check_parameters: true) }
+    def ancestor_href? = options[:href]&.then { @template.ancestor_href?(_1) }
+
+    def data
+      super.merge({ tip: }.compact_blank)
+    end
+
+    def partial?     = @template.partial?(partial_name)
+    def partial_name = "ui/" + @names.join("_")
+
+    def render_partial
+      render(partial_name, options:, flags:, name => self, **options) { content }
+    end
+
+    def selector = class_names.join(?_).then { ?. + _1 }
+
+    def class_names = @names.map(&:camelize)
+
+    def class_name
+      @template.ui_class(class_names, *flags, *options[:class], options[:tag].to_s => href?,
+                                                        current: current_href?,
+                                                        ancestor: ancestor_href? && !current_href?)
+    end
+
+    def attributes
+      @attributes.merge(class: class_name, href:, data:)
+    end
+
+    def children
+      @children.map { |name, content| send(name) { content } }
+    end
+
+    def blank?
+      @block and body and content.blank? || !content.match?(/^.*?[^<\s]/) || content.gsub(/<!--.*?-->/, "").blank?
+    end
+
+    def body
+      @body ||= context { partial? ? render_partial : content }
+    end
+
+    def content
+      @content ||= safe_join [ *children, *@args, *(capture(self, &@block) if @block) ]
+    end
+
+    def context(&)
+      href? ? @template.context(:a, &) : capture(&)
+    end
+
+    def wrapper(&)
+      @template.content_tag(tag, **attributes, &)
+    end
+
+    def ~@    = @template.concat(self)
+    def +(o)  = safe_join([ self, o ])
+    def <<(o) = @template.concat(o)
+
+    def html_safe? = true
+
+    def to_s = to_html
+
+    def to_html
+      return "" if blank?
+      wrapper { body }
+    end
+
+    def child(name, ...)
+      c = self.class.try { const_defined?(name) ? const_get(name) : Component }
+      c.new(@template, [ *@names, name ], ...)
+    end
+
+    def method_missing(name, ...)
+      if name =~ /^[A-Z]/
+        child(name, ...)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/cafe_car/context.rb

@@ -0,0 +1,17 @@
+module CafeCar
+  class Context
+    def initialize(template, prefix: nil)
+      @template = template
+      @prefix   = prefix
+    end
+
+    def class(name, ...) = @template.ui_class([ *@prefix, *name ], ...)
+    # def wrapper(...)     = Component.new(@template, [*@prefix], ...).wrapper(...)
+    def <<(obj)          = @template.concat(obj)
+
+    def method_missing(name, ...)
+      c = CafeCar[:UI].const_try(name) || Component
+      c.new(@template, [ *@prefix, name ], ...)
+    end
+  end
+end

data/lib/cafe_car/controller/filtering.rb

@@ -0,0 +1,30 @@
+module CafeCar::Controller::Filtering
+  extend ActiveSupport::Concern
+
+  included do
+    helper_method :parsed_params, :dot_params, :filtered?
+  end
+
+  private
+
+  def filtered(scope)
+    scope.query(parsed_params[""])
+  end
+
+  def filtered?
+    parsed_params[""].present?
+  end
+
+  def dot_params
+    request.params.slice(*request.params.keys.grep(/^\./))
+  end
+
+  def parsed_params
+    @parsed_params ||=
+      if request.get? || request.head?
+        CafeCar::ParamParser.new(request.params).parsed
+      else
+        request.params
+      end
+  end
+end

data/lib/cafe_car/controller.rb

@@ -0,0 +1,218 @@
+require "responders"
+
+module CafeCar
+  module Controller
+    extend ActiveSupport::Concern
+
+    include Pundit::Authorization
+    include Filtering, Authentication
+
+    class_methods do
+      def model(model)
+        define_method(:model) { @model ||= model }
+      end
+
+      def default_view(v = @default_view || "table")
+        @default_view = v.to_s
+      end
+
+      def cafe_car(only: nil, except: nil, model: nil)
+        _only = ->(actions) do
+          actions -= except if except
+          actions &= only if only
+          actions
+        end
+
+        self.model model if model
+
+        rescue_from ::ActiveRecord::RecordInvalid,
+                    ::ActiveModel::ValidationError, with: :render_invalid_object
+
+        rescue_from ::Pundit::NotAuthorizedError, with: :render_unauthorized
+
+        append_cafe_car_views
+
+        respond_to :json, :html, :turbo_stream
+
+        before_action :set_current_attributes
+
+        before_action :find_object,       only: _only.(%i[show edit update destroy])
+        before_action :build_object,      only: _only.(%i[new create])
+        before_action :find_objects,      only: _only.(%i[index])
+        before_action :assign_attributes, only: _only.(%i[create update])
+        before_action :authorize!
+      end
+
+      def append_cafe_car_views
+        append_view_path CafeCar::Engine.root.join("app/views/cafe_car")
+        append_view_path "app/views/cafe_car"
+      end
+
+      def define_callbacks_with_helpers(*names, **)
+        define_callbacks(*names, **)
+
+        names.each do |name|
+          %i[before around after].each do |kind|
+            define_singleton_method "#{kind}_#{name}" do |*args, **opts|
+              set_callback(name, kind, *args, prepend: true, **opts)
+            end
+
+            define_singleton_method "skip_#{kind}_#{name}" do |*args|
+              skip_callback(name, kind, *args)
+            end
+          end
+        end
+      end
+    end
+
+    included do
+      self.responder = CafeCar[:ApplicationResponder]
+      default_form_builder CafeCar[:FormBuilder]
+
+      define_callbacks_with_helpers :render, :update, :create, :destroy
+      add_flash_types :success, :warning, :error
+
+      helper_method :model, :model_name, :object, :objects
+      helper_method :action, :scope, :view, :default_view
+
+      helper Helpers
+      delegate :present, :href_for, :namespace, to: :helpers
+
+      after_action :verify_authorized, :verify_policy_scoped
+    end
+
+    def index = respond_with objects
+    def show  = respond_with object
+    def new   = respond_with object
+    def edit  = respond_with object
+
+    def create
+      run_callbacks(:create) { object.save! }
+      respond_with object
+    end
+
+    def update
+      run_callbacks(:update) { object.save! }
+      respond_with object
+    end
+
+    def destroy
+      run_callbacks(:destroy) { object.destroy! }
+      respond_with object
+    end
+
+    def respond_with(*resources, **options, &block)
+      super(*namespace, *resources, **options, &block)
+    end
+
+    private
+
+    def authorize!
+      return authorize object if object
+      return authorize objects if objects
+      raise "nothing to authorize! Define self.object or self.objects"
+    end
+
+    def flash!
+      flash[:success] = present(object).i18n("#{action_name}_html", scope: :flashes)
+    end
+
+    def sorted(scope)
+      scope.sorted(*params[:sort].presence)
+    end
+
+    def paginated(scope, page: params[:page], per: params[:per])
+      scope.page(page).per(per)
+    end
+
+    def build_object
+      self.object = scope.new
+    end
+
+    def find_object
+      delimiter = model.param_delimiter
+      id = unwrap params.extract_value(:id, delimiter:)
+      self.object = scope.except(:limit, :offset).find(id)
+    end
+
+    def unwrap(arr) = arr.size == 1 ? arr.first : arr
+
+    def find_objects
+      self.objects = scope
+    end
+
+    def assign_attributes
+      object.assign_attributes(permitted_attributes(object))
+    end
+
+    def scope   = model.all.then { policy_scope _1 }
+                           .then { sorted _1 }
+                           .then { filtered _1 }
+                           .then { paginated _1 }
+    def objects = instance_variable_get("@#{model_name.plural}")
+    def objects=(value)
+      instance_variable_set("@#{model_name.plural}", value)
+    end
+
+    def object = instance_variable_get("@#{model_name.singular}")
+    def object=(value)
+      instance_variable_set("@#{model_name.singular}", value)
+    end
+
+    def model_name = model.model_name
+
+    def model
+      @model ||= self.class.name.gsub(/.*::|Controller$/, "")
+                                .classify
+                                .then { self.class.module_parent.const_get _1 }
+    end
+
+    def render_invalid_object
+      render(object.persisted? ? "edit" : "new", status: :unprocessable_content)
+    end
+
+    def render_unauthorized
+      if !sessions_available?
+        head :forbidden
+      elsif authenticated?
+        redirect_back_or_to root_path
+      else
+        request_authentication
+      end
+    end
+
+    # def default_render(...) = run_callbacks(:render) { super }
+
+    def default_url_options
+      {} # { locale: I18n.locale }
+    end
+
+    def action
+      @action ||= ActiveSupport::StringInquirer.new(action_name)
+    end
+
+    def default_view = self.class.default_view
+    def view
+      params.fetch(:view) { default_view }
+    end
+
+    def _render_with_renderer_json(obj, options)
+      # permitted_attributes is record-oriented, so ask a record for the column
+      # list even when serializing a collection.
+      record = obj.is_a?(CafeCar::Model) ? obj : obj.klass.new
+      options[:only] ||= [ :id ] | policy(record).displayable_attributes
+
+      if obj.is_a?(CafeCar::Model)
+        options[:include] ||= policy(obj).displayable_associations
+      end
+
+      super obj, **options
+    end
+
+    def set_current_attributes
+      CafeCar[:Current].request_id = request.uuid
+      CafeCar[:Current].user_agent = request.user_agent
+      CafeCar[:Current].ip_address = request.ip
+    end
+  end
+end

data/lib/cafe_car/core_ext/array.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class Array
+  def overlap(other)
+    0.upto(size) do |i|
+      if other.start_with? drop(i)
+        return slice(0, i) + other
+      end
+    end
+  end
+
+  def extract!(pattern = nil, &block)
+    block = -> { pattern === _1 } if pattern
+    return to_enum(:extract!) { size } unless block
+
+    extracted_elements = []
+
+    reject! do |element|
+      extracted_elements << element if block.(element)
+    end
+
+    extracted_elements
+  end
+end

data/lib/cafe_car/core_ext/hash.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Hash
+  # Removes and returns a hash containing the key/value pairs for which the
+  # block returns a true value given the key.
+  #
+  #   hash = {:a => 1, "b" => 2, :c => 3}
+  #   hash.extract_if! { _1.is_a? Symbol } #=> {a: 1, c: 3}
+  #   hash                                 #=> {"b" => 2 }
+  def extract_if!
+    each_with_object(self.class.new) do |(key, value), result|
+      result[key] = delete(key) if yield(key, value)
+    end
+  end
+end

data/lib/cafe_car/core_ext/module.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Module
+  # Shorthand for `const_set(name.camelize, Class.new(parent) { ... })`.
+  # Useful when defining classes in macros.
+  def define_class(name, *, **macros, &)
+    name = name.to_s.camelize
+    raise NameError, "class exists: #{name}" if const_defined?(name, false)
+    klass = Class.new(*) do
+      macros.each { |key, value| send(key, *value) }
+      class_eval(&) if block_given?
+    end
+    const_set name, klass
+  end
+end

data/lib/cafe_car/core_ext.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Dir.glob(File.expand_path("core_ext/*.rb", __dir__)).sort.each do |path|
+  require path
+end

data/lib/cafe_car/current.rb

@@ -0,0 +1,9 @@
+module CafeCar
+  class Current < ActiveSupport::CurrentAttributes
+    delegate :user, to: :session, allow_nil: true
+
+    attribute :request_id, :user_agent, :ip_address
+    attribute :session
+    # attribute :user
+  end
+end

data/lib/cafe_car/engine.rb

@@ -0,0 +1,107 @@
+require "chronic"
+require "haml-rails"
+require "kaminari"
+require "image_processing"
+require "propshaft"
+require "pundit"
+require "importmap-rails"
+require "turbo-rails"
+require "potter"
+require "potter/type"
+
+module CafeCar
+  class Engine < ::Rails::Engine
+    config.autoload_paths += paths["lib"].to_a
+
+    initializer "cafe_car.inflections" do
+      ActiveSupport::Inflector.inflections do |i|
+        i.acronym "UI"
+      end
+    end
+
+    initializer "cafe_car.i18n" do |app|
+      app.reloader.to_prepare do
+        CafeCar::NamePatch.patch!
+        I18n::Backend::Simple.include(CafeCar::Pluralization)
+      end
+    end
+
+    initializer "cafe_car.assets" do |app|
+      app.config.assets.paths << root.join("app/javascript")
+    end
+
+    initializer "cafe_car.preload_header" do |app|
+      app.config.action_view.preload_links_header = false
+    end
+
+    initializer "cafe_car.filter_parameters" do |app|
+      app.config.filter_parameters |= %i[authorization passw secret token _key crypt salt certificate otp ssn]
+    end
+
+    initializer "cafe_car.importmap", before: "importmap" do |app|
+      app.config.importmap.paths << root.join("config/importmap.rb")
+      app.config.importmap.cache_sweepers << root.join("app/javascript")
+    end
+
+    initializer "cafe_car.active_record" do |app|
+      app.reloader.to_prepare do
+        ::ActiveRecord::Base.include(Model)
+      end
+    end
+
+    initializer "cafe_car.routing" do |app|
+      app.reloader.to_prepare do
+        ::ActionDispatch::Routing::Mapper.include(Routing)
+      end
+    end
+
+    initializer "cafe_car.chronic" do |app|
+      app.reloader.to_prepare do
+        Chronic.time_class = Time.zone
+      end
+    end
+
+    initializer "cafe_car.sqlite_regexp" do |app|
+      ActiveSupport.on_load :active_record_sqlite3adapter do
+        ::Arel::Visitors::SQLite.include(Visitors::SQLite)
+        include ActiveRecord::SQLite3Extension
+      end
+    end
+
+    initializer "cafe_car.turbo" do
+      ActiveSupport.on_load :turbo_streams_tag_builder do
+        include TurboTagBuilder
+      end
+    end
+
+    initializer "cafe_car.responders" do
+      require "responders"
+      config.responders.flash_keys = [ :success, :error ]
+    end
+
+    initializer "cafe_car.field_with_errors" do
+      ActionView::Base.field_error_proc = proc { _1.html_safe }
+    end
+
+    initializer "cafe_car.console" do |app|
+      app.console do
+        TOPLEVEL_BINDING.eval("self").instance_exec do
+          def logger = Rails.logger
+
+          if defined?(FactoryBot)
+            include FactoryBot::Syntax::Methods
+            logger.info "FactoryBot methods enabled."
+          end
+
+          logger.info "SQL logs enabled."
+
+          ApplicationController.allow_forgery_protection = false
+          logger.info "CSRF disabled to enable app.post calls."
+
+          def present(...) = CafeCar[:Presenter].present(helper, ...)
+          def ui(...) = helper.ui(...)
+        end
+      end
+    end
+  end
+end

data/lib/cafe_car/field_builder.rb

@@ -0,0 +1,44 @@
+module CafeCar
+  class FieldBuilder
+    attr_reader :form, :method, :as
+
+    delegate :object, :info, to: :form
+
+    def initialize(method:, form:, template:, **options, &block)
+      @method   = method
+      @form     = form
+      @template = template
+      @options  = options
+      @block    = block
+    end
+
+    def info         = form.info(@method)
+    def wrapper(...) = @template.ui.Field(...)
+    def input(...)   = send_to_form(:input, ...)
+    def label(...)   = send_to_form_with_text(:label, ...)
+    def hint(...)    = send_to_form_with_text(:hint, ...)
+    def error(...)   = send_to_form_with_text(:error, ...)
+
+
+    def html_safe? = true
+    def to_s
+      return input if info.polymorphic? and object.new_record?
+      partial = %W[#{info.type}_field field].find { @template.partial?(_1) }
+      @template.render(partial, field: self, **@options)
+    end
+
+    private
+
+    def add_class(*args, opts) = { class: @template.ui_class([ :field, *args ], *opts.delete(:class)), **opts }
+
+    def send_to_form_with_text(method, text = @options.delete(method), **, &)
+      return if text == false
+      send_to_form(method, *text, **, &)
+    end
+
+    def send_to_form(method, *, **opts, &)
+      return if @options[method] == false
+      form.public_send(method, @method, *, **add_class(*method, opts), &)
+    end
+  end
+end