alba_migration 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37c933abf40cb29de3d7ee33581bc488348fccd849c86175c29c6e734d311151
-  data.tar.gz: 82b9f993d2f2d9b672f1396f6b4949f6ec8c9629f1eb637f92f22c91042e21db
+  metadata.gz: 2d8b22bb77ee9707b3787fbef95b63722b8303ccc02044e905174b673b024517
+  data.tar.gz: f9f5d8c943160355a7fbd9e38308347929df48afc6062751cd8a5f38ae0f1984
 SHA512:
-  metadata.gz: aa7e60457a914cd063c42c9191655e1ddcc3b4e0a7a2c9b43f4c5194f10e097d4d7336ac9b1253a8bb478805e6c12fe934329b4595f404e535076b95334b7e46
-  data.tar.gz: 53ce5eaa008faf881c656514b28be1a47a6b13e524666a188d935d60c080d1e0f2b24ec4948926bbee5a187136a25046c43777940a1f620d77f83285d45e6e52
+  metadata.gz: 61967197eadc4abb078a2563d0cf8b118872f61373ef964e35267e2d819d6e7a94ab3fbf720a32bb8c75f94ff943cee2c01f7d8a38bb971c9c25062f6da70887
+  data.tar.gz: 732ffb30e8a855349c4a7d8602deec121ee51ce4d0dc864d877da6ef62eb3444a5fcab14c8818b1219a8391192dcb0df290cbd47537c7f0668da8bc9454cc2a5

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # GHANGELOG
 
+## 0.0.4 (2024-06-08)
+
+- Extend support for attribute rewriting
+
+## 0.0.3 (2024-06-07)
+
+- Add gem dependency for easier installation
+
 ## 0.0.2 (2024-05-19)
 
 - Add attribute method rewriter for better AMS to Alba conversion

data/lib/alba_migration/cli.rb

@@ -28,10 +28,7 @@ module AlbaMigration
         exit(1)
       end
 
-      snippets = AlbaMigration::Snippet.snippets(migrate_file_path: matched_files)
-      snippets.each do |rewriter|
-        rewriter.process
-      end
+      AlbaMigration::Snippet.process_snippets(migrate_file_path: matched_files)
     end
   end
 end

data/lib/alba_migration/snippet/attribute_rewritable.rb

@@ -0,0 +1,334 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+require "synvert/core"
+require "standard"
+
+module AlbaMigration
+  class Snippet
+    module AttributeRewritable
+      # @rbs return: Synvert::Core::Rewriter
+      def attribute_method_rewriter
+        migrate_file_path = @migrate_file_path
+
+        Synvert::Core::Rewriter.new "alba_migration", "rewrite_attribute_method" do
+          description <<~EOS
+            It migrates ActiveModelSerializers attribute syntax to Alba attribute syntax.
+      
+            Example:
+      
+            # 1. Simple attribute methods grouped
+            ```ruby
+            class AttributeResource
+              attribute(:object)
+              attribute(:user_id)
+              attribute :user_name
+            end
+            ```
+
+            =>
+
+            ```ruby
+            class AttributeResource
+              attributes :object, :user_id, :user_name
+            end
+            ```
+
+            # 2. attribute with block
+            ```ruby
+            class AttributeResource
+              attribute(:object) { 'access_token' }
+              attribute(:user_id) { object.user_id }
+              attribute :user_name
+              def user_name
+                object.user.name
+              end
+            end
+            ```
+
+            =>
+
+            ```ruby
+            class AttributeResource
+              attribute :object do
+                'access_token'
+              end
+              attribute :user_id do |object|
+                object.user_id
+              end
+              attribute :user_name do |object|
+                object.user.name
+              end
+            end
+            ```
+
+            # 3. attribute :name + def name ... end
+            ```ruby
+            class AttributeResource
+              attribute :user_name
+              def user_name
+                object.user.name
+              end
+            end
+            ```
+
+            =>
+
+            ```ruby
+            class AttributeResource
+              attribute :user_name do |object|
+                object.user.name
+              end
+            end
+            ```
+
+            # 4. attributes :a, :b, ... + def a ... end
+            ```ruby
+            class AttributeResource
+              attributes :user_name, :user_id
+              def user_name
+                object.user.name
+              end
+              def user_id
+                object.user.id
+              end
+            end
+            ```
+
+            =>
+
+            ```ruby
+            class AttributeResource
+              attribute :user_name do |object|
+                object.user.name
+              end
+              attribute :user_id do |object|
+                object.user.id
+              end
+            end
+            ```
+          EOS
+
+          configure(parser: "parser")
+
+          within_files migrate_file_path do
+            # Rewrite the entire class at once
+            with_node type: "class" do
+              class_name = node.children[0].loc.expression.source
+              superclass_node = node.children[1]
+              superclass_src = superclass_node ? " < #{superclass_node.loc.expression.source}" : ""
+              class_body = node.children[2]
+              # If class_body is a :begin node, loop through its children. Otherwise, treat it as a single node in an array.
+              body_nodes = if class_body && class_body.type == :begin
+                class_body.children
+              elsif class_body
+                [class_body]
+              else
+                []
+              end
+
+              # Detect include Alba::Resource
+              include_line = nil
+              body_nodes.each do |child|
+                next unless child.is_a?(Parser::AST::Node)
+                if child.type == :send && child.children[1] == :include
+                  include_line = "  " + child.loc.expression.source
+                end
+              end
+
+              # 1-1. Collect attribute(:xxx) { ... } style
+              attribute_blocks = []
+              body_nodes.each do |child|
+                next unless child.is_a?(Parser::AST::Node)
+                if child.type == :block &&
+                    child.children[0] && child.children[0].is_a?(Parser::AST::Node) && child.children[0].type == :send &&
+                    child.children[0].children[1] == :attribute
+
+                  # Process arguments
+                  arg_node = child.children[0].children[2]
+                  arg = if arg_node.is_a?(Parser::AST::Node) && arg_node.type == :sym
+                    ":#{arg_node.children[0]}"
+                  else
+                    ((arg_node.respond_to?(:loc) && arg_node.loc.respond_to?(:expression)) ? arg_node.loc.expression.source : arg_node.to_s)
+                  end
+
+                  # Process block parameters
+                  block_params = child.children[1] ? child.children[1].children.map { |c| c.children[0].to_s }.join(", ") : ""
+
+                  # Process block body
+                  block_body = child.children[2] ? child.children[2].loc.expression.source : ""
+
+                  # Add 'object' to parameters if used in block body
+                  if block_params.strip.empty? && block_body.include?("object")
+                    block_params = "object"
+                  end
+
+                  # Generate new code (no indentation added)
+                  attribute_blocks << if block_params.strip.empty?
+                    "attribute #{arg} do\n#{block_body}\nend"
+                  else
+                    "attribute #{arg} do |#{block_params.strip}|\n#{block_body}\nend"
+                  end
+                end
+              end
+
+              # 1-2. Collect attribute :name + def name ... end style
+              attr_names = {}
+              other_methods = []
+
+              # First, collect attribute :name
+              body_nodes.each do |child|
+                next unless child.is_a?(Parser::AST::Node)
+                if child.type == :send &&
+                    child.children[1] == :attribute &&
+                    child.children.length == 3 &&
+                    child.children[2].is_a?(Parser::AST::Node) &&
+                    child.children[2].type == :sym
+
+                  attr_name = child.children[2].children[0].to_s
+                  attr_names[attr_name] = nil
+                end
+              end
+
+              # Extract attribute names to be grouped as attributes
+              attributes_group = []
+              attributes_methods = {}
+              body_nodes.each do |child|
+                next unless child.is_a?(Parser::AST::Node)
+                # attribute :xxx
+                if child.type == :send && child.children[1] == :attribute && child.children.length == 3 && child.children[2].is_a?(Parser::AST::Node) && child.children[2].type == :sym
+                  method_name = child.children[2].children[0].to_s
+                  unless body_nodes.any? { |c| c.is_a?(Parser::AST::Node) && c.type == :def && c.children[0].to_s == method_name }
+                    attributes_group << ":#{method_name}"
+                  end
+                # attributes :xxx, :yyy, ...
+                elsif child.type == :send && child.children[1] == :attributes
+                  # attributes [:a, :b] or attributes %i[a b] style
+                  if child.children.length == 3 && child.children[2].is_a?(Parser::AST::Node)
+                    arg_node = child.children[2]
+                    if arg_node.type == :array
+                      syms = arg_node.children.select { |n| n.is_a?(Parser::AST::Node) && n.type == :sym }
+                      syms.each { |sym_node| attributes_group << ":#{sym_node.children[0]}" }
+                    elsif arg_node.type == :sym_array
+                      # For %i[a b] style
+                      arg_node.children.each do |sym_lit|
+                        attributes_group << ":#{sym_lit}" # sym_lit is a Symbol
+                      end
+                    end
+                  else
+                    child.children[2..].each do |a|
+                      if a.is_a?(Parser::AST::Node) && a.type == :sym
+                        method_name = a.children[0].to_s
+                        def_node = body_nodes.find { |c| c.is_a?(Parser::AST::Node) && c.type == :def && c.children[0].to_s == method_name }
+                        if def_node
+                          method_body = def_node.children[2]
+                          method_src = method_body ? method_body.loc.expression.source : ""
+                          attributes_methods[method_name] = "attribute :#{method_name} do |object|\n#{method_src}\nend"
+                        else
+                          attributes_group << ":#{method_name}"
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+
+              # 2. Generate new code for the entire class
+              new_lines = ["class #{class_name}#{superclass_src}"]
+
+              # Add include Alba::Resource first if present
+              if include_line
+                new_lines << include_line
+                new_lines << ""
+              end
+
+              # Add attributes group after include
+              unless attributes_group.empty?
+                new_lines << "  attributes #{attributes_group.join(", ")}"
+                new_lines << ""
+              end
+
+              # Add attribute blocks (no extra blank lines)
+              new_lines.concat(attribute_blocks)
+
+              # Convert attribute :name + def name ... end pairs
+              attributeized_method_names = []
+              body_nodes.each do |child|
+                next unless child.is_a?(Parser::AST::Node)
+                next unless child.type == :def
+                method_name = child.children[0].to_s
+                method_body = child.children[2]
+                method_src = method_body ? method_body.loc.expression.source : ""
+                # attribute :name + def name ... end
+                if attr_names.key?(method_name)
+                  attr_names[method_name] = "attribute :#{method_name} do |object|\n#{method_src}\nend"
+                  attributeized_method_names << method_name
+                  attributes_group.delete(":#{method_name}")
+                  next
+                end
+                # attributes :name + def name ... end
+                if attributes_methods.key?(method_name)
+                  new_lines << attributes_methods[method_name]
+                  attributeized_method_names << method_name
+                  attributes_group.delete(":#{method_name}")
+                  next
+                end
+                # def name ... object.xxx ... end
+                if method_src.strip.start_with?("object.")
+                  new_lines << "attribute :#{method_name} do |object|\n#{method_src}\nend"
+                  attributeized_method_names << method_name
+                  attributes_group.delete(":#{method_name}")
+                  next
+                end
+                # def accounts ... object.account_id ... end (plural method names are converted as-is to attribute)
+                if method_name.end_with?("s") && method_body
+                  new_lines << "attribute :#{method_name} do |object|\n#{method_src}\nend"
+                  attributeized_method_names << method_name
+                  attributes_group.delete(":#{method_name}")
+                  next
+                end
+                # All other methods go to other_methods (excluding those already converted to attribute)
+                unless attributeized_method_names.include?(method_name)
+                  method_src_full = child.loc.expression.source
+                  other_methods << method_src_full
+                end
+              end
+
+              # Add conversion results of attribute :name + def name ... end (no extra blank lines)
+              attr_blocks = []
+              attr_names.each do |k, _|
+                def_node = body_nodes.find { |c| c.is_a?(Parser::AST::Node) && c.type == :def && c.children[0].to_s == k }
+                if def_node && def_node.children[2] && def_node.children[2].loc.expression.source.strip.start_with?("object.")
+                  method_src = def_node.children[2].loc.expression.source
+                  attr_blocks << "attribute :#{k} do |object|\n#{method_src}\nend"
+                  # Also remove from attributes_group
+                  attributes_group.delete(":#{k}")
+                end
+              end
+              new_lines.concat(attr_blocks)
+              # Add other methods (def not corresponding to attribute) (no extra blank lines)
+              filtered_other_methods = other_methods.reject do |src|
+                attributeized_method_names.any? { |name| src.match?(/def\s+#{name}\b/) }
+              end
+              new_lines.concat(filtered_other_methods)
+
+              new_lines << "end"
+
+              # Remove consecutive blank lines except immediately after attributes or include Alba::Resource
+              final_code = new_lines.each_with_object([]) do |line, arr|
+                if line.strip.empty? && arr.last&.strip&.empty?
+                  next
+                end
+                arr << line
+              end.join("\n")
+              replace_with final_code
+            end
+          end
+
+          Standard::Cli.new(["--fix", Array(migrate_file_path).join(" ")]).run
+        end
+      end
+    end
+  end
+end

data/lib/alba_migration/snippet/superclass_rewritable.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+require "synvert/core"
+require "standard"
+
+module AlbaMigration
+  class Snippet
+    module SuperclassRewritable
+      # @rbs return: Synvert::Core::Rewriter
+      def superclass_rewriter
+        migrate_file_path = @migrate_file_path
+
+        Synvert::Core::Rewriter.new "alba_migration", "rewrite_superclass" do
+          description <<~EOS
+            It migrates ActiveModelSerializers syntax to Alba syntax.
+      
+            Example:
+      
+            ```ruby
+            class AttributesResource < ActiveModel::Serializer
+              attributes :id, :name
+            end
+            ```
+      
+            =>
+      
+            ```ruby
+            class AttributesResource
+              include Alba::Resource
+      
+              attributes :id, :name
+            end
+            ```
+          EOS
+
+          configure(parser: "prism")
+
+          within_files migrate_file_path do
+            with_node node_type: "class_node", superclass: "ActiveModel::Serializer" do
+              body_src = node.body ? node.body.to_source : ""
+              replace_with "class #{node.constant_path.to_source}\ninclude Alba::Resource\n\n#{body_src}\nend"
+            end
+          end
+
+          Standard::Cli.new(["--fix", Array(migrate_file_path).join(" ")]).run
+        end
+      end
+    end
+  end
+end

data/lib/alba_migration/snippet.rb

@@ -2,11 +2,14 @@
 
 # rbs_inline: enabled
 
-require "synvert/core"
-require "standard"
+require_relative "snippet/superclass_rewritable"
+require_relative "snippet/attribute_rewritable"
 
 module AlbaMigration
   class Snippet
+    include SuperclassRewritable
+    include AttributeRewritable
+
     # @rbs migrate_file_path: String
     # @rbs return: Array[Synvert::Core::Rewriter]
     def self.snippets(migrate_file_path:)
@@ -19,245 +22,15 @@ module AlbaMigration
 
     # @rbs migrate_file_path: String
     # @rbs return: void
-    def initialize(migrate_file_path:)
-      @migrate_file_path = migrate_file_path
+    def self.process_snippets(migrate_file_path:)
+      snippets = snippets(migrate_file_path:)
+      snippets.each(&:process)
     end
 
-    # @rbs return: Synvert::Core::Rewriter
-    def superclass_rewriter
-      migrate_file_path = @migrate_file_path
-
-      Synvert::Core::Rewriter.new "alba_migration", "rewrite_superclass" do
-        description <<~EOS
-          It migrates ActiveModelSerializers syntax to Alba syntax.
-      
-          Example:
-      
-          ```ruby
-          class AttributesResource < ActiveModel::Serializer
-            attributes :id, :name
-          end
-          ```
-      
-          =>
-      
-          ```ruby
-          class AttributesResource
-            include Alba::Resource
-      
-            attributes :id, :name
-          end
-          ```
-        EOS
-
-        configure(parser: "prism")
-
-        within_files migrate_file_path do
-          with_node node_type: "class_node", superclass: "ActiveModel::Serializer" do
-            body_src = node.body ? node.body.to_source : ""
-            replace_with "class #{node.constant_path.to_source}\ninclude Alba::Resource\n\n#{body_src}\nend"
-          end
-        end
-
-        Standard::Cli.new(["--fix", Array(migrate_file_path).join(" ")]).run
-      end
-    end
-
-    # @rbs return: Synvert::Core::Rewriter
-    def attribute_method_rewriter
-      migrate_file_path = @migrate_file_path
-
-      Synvert::Core::Rewriter.new "alba_migration", "rewrite_attribute_method" do
-        description <<~EOS
-          It migrates ActiveModelSerializers attribute syntax to Alba attribute syntax.
-      
-          Example:
-      
-          ```ruby
-          class AttributeResource
-            attribute(:object)
-            attribute(:user_id)
-            attribute :user_name
-          end
-          ```
-
-          =>
-
-          ```ruby
-          class AttributeResource
-            attributes :object, :user_id, :user_name
-          end
-          ```
-  
-          ```ruby
-          class AttributeResource
-            attribute(:object) { 'access_token' }
-            attribute(:user_id) { object.user_id }
-            attribute :user_name
-            def user_name
-              object.user.name
-            end
-          end
-          ```
-
-          =>
-
-          ```ruby
-          class AttributeResource
-            attribute :object do
-              'access_token'
-            end
-            attribute :user_id do |object|
-              object.user_id
-            end
-            attribute :user_name do |object|
-              object.user.name
-            end
-          end
-          ```
-        EOS
-
-        configure(parser: "parser")
-
-        within_files migrate_file_path do
-          # Rewrite the entire class at once
-          with_node type: "class" do
-            class_name = node.children[0].loc.expression.source
-            class_body = node.children[2]
-            next unless class_body
-
-            # 1. Collect attribute blocks
-            attribute_blocks = []
-            other_lines = []
-
-            # Collect other lines in the class
-            class_body.children.each do |child|
-              if child && child.type == :send
-                if child.children[1] == :include || child.children[1] == :attributes
-                  other_lines << "  " + child.loc.expression.source
-                end
-              end
-            end
-
-            # 1-1. Collect attribute(:xxx) { ... } style
-            class_body.children.each do |child|
-              if child && child.type == :block &&
-                  child.children[0] && child.children[0].type == :send &&
-                  child.children[0].children[1] == :attribute
-
-                # Process arguments
-                arg_node = child.children[0].children[2]
-                arg = (arg_node.type == :sym) ? ":#{arg_node.children[0]}" : arg_node.loc.expression.source
-
-                # Process block parameters
-                block_params = child.children[1] ? child.children[1].children.map { |c| c.children[0].to_s }.join(", ") : ""
-
-                # Process block body
-                block_body = child.children[2] ? child.children[2].loc.expression.source : ""
-
-                # Add 'object' to parameters if used in block body
-                if block_params.strip.empty? && block_body.include?("object")
-                  block_params = "object"
-                end
-
-                # Generate new code（インデント付与はしない）
-                attribute_blocks << if block_params.strip.empty?
-                  "attribute #{arg} do\n#{block_body}\nend"
-                else
-                  "attribute #{arg} do |#{block_params.strip}|\n#{block_body}\nend"
-                end
-              end
-            end
-
-            # 1-2. Collect attribute :name + def name ... end style
-            attr_names = {}
-            other_methods = []
-
-            # First, collect attribute :name
-            class_body.children.each do |child|
-              if child && child.type == :send &&
-                  child.children[1] == :attribute &&
-                  child.children.length == 3 &&
-                  child.children[2].type == :sym
-
-                attr_name = child.children[2].children[0].to_s
-                attr_names[attr_name] = nil
-              end
-            end
-
-            # Extract attribute names to be grouped as attributes
-            attributes_group = []
-            class_body.children.each do |child|
-              if child && child.type == :send &&
-                  child.children[1] == :attribute &&
-                  child.children.length == 3 &&
-                  child.children[2].type == :sym
-                method_name = child.children[2].children[0].to_s
-                # Only group as attributes if there is no corresponding def method
-                unless class_body.children.any? { |c| c && c.type == :def && c.children[0].to_s == method_name }
-                  attributes_group << ":#{method_name}"
-                end
-              end
-            end
-
-            # 2. Generate new code for the entire class
-            new_lines = ["class #{class_name}"]
-
-            # Add attributes group at the top
-            unless attributes_group.empty?
-              new_lines << "  attributes #{attributes_group.join(", ")}"
-            end
-
-            # Add include and attributes lines
-            if !other_lines.empty?
-              include_line = other_lines.find { |line| line.include?("include") }
-              attribute_lines = other_lines.select { |line| !line.include?("include") }
-
-              # Add include first
-              new_lines << include_line if include_line
-
-              # Add a blank line
-              new_lines << ""
-
-              # Add attributes lines
-              new_lines.concat(attribute_lines) unless attribute_lines.empty?
-            end
-
-            # 2-1. Add attribute blocks (no extra blank lines)
-            new_lines.concat(attribute_blocks)
-
-            # Convert attribute :name + def name ... end pairs
-            class_body.children.each do |child|
-              if child && child.type == :def
-                method_name = child.children[0].to_s
-                if attr_names.key?(method_name)
-                  # Method corresponding to attribute (to be converted)
-                  method_body = child.children[2]
-                  method_src = method_body ? method_body.loc.expression.source : ""
-                  # No indent
-                  attr_names[method_name] = "attribute :#{method_name} do |object|\n#{method_src}\nend"
-                elsif child.respond_to?(:loc) && child.loc.respond_to?(:expression)
-                  # Methods not corresponding to attribute (preserved)
-                  method_src = child.loc.expression.source
-                  other_methods << method_src
-                end
-              end
-            end
-
-            # 2-2. Add conversion results of attribute :name + def name ... end (no extra blank lines)
-            attr_blocks = attr_names.values.compact
-            new_lines.concat(attr_blocks)
-            # 2-3. Add other methods (def not corresponding to attribute) (no extra blank lines)
-            new_lines.concat(other_methods)
-
-            new_lines << "end"
-
-            replace_with new_lines.join("\n")
-          end
-        end
-
-        Standard::Cli.new(["--fix", Array(migrate_file_path).join(" ")]).run
-      end
+    # @rbs migrate_file_path: String
+    # @rbs return: void
+    def initialize(migrate_file_path:)
+      @migrate_file_path = migrate_file_path
     end
   end
 end

data/lib/alba_migration/version.rb

@@ -3,5 +3,5 @@
 # rbs_inline: enabled
 
 module AlbaMigration
-  VERSION = "0.0.2"
+  VERSION = "0.0.4"
 end

data/sig/generated/alba_migration/snippet/attribute_rewritable.rbs

@@ -0,0 +1,10 @@
+# Generated from lib/alba_migration/snippet/attribute_rewritable.rb with RBS::Inline
+
+module AlbaMigration
+  class Snippet
+    module AttributeRewritable
+      # @rbs return: Synvert::Core::Rewriter
+      def attribute_method_rewriter: () -> Synvert::Core::Rewriter
+    end
+  end
+end

data/sig/generated/alba_migration/snippet/superclass_rewritable.rbs

@@ -0,0 +1,10 @@
+# Generated from lib/alba_migration/snippet/superclass_rewritable.rb with RBS::Inline
+
+module AlbaMigration
+  class Snippet
+    module SuperclassRewritable
+      # @rbs return: Synvert::Core::Rewriter
+      def superclass_rewriter: () -> Synvert::Core::Rewriter
+    end
+  end
+end

data/sig/generated/alba_migration/snippet.rbs

@@ -2,18 +2,20 @@
 
 module AlbaMigration
   class Snippet
+    include SuperclassRewritable
+
+    include AttributeRewritable
+
     # @rbs migrate_file_path: String
     # @rbs return: Array[Synvert::Core::Rewriter]
     def self.snippets: (migrate_file_path: String) -> Array[Synvert::Core::Rewriter]
 
     # @rbs migrate_file_path: String
     # @rbs return: void
-    def initialize: (migrate_file_path: String) -> void
-
-    # @rbs return: Synvert::Core::Rewriter
-    def superclass_rewriter: () -> Synvert::Core::Rewriter
+    def self.process_snippets: (migrate_file_path: String) -> void
 
-    # @rbs return: Synvert::Core::Rewriter
-    def attribute_method_rewriter: () -> Synvert::Core::Rewriter
+    # @rbs migrate_file_path: String
+    # @rbs return: void
+    def initialize: (migrate_file_path: String) -> void
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: alba_migration
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - ShoheiMitani
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-05-19 00:00:00.000000000 Z
+date: 2025-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: synvert-core
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: AlbaMigration is a CLI tool and library to help you convert your Ruby
   code from ActiveModelSerializers (AMS) to Alba syntax. It rewrites AMS serializer
   classes to Alba resource classes, supporting the migration of class definitions
@@ -54,10 +68,14 @@ files:
 - lib/alba_migration.rb
 - lib/alba_migration/cli.rb
 - lib/alba_migration/snippet.rb
+- lib/alba_migration/snippet/attribute_rewritable.rb
+- lib/alba_migration/snippet/superclass_rewritable.rb
 - lib/alba_migration/version.rb
 - sig/generated/alba_migration.rbs
 - sig/generated/alba_migration/cli.rbs
 - sig/generated/alba_migration/snippet.rbs
+- sig/generated/alba_migration/snippet/attribute_rewritable.rbs
+- sig/generated/alba_migration/snippet/superclass_rewritable.rbs
 - sig/generated/alba_migration/version.rbs
 homepage: https://github.com/ShoheiMitani/alba_migration
 licenses: