cafe_car 0.1.0 → 0.1.2

data/lib/cafe_car/inputs/base_input.rb

@@ -0,0 +1,19 @@
+module CafeCar
+  module Inputs
+    class BaseInput
+      attr_accessor :options
+
+      def initialize(template:, **options)
+        @template = template
+        @options  = options
+      end
+
+      def tag  = :input
+      def type = :text
+
+      def to_html
+        @template.Input(tag:, type:, **options)
+      end
+    end
+  end
+end

data/lib/cafe_car/inputs/belongs_to_builder.rb

@@ -0,0 +1,6 @@
+module CafeCar
+  module Inputs
+    class BelongsToBuilder < AssociationBuilder
+    end
+  end
+end

data/lib/cafe_car/inputs/password_input.rb

@@ -0,0 +1,7 @@
+module CafeCar
+  module Inputs
+    class StringInput < BaseInput
+      def tag = :input
+    end
+  end
+end

data/lib/cafe_car/inputs/string_input.rb

@@ -0,0 +1,7 @@
+module CafeCar
+  module Inputs
+    class StringInput < BaseInput
+      def type = :text
+    end
+  end
+end

data/lib/cafe_car/link_builder.rb

@@ -0,0 +1,65 @@
+module CafeCar
+  class LinkBuilder
+    attr_reader :object
+
+    delegate :capture, :link_to, :link_to_unless, :current_page?, :href_for, to: :@template
+    delegate :model, :policy, to: :p
+
+    def initialize(template, object, namespace: template.namespace)
+      @template  = template
+      @object    = object
+      @namespace = namespace
+    end
+
+    def p             = @template.present(@object)
+    def can?(action)  = policy.public_send("#{action}?")
+    def cant?(action) = !can?(action) && disabled(action, :policy)
+
+    def i18n(*, scope: nil, **) = p.i18n(*, scope: [ :controls, *scope ], **)
+
+    def confirm(key)             = i18n(key, scope: :confirm)
+    def disabled(action, reason) = i18n(action, scope: [ :disabled, reason ])
+
+    def turbo!(opts)
+      opts.replace({
+        data: {
+          turbo_stream:  true,
+          turbo_method:  opts.delete(:method),
+          turbo_confirm: opts.delete(:confirm)
+        }
+      }.deep_merge(opts))
+    end
+
+    def link(action, target, label = i18n(action), disabled: false, hide: false, params: nil, **opts, &)
+      params ||= {}
+      disabled ||= cant?(action)
+      return if disabled and hide
+
+      href    = href_for(*target, action:, namespace: @namespace, **params)
+      current = current_page?(href, check_parameters: true)
+      in_link = @template.context?(:a)
+      content = block_given? ? capture(label, &) : label
+
+      link_to_unless(disabled || current || in_link, content, href, **turbo!(opts)) do
+        @template.tag.span(content, class: "disabled", disabled: true, title: disabled.presence)
+      end
+    end
+
+    def show(*, **, &)    = link(:show, @object, *, data: { turbo_stream:  nil }, **, &)
+    def edit(...)         = link(:edit, @object, ...)
+    def destroy(*, **, &) = link(:destroy, @object, *, method: :delete, confirm: confirm(:destroy), **, &)
+    def index(*, **, &)   = link(:index, model, *, hide: true, data: { turbo_stream:  nil }, **, &)
+    def new(*, **, &)     = link(:new, model, *, hide: true, **, &)
+
+    def code(path = nil)
+      return unless Rails.env.development?
+      return unless @template.request.local?
+      path ||= caller_locations(1, 1).first.path
+
+      link_to "✎", "rubymine://open?file=#{path}" # &line=%{line}
+    end
+
+    def html_safe? = true
+    def to_s = p.to_s
+  end
+end

data/lib/cafe_car/model.rb

@@ -0,0 +1,23 @@
+module CafeCar::Model
+  extend ActiveSupport::Concern
+
+  include CafeCar::Queryable
+  include CafeCar::Informable
+
+  class_methods do
+    def sorted(*args)
+      return all if args.compact_blank!.empty?
+      args = args.flat_map { normalize_sort_key(_1) }
+      reorder(*args)
+    end
+
+    def normalize_sort_key(key)
+      case key
+      when /,/
+        key.split(",").map { normalize_sort_key _1 }
+      when /^-(.+)$/ then { $1 => :desc }
+      else key
+      end
+    end
+  end
+end

data/lib/cafe_car/model_info.rb

@@ -0,0 +1,24 @@
+module CafeCar
+  class ModelInfo
+    include Caching
+
+    attr_reader :model
+
+    def self.find(object)
+      model = object.is_a?(Class) ? object : object.class
+      @cache        ||= {}
+      @cache[model] ||= new(model:)
+    end
+
+    def initialize(model:)
+      @model  = model
+      @field  = {}
+    end
+
+    def columns         = model.column_names
+    def field_names     = model.column_names | model.reflect_on_all_attachments.map(&:name)
+    def field(method)   = @field[method]   ||= FieldInfo.new(model:, method:)
+
+    derive :fields, -> { Fields.new(field_names.map { field _1 }) }
+  end
+end

data/lib/cafe_car/name_patch.rb

@@ -0,0 +1,17 @@
+module CafeCar
+  module NamePatch
+    def self.patch!
+      ActiveModel::Name.class_eval do
+        def human(options = {})
+          return @human if i18n_keys.empty? || i18n_scope.empty?
+
+          key, *defaults = i18n_keys
+          defaults << options[:default] if options[:default]
+          defaults << @human
+
+          I18n.translate(key, scope: i18n_scope, count: 1, **options, default: defaults)
+        end
+      end
+    end
+  end
+end

data/lib/cafe_car/navigation.rb

@@ -0,0 +1,76 @@
+module CafeCar
+  class Navigation
+    class Route
+      delegate :tag, :ui, :ui_class, :capture, :concat, :t, to: :@template
+      delegate :name, :requirements, to: :@route
+
+      def initialize(route, template:)
+        @route = route
+        @template = template
+      end
+
+      def controller = requirements[:controller]
+      def action = requirements[:action]
+      def index? = action == "index"
+      def rails? = name =~ /rails/
+      def group  = controller.split(?/)[..-2]
+      def text   = controller.split(?/).last
+      def params = requirements.clone.tap do |p|
+        p[:controller] = "/" + p[:controller]
+      end
+
+      def icon_name = t(text, scope: "navigation.icon", default: nil)&.to_sym
+      def icon = @template.icon(icon_name, :before)
+
+      def content
+        capture do
+          concat icon
+          concat text.titleize
+        end
+      end
+
+      def link(**opts)
+        ui.Navigation().Link(href: @template.href_for([ params ]), **opts) { content }
+      end
+    end
+
+    def initialize(template, **options)
+      @template = template
+      @options  = options
+    end
+
+    delegate :ui_class, to: :@template
+
+    def router = Rails.application.routes.router
+    def named_routes = Rails.application.routes.named_routes.to_h.values.map { Route.new(_1, template: @template) }
+    def index_routes = named_routes.select(&:index?)
+    def groups = routes.group_by(&:group)
+
+    def routes
+      @routes ||= index_routes.reject(&:rails?)
+                              .uniq(&:requirements)
+    end
+
+    def recognize(obj, **)
+      req = case obj
+      when String
+              path = ActionDispatch::Journey::Router::Utils.normalize_path(path)
+              env  = Rack::MockRequest.env_for(path, method: :get, **)
+              ActionDispatch::Request.new(env)
+      when ActionDispatch::Request then obj
+      else raise "cannot recognize this obj"
+      end
+
+      router.recognize(req) do |route, params|
+        return Route.new(route, template: @template)
+      end
+    end
+
+    def current = recognize(@template.request)
+
+    def link_to(*args, **opts, &block)
+      block ||= -> { @template.tag.span(_1, class: ui_class([ :navigation, :link ], :current)) }
+      @template.link_to_unless_current(*args, class: ui_class([ :navigation, :link ]), **opts, &block)
+    end
+  end
+end

data/lib/cafe_car/option_helpers.rb

@@ -0,0 +1,53 @@
+module CafeCar
+  module OptionHelpers
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :option_defaults, default: {}
+    end
+
+    def get_options = @options
+
+    def assign_options!
+      raise "@options is not a hash" unless get_options.is_a? Hash
+      option_defaults.each { assign_option!(_1, _2) }
+    end
+
+    def assign_option!(k, default)
+      value = get_options.delete(k) { default.respond_to?(:call) ? default.call : default.clone }
+      instance_variable_set("@#{k}", value)
+    end
+
+    class_methods do
+      def inherited(subclass)
+        super
+        subclass.option_defaults = option_defaults.deep_dup
+      end
+
+      def option(*names, default: nil, accessor: true, reader: accessor, writer: accessor, presence: accessor, macro: accessor)
+        names.each do |name|
+          if respond_to?(name) and reader
+            raise ArgumentError, "Option name #{name} conflicts with existing method"
+          end
+          attr_reader name if reader
+          attr_writer name if writer
+          option_defaults[name] = default
+          define_method("#{name}?") { instance_variable_get("@#{name}").present? } if presence
+          define_singleton_method(name) { |v| option_defaults[name] = v } if macro
+        end
+      end
+
+      def flag(*names, setter: true, **)
+        names.each do |name|
+          option(name, default: false, reader: false, **)
+          define_method(name) { instance_variable_set("@#{name}", true); self } if setter
+        end
+      end
+
+      def option_accessor(name)
+        define_method(name) { get_options[name] }
+        define_method("#{name}=") { get_options[name] = _1 }
+      end
+    end
+  end
+end

data/lib/cafe_car/param_parser.rb

@@ -0,0 +1,45 @@
+class CafeCar::ParamParser
+  def initialize(params)
+    @params = params
+  end
+
+  def parsed
+    @parsed ||= @params.compact_blank
+                       .then { params _1 }
+  end
+
+  def params(params)
+    params.map { |k, v| k.split(".").reverse.reduce(value(v)) { { _2 => _1 } } }
+          .reduce({}) { _1.deep_merge(_2, &method(:merge)) }
+          .with_indifferent_access
+  end
+
+  def merge(_, a, b)
+    if a.is_a?(Array) || b.is_a?(Array)
+      [ *Array.wrap(a), *Array.wrap(b) ]
+    else
+      b
+    end
+  end
+
+  def value(v)
+    case v
+    when Array      then v.map { value(_1) }
+    when Hash       then params(v).tap { _1.merge!(_1.delete("")) if _1[""] }
+    when '""', "''" then ""
+    when "nil", ""  then nil
+    when /[{}\[\]]/ then value(JSON.parse(v))
+    when /,/        then value(v.split(","))
+    when /^(.*?)\.\.(\.?)(.*)$/
+      begin
+        Range.new(value($1), value($3), $2.present?)
+      rescue ArgumentError
+        v
+      end
+    when /^\$(\w+)\.(\w+)$/
+      # TODO: make less scary
+      $1.constantize.arel_table[$2]
+    else v
+    end
+  end
+end

data/lib/cafe_car/pluralization.rb

@@ -0,0 +1,15 @@
+module CafeCar
+  module Pluralization
+    def pluralize(locale, entry, count)
+      return super unless entry.is_a?(String) && count
+      count = 1 if count == :one
+      count = 2 unless count.is_a?(Integer)
+      entry.pluralize(count)
+    end
+
+    def localize(locale, object, format = :default, options = {})
+      options[:ordinal] ||= object.day.ordinalize
+      super
+    end
+  end
+end

data/lib/cafe_car/policy.rb

@@ -0,0 +1,77 @@
+module CafeCar::Policy
+  extend ActiveSupport::Concern
+
+  def policy(object) = Pundit.policy(user, object)
+
+  def model
+    @model ||= object.try(:klass) or object.is_a?(Class) ? object : object.class
+  end
+
+  def info(method)
+    @info         ||= {}
+    @info[method] ||= CafeCar[:FieldInfo].new(model:, method:)
+  end
+
+  def title_attribute
+    @title_attribute ||= displayable_attributes.first
+  end
+
+  def logo_attribute
+    model.info.fields.listable.attachments.first&.method
+  end
+
+  def listable_attributes
+    model.info.fields.listable.map(&:method)
+  end
+
+  def displayable_attributes
+    permitted_attribute_keys
+      .union(model.columns.map(&:name).map(&:to_sym))
+      .map    { association_for_attribute(_1) || _1 }
+      .reject { filtered_attribute? _1 } - %i[id]
+  end
+
+  def permitted_fields
+    @permitted_fields ||= permitted_attribute_keys.map { info _1 }
+  end
+
+  def editable_attributes
+    permitted_fields.map(&:input_key) - permitted_fields.flat_map(&:abrogated_keys)
+  end
+
+  def displayable_associations
+    model.reflections.values
+         .select { |a| !a.options[:autosave] && !a.options[:polymorphic] }
+         .reject { _1.class_name =~ /^ActiveStorage::/ }
+         .map    { _1.name.to_sym }
+  end
+
+  def permitted_attribute_keys
+    permitted_attributes.flat_map { |a| a.try(:keys) || a }
+  end
+
+  def permitted_association?(name)
+    ref = model.reflect_on_association(name)
+
+    return false if ref.has_one?
+    return permitted_attribute?(ref.foreign_key) if ref.belongs_to?
+
+    permitted_attribute?("#{ref.name.to_s.singularize}_ids")
+  end
+
+  def filtered_attribute?(attribute)
+    model.inspection_filter.filter_param(attribute, nil).present?
+  end
+
+  def permitted_attribute?(attribute)
+    permitted_attribute_keys.include?(attribute.to_sym)
+  end
+
+  def displayable_attribute?(attribute)
+    displayable_attributes.include?(attribute.to_sym)
+  end
+
+  def association_for_attribute(attribute)
+    info(attribute).reflection&.name
+  end
+end

data/lib/cafe_car/proc_helpers.rb

@@ -0,0 +1,13 @@
+module CafeCar
+  module ProcHelpers
+    def call_procs!(options, ...)
+      options.each do |k, v|
+        options[k] = v.call(...) if v.respond_to? :call
+      end
+    end
+
+    def clone_or_call!(value, ...)
+      value.respond_to?(:call) ? value.call(...) : value.clone
+    end
+  end
+end

data/lib/cafe_car/query_builder.rb

@@ -0,0 +1,186 @@
+module CafeCar
+  class QueryBuilder
+    require "activerecord_where_assoc"
+
+    Op = Struct.new(:op, :rhs) do
+      def initialize(op, rhs)
+        super(op.to_sym, rhs)
+      end
+
+      def flop = op.to_s.tr("<>", "><").to_sym
+      def map  = Op.new(op, yield(rhs))
+
+      def arel(node) = node.public_send(arel_op, rhs)
+
+      def arel_op
+        case op
+        when :<  then :lt
+        when :>  then :gt
+        when :>= then :gteq
+        when :<= then :lteq
+        when :== then :eq
+        else op
+        end
+      end
+    end
+
+    attr_reader :scope
+
+    def initialize(scope)
+      @scope = scope
+    end
+
+    def unscoped   = QueryBuilder.new(@scope.unscope(:where))
+    def arel(key)  = @scope.arel_table[chomp(key)]
+    def chomp(key) = key.to_s.sub(/\W+$/, "")
+
+    def parse_time(value)
+      Chronic.parse(value, guess: false, context: :past)
+    rescue NoMethodError
+      nil
+    end
+
+    def parse_range(key, value)
+      Range.new(parse_value(key, value.begin).then { _1.try(:begin) or _1 },
+                parse_value(key, value.end).then { value.exclude_end? ? _1.try(:begin) : _1.try(:end) or _1 },
+                value.exclude_end?)
+    end
+
+    def parse(key, value)
+      new_value = parse_value(key, value)
+      if new_value != value
+        parse(key, new_value)
+      else
+        new_value
+      end
+    end
+
+    def parse_value(key, value)
+      case value
+      in Op(rhs: /^=(.*)$/)
+        Op.new("#{value.op}=", $1)
+      in Op(op: (:< | :>=), rhs: Range)
+        value.map(&:begin)
+      in Op(op: (:> | :<=), rhs: Range)
+        value.map(&:end)
+      in Range
+        parse_range(key, value)
+      in Array | Op
+        value.map { parse_value(key, _1) }
+      in "true" then true
+      in "false" then false
+      in String
+        case column(key)&.type || reflection(key)&.macro
+        when :datetime then parse_time(value) || value
+        when :integer  then value.to_i
+        when :float    then value.to_f
+        when :belongs_to, :has_many, :has_one
+          value.to_i
+        else value
+        end
+      else value
+      end
+    end
+
+    def update!(&)
+      scope  = yield @scope
+      @scope = scope if scope
+      self
+    end
+
+    def not!(&)
+      inverted = unscoped.tap { _1.instance_exec(&) }.scope.invert_where
+      update! { _1.and(inverted) }
+    end
+
+    def column(name)       = @scope.columns_hash[name.to_s]
+    def reflection(name)   = @scope.reflect_on_association(name)
+    def association?(name) = reflection(name).present?
+    def attribute?(name)   = column(name).present?
+    def scope?(name)       = name.intern.in? @scope.local_methods
+
+    def arel!(node) = @scope.where!(node)
+
+    def param!(key, value)
+      case key
+      when /^(.*?)\s*!$/
+        not! { param!($1, value) }
+      when /^(.*?)\s*~$/
+        param!($1, Regexp.new(value, Regexp::IGNORECASE))
+      when /^(.*?)\s*([<>]=?)$/
+        param!($1, Op.new($2, value))
+      when method(:association?)
+        association!(key, value)
+      when method(:attribute?)
+        attribute!(key, value)
+      when method(:scope?)
+        scope!(key, value)
+      else
+        raise MissingAttributeError, "can't find #{key.inspect} on #{@scope.model_name}"
+      end
+    end
+
+    def attribute!(key, value)
+      case [ key, value ]
+      in _, Regexp
+        @scope.where!(arel(key).matches_regexp(value.source, !value.casefold?))
+      in _, Op
+        @scope.where!(parse(key, value).arel(arel(key)))
+      else @scope.where!(key => parse(key, value))
+      end
+    end
+
+    def association!(name, value, ...)
+      update! do
+        case value
+        when true  then @scope.where_assoc_exists(name)
+        when false then @scope.where_assoc_not_exists(name)
+        when Integer, Range, /^\d+$/
+          @scope.where_assoc_count(parse(name, value), :==, name)
+        when Op
+          value = parse(name, value)
+          @scope.where_assoc_count(value.rhs, value.flop, name)
+        else @scope.where_assoc_exists(name) { all.query!(value, ...) }
+        end
+      end
+    end
+
+    def scope!(name, value)
+      value = parse_value(name, value)
+      arity = (@scope.scopes[name] || @scope.method(name)).arity
+      value = nil if arity == 0 and value == true
+
+      update! { _1.public_send(name, *value) }
+    end
+
+    def search!(term)
+      @scope.search!(term) if @scope.respond_to?(:search!)
+      @scope.query!("body~": term) if @scope < ::ActionText::RichText
+      update! { _1.search(term) }
+    end
+
+    def query!(params = nil)
+      case params
+      when Hash  then params.each { param!(_1, _2) }
+      when Array then params.each { query! _1 }
+      when String then search!(params)
+      # when Arel::Nodes::Node then arel!(params)
+      when nil
+      else raise ArgumentError, "cannot query on #{params}"
+      end
+      self
+    end
+
+    def query(...) = clone.update!(&:all).query!(...)
+  end
+end
+
+# Article.query do
+#   published
+#   user { name(/bob/i) }
+#   user.name(/bob/i)
+# end
+#
+# Article.query(published: true, user: {name: /bob/i})
+#
+# Article.published(true).where_assoc_exists(:user) { where(name: /bob/i) }

data/lib/cafe_car/queryable.rb

@@ -0,0 +1,29 @@
+module CafeCar::Queryable
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def scope(name, body)
+      scopes[name] = body
+      super
+    end
+
+    def sample = offset(rand(count)).first
+
+    def query(params)  = query_builder.query(params).scope
+    def query!(params) = query_builder.query!(params).scope
+
+    def query_builder
+      CafeCar::QueryBuilder.new(all)
+    end
+
+    def scopes
+      @scopes ||= {}.with_indifferent_access
+    end
+
+    def local_methods
+      @local_methods ||= public_methods -
+        ActiveRecord::Base.public_methods -
+        Kaminari::ConfigurationMethods::ClassMethods.instance_methods
+    end
+  end
+end