alba_migration 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df7bbe77cae170bad5af5a2540c34d0a2d168d0c20b1a63878fb8d97cba67f5a
-  data.tar.gz: 2cef8adf32f038d6b9ee4460bf5ee91b079d9a486159689c5c045c3b343202ff
+  metadata.gz: 4363f4b67228f48ef7986a8cfcc678ab88ed8a752809361de7aa249e0889ae52
+  data.tar.gz: 41947e0ad9125fcb418fe71053483dccc7b8370210fcdc9cb081571d7a524ec7
 SHA512:
-  metadata.gz: d987b4eb4a8e04c09ed01141a3bb4106379723e00bfb6322042a3610e05e5cf7d5a78e6d69a10d2df177634437ef5c5e93c4a56443ea3414c8f5ea3f79b9a6df
-  data.tar.gz: fdbf061dcf55e0cea70e6894681f4bee91fe0c09258f835a60db825b21dd55ea4f8b414ede2fcd3f0281cb2a3d0275bbb2a545d9f53267b64698a1b0c6882b70
+  metadata.gz: 162e777325e434a0d9ec8b6f129b7911ef75a3d62edd729c0c1e9f1623aeb8fed03c52b2d0e1f34c637da7537a980f64ca16dd1a50c01867f2d7ad42b2a4ef84
+  data.tar.gz: d5a5a6d48bf7b068edfd7ddf0ec9749d06a946edda20a11c759c1ff886a5168106079e08dfef9ce062b49ab4f126a70cdd266cd561d9eec086b35804e5316af9

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # GHANGELOG
 
+## 0.0.6 (2024-06-08)
+
+- Implement if condition lambda-to-proc conversion in AMS to Alba migration
+- Improve conditional attribute handling for better Alba compatibility
+
 ## 0.0.5 (2024-06-08)
 
 - --add_on option to CLI for custom snippet support

data/README.md

@@ -39,6 +39,17 @@ If you are using Bundler:
 bundle exec alba_migration app/serializers/**/*.rb
 ```
 
+#### Custom Snippet Support (`--add_on` option)
+
+You can specify a custom snippet Ruby file to extend or override the default migration behavior using the `--add_on` option:
+
+```bash
+alba_migration --add_on path/to/custom_snippet.rb path/to/your/serializer.rb
+```
+
+- The custom snippet file should define a Synvert rewriter object.
+- This allows you to add your own migration logic in addition to the built-in conversion.
+
 #### Example
 
 **Before:**
@@ -65,6 +76,7 @@ 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
+- Conditional attributes with `if` option are converted from lambda to proc syntax
 - Other AMS features (e.g., associations, custom methods) are **not** yet supported
 
 ## Contributing

data/lib/alba_migration/snippet/attribute_rewritable.rb

@@ -15,7 +15,7 @@ module AlbaMigration
         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
@@ -119,6 +119,7 @@ module AlbaMigration
               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
@@ -128,56 +129,52 @@ module AlbaMigration
                 []
               end
 
-              # Detect include Alba::Resource
-              include_line = nil
+              # Pre-collect conversion data
+              attribute_blocks = {}  # Conversion results for block-based attributes
+              attr_names = {}        # Combination of attribute :name + def name
+              attributes_groups = {} # Grouped attributes :a, :b
+              def_method_names = []  # List of def method names
+
+              # 0. Pre-collect def method names
               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
+                if child.type == :def
+                  def_method_names << child.children[0].to_s
                 end
               end
 
-              # 1-1. Collect attribute(:xxx) { ... } style
-              attribute_blocks = []
+              # 1. Collect attribute(:xxx) { ... } 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)
+                    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"
+                  converted = if block_params.strip.empty?
+                    "  attribute #{arg} do\n    #{block_body}\n  end"
                   else
-                    "attribute #{arg} do |#{block_params.strip}|\n#{block_body}\nend"
+                    "  attribute #{arg} do |#{block_params.strip}|\n    #{block_body}\n  end"
                   end
+
+                  attribute_blocks[child] = converted
                 end
               end
 
-              # 1-2. Collect attribute :name + def name ... end style
-              attr_names = {}
-              other_methods = []
-
-              # First, collect attribute :name
+              # 2. Collect attribute :name + def name combinations
               body_nodes.each do |child|
                 next unless child.is_a?(Parser::AST::Node)
                 if child.type == :send &&
@@ -187,141 +184,134 @@ module AlbaMigration
                     child.children[2].type == :sym
 
                   attr_name = child.children[2].children[0].to_s
-                  attr_names[attr_name] = nil
+                  attr_names[attr_name] = child
                 end
               end
 
-              # Extract attribute names to be grouped as attributes
-              attributes_group = []
-              attributes_methods = {}
+              # 3. Process attributes :a, :b grouping
+              standalone_attributes = []
               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}"
+                    standalone_attributes << ":#{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)
+                  if child.children.length >= 3 && child.children[2].is_a?(Parser::AST::Node)
                     arg_node = child.children[2]
+                    attrs_from_this_node = []
                     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]}" }
+                      syms.each { |sym_node| attrs_from_this_node << ":#{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}"
+                      arg_node.children.each { |sym_lit| attrs_from_this_node << ":#{sym_lit}" }
+                    else
+                      # For multiple arguments case (attributes :a, :b)
+                      child.children[2..].each do |arg|
+                        if arg.is_a?(Parser::AST::Node) && arg.type == :sym
+                          attrs_from_this_node << ":#{arg.children[0]}"
                         end
                       end
                     end
+
+                    # Keep only those not converted by def methods
+                    remaining_attrs = attrs_from_this_node.reject do |attr_name|
+                      method_name = attr_name[1..] # Remove :
+                      def_method_names.include?(method_name)
+                    end
+
+                    attributes_groups[child] = remaining_attrs
                   end
                 end
               end
 
-              # 2. Generate new code for the entire class
+              # Main processing: process body_nodes sequentially
               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}")
+                case child.type
+                when :send
+                  if child.children[1] == :include
+                    # include Alba::Resource
+                    new_lines << "  " + child.loc.expression.source
+                    new_lines << ""
+                  elsif child.children[1] == :attribute && child.children.length == 3 && child.children[2].is_a?(Parser::AST::Node) && child.children[2].type == :sym
+                    # attribute :xxx
+                    method_name = child.children[2].children[0].to_s
+                    def_exists = body_nodes.any? { |c| c.is_a?(Parser::AST::Node) && c.type == :def && c.children[0].to_s == method_name }
+
+                    if def_exists
+                      # Do nothing if def method exists (convert at def processing)
+                      next
+                    elsif child.children.length > 3
+                      # Unsupported attribute with options
+                      new_lines << "  " + child.loc.expression.source
+                    else
+                      # Output as standalone attribute grouping (only once)
+                      unless standalone_attributes.empty?
+                        new_lines << "  attributes #{standalone_attributes.join(", ")}"
+                        new_lines << ""
+                        standalone_attributes.clear
+                      end
+                    end
+                  elsif child.children[1] == :attributes
+                    # attributes :xxx, :yyy, ...
+                    if attributes_groups[child]
+                      unless attributes_groups[child].empty?
+                        new_lines << "  attributes #{attributes_groups[child].join(", ")}"
+                        new_lines << ""
+                      end
+                    else
+                      # Unsupported attributes syntax
+                      new_lines << "  " + child.loc.expression.source
+                    end
+                  else
+                    # Other method calls (including unsupported syntax)
+                    new_lines << "  " + child.loc.expression.source
+                  end
+
+                when :block
+                  new_lines << (attribute_blocks[child] || "  " + child.loc.expression.source)
+
+                when :def
+                  method_name = child.children[0].to_s
+                  method_body = child.children[2]
+                  method_src = method_body ? method_body.loc.expression.source : ""
+
+                  if attr_names.key?(method_name)
+                    # Convert attribute :name + def name
+                    new_lines << "  attribute :#{method_name} do |object|"
+                    new_lines << "    #{method_src}"
+                    new_lines << "  end"
+                  elsif method_src.strip.start_with?("object.") || (method_name.end_with?("s") && method_body)
+                    # Convert def methods containing object.xxx
+                    new_lines << "  attribute :#{method_name} do |object|"
+                    new_lines << "    #{method_src}"
+                    new_lines << "  end"
+                  else
+                    # Non-convertible def methods
+                    new_lines << "  " + child.loc.expression.source
+                  end
+
+                else
+                  # Other nodes
+                  new_lines << "  " + child.loc.expression.source
                 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
+              # Remove consecutive blank lines
               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

data/lib/alba_migration/snippet/if_rewritable.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+require "synvert/core"
+require "standard"
+
+module AlbaMigration
+  class Snippet
+    module IfRewritable
+      # @rbs return: Synvert::Core::Rewriter
+      def if_rewriter
+        migrate_file_path = @migrate_file_path
+
+        Synvert::Core::Rewriter.new "alba_migration", "rewrite_if" do
+          description <<~EOS
+            It migrates if syntax to Alba syntax.
+      
+            Example:
+      
+            ```ruby
+            class AttributesResource < ActiveModel::Serializer
+              attributes :id, if: -> { true }
+            end
+            ```
+      
+            =>
+      
+            ```ruby
+            class AttributesResource
+              include Alba::Resource
+      
+              attributes :id, if: proc { true }
+            end
+            ```
+          EOS
+
+          configure(parser: "prism")
+
+          within_files migrate_file_path do
+            # Convert lambda syntax to proc syntax in if option
+            with_node node_type: "lambda_node" do
+              body_src = node.body ? node.body.to_source : ""
+              replace_with "proc { #{body_src} }"
+            end
+
+            # Convert attribute method to attributes method only if it has an if condition
+            with_node node_type: "call_node", receiver: nil, message: "attribute" do
+              # Check if this attribute call has an 'if' argument
+              has_if_option = false
+              if node.arguments&.arguments
+                node.arguments.arguments.each do |arg|
+                  if arg.type == :keyword_hash_node && arg.elements
+                    arg.elements.each do |element|
+                      if element.type == :assoc_node && element.key.type == :symbol_node && element.key.unescaped == "if"
+                        has_if_option = true
+                        break
+                      end
+                    end
+                  end
+                end
+              end
+
+              if has_if_option
+                # Get all arguments
+                args = node.arguments ? node.arguments.arguments.map(&:to_source).join(", ") : ""
+                replace_with "attributes #{args}"
+              end
+            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

@@ -42,6 +42,12 @@ module AlbaMigration
               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
+
+            # Convert lambda syntax to proc syntax in if option
+            with_node node_type: "lambda_node" do
+              body_src = node.body ? node.body.to_source : ""
+              replace_with "proc { #{body_src} }"
+            end
           end
 
           Standard::Cli.new(["--fix", Array(migrate_file_path).join(" ")]).run

data/lib/alba_migration/snippet/superclass_rewriter.rb

@@ -0,0 +1,82 @@
+# 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
+
+            # Convert lambda syntax to proc syntax in if option
+            with_node node_type: "lambda_node" do
+              body_src = node.body ? node.body.to_source : ""
+              replace_with "proc { #{body_src} }"
+            end
+
+            # Convert attribute method to attributes method only if it has an if condition
+            with_node node_type: "call_node", receiver: nil, message: "attribute" do
+              # Check if this attribute call has an 'if' argument
+              has_if_option = false
+              if node.arguments&.arguments
+                node.arguments.arguments.each do |arg|
+                  if arg.type == :keyword_hash_node && arg.elements
+                    arg.elements.each do |element|
+                      if element.type == :assoc_node && element.key.type == :symbol_node && element.key.unescaped == "if"
+                        has_if_option = true
+                        break
+                      end
+                    end
+                  end
+                end
+              end
+
+              if has_if_option
+                # Get all arguments
+                args = node.arguments ? node.arguments.arguments.map(&:to_source).join(", ") : ""
+                replace_with "attributes #{args}"
+              end
+            end
+          end
+
+          Standard::Cli.new(["--fix", Array(migrate_file_path).join(" ")]).run
+        end
+      end
+    end
+  end
+end

data/lib/alba_migration/snippet.rb

@@ -2,13 +2,15 @@
 
 # rbs_inline: enabled
 
-require_relative "snippet/superclass_rewritable"
 require_relative "snippet/attribute_rewritable"
+require_relative "snippet/if_rewritable"
+require_relative "snippet/superclass_rewritable"
 
 module AlbaMigration
   class Snippet
     include SuperclassRewritable
     include AttributeRewritable
+    include IfRewritable
 
     # @rbs migrate_file_path: String
     # @rbs return: Array[Synvert::Core::Rewriter]
@@ -16,7 +18,8 @@ module AlbaMigration
       snippet_creator = new(migrate_file_path:)
       [
         snippet_creator.superclass_rewriter,
-        snippet_creator.attribute_method_rewriter
+        snippet_creator.attribute_method_rewriter,
+        snippet_creator.if_rewriter
       ]
     end
 

data/lib/alba_migration/version.rb

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

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

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

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

@@ -0,0 +1,10 @@
+# Generated from lib/alba_migration/snippet/superclass_rewriter.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

@@ -6,6 +6,8 @@ module AlbaMigration
 
     include AttributeRewritable
 
+    include IfRewritable
+
     # @rbs migrate_file_path: String
     # @rbs return: Array[Synvert::Core::Rewriter]
     def self.snippets: (migrate_file_path: String) -> Array[Synvert::Core::Rewriter]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: alba_migration
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - ShoheiMitani
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-05-21 00:00:00.000000000 Z
+date: 2025-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: synvert-core
@@ -69,13 +69,17 @@ files:
 - lib/alba_migration/cli.rb
 - lib/alba_migration/snippet.rb
 - lib/alba_migration/snippet/attribute_rewritable.rb
+- lib/alba_migration/snippet/if_rewritable.rb
 - lib/alba_migration/snippet/superclass_rewritable.rb
+- lib/alba_migration/snippet/superclass_rewriter.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/if_rewritable.rbs
 - sig/generated/alba_migration/snippet/superclass_rewritable.rbs
+- sig/generated/alba_migration/snippet/superclass_rewriter.rbs
 - sig/generated/alba_migration/version.rbs
 homepage: https://github.com/ShoheiMitani/alba_migration
 licenses: