compony 0.11.12 → 0.11.14

data/spec/compony/intent_spec.rb

@@ -0,0 +1,94 @@
+RSpec.describe Compony::Intent do
+  let(:user) { User.create!(name: 'Alice') }
+  let(:admin) { User.create!(name: 'Root', admin: true) }
+
+  describe 'component resolution' do
+    it 'resolves from comp and family' do
+      expect(described_class.new(:show, :users).comp_class).to eq(Components::Users::Show)
+    end
+
+    it 'resolves from a model' do
+      expect(described_class.new(:show, user).comp_class).to eq(Components::Users::Show)
+    end
+
+    it 'accepts a component class directly' do
+      expect(described_class.new(Components::Users::Show).comp_class).to eq(Components::Users::Show)
+    end
+
+    it 'fails when neither component nor name/label are given' do
+      expect { described_class.new }.to raise_error(RuntimeError, /must be given the kwargs/)
+    end
+
+    it 'allows a component-less intent with name and label' do
+      intent = described_class.new(name: :external, label: 'External', path: 'https://example.com')
+      expect(intent.comp_class).to be_nil
+      expect(intent.name).to eq(:external)
+      expect(intent.label).to eq('External')
+      expect(intent.path).to eq('https://example.com')
+    end
+  end
+
+  describe '#model?' do
+    it 'is true for a record' do
+      expect(described_class.new(:show, user).model?).to be(true)
+    end
+
+    it 'is false for a family symbol' do
+      expect(described_class.new(:index, :users).model?).to be(false)
+    end
+  end
+
+  describe '#path' do
+    it 'builds the path from the model' do
+      expect(described_class.new(:show, user).path).to eq("/users/show/#{user.id}")
+    end
+
+    it 'prefers an explicitly given path string' do
+      expect(described_class.new(:show, user, path: '/custom').path).to eq('/custom')
+    end
+  end
+
+  describe '#name' do
+    it 'joins comp and family name' do
+      expect(described_class.new(:show, :users).name).to eq(:show_users)
+    end
+  end
+
+  describe '#method' do
+    it 'defaults to :get' do
+      expect(described_class.new(:show, user).method).to eq(:get)
+    end
+
+    it 'can be overridden' do
+      expect(described_class.new(:destroy, user, method: :delete).method).to eq(:delete)
+    end
+  end
+
+  describe 'feasibility' do
+    it 'is feasible for allowed actions' do
+      expect(described_class.new(:destroy, user).feasible?).to be(true)
+    end
+
+    it 'is infeasible when the model prevents the action' do
+      expect(described_class.new(:destroy, admin).feasible?).to be(false)
+    end
+
+    it 'is feasible when no model is involved' do
+      expect(described_class.new(:index, :users).feasible?).to be(true)
+    end
+
+    it 'disables the button when infeasible' do
+      opts = described_class.new(:destroy, admin).button_comp_opts
+      expect(opts[:href]).to be_nil
+      expect(opts[:class]).to eq('disabled')
+      expect(opts[:title]).to eq('Cannot destroy admins.')
+    end
+
+    it 'enables the button when feasible' do
+      opts = described_class.new(:destroy, user).button_comp_opts
+      expect(opts[:href]).to be_present
+      expect(opts[:class]).to be_nil
+      expect(opts[:title]).to be_nil
+    end
+  end
+end

data/spec/compony/method_accessible_hash_spec.rb

@@ -0,0 +1,32 @@
+RSpec.describe Compony::MethodAccessibleHash do
+  it 'symbolizes keys given in the constructor' do
+    hash = described_class.new('foo' => 1, bar: 2)
+    expect(hash[:foo]).to eq(1)
+    expect(hash[:bar]).to eq(2)
+  end
+
+  it 'provides read access via methods' do
+    hash = described_class.new(foo: :bar)
+    expect(hash.foo).to eq(:bar)
+  end
+
+  it 'returns nil for missing keys' do
+    expect(described_class.new.anything).to be_nil
+  end
+
+  it 'provides write access via methods' do
+    hash = described_class.new
+    hash.foo = 42
+    expect(hash[:foo]).to eq(42)
+  end
+
+  it 'responds to any method' do
+    expect(described_class.new).to respond_to(:whatever)
+  end
+
+  it 'symbolizes keys on merge' do
+    merged = described_class.new(foo: 1).merge('bar' => 2)
+    expect(merged[:bar]).to eq(2)
+    expect(merged['bar']).to be_nil
+  end
+end

data/spec/compony/model_fields_spec.rb

@@ -0,0 +1,70 @@
+RSpec.describe 'Compony::ModelFields' do
+  let(:user) do
+    User.create!(name: 'Alice', age: 30, comment: 'Hi', email: 'alice@example.com', admin: true, born_on: Date.new(1990, 5, 6))
+  end
+
+  let(:controller) do
+    ApplicationController.new.tap { |controller| controller.set_request!(ActionDispatch::Request.new({})) }
+  end
+
+  describe 'value_for' do
+    it 'returns the raw value for string fields' do
+      expect(User.fields[:name].value_for(user)).to eq('Alice')
+    end
+
+    it 'formats booleans via I18n' do
+      value = User.fields[:admin].value_for(user)
+      expect(value).to be_present
+      expect(value).not_to eq(true) # must be a human-readable representation, not the raw boolean
+    end
+
+    it 'localizes dates' do
+      expect(User.fields[:born_on].value_for(user)).to eq(I18n.l(Date.new(1990, 5, 6)))
+    end
+
+    it 'renders emails as mailto links when given a controller' do
+      controller = ApplicationController.new
+      controller.set_request!(ActionDispatch::Request.new({}))
+      value = User.fields[:email].value_for(user, controller:)
+      expect(value).to include('mailto:alice@example.com')
+    end
+
+    it 'fails for emails without controller' do
+      expect { User.fields[:email].value_for(user) }.to raise_error(RuntimeError, /Must pass controller/)
+    end
+
+    it 'formats percentages' do
+      user.update!(margin_relative: 0.5)
+      expect(User.fields[:margin_relative].value_for(user, controller:)).to eq('50.0%')
+    end
+
+    it 'returns nil-safe values for blank fields' do
+      empty = User.create!(name: 'Bob')
+      expect(User.fields[:born_on].value_for(empty)).to be_blank
+      expect(User.fields[:email].value_for(empty, controller: ApplicationController.new)).to be_blank
+    end
+
+    # A field may legitimately hold no value, e.g. a percentage that relates to zero. Formatting such a value must not
+    # raise, no matter which type the field has.
+    it 'returns nil for every field type of a record that has no values' do
+      empty = User.create!(name: 'Bob')
+      User.fields.each_value do |field|
+        next unless empty.send(field.name).nil? # e.g. name is given and admin defaults to false
+        expect { field.value_for(empty, controller:) }.not_to raise_error, "field #{field.name} raised"
+        expect(field.value_for(empty, controller:)).to be_blank, "field #{field.name} did not answer with a blank value"
+      end
+    end
+  end
+
+  describe 'label' do
+    it 'uses human_attribute_name' do
+      expect(User.fields[:name].label).to eq(User.human_attribute_name(:name))
+    end
+  end
+
+  describe 'schema_line' do
+    it 'returns a proc for schemacop integration' do
+      expect(User.fields[:name].schema_line).to be_a(Proc)
+    end
+  end
+end

data/spec/compony/model_mixin_spec.rb

@@ -0,0 +1,109 @@
+RSpec.describe Compony::ModelMixin do
+  describe '.field' do
+    it 'registers fields with the correct types' do
+      expect(User.fields[:name]).to be_a(Compony::ModelFields::String)
+      expect(User.fields[:age]).to be_a(Compony::ModelFields::Integer)
+      expect(User.fields[:comment]).to be_a(Compony::ModelFields::Text)
+      expect(User.fields[:email]).to be_a(Compony::ModelFields::Email)
+      expect(User.fields[:admin]).to be_a(Compony::ModelFields::Boolean)
+      expect(User.fields[:born_on]).to be_a(Compony::ModelFields::Date)
+      expect(User.fields[:created_at]).to be_a(Compony::ModelFields::Datetime)
+    end
+
+    it 'keeps the field name and model class' do
+      field = User.fields[:name]
+      expect(field.name).to eq(:name)
+      expect(field.model_class).to eq(User)
+    end
+
+    it 'rebinds fields to the subclass on inheritance' do
+      subclass = Class.new(User)
+      expect(subclass.fields[:name].model_class).to eq(subclass)
+      expect(User.fields[:name].model_class).to eq(User) # parent untouched
+    end
+
+    it 'does not leak fields defined on a subclass into the parent' do
+      subclass = Class.new(User) do
+        def self.name = 'SpecialUser'
+        field :extra, :string
+      end
+      expect(subclass.fields).to have_key(:extra)
+      expect(User.fields).not_to have_key(:extra)
+    end
+
+    context 'with multilang: true' do
+      around do |example|
+        original_available_locales = I18n.available_locales
+        I18n.available_locales = %i[en de de-CH fr es]
+        example.run
+      ensure
+        I18n.available_locales = original_available_locales
+        Compony.content_locales = nil
+      end
+
+      def multilang_model
+        Class.new(User) do
+          def self.name = 'MultilangUser'
+          field :label, :string, multilang: true
+        end
+      end
+
+      it 'generates a virtual field plus one suffixed field per available locale by default' do
+        expect(multilang_model.fields.keys - User.fields.keys).to eq(%i[label label_en label_de label_de-CH label_fr label_es])
+        expect(multilang_model.fields[:label].extra_attrs).to eq(virtual: true)
+      end
+
+      it 'generates one suffixed field per content locale when configured' do
+        Compony.content_locales = %i[de en fr es]
+        expect(multilang_model.fields.keys - User.fields.keys).to eq(%i[label label_de label_en label_fr label_es])
+      end
+    end
+  end
+
+  describe 'feasibility' do
+    it 'is feasible when no prevention triggers' do
+      user = User.create!(name: 'Alice', admin: false)
+      expect(user.feasible?(:destroy)).to be(true)
+      expect(user.feasibility_messages(:destroy)).to eq([])
+      expect(user.full_feasibility_messages(:destroy)).to eq('')
+    end
+
+    it 'is infeasible when a prevention triggers' do
+      admin = User.create!(name: 'Root', admin: true)
+      expect(admin.feasible?(:destroy)).to be(false)
+      expect(admin.feasibility_messages(:destroy)).to eq(['Cannot destroy admins'])
+      expect(admin.full_feasibility_messages(:destroy)).to eq('Cannot destroy admins.')
+    end
+
+    it 'caches the result until recompute is requested' do
+      user = User.create!(name: 'Alice', admin: false)
+      expect(user.feasible?(:destroy)).to be(true)
+      user.admin = true
+      expect(user.feasible?(:destroy)).to be(true) # cached
+      expect(user.feasible?(:destroy, recompute: true)).to be(false)
+    end
+
+    it 'returns true for unknown actions' do
+      user = User.create!(name: 'Alice')
+      expect(user.feasible?(:frobnicate)).to be(true)
+    end
+  end
+
+  describe '.owned_by' do
+    it 'stores the owner attribute' do
+      klass = Class.new(User) do
+        def self.name = 'OwnedUser'
+        owned_by :parent
+      end
+      expect(klass.owner_model_attr).to eq(:parent)
+      expect(User.owner_model_attr).to be_nil
+    end
+  end
+
+  describe '#field' do
+    it 'returns the formatted value for a field' do
+      user = User.create!(name: 'Alice', age: 30)
+      expect(user.field(:name, nil)).to eq('Alice')
+    end
+  end
+end

data/spec/compony/natural_ordering_spec.rb

@@ -0,0 +1,61 @@
+RSpec.describe Compony::NaturalOrdering do
+  subject(:collection) { described_class.new }
+
+  it 'appends elements in order' do
+    collection.natural_push(:a, 1)
+    collection.natural_push(:b, 2)
+    expect(collection.map(&:name)).to eq(%i[a b])
+    expect(collection.map(&:payload)).to eq([1, 2])
+  end
+
+  it 'inserts before a given element' do
+    collection.natural_push(:a, 1)
+    collection.natural_push(:c, 3)
+    collection.natural_push(:b, 2, before: :c)
+    expect(collection.map(&:name)).to eq(%i[a b c])
+  end
+
+  it 'overwrites an existing element in place' do
+    collection.natural_push(:a, 1)
+    collection.natural_push(:b, 2)
+    collection.natural_push(:a, 99)
+    expect(collection.map(&:name)).to eq(%i[a b])
+    expect(collection.first.payload).to eq(99)
+  end
+
+  it 'keeps old kwargs when overwriting without specifying them' do
+    collection.natural_push(:a, 1, hidden: true)
+    collection.natural_push(:a, 2)
+    expect(collection.first.hidden).to be(true)
+    expect(collection.first.payload).to eq(2)
+  end
+
+  it 'allows omitting the payload when overwriting' do
+    collection.natural_push(:a, 1)
+    collection.natural_push(:a, hidden: true)
+    expect(collection.first.payload).to eq(1)
+    expect(collection.first.hidden).to be(true)
+  end
+
+  it 'moves an existing element when overwriting with before:' do
+    collection.natural_push(:a, 1)
+    collection.natural_push(:b, 2)
+    collection.natural_push(:c, 3)
+    collection.natural_push(:c, 3, before: :a)
+    expect(collection.map(&:name)).to eq(%i[c a b])
+  end
+
+  it 'fails when inserting a new element without payload' do
+    expect { collection.natural_push(:a) }.to raise_error(RuntimeError, /without a payload/)
+  end
+
+  it 'fails when before: refers to a missing element' do
+    collection.natural_push(:a, 1)
+    expect { collection.natural_push(:b, 2, before: :nope) }.to raise_error(RuntimeError, /not found/)
+  end
+
+  it 'stores extra kwargs on the element' do
+    collection.natural_push(:a, 1, hidden: true)
+    expect(collection.select(&:hidden).map(&:name)).to eq([:a])
+  end
+end

data/spec/dummy/app/components/statics/home.rb

@@ -0,0 +1,17 @@
+class Components::Statics::Home < Compony::Component
+  setup do
+    label(:all) { 'Home' }
+
+    standalone path: 'home' do
+      skip_authentication!
+      verb :get do
+        authorize { true }
+      end
+    end
+
+    content do
+      h1 'Welcome home'
+      para 'This is a plain component.'
+    end
+  end
+end

data/spec/dummy/app/components/statics/secret.rb

@@ -0,0 +1,15 @@
+class Components::Statics::Secret < Compony::Component
+  setup do
+    label(:all) { 'Secret' }
+
+    standalone path: 'secret' do
+      verb :get do
+        authorize { false }
+      end
+    end
+
+    content do
+      h1 'You should never see this'
+    end
+  end
+end

data/spec/dummy/app/components/users/destroy.rb

@@ -0,0 +1,2 @@
+class Components::Users::Destroy < Compony::Components::Destroy
+end

data/spec/dummy/app/components/users/edit.rb

@@ -0,0 +1,2 @@
+class Components::Users::Edit < Compony::Components::Edit
+end

data/spec/dummy/app/components/users/form.rb

@@ -0,0 +1,14 @@
+class Components::Users::Form < Compony::Components::Form
+  setup do
+    form_fields do
+      concat field(:name)
+      concat field(:age)
+      concat field(:comment)
+      concat field(:email)
+      concat field(:admin)
+      concat field(:born_on)
+    end
+
+    schema_fields :name, :age, :comment, :email, :admin, :born_on
+  end
+end

data/spec/dummy/app/components/users/index.rb

@@ -0,0 +1,29 @@
+class Components::Users::Index < Compony::Component
+  include Compony::ComponentMixins::Resourceful
+
+  setup do
+    label(:all) { 'Users' }
+    standalone path: 'users' do
+      verb :get do
+        authorize { true }
+      end
+    end
+
+    load_data { @data = User.order(:id) }
+
+    content do
+      h4 'Users:'
+      concat render_intent(:new, :users)
+      div class: 'users' do
+        @data.each do |user|
+          div class: 'user' do
+            span user.name
+            concat render_intent(:show, user, button: { label: { format: :short } })
+            concat render_intent(:edit, user, button: { label: { format: :short } })
+            concat render_intent(:destroy, user, button: { label: { format: :short } })
+          end
+        end
+      end
+    end
+  end
+end

data/spec/dummy/app/components/users/new.rb

@@ -0,0 +1,2 @@
+class Components::Users::New < Compony::Components::New
+end

data/spec/dummy/app/components/users/show.rb

@@ -0,0 +1,26 @@
+class Components::Users::Show < Compony::Component
+  include Compony::ComponentMixins::Resourceful
+
+  setup do
+    label(:short) { |_u| 'Show' }
+    label(:long) { |u| "Show user #{u.label}" }
+
+    standalone path: 'users/show/:id' do
+      verb :get do
+        authorize { true }
+      end
+    end
+
+    content do
+      h3 @data.label
+      table do
+        tr do
+          @data.fields.each_value { |field| th field.label }
+        end
+        tr do
+          @data.fields.each_value { |field| td field.value_for(@data, controller:) }
+        end
+      end
+    end
+  end
+end

data/spec/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,3 @@
+class ApplicationController < ActionController::Base
+  attr_accessor :current_user
+end

data/spec/dummy/app/models/ability.rb

@@ -0,0 +1,7 @@
+class Ability
+  include CanCan::Ability
+
+  def initialize(_user)
+    can :manage, :all
+  end
+end

data/spec/dummy/app/models/application_record.rb

@@ -0,0 +1,4 @@
+class ApplicationRecord < ActiveRecord::Base
+  primary_abstract_class
+  include Compony::ModelMixin
+end

data/spec/dummy/app/models/user.rb

@@ -0,0 +1,22 @@
+class User < ApplicationRecord
+  field :name, :string
+  field :age, :integer
+  field :comment, :text
+  field :email, :email
+  field :admin, :boolean
+  field :born_on, :date
+  field :margin_relative, :percentage
+  field :salary, :currency
+  field :homepage, :url
+  field :created_at, :datetime
+
+  validates :name, presence: true
+
+  prevent :destroy, 'Cannot destroy admins' do
+    admin?
+  end
+
+  def label
+    name
+  end
+end

data/spec/dummy/app/views/layouts/application.html.erb

@@ -0,0 +1,7 @@
+<!DOCTYPE html>
+<html>
+  <head><title>Dummy</title></head>
+  <body data-layout="application">
+    <%= yield %>
+  </body>
+</html>

data/spec/dummy/config/application.rb

@@ -0,0 +1,20 @@
+require 'rails'
+require 'active_record/railtie'
+require 'action_controller/railtie'
+require 'action_view/railtie'
+
+require 'compony'
+
+module Dummy
+  class Application < Rails::Application
+    config.root = File.expand_path('..', __dir__)
+    config.load_defaults Rails::VERSION::STRING.to_f
+    config.eager_load = false
+    config.hosts.clear
+    config.secret_key_base = 'dummy-secret-key-base-for-tests-only'
+    config.logger = Logger.new(nil)
+    config.active_support.deprecation = :stderr
+    config.action_dispatch.show_exceptions = :none
+    config.action_controller.allow_forgery_protection = false
+  end
+end

data/spec/dummy/config/database.yml

@@ -0,0 +1,3 @@
+test:
+  adapter: sqlite3
+  database: ':memory:'

data/spec/dummy/config/environment.rb

@@ -0,0 +1,3 @@
+require_relative 'application'
+
+Rails.application.initialize!

data/spec/dummy/config/initializers/simple_form.rb

@@ -0,0 +1,9 @@
+SimpleForm.setup do |config|
+  config.wrappers :default, class: :input do |b|
+    b.use :html5
+    b.use :label_input
+    b.use :error, wrap_with: { tag: :span, class: :error }
+  end
+  config.default_wrapper = :default
+  config.button_class = 'btn'
+end

data/spec/dummy/config/routes.rb

@@ -0,0 +1,3 @@
+# Compony draws its routes via the gem's own config/routes.rb (loaded by the engine).
+Rails.application.routes.draw do # rubocop:disable Lint/EmptyBlock
+end

data/spec/dummy/db/schema.rb

@@ -0,0 +1,14 @@
+ActiveRecord::Schema.define do
+  create_table :users, force: true do |t|
+    t.string :name
+    t.integer :age
+    t.text :comment
+    t.string :email
+    t.boolean :admin, default: false, null: false
+    t.date :born_on
+    t.decimal :margin_relative
+    t.decimal :salary
+    t.string :homepage
+    t.timestamps
+  end
+end

data/spec/rails_helper.rb

@@ -0,0 +1,23 @@
+ENV['RAILS_ENV'] = 'test'
+
+require_relative 'dummy/config/environment'
+require 'rspec/rails'
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+load File.expand_path('dummy/db/schema.rb', __dir__)
+
+RSpec.configure do |config|
+  config.use_transactional_fixtures = true
+  config.infer_spec_type_from_file_location!
+
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.order = :random
+  Kernel.srand config.seed
+end

data/spec/requests/authorization_spec.rb

@@ -0,0 +1,16 @@
+RSpec.describe 'Authorization', type: :request do
+  it 'denies access when the authorize block returns false' do
+    expect { get '/secret' }.to raise_error(CanCan::AccessDenied)
+  end
+
+  it 'grants access when the authorize block returns true' do
+    get '/home'
+    expect(response).to have_http_status(:ok)
+  end
+
+  it 'hides buttons pointing to unauthorized components' do
+    comp = Components::Statics::Secret.new
+    controller = ApplicationController.new
+    expect(comp.standalone_access_permitted_for?(controller, verb: :get)).to be(false)
+  end
+end

data/spec/requests/plain_component_spec.rb

@@ -0,0 +1,9 @@
+RSpec.describe 'Plain standalone component', type: :request do
+  it 'renders content within the application layout' do
+    get '/home'
+    expect(response).to have_http_status(:ok)
+    expect(response.body).to include('data-layout="application"')
+    expect(response.body).to include('<h1>Welcome home</h1>')
+    expect(response.body).to include('<p>This is a plain component.</p>')
+  end
+end

data/spec/requests/routing_spec.rb

@@ -0,0 +1,20 @@
+RSpec.describe 'Compony routing', type: :request do
+  it 'generates a route per standalone component' do
+    routes = Rails.application.routes.routes.map { |r| r.path.spec.to_s }
+    expect(routes).to include('/users(.:format)')
+    expect(routes).to include('/users/show/:id(.:format)')
+    expect(routes).to include('/home(.:format)')
+  end
+
+  it 'creates named path helpers' do
+    expect(Rails.application.routes.url_helpers.index_users_comp_path).to eq('/users')
+  rescue NoMethodError
+    # Fallback: assert helper name from standalone config
+    helper = Components::Users::Index.new.standalone_configs.values.first.path_helper_name
+    expect(Rails.application.routes.url_helpers.send(:"#{helper}_path")).to eq('/users')
+  end
+
+  it 'routes only the configured verbs' do
+    expect { post '/users/show/1' }.to raise_error(ActionController::RoutingError)
+  end
+end