roda-project 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bca56b06faeb347730f67dce564950b0f3fb9a2e0271820551f96752678121e1
-  data.tar.gz: 1233a11fa1418c2492e956e79ea8d2f74db2689ce902e3fad04159245fc8a451
+  metadata.gz: b31e88696427968c61a574f01c1860abcede888273244d75d258bacc35da4935
+  data.tar.gz: b24dc4b5f0ad6a8e9acc24dd192e927c6c6251dd3d163088daf862e941d52e71
 SHA512:
-  metadata.gz: 0f42c3f7152377f79986fbba0fb2c2cfa7cb6c583c68ca05c9f78463c44e8445ad9c76a87e506302718f8d07c1ea97b195359878b21357b89b005e329de45e35
-  data.tar.gz: 23ce0cb9af858542d5a213e5e934a97619ea3b4be93b3379b06a04b63dabaa2019d18cc5e4fcf847581bad81a1c9de4eed81efa660367827b6627cbee57a6158
+  metadata.gz: 0fdf4cc809987b8b6167e06499989a9d101f39923aba2d7493fcc479609d141b9dd24229f33bae3fd897604ab92f812179ae7c13be7148579d1ba822b3691c14
+  data.tar.gz: 6206ac4f835a181f839277576bb52b572b25a2b163e2a9403819c8b0d4ff5a0ce913871083328a9c01f4c8f146938fa42f733f7a94a5f7130f448689675f8b75

data/lib/roda/project/bin/generators/migration/action_detector.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+class Roda
+  module Project
+    module Bin
+      class Generators < ::Thor
+        class Migration
+          class ActionDetector
+            include Roda::Project::Helpers::Inflections
+
+            attr_reader :name, :args
+
+            def initialize(name, args: [])
+              @name = name.to_s
+              @args = args || []
+            end
+
+            def detect
+              camel_name = camelize(name)
+
+              if (m = camel_name.match(/^CreateJoinTable(?<t1>[A-Z][a-zA-Z0-9]*?)(?<t2>[A-Z][a-zA-Z0-9]*)$/)) ||
+                 (m = camel_name.match(/JoinTable(?<t1>[A-Z][a-zA-Z0-9]*?)(?<t2>[A-Z][a-zA-Z0-9]*)$/)) ||
+                 camel_name.start_with?("CreateJoinTable") || camel_name.include?("JoinTable")
+                tables = parse_join_tables(m)
+                { action: :create_join_table, tables: tables }
+              elsif (m = camel_name.match(/^Create(?<table_name>[A-Z0-9].*)$/))
+                { action: :create_table, table_name: pluralize(underscore(m[:table_name])) }
+              elsif (m = camel_name.match(/^Add.+To(?<table_name>[A-Z0-9].*)$/))
+                { action: :add_columns, table_name: pluralize(underscore(m[:table_name])) }
+              elsif (m = camel_name.match(/^Remove.+From(?<table_name>[A-Z0-9].*)$/))
+                { action: :drop_columns, table_name: pluralize(underscore(m[:table_name])) }
+              else
+                { action: :generic, table_name: nil }
+              end
+            end
+
+            private
+
+            def parse_join_tables(match)
+              if args.size >= 2
+                args[0..1].map do |arg|
+                  clean = underscore(arg.to_s.gsub(/:.*$/, ""))
+                  s_clean = singularize(clean)
+                  p_clean = pluralize(s_clean)
+                  ["#{s_clean}_id", p_clean]
+                end
+              elsif match
+                raw1 = underscore(match[:t1])
+                raw2 = underscore(match[:t2])
+                s1 = singularize(raw1)
+                s2 = singularize(raw2)
+                t1 = pluralize(s1)
+                t2 = pluralize(s2)
+                [["#{s1}_id", t1], ["#{s2}_id", t2]]
+              else
+                []
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roda/project/bin/generators/migration/code_builder.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+class Roda
+  module Project
+    module Bin
+      class Generators
+        class Migration
+          class CodeBuilder
+            attr_reader :detection, :fields
+
+            def initialize(detection:, fields:)
+              @detection = detection || {}
+              @fields = fields || []
+            end
+
+            def build
+              action = detection[:action]
+
+              case action
+              when :create_table
+                build_create_table
+              when :add_columns
+                build_add_columns
+              when :drop_columns
+                build_drop_columns
+              when :create_join_table
+                build_create_join_table
+              else
+                build_generic
+              end
+            end
+
+            private
+
+            def build_create_table
+              table = detection[:table_name]
+              lines = []
+              lines << "Sequel.migration do"
+              lines << "  change do"
+              lines << "    create_table(:#{table}) do"
+              lines << "      primary_key :id"
+
+              indexes = []
+
+              fields.each do |field|
+                if field[:is_reference]
+                  ref_line = "      foreign_key :#{field[:name]}, :#{field[:target_table]}"
+                  ref_line += format_options(field[:options]) unless field[:options].empty?
+                  lines << ref_line
+                  indexes << "      index :#{field[:name]}" if field[:index]
+                else
+                  col_line = "      #{field[:type]} :#{field[:name]}"
+                  col_line += format_options(field[:options]) unless field[:options].empty?
+                  lines << col_line
+
+                  if field[:index] == :unique
+                    indexes << "      index :#{field[:name]}, unique: true"
+                  elsif field[:index]
+                    indexes << "      index :#{field[:name]}"
+                  end
+
+                  if field[:composite_index]
+                    cols_str = field[:composite_index].map { |c| ":#{c}" }.join(", ")
+                    indexes << "      index [#{cols_str}]"
+                  end
+                end
+              end
+
+              lines << "      DateTime :created_at"
+              lines << "      DateTime :updated_at"
+
+              unless indexes.empty?
+                lines << ""
+                lines.concat(indexes)
+              end
+
+              lines << "    end"
+              lines << "  end"
+              lines << "end"
+              lines.join("\n") + "\n"
+            end
+
+            def build_add_columns
+              table = detection[:table_name]
+              lines = []
+              lines << "Sequel.migration do"
+              lines << "  change do"
+              lines << "    alter_table(:#{table}) do"
+
+              fields.each do |field|
+                if field[:is_reference]
+                  ref_line = "      add_foreign_key :#{field[:name]}, :#{field[:target_table]}"
+                  ref_line += format_options(field[:options]) unless field[:options].empty?
+                  lines << ref_line
+                  lines << "      add_index :#{field[:name]}" if field[:index]
+                else
+                  col_line = "      add_column :#{field[:name]}, #{field[:type]}"
+                  col_line += format_options(field[:options]) unless field[:options].empty?
+                  lines << col_line
+
+                  if field[:index] == :unique
+                    lines << "      add_index :#{field[:name]}, unique: true"
+                  elsif field[:index]
+                    lines << "      add_index :#{field[:name]}"
+                  end
+
+                  if field[:composite_index]
+                    cols_str = field[:composite_index].map { |c| ":#{c}" }.join(", ")
+                    lines << "      add_index [#{cols_str}]"
+                  end
+                end
+              end
+
+              lines << "    end"
+              lines << "  end"
+              lines << "end"
+              lines.join("\n") + "\n"
+            end
+
+            def build_drop_columns
+              table = detection[:table_name]
+              lines = []
+              lines << "Sequel.migration do"
+              lines << "  change do"
+              lines << "    alter_table(:#{table}) do"
+
+              fields.each do |field|
+                lines << "      drop_column :#{field[:name]}"
+              end
+
+              lines << "    end"
+              lines << "  end"
+              lines << "end"
+              lines.join("\n") + "\n"
+            end
+
+            def build_create_join_table
+              tables = detection[:tables] || []
+              args_str = tables.map { |fk, tbl| "#{fk}: :#{tbl}" }.join(", ")
+
+              lines = []
+              lines << "Sequel.migration do"
+              lines << "  change do"
+              lines << "    create_join_table(#{args_str})"
+              lines << "  end"
+              lines << "end"
+              lines.join("\n") + "\n"
+            end
+
+            def build_generic
+              <<~RUBY
+                Sequel.migration do
+                  up do
+                    # add your migration here
+                  end
+
+                  down do
+                    # remove your migration here
+                  end
+                end
+              RUBY
+            end
+
+            def format_options(opts)
+              return "" if opts.empty?
+
+              formatted = opts.map do |k, v|
+                val_str = case v
+                          when Array
+                            "[#{v.join(', ')}]"
+                          when Symbol
+                            ":#{v}"
+                          else
+                            v.inspect
+                          end
+                "#{k}: #{val_str}"
+              end.join(", ")
+
+              ", #{formatted}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roda/project/bin/generators/migration/field_parser.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+class Roda
+  module Project
+    module Bin
+      class Generators
+        class Migration
+          class FieldParser
+            TYPE_MAP = {
+              "string" => "String",
+              "text" => "String",
+              "integer" => "Integer",
+              "bigint" => "Bignum",
+              "float" => "Float",
+              "decimal" => "BigDecimal",
+              "datetime" => "DateTime",
+              "timestamp" => "DateTime",
+              "time" => "Time",
+              "date" => "Date",
+              "boolean" => "TrueClass",
+              "binary" => "File",
+              "json" => ":json",
+              "jsonb" => ":jsonb",
+              "uuid" => ":uuid"
+            }.freeze
+
+            attr_reader :raw_fields
+
+            def initialize(raw_fields)
+              @raw_fields = raw_fields || []
+            end
+
+            def parse
+              fields = []
+
+              raw_fields.each do |raw_field|
+                parts = raw_field.to_s.split(":")
+                next if parts.empty?
+
+                name = parts[0]
+                type_part = parts[1] || "string"
+                index_part = parts[2]
+
+                # Extract modifier e.g. string{50}, decimal{10.2}, references{polymorphic}
+                type, modifier = extract_type_and_modifier(type_part)
+
+                if type == "references" || type == "belongs_to"
+                  if modifier == "polymorphic"
+                    fields << {
+                      name: "#{name}_id",
+                      type: "Bignum",
+                      options: {},
+                      index: false,
+                      composite_index: ["#{name}_type", "#{name}_id"]
+                    }
+                    fields << {
+                      name: "#{name}_type",
+                      type: "String",
+                      options: {},
+                      index: false
+                    }
+                  else
+                    singular_name = singularize(name)
+                    plural_table = pluralize(singular_name)
+                    fields << {
+                      name: "#{name}_id",
+                      is_reference: true,
+                      target_table: plural_table,
+                      index: true,
+                      options: {}
+                    }
+                  end
+                else
+                  sequel_type = TYPE_MAP[type] || "String"
+                  options = {}
+
+                  options[:text] = true if type == "text"
+
+                  if modifier
+                    if modifier.include?(".")
+                      prec, scale = modifier.split(".").map(&:to_i)
+                      options[:size] = [prec, scale]
+                    elsif modifier =~ /^\d+$/
+                      options[:size] = modifier.to_i
+                    end
+                  end
+
+                  index_val = parse_index_spec(index_part)
+
+                  fields << {
+                    name: name,
+                    type: sequel_type,
+                    options: options,
+                    index: index_val
+                  }
+                end
+              end
+
+              fields
+            end
+
+            private
+
+            def extract_type_and_modifier(type_part)
+              if type_part =~ /^(.*?)\{(.*?)\}$/
+                [Regexp.last_match(1), Regexp.last_match(2)]
+              else
+                [type_part, nil]
+              end
+            end
+
+            def parse_index_spec(index_part)
+              case index_part
+              when "uniq", "unique"
+                :unique
+              when "index"
+                true
+              else
+                false
+              end
+            end
+
+            def singularize(str)
+              if str.end_with?("ies")
+                "#{str[0..-4]}y"
+              elsif str.end_with?("es") && !str.end_with?("ques")
+                str[0..-3]
+              elsif str.end_with?("s") && !str.end_with?("ss")
+                str[0..-2]
+              else
+                str
+              end
+            end
+
+            def pluralize(str)
+              return str if str.end_with?("s")
+
+              if str.end_with?("y") && !str.end_with?("ay", "ey", "oy", "uy")
+                "#{str[0..-2]}ies"
+              elsif str.end_with?("s", "x", "z", "ch", "sh")
+                "#{str}es"
+              else
+                "#{str}s"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roda/project/bin/generators/migration.rb

@@ -1,4 +1,5 @@
-# rubocop:disable Layout/HeredocIndentation
+# frozen_string_literal: true
+
 class Roda
   module Project
     module Bin
@@ -18,19 +19,12 @@ class Roda
             end.max || 0
             next_number = (max_number + 1).to_s.rjust(3, "0")
 
-            filename = File.join(migrations_path, "#{next_number}_#{migration_name}.rb")
-
-            content = <<~RUBY
-      Sequel.migration do
-        up do
-          # add your migration here
-        end
+            formatted_name = underscore(migration_name)
+            filename = File.join(migrations_path, "#{next_number}_#{formatted_name}.rb")
 
-        down do
-          # remove your migration here
-        end
-      end
-            RUBY
+            detection = ActionDetector.new(migration_name, args: field_args).detect
+            fields = FieldParser.new(field_args).parse
+            content = CodeBuilder.new(detection: detection, fields: fields).build
 
             File.write(filename, content)
             puts "* created migration: #{filename}"
@@ -43,9 +37,21 @@ class Roda
           def migration_name
             @migration_name ||= @args[0]
           end
+
+          def field_args
+            @field_args ||= (@args[1..] || [])
+          end
+
+          private
+
+          def underscore(str)
+            str.to_s.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+               .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+               .tr("-", "_")
+               .downcase
+          end
         end
       end
     end
   end
 end
-# rubocop:enable Layout/HeredocIndentation

data/lib/roda/project/helpers/inflections.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class Roda
+  module Project
+    module Helpers
+      module Inflections
+        module_function
+
+        def camelize(str)
+          return str if str =~ /[A-Z]/
+
+          str.split("_").map(&:capitalize).join
+        end
+
+        def underscore(str)
+          str.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+             .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+             .tr("-", "_")
+             .downcase
+        end
+
+        def pluralize(str)
+          return str if str.end_with?("s")
+
+          if str.end_with?("y") && !str.end_with?("ay", "ey", "oy", "uy")
+            "#{str[0..-2]}ies"
+          elsif str.end_with?("s", "x", "z", "ch", "sh")
+            "#{str}es"
+          else
+            "#{str}s"
+          end
+        end
+
+        def singularize(str)
+          if str.end_with?("ies")
+            "#{str[0..-4]}y"
+          elsif str.end_with?("es") && !str.end_with?("ques")
+            str[0..-3]
+          elsif str.end_with?("s") && !str.end_with?("ss")
+            str[0..-2]
+          else
+            str
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roda/project/version.rb

@@ -2,6 +2,6 @@
 
 class Roda
   module Project
-    VERSION = "0.1.9"
+    VERSION = "0.1.10"
   end
 end

data/lib/roda/project.rb

@@ -55,14 +55,21 @@ require "thor"
 require_relative "project/helpers/ids"
 require_relative "project/helpers/interactive_input"
 require_relative "project/helpers/template"
+require_relative "project/helpers/inflections"
 # Base
 require_relative "project/main_context"
 require_relative "project/generator"
 require_relative "project/cli"
-# Generators
+# Generators/base
 require_relative "project/bin/generator"
+# Generators/migration
 require_relative "project/bin/generators/migration"
+require_relative "project/bin/generators/migration/action_detector"
+require_relative "project/bin/generators/migration/field_parser"
+require_relative "project/bin/generators/migration/code_builder"
+# Generators/routes
 require_relative "project/bin/generators/routes"
+# Generators/base
 require_relative "project/bin/generators"
 # Version
 require_relative "project/version"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: roda-project
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.10
 platform: ruby
 authors:
 - Henrique F. Teixeira
@@ -80,10 +80,14 @@ files:
 - lib/roda/project/bin/generator.rb
 - lib/roda/project/bin/generators.rb
 - lib/roda/project/bin/generators/migration.rb
+- lib/roda/project/bin/generators/migration/action_detector.rb
+- lib/roda/project/bin/generators/migration/code_builder.rb
+- lib/roda/project/bin/generators/migration/field_parser.rb
 - lib/roda/project/bin/generators/routes.rb
 - lib/roda/project/cli.rb
 - lib/roda/project/generator.rb
 - lib/roda/project/helpers/ids.rb
+- lib/roda/project/helpers/inflections.rb
 - lib/roda/project/helpers/interactive_input.rb
 - lib/roda/project/helpers/template.rb
 - lib/roda/project/main_context.rb