blanks 1.0.0

data/spec/blanks/id_tracking_spec.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "ID tracking in nested forms" do
+  describe "AssociationProxy#find_by_id" do
+    it "finds form by id" do
+      form_class = Class.new(Blanks::Base) do
+        attribute :id, :integer
+        attribute :url, :string
+      end
+      stub_const("ImageForm", form_class)
+
+      proxy = Blanks::AssociationProxy.new("ImageForm")
+      image = proxy.new(id: 123, url: "test.jpg")
+
+      expect(proxy.find_by_id(123)).to eq(image)
+    end
+
+    it "returns nil when id not found" do
+      form_class = Class.new(Blanks::Base) do
+        attribute :id, :integer
+        attribute :url, :string
+      end
+      stub_const("ImageForm", form_class)
+
+      proxy = Blanks::AssociationProxy.new("ImageForm")
+
+      expect(proxy.find_by_id(999)).to be_nil
+    end
+
+    it "handles string and integer ids" do
+      form_class = Class.new(Blanks::Base) do
+        attribute :id, :integer
+        attribute :url, :string
+      end
+      stub_const("ImageForm", form_class)
+
+      proxy = Blanks::AssociationProxy.new("ImageForm")
+      image = proxy.new(id: 123, url: "test.jpg")
+
+      expect(proxy.find_by_id("123")).to eq(image)
+    end
+  end
+
+  describe "updating existing nested forms by id" do
+    it "updates existing form when id matches" do
+      image_form_class = Class.new(Blanks::Base) do
+        attribute :id, :integer
+        attribute :url, :string
+      end
+      stub_const("ImageForm", image_form_class)
+
+      form_class = Class.new(Blanks::Base) do
+        has_many :images
+        attribute :title, :string
+      end
+
+      form = form_class.new(title: "test")
+      form.images.new(id: 1, url: "original.jpg")
+      form.images.new(id: 2, url: "another.jpg")
+
+      form.images_attributes = [
+        { id: 1, url: "updated.jpg" }
+      ]
+
+      expect(form.images[0].url).to eq("updated.jpg")
+    end
+
+    it "creates new form when id not found" do
+      image_form_class = Class.new(Blanks::Base) do
+        attribute :id, :integer
+        attribute :url, :string
+      end
+      stub_const("ImageForm", image_form_class)
+
+      form_class = Class.new(Blanks::Base) do
+        has_many :images
+        attribute :title, :string
+      end
+
+      form = form_class.new(title: "test")
+      form.images.new(id: 1, url: "original.jpg")
+
+      form.images_attributes = [
+        { id: 999, url: "new.jpg" }
+      ]
+
+      expect(form.images.count).to eq(2)
+    end
+
+    it "creates new form when no id provided" do
+      image_form_class = Class.new(Blanks::Base) do
+        attribute :id, :integer
+        attribute :url, :string
+      end
+      stub_const("ImageForm", image_form_class)
+
+      form_class = Class.new(Blanks::Base) do
+        has_many :images
+        attribute :title, :string
+      end
+
+      form = form_class.new(title: "test")
+      form.images.new(id: 1, url: "original.jpg")
+
+      form.images_attributes = [
+        { url: "new.jpg" }
+      ]
+
+      expect(form.images.count).to eq(2)
+    end
+
+    it "preserves unchanged forms" do
+      image_form_class = Class.new(Blanks::Base) do
+        attribute :id, :integer
+        attribute :url, :string
+      end
+      stub_const("ImageForm", image_form_class)
+
+      form_class = Class.new(Blanks::Base) do
+        has_many :images
+        attribute :title, :string
+      end
+
+      form = form_class.new(title: "test")
+      form.images.new(id: 1, url: "first.jpg")
+      form.images.new(id: 2, url: "second.jpg")
+
+      form.images_attributes = [
+        { id: 1, url: "updated.jpg" }
+      ]
+
+      expect(form.images.count).to eq(2)
+      expect(form.images[0].url).to eq("updated.jpg")
+      expect(form.images[1].url).to eq("second.jpg")
+    end
+
+    it "works with from_model then update" do
+      model_image1 = Struct.new(:id, :url).new(1, "model1.jpg")
+      model_image2 = Struct.new(:id, :url).new(2, "model2.jpg")
+      model = Struct.new(:title, :images).new("test", [model_image1, model_image2])
+
+      image_form_class = Class.new(Blanks::Base) do
+        attribute :id, :integer
+        attribute :url, :string
+      end
+      stub_const("ImageForm", image_form_class)
+
+      form_class = Class.new(Blanks::Base) do
+        has_many :images
+        attribute :title, :string
+      end
+
+      form = form_class.from_model(model)
+
+      form.images_attributes = [
+        { id: 1, url: "updated1.jpg" },
+        { url: "new.jpg" }
+      ]
+
+      expect(form.images.count).to eq(3)
+      expect(form.images[0].url).to eq("updated1.jpg")
+      expect(form.images[1].url).to eq("model2.jpg")
+      expect(form.images[2].url).to eq("new.jpg")
+    end
+  end
+end

data/spec/blanks/inherit_attributes_from_spec.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Blanks::Base.inherit_attributes_from" do
+  before(:all) do
+    @model_class = Class.new do
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+
+      attribute :id, :integer
+      attribute :title, :string
+      attribute :content, :string
+      attribute :published_at, :datetime
+      attribute :view_count, :integer
+      attribute :created_at, :datetime
+      attribute :updated_at, :datetime
+
+      def self.name
+        "Post"
+      end
+    end
+  end
+
+  describe "with no options" do
+    it "inherits all attributes from model class" do
+      model_class = @model_class
+      form_class = Class.new(Blanks::Base) do
+        inherit_attributes_from model_class
+      end
+
+      expect(form_class.attribute_names).to include("id", "title", "content", "published_at", "view_count", "created_at", "updated_at")
+    end
+
+    it "preserves attribute types from model class" do
+      model_class = @model_class
+      form_class = Class.new(Blanks::Base) do
+        inherit_attributes_from model_class
+      end
+
+      form = form_class.new(title: "test", view_count: "42")
+
+      expect(form.title).to eq("test")
+      expect(form.view_count).to eq(42)
+    end
+  end
+
+  describe "with only: option" do
+    it "inherits only specified attributes" do
+      model_class = @model_class
+      form_class = Class.new(Blanks::Base) do
+        inherit_attributes_from model_class, only: [:title, :content]
+      end
+
+      expect(form_class.attribute_names).to include("title", "content")
+      expect(form_class.attribute_names).not_to include("id", "created_at", "updated_at")
+    end
+
+    it "works with single attribute" do
+      model_class = @model_class
+      form_class = Class.new(Blanks::Base) do
+        inherit_attributes_from model_class, only: :title
+      end
+
+      expect(form_class.attribute_names).to eq(["title"])
+    end
+  end
+
+  describe "with except: option" do
+    it "inherits all attributes except specified ones" do
+      model_class = @model_class
+      form_class = Class.new(Blanks::Base) do
+        inherit_attributes_from model_class, except: [:created_at, :updated_at]
+      end
+
+      expect(form_class.attribute_names).to include("id", "title", "content", "published_at", "view_count")
+      expect(form_class.attribute_names).not_to include("created_at", "updated_at")
+    end
+
+    it "works with single attribute" do
+      model_class = @model_class
+      form_class = Class.new(Blanks::Base) do
+        inherit_attributes_from model_class, except: :id
+      end
+
+      expect(form_class.attribute_names).to include("title", "content")
+      expect(form_class.attribute_names).not_to include("id")
+    end
+  end
+
+  describe "validation" do
+    it "raises error when both only and except are specified" do
+      model_class = @model_class
+      expect {
+        Class.new(Blanks::Base) do
+          inherit_attributes_from model_class, only: [:title], except: [:id]
+        end
+      }.to raise_error(ArgumentError, "cannot specify both :only and :except")
+    end
+
+    it "raises error when model class does not respond to attribute_types or columns" do
+      invalid_class = Class.new
+
+      expect {
+        Class.new(Blanks::Base) do
+          inherit_attributes_from invalid_class
+        end
+      }.to raise_error(ArgumentError, /does not respond to :attribute_types or :columns/)
+    end
+  end
+
+  describe "integration with existing attributes" do
+    it "does not override existing attribute definitions" do
+      model_class = @model_class
+      form_class = Class.new(Blanks::Base) do
+        attribute :title, :integer
+        inherit_attributes_from model_class, only: [:title, :content]
+      end
+
+      expect(form_class.attribute_types["title"].type).to eq(:integer)
+    end
+
+    it "adds new attributes alongside existing ones" do
+      model_class = @model_class
+      form_class = Class.new(Blanks::Base) do
+        attribute :custom_field, :string
+        inherit_attributes_from model_class, only: [:title, :content]
+      end
+
+      expect(form_class.attribute_names).to include("custom_field", "title", "content")
+    end
+  end
+
+  describe "integration with from_model" do
+    it "loads values from model for inherited attributes" do
+      model_class = @model_class
+      form_class = Class.new(Blanks::Base) do
+        inherit_attributes_from model_class, only: [:title, :content]
+      end
+
+      model = model_class.new(title: "Test Post", content: "Test Content")
+      form = form_class.from_model(model)
+
+      expect(form.title).to eq("Test Post")
+      expect(form.content).to eq("Test Content")
+    end
+  end
+end

data/spec/blanks/inherit_validations_from_spec.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Blanks::Base.inherit_validations_from" do
+  before(:all) do
+    @model_class = Class.new do
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+      include ActiveModel::Validations
+
+      attribute :id, :integer
+      attribute :title, :string
+      attribute :content, :string
+      attribute :email, :string
+
+      validates :title, presence: true
+      validates :content, presence: true, length: { minimum: 10 }
+      validates :email, format: { with: /\A[^@\s]+@[^@\s]+\z/ }
+
+      def self.name
+        "Post"
+      end
+    end
+
+    @model_with_conditionals = Class.new do
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+      include ActiveModel::Validations
+
+      attribute :title, :string
+      attribute :content, :string
+      attribute :status, :string
+
+      validates :title, presence: true
+      validates :content, presence: true, if: -> { status == "published" }
+      validates :status, presence: true, if: :published?
+
+      def published?
+        status == "published"
+      end
+
+      def self.name
+        "ConditionalPost"
+      end
+    end
+  end
+
+  describe "with no options" do
+    it "inherits all validators from model class" do
+      model_class = @model_class
+      form_class = Class.new(Blanks::Base) do
+        model_name_for :test
+        attribute :title, :string
+        attribute :content, :string
+        attribute :email, :string
+        inherit_validations_from model_class
+      end
+
+      form = form_class.new
+      form.valid?
+
+      expect(form.errors[:title]).to include("can't be blank")
+      expect(form.errors[:content]).to include("can't be blank")
+    end
+
+    it "preserves validator options" do
+      model_class = @model_class
+      form_class = Class.new(Blanks::Base) do
+        model_name_for :test
+        attribute :title, :string
+        attribute :content, :string
+        inherit_validations_from model_class, only: [:content]
+      end
+
+      form = form_class.new(content: "short")
+      form.valid?
+
+      expect(form.errors[:content]).to include("is too short (minimum is 10 characters)")
+    end
+
+    it "inherits format validators" do
+      model_class = @model_class
+      form_class = Class.new(Blanks::Base) do
+        model_name_for :test
+        attribute :email, :string
+        inherit_validations_from model_class, only: [:email]
+      end
+
+      form = form_class.new(email: "invalid")
+      form.valid?
+
+      expect(form.errors[:email]).to include("is invalid")
+    end
+  end
+
+  describe "with only: option" do
+    it "inherits only specified validators" do
+      model_class = @model_class
+      form_class = Class.new(Blanks::Base) do
+        model_name_for :test
+        attribute :title, :string
+        attribute :content, :string
+        inherit_validations_from model_class, only: [:title]
+      end
+
+      form = form_class.new
+      form.valid?
+
+      expect(form.errors[:title]).to include("can't be blank")
+      expect(form.errors[:content]).to be_empty
+    end
+
+    it "works with single attribute" do
+      model_class = @model_class
+      form_class = Class.new(Blanks::Base) do
+        model_name_for :test
+        attribute :title, :string
+        inherit_validations_from model_class, only: :title
+      end
+
+      form = form_class.new
+      form.valid?
+
+      expect(form.errors[:title]).to include("can't be blank")
+    end
+  end
+
+  describe "with except: option" do
+    it "inherits all validators except specified ones" do
+      model_class = @model_class
+      form_class = Class.new(Blanks::Base) do
+        model_name_for :test
+        attribute :title, :string
+        attribute :content, :string
+        attribute :email, :string
+        inherit_validations_from model_class, except: [:content, :email]
+      end
+
+      form = form_class.new
+      form.valid?
+
+      expect(form.errors[:title]).to include("can't be blank")
+      expect(form.errors[:content]).to be_empty
+      expect(form.errors[:email]).to be_empty
+    end
+
+    it "works with single attribute" do
+      model_class = @model_class
+      form_class = Class.new(Blanks::Base) do
+        model_name_for :test
+        attribute :title, :string
+        attribute :content, :string
+        inherit_validations_from model_class, except: [:content, :email]
+      end
+
+      form = form_class.new
+      form.valid?
+
+      expect(form.errors[:title]).to include("can't be blank")
+      expect(form.errors[:content]).to be_empty
+    end
+  end
+
+  describe "validation" do
+    it "raises error when both only and except are specified" do
+      model_class = @model_class
+      expect {
+        Class.new(Blanks::Base) do
+          inherit_validations_from model_class, only: [:title], except: [:content]
+        end
+      }.to raise_error(ArgumentError, "cannot specify both :only and :except")
+    end
+  end
+
+  describe "skipping unsafe validators" do
+    it "skips validators with proc conditionals" do
+      model_class = @model_with_conditionals
+      form_class = Class.new(Blanks::Base) do
+        model_name_for :test
+        attribute :title, :string
+        attribute :content, :string
+        attribute :status, :string
+        inherit_validations_from model_class
+      end
+
+      validators = form_class.validators.map { |v| [v.attributes, v.kind] }
+
+      expect(validators).to include([[:title], :presence])
+      expect(validators).to include([[:status], :presence])
+      expect(validators).not_to include([[:content], :presence])
+    end
+
+    it "inherits validators with symbol conditionals" do
+      model_class = @model_with_conditionals
+      form_class = Class.new(Blanks::Base) do
+        model_name_for :test
+        attribute :status, :string
+        inherit_validations_from model_class, only: [:status]
+
+        def published?
+          status == "published"
+        end
+      end
+
+      form = form_class.new(status: nil)
+      form.valid?
+      expect(form.errors[:status]).to be_empty
+
+      form_published = form_class.new(status: "published")
+      form_published.instance_variable_set(:@status, nil)
+      form_published.valid?
+    end
+  end
+
+  describe "integration with inherit_attributes_from" do
+    it "works with inherited attributes" do
+      model_class = @model_class
+      form_class = Class.new(Blanks::Base) do
+        model_name_for :test
+        inherit_attributes_from model_class, only: [:title, :content]
+        inherit_validations_from model_class, only: [:title]
+      end
+
+      form = form_class.new
+      form.valid?
+
+      expect(form.errors[:title]).to include("can't be blank")
+      expect(form.errors[:content]).to be_empty
+    end
+  end
+
+  describe "multiple calls" do
+    it "accumulates validators from multiple sources" do
+      model_class = @model_class
+      other_model = Class.new do
+        include ActiveModel::Model
+        include ActiveModel::Attributes
+        include ActiveModel::Validations
+
+        attribute :author, :string
+        validates :author, presence: true
+      end
+
+      form_class = Class.new(Blanks::Base) do
+        model_name_for :test
+        attribute :title, :string
+        attribute :author, :string
+        inherit_validations_from model_class, only: [:title]
+        inherit_validations_from other_model, only: [:author]
+      end
+
+      form = form_class.new
+      form.valid?
+
+      expect(form.errors[:title]).to include("can't be blank")
+      expect(form.errors[:author]).to include("can't be blank")
+    end
+  end
+end

data/spec/blanks/model_naming_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Blanks::ModelNaming do
+  describe ".model_name" do
+    it "strips Form suffix from class name" do
+      form_class = Class.new(Blanks::Base)
+      stub_const("PostForm", form_class)
+
+      expect(PostForm.model_name.name).to eq("Post")
+    end
+
+    it "generates correct param_key" do
+      form_class = Class.new(Blanks::Base)
+      stub_const("PostForm", form_class)
+
+      expect(PostForm.model_name.param_key).to eq("post")
+    end
+
+    it "generates correct route_key" do
+      form_class = Class.new(Blanks::Base)
+      stub_const("PostForm", form_class)
+
+      expect(PostForm.model_name.route_key).to eq("posts")
+    end
+
+    it "handles class names without Form suffix" do
+      form_class = Class.new(Blanks::Base)
+      stub_const("Article", form_class)
+
+      expect(Article.model_name.name).to eq("Article")
+    end
+  end
+
+  describe ".model_name_for" do
+    it "overrides the model name" do
+      form_class = Class.new(Blanks::Base) do
+        model_name_for :article
+      end
+      stub_const("AdminPostForm", form_class)
+
+      expect(AdminPostForm.model_name.name).to eq("Article")
+    end
+
+    it "generates correct param_key from override" do
+      form_class = Class.new(Blanks::Base) do
+        model_name_for :article
+      end
+      stub_const("AdminPostForm", form_class)
+
+      expect(AdminPostForm.model_name.param_key).to eq("article")
+    end
+
+    it "accepts symbol" do
+      form_class = Class.new(Blanks::Base) do
+        model_name_for :blog_post
+      end
+
+      expect(form_class.model_name.name).to eq("BlogPost")
+    end
+
+    it "accepts string" do
+      form_class = Class.new(Blanks::Base) do
+        model_name_for "blog_post"
+      end
+
+      expect(form_class.model_name.name).to eq("BlogPost")
+    end
+  end
+
+  describe "#model_name" do
+    it "delegates to class method" do
+      form_class = Class.new(Blanks::Base)
+      stub_const("PostForm", form_class)
+
+      form = PostForm.new
+
+      expect(form.model_name.name).to eq("Post")
+    end
+  end
+end