cafe_car 0.1.0 → 0.1.2

data/lib/cafe_car/field_info.rb

@@ -0,0 +1,144 @@
+module CafeCar
+  class FieldInfo
+    attr_reader :method, :model
+    alias_method :name, :method
+
+    delegate :model_name, to: :@model
+
+    def initialize(model:, method:)
+      # raise "Cannot get FieldInfo for nil method" if method.nil?
+      @method = method&.to_sym
+      @model = model
+    end
+
+    def info(method) = model.info.field(method)
+
+    def id?        = method =~ /_ids?$/
+    def constant?  = method.in? %i[id created_at updated_at]
+    def timestamp? = type.in? %i[date datetime time]
+
+    def association?
+      return if @method.nil?
+      model.reflect_on_association(@method).present?
+    end
+
+    def associated?  = reflection.present?
+    def polymorphic? = reflection&.polymorphic?
+    def digest?      = method =~ /_digest$/
+    def password?    = type == :password
+    def rich_text?   = reflection&.name =~ /^rich_text_(\w+)$/
+    def attachment?  = model.reflect_on_attachment(method)
+    def collection   = reflection.klass.all
+    def reflection
+      return if @method.nil?
+      model.try(:reflect_on_association, @method) || reflections_by_attribute[@method]
+    end
+
+    def abrogated_keys
+      [ *reflection&.foreign_type&.to_sym ]
+    end
+
+    def displayable = reflection&.name&.then { info(_1) } || self
+
+    def default_type
+      case method
+      when :controls then method
+      end
+    end
+
+    def reflection_type = reflection&.macro
+    def attribute_type  = model.type_for_attribute(@method)&.type
+    def digest_type
+      key = @method.to_s.chomp("_confirmation")
+      model.type_for_attribute("#{key}_digest")&.type && :password
+    end
+
+    def attachment_type
+      :attachment if attachment?
+    end
+
+    def nested_attributes_type
+      key = @method.to_s.chomp("_attributes").to_sym
+      model.nested_attributes_options.key?(key) && :nested
+    end
+
+    def polymorphic_methods = [ reflection.foreign_type, reflection.foreign_key ]
+
+    def placeholder  = i18n(:placeholder)
+    def autocomplete = i18n(:autocomplete)
+    def hint         = i18n(:hint)
+    def label        = i18n(:label, default: human)
+    def prompt       = i18n(:prompt, default: "Select #{human.downcase}...")
+    def human(...)   = @method&.then { model.human_attribute_name(_1, ...) }
+    def required?    = validator?(:presence)
+
+    def validator?(kind, **options)
+      model.validators_on(@method).any? { _1.kind == kind and _1.options >= options }
+    end
+
+    def i18n_key = model_name.i18n_key
+    def i18n(key, **opts)
+      return if @method.nil?
+      I18n.t(@method, scope: [ :helpers, key, i18n_key ], raise: true, **opts)
+    rescue I18n::MissingTranslationData
+    end
+
+    def type
+      return if @method.nil?
+      @type ||= reflection_type || attribute_type || digest_type || attachment_type ||
+                default_type || nested_attributes_type ||
+                raise(NoMethodError.new "Can't find attribute :#{@method} on #{model_name}", @method)
+    end
+
+    def width
+      case type
+      when :text, :string, :json
+        # "minmax(10em, fit-content)"
+        # "minmax(10em, 1fr)"
+        "minmax(10em, auto)"
+        # "minmax(min-content, auto)"
+      else "min-content"
+      end
+    end
+
+    def input
+      case type
+      when :string   then :text_field
+      when :decimal  then :text_field
+      when :text, :json then :text_area
+      when :integer  then :number_field
+      when :date     then :date_field
+      when :datetime then :datetime_field
+      when :password then :password_field
+      when :nested   then :fields_for
+      when :attachment then :file_field
+      when :belongs_to, :has_many then :association
+      when :has_one
+        rich_text? ? :rich_text_area : nil
+      else raise "Missing input type for #{model_name}##{@method} of type :#{type}"
+      end
+    end
+
+    def input_key
+      case type
+      when :belongs_to then reflection.foreign_key
+      else method
+      end
+    end
+
+    @@reflections_by_attribute = {}
+    def reflections_by_attribute
+      return {} unless model.respond_to? :reflections
+      @@reflections_by_attribute[model] ||=
+        model.reflections.values.index_by do |r|
+          case [ r.macro, r.name ]
+          in [ :belongs_to, * ]                then r.foreign_key
+          in [ :has_many, * ]                  then "#{r.name.to_s.singularize}_ids"
+          in [ :has_one, /^rich_text_(\w+)$/ ] then $1
+          in [ :has_one, * ]                   then r.name
+          else raise NoMethodError.new("Not yet implemented :#{r.macro}")
+          end
+        end.with_indifferent_access
+    end
+  end
+end

data/lib/cafe_car/fields.rb

@@ -0,0 +1,21 @@
+module CafeCar
+  class Fields < Array
+    include Caching
+
+    derive :editable,    -> { Fields.new reject(&:constant?) }
+    derive :listable,    -> { Fields.new editable.reject(&:digest?) }
+    derive :attachments, -> { Fields.new select(&:attachment?) }
+    derive :timestamps,  -> { Fields.new select(&:timestamp?) }
+
+    derive :by_name,     -> { index_by(&:name).with_indifferent_access }
+    derive :names,       -> { map(&:name) }
+
+    def reverse = Fields.new(super)
+
+    def sort_with(obj)
+      Fields.new(sort_by { obj.try(_1.name) })
+    end
+
+    def has?(name) = by_name.key?(name)
+  end
+end

data/lib/cafe_car/filter/field_builder.rb

@@ -0,0 +1,4 @@
+module CafeCar::Filter
+  class FieldBuilder < CafeCar[:FieldBuilder]
+  end
+end

data/lib/cafe_car/filter/field_info.rb

@@ -0,0 +1,22 @@
+class CafeCar::Filter::FieldInfo < CafeCar[:FieldInfo]
+  def i18n(key, **opts)
+    I18n.t(@method, scope: [ :helpers, :filter, key, i18n_key ], raise: true, **opts)
+  rescue I18n::MissingTranslationData
+  end
+
+  def input
+    case type
+    when :string   then :text_field
+    when :text     then :text_field
+    when :decimal  then :text_field # :range_field
+    when :integer  then :text_field # :range_field
+    when :date     then :text_field
+    when :datetime then :text_field
+    when :password then :password_field
+    when :belongs_to, :has_many then :association
+    when :has_one
+      rich_text? ? :text_field : nil
+    else raise "Missing input type for #{model_name}##{@method} of type :#{type}"
+    end
+  end
+end

data/lib/cafe_car/filter/form_builder.rb

@@ -0,0 +1,21 @@
+module CafeCar::Filter
+  class FormBuilder < CafeCar[:FormBuilder]
+    def self.dotted_name(method)
+      define_method method do |key, *args, **opts, &block|
+        super(key, *args, name: field_name(key), **opts, &block)
+      end
+    end
+
+    instance_methods.grep(/_(field|select)$/).each do |method|
+      dotted_name method
+    end
+
+    def clean(method) = method.to_s.sub(/^\W+|\W+$/, "")
+    def info(method)  = super(clean(method))
+
+    def field_name(*methods, multiple: false, index: @options[:index])
+      # TODO: handle multiple/index
+      [ "", *methods ].join(".")
+    end
+  end
+end

data/lib/cafe_car/filter.rb

@@ -0,0 +1,5 @@
+module CafeCar
+  module Filter
+    include Resolver
+  end
+end

data/lib/cafe_car/filter_builder.rb

@@ -0,0 +1,20 @@
+module CafeCar
+  class FilterBuilder
+    delegate :model_name, :klass, to: :@objects
+
+    def initialize(objects, params)
+      @objects = objects
+      @params  = params
+    end
+
+    def model      = @objects.klass
+    def to_key     = [ model_name.param_key, :filters ]
+    def to_model   = self
+    def persisted? = false
+    def errors     = Hash.new([])
+
+    def method_missing(name, *, &)
+      @params.dig("", name)
+    end
+  end
+end

data/lib/cafe_car/form_builder.rb

@@ -0,0 +1,105 @@
+module CafeCar
+  class FormBuilder < ActionView::Helpers::FormBuilder
+    include Resolver
+
+    delegate :ui, to: :@template
+
+    def initialize(...)
+      super
+      @fields = {}
+    end
+
+    def model     = @object.is_a?(Class) ? @object : @object.class
+    def policy    = @template.policy(@object)
+    def show(...) = ui.Input { @template.present(@object).show(...) }
+
+    def association(method, collection: nil, **options)
+      info = info(method)
+
+      return show(info.input_key) if info.polymorphic? and object.persisted?
+      return hidden(*info.polymorphic_methods) if info.polymorphic?
+
+      collection              ||= info.collection
+      # options[:prompt]      ||= info.prompt
+      options[:include_blank] ||= info.prompt
+
+      input(info.input_key, collection, :id, -> { @template.present(_1).title }, as: :collection_select, **options)
+    end
+
+    def hidden(*methods, **, &)
+      methods.map  { input(_1, as: :hidden_field, **, &) }
+             .then { @template.safe_join(_1) }
+    end
+
+    def field(method, **, &)
+      @fields[method] ||= const(:FieldBuilder).new(method:, form: self, template: @template, **, &)
+    end
+
+    def label(method, text = info(method).label, required: info(method).required?, **, &)
+      super(method, @template.safe_join([ text, required ? "*" : "" ]), required:, **, &)
+    end
+
+    def submit(value = nil, **options)
+      options[:class] ||= ui.class(:button, :primary)
+      super(value, options)
+    end
+
+    def info(method) = model.info.field(method)
+
+    def input(method, *args, as: nil, **options)
+      info = info(method)
+      as ||= info.input
+
+      options[:placeholder]  = info.placeholder  unless options.key?(:placeholder)
+      options[:autocomplete] = info.autocomplete unless options.key?(:autocomplete)
+
+      public_send(as, method, *args, **options)
+    end
+
+    def hint(method, text = info(method).hint, **)
+      @template.tag.small(text, **) if text.present?
+    end
+
+    def errors(method)
+      errors     = object.try(:errors)
+      associated = info(method).reflection&.then { errors[_1.name] } || []
+      errors[method] | associated
+    end
+
+    def error_text(method)
+      errors(method).to_sentence.presence
+    end
+
+    def error(method, text = error_text(method), **)
+      @template.tag.span(text, **) if text.present?
+    end
+
+    def fields_for(method, object = object_for(method), **, &)
+      method = method.to_s.chomp("_attributes").to_sym
+      if block_given?
+        super
+      else
+        super(method, **) do |f|
+          f.remaining_fields
+        end
+      end
+    end
+
+    def object_for(method)
+      method = method.to_s.chomp("_attributes").to_sym
+      if info(method).reflection.collection?
+        object.try(method)
+      else
+        object.try(method) || object.try("build_#{method}")
+      end
+    end
+
+    def remaining_attributes = policy.editable_attributes - @fields.keys
+
+    def remaining_fields(**, &block)
+      block  ||= proc { field(_1, **) }
+      fields   = remaining_attributes.map(&block)
+      @template.safe_join(fields)
+    end
+  end
+end

data/lib/cafe_car/generators.rb

@@ -0,0 +1,30 @@
+require "rails/generators/active_record/migration"
+require "rails/generators/bundle_helper"
+
+module CafeCar::Generators
+  extend ActiveSupport::Concern
+  include ActiveRecord::Generators::Migration
+  include Rails::Generators::BundleHelper
+
+  private
+
+  def migration(name, ...) = migration_template("#{name}.rb", "db/migrate/#{name}.rb", ...)
+
+  def model(name, ...)
+    name = name.chomp(".rb").underscore
+    template("#{name}.rb", "app/models/#{name}.rb", ...)
+  end
+
+  def class_namespace = class_path.join("/").classify
+
+  def module_namespacing(&block)
+    super { concat wrap_with_module(class_namespace, &block) }
+  end
+
+  def wrap_with_module(module_name, &block)
+    content = capture(&block)
+    return content if module_name.blank?
+    content = indent(content).chomp
+    "module #{module_name}\n#{content}\nend\n"
+  end
+end

data/lib/cafe_car/helpers.rb

@@ -0,0 +1,178 @@
+module CafeCar
+  module Helpers
+    # Returns a new `Context`. Used for instantiating components: `ui.Button(:primary, "Submit")`
+    def ui(*args, **, &)
+      # For now, this must be defined in a helper instead of in the controller. Passing `view_context` or `helpers`
+      # from the controller somehow breaks `capture`. `capture` will return the captured content, but the content
+      # _also_ gets appended to the original output buffer.
+      # This can be tested in a view by comparing the behavior of `= capture do` with
+      # `= controller.view_context.capture do`; the latter outputs the content twice.
+      if args.any?
+        present(*args, **, &)
+      elsif block_given?
+        capture(&)
+      else
+        @ui ||= CafeCar::Context.new(self)
+      end
+    end
+
+    def ui_class(names, *args, **opts)
+      names  = [ *names ].map(&:camelize)
+      name   = names.join("_")
+      args.flatten!
+      args.compact_blank!
+      opts.compact_blank!
+      opts.merge!(*args.extract!(Hash))
+
+      flags = args.extract!(Symbol)
+      flags |= opts.extract_if! { _1.is_a? Symbol }.keys
+      flags.map! { "#{name}-#{_1}" }
+
+      [ *name, *flags, *args, *opts.keys ].join(" ")
+    end
+
+    def body_classes = [ *controller_path.split(?/), action_name, *@body_class ]
+
+    def title(object)
+      present(object).title.presence.tap do |title|
+        content_for(:title, title)
+      end
+    end
+
+    def cat(*args)
+      args.flatten.each do |arg|
+        arg = capture(&arg) if arg.respond_to?(:to_proc)
+        arg = arg.to_s
+        concat(arg) if arg.present?
+      end
+    end
+
+    def cap(*)
+      capture { cat(*) }
+    end
+
+    def capture(*, &)
+      super do
+        yield(*).then { _1.try(:html_safe?) ? _1.to_s : _1 }
+      end
+    end
+
+    def present(*args, **options)
+      @presenters                  ||= {}
+      @presenters[[ args, options ]] ||= CafeCar[:Presenter].present(self, *args, **options)
+    end
+    alias_method :p, :present
+
+    def current_href?(*, check_parameters: false, **) = current_page?(href_for(*, **), check_parameters:)
+    def ancestor_href?(...) = URI(href_for(...)) < URI(url_for(request.url))
+
+    def href_for(*parts, namespace: self.namespace, **params)
+      HrefBuilder.new(*parts, namespace:, template: self, **params).to_s
+    end
+
+    def view_url(view)
+      view = view.to_s
+      params = request.params.merge(view:)
+      params.delete(:view) if params[:view] == default_view
+      url_for(params)
+    end
+
+    def context(name = nil, &)
+      @context ||= []
+
+      if block_given?
+        @context << name
+        r = capture(&)
+        @context.pop
+        r
+      else
+        @context
+      end
+    end
+
+    def context?(*names)
+      context.reverse_each do |ctx|
+        return true if names.empty?
+        names.pop if ctx == names.last
+      end
+      names.empty?
+    end
+
+    def link(object)
+      @links         ||= {}
+      @links[object] ||= CafeCar[:LinkBuilder].new(self, object)
+    end
+
+    def link_to(...)
+      raise ArgumentError, "Links cannot be nested" if context?(:a)
+      context(:a) { super }
+    end
+
+    def icon(name = nil, *, **, &)
+      case name
+      when Symbol
+        class_ = name&.then { "iconoir-#{_1.to_s.dasherize}" }
+      when String, Array
+        label = name
+      end
+
+      ui.Icon(*label, *, tag: :i, class: class_, **, &)
+    end
+
+    def breadcrumbs(*items)
+      ui.Row safe_join(items.compact_blank, icon(:nav_arrow_right, :dim))
+    end
+
+    def filter_form_for(objects, **options, &block)
+      raise ArgumentError, "First argument to filter_form_for cannot be nil" if objects.nil?
+
+      form_for CafeCar[:FilterBuilder].new(objects, parsed_params),
+               builder: CafeCar["Filter::FormBuilder"],
+               method: :get,
+               url: "",
+               as: "",
+               **options,
+               &block
+    end
+
+    def table_for(objects, **options, &block)
+      CafeCar[:TableBuilder].new(self, objects:, **options, &block)
+    end
+
+    def debug?   = params.key?(:debug)
+    def console? = params.key?(:console)
+
+    def comment(text)
+      "<!-- #{text} -->".html_safe
+    end
+
+    def partial?(path)
+      prefixes = path.include?(?/) ? [] : lookup_context.prefixes
+      lookup_context.any?(path, prefixes, true)
+    end
+
+    def get_partial(path)
+      prefixes = path.include?(?/) ? [] : lookup_context.prefixes
+      lookup_context.find(path, prefixes, true)
+    end
+
+    def template_glob(glob)
+      lookup_context.view_paths
+        .flat_map { _1.send(:template_glob, glob) }
+        .map { ActionView::TemplatePath.parse(_1) }
+    end
+
+    def navigation
+      @navigation ||= CafeCar::Navigation.new(self)
+    end
+
+    def namespace
+      @namespace ||= controller_path.split("/").tap(&:pop).map(&:to_sym)
+    end
+
+    def method_missing(name, ...)
+      return ui.send(name, ...) if name =~ /^[A-Z]/
+      super
+    end
+  end
+end

data/lib/cafe_car/href_builder.rb

@@ -0,0 +1,97 @@
+module CafeCar
+  class HrefBuilder
+    attr_reader :parts, :namespace
+
+    def initialize(*parts, namespace: [], template: nil, **params)
+      @params    = params
+      @parts     = parts
+      @namespace = namespace
+      @template  = template
+      normalize!
+    end
+
+    def to_s
+      case [ *@parts ]
+      in [ String ]
+        [ *@parts, *@params.to_query.presence ].join(??)
+      in []
+        @template.url_for(@params)
+      else
+        namespace = collapsed_namespace
+        parts     = @parts.map { singular_resource(_1) }
+        begin
+          @template.url_for([ *namespace, *parts, @params ])
+        rescue NoMethodError
+          raise if namespace.empty?
+          namespace.pop
+          retry
+        end
+      end
+    end
+
+    def normalize!
+      @parts.flatten!
+      @params.with_defaults!(@parts.extract_options!)
+      @namespace = @namespace.underscore.split(?/).map(&:to_sym) if @namespace.is_a? String
+      @params.delete(:action) if @params[:action].in? %i[show destroy index]
+      self
+    end
+
+    def collapsed_namespace
+      0.upto(@namespace.size) do |i|
+        if parts_start_with? @namespace.drop(i)
+          return @namespace.slice(0, i)
+        end
+      end
+    end
+
+    def expanded_parts
+      @expanded_parts ||= @parts.flat_map { expand_part _1 }
+    end
+
+    private
+
+    # Records route polymorphically via the plural `route_key`. For a singular
+    # resource (`resource :session`) that helper doesn't exist, so fall back to
+    # the singular route key. Leaves non-records (symbols, strings) untouched.
+    def singular_resource(part)
+      name = model_name_for(part) or return part
+      return part if @template.respond_to?("#{name.route_key}_path")
+
+      @template.respond_to?("#{name.singular_route_key}_path") ?
+        name.singular_route_key.to_sym : part
+    end
+
+    def model_name_for(part)
+      klass = part.is_a?(Module) ? part : part.class
+      klass.model_name if klass.respond_to?(:model_name)
+    end
+
+    def expand_part(part)
+      normalize case part
+      when Symbol, String, Hash, Array then part
+      when ActiveModel::Naming then part.model_name.collection
+      when Class then part.name.underscore
+      else expand_part(part.class)
+      end
+    end
+
+    def normalize(part)
+      case part
+      when String
+        part.split(?/).map(&:to_sym)
+      else part
+      end
+    end
+
+    def parts_start_with?(prefix)
+      prefix.zip(expanded_parts).all? { _1 == _2 }
+    end
+  end
+end
+
+# def href(*parts, **params)
+#   params.merge! parts.extract_options!
+#   params.delete(:action) if %i[show destroy index].include? params[:action]
+#   url_for([*namespace, *parts, params])
+# end

data/lib/cafe_car/informable.rb

@@ -0,0 +1,9 @@
+module CafeCar
+  module Informable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def info = CafeCar[:ModelInfo].find(self)
+    end
+  end
+end

data/lib/cafe_car/input_builder.rb

@@ -0,0 +1,25 @@
+module CafeCar
+  class InputBuilder
+    attr_reader :form, :method, :as
+
+    delegate :object, :object_name, to: :form
+
+    def initialize(method:, form:, **options, &block)
+      @method  = method
+      @form    = form
+      @options = options
+      @block   = block
+    end
+
+    def type
+      @type ||=
+        object.type_for_attribute(@method)&.type ||
+          reflect_on(method)&.macro
+    end
+
+    def placeholder
+      I18n.t(method, scope: [ :helpers, :placeholder, object_name ], raise: true).presence
+    rescue I18n::MissingTranslationData => _
+    end
+  end
+end

data/lib/cafe_car/inputs/association_builder.rb

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