alba_migration 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d0d4f72523fe8a34222de3cfe8a36d66aac6c5435f5efa1838899d0c70dec70
-  data.tar.gz: 1a1c8a0d42928db2f3bda02ad2f0202153f2706b95ef3c84d56348e47c575800
+  metadata.gz: 0f67906a1b1a0b5a723ed8c008a01ddc3175605b951545e5f9c63a6abea87720
+  data.tar.gz: bb47d0f21eb17c2ce923d3073426936fcfe30836c55010dd0eef6f99de664a61
 SHA512:
-  metadata.gz: a6fb7aec6e909fdeeee455f04bf0a3fe8b4ae7596673d995f7288311fca94c19b5682260696d66b1b3a5b60ba2ca561d4b50eec30f6e59a01a0821a356629d79
-  data.tar.gz: 1157bfbcf57f3ef83d22aa2b1896c125c550b3744cab656312f1220d2083303ff16f84191b067afe310eda19182c874d20d1a9ed6e389965893976c3068f5780
+  metadata.gz: 8bcfd3e77babad553ad41e7e6889448bc47c5da2fd7fa199238a04b547dfa7f3ed7c18c18fcc8eae37f01622aca87ccd4e4381346ab6c6509e6ce3faec63c428
+  data.tar.gz: a8e02d2763f1d6745ca9d5d7db8f079bc9988df7fda1229e7e9b6df7069560a7116a5db46e4574a4aa07535509ef49fbedefdbd117a6bf0d745757bf90a56a54

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # GHANGELOG
 
+## 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
+- Add tests for nested class conversion
+
 ## 0.0.1 (2025-05-19)
 
 - Initial release

data/README.md

@@ -64,6 +64,7 @@ end
 Currently, AlbaMigration supports the following AMS syntax:
 - `class ... < ActiveModel::Serializer` with `attributes ...` inside the class body
 - Only the conversion of the class definition and `attributes` is supported at this time
+- Attribute methods (e.g. `attribute :foo do ... end`) are now automatically converted
 - Other AMS features (e.g., associations, custom methods) are **not** yet supported
 
 ## Contributing

data/lib/alba_migration/cli.rb

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

data/lib/alba_migration/snippet.rb

@@ -3,13 +3,31 @@
 # rbs_inline: enabled
 
 require "synvert/core"
+require "standard"
 
 module AlbaMigration
   class Snippet
-    # @rbs file_patterns: Array[String]
+    # @rbs migrate_file_path: String
+    # @rbs return: Array[Synvert::Core::Rewriter]
+    def self.snippets(migrate_file_path:)
+      snippet_creator = new(migrate_file_path:)
+      [
+        snippet_creator.superclass_rewriter,
+        snippet_creator.attribute_method_rewriter
+      ]
+    end
+
+    # @rbs migrate_file_path: String
+    # @rbs return: void
+    def initialize(migrate_file_path:)
+      @migrate_file_path = migrate_file_path
+    end
+
     # @rbs return: Synvert::Core::Rewriter
-    def self.create(migrate_file_path:)
-      Synvert::Core::Rewriter.new "alba", "convert_ams_to_alba" do
+    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.
       
@@ -36,16 +54,209 @@ module AlbaMigration
 
         within_files migrate_file_path do
           with_node node_type: "class_node", superclass: "ActiveModel::Serializer" do
-            body = node.body ? node.body.to_source : ""
-            if body.strip.empty?
-              indented_body = ""
-            else
-              min_indent = body.lines.reject { |l| l.strip.empty? }.map { |l| l[/^\s*/].size }.min || 0
-              indented_body = body.lines.map { |l| "  " + l[min_indent..] }.join
+            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
-            replace_with "class #{node.constant_path.to_source}\n  include Alba::Resource\n\n#{indented_body}\nend"
+          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
     end
   end

data/lib/alba_migration/version.rb

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

data/sig/generated/alba_migration/snippet.rbs

@@ -2,8 +2,18 @@
 
 module AlbaMigration
   class Snippet
-    # @rbs file_patterns: Array[String]
+    # @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
+
     # @rbs return: Synvert::Core::Rewriter
-    def self.create: (migrate_file_path: untyped) -> Synvert::Core::Rewriter
+    def attribute_method_rewriter: () -> Synvert::Core::Rewriter
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: alba_migration
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - ShoheiMitani
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-05-19 00:00:00.000000000 Z
+date: 2025-05-20 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