roda-project 0.1.8 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e2e4f0e1a643cc30ca1efff43c571e29acf2ef47385c8fb6b5b1b1553641d6b
-  data.tar.gz: 0f81e9706caee934a023ba77243fc21447a39279719713e610c237136ae66a01
+  metadata.gz: b31e88696427968c61a574f01c1860abcede888273244d75d258bacc35da4935
+  data.tar.gz: b24dc4b5f0ad6a8e9acc24dd192e927c6c6251dd3d163088daf862e941d52e71
 SHA512:
-  metadata.gz: 4f27ffba5ba456ec2d937f69f1781f58193fc27567bf0ac3d7ea83edad23e948f3d127b3f608ca354cec3746bad1dcba85203bcd529a64c156734a38ded7a9d2
-  data.tar.gz: 104494e4ff9bb346b440ac9b0be67d430653861079cdea90e99e813a7aad8236d63609bfbd0fb8bf2bb3043718e3fb6e8001cd5ccae59ee384a22eb4ba9123b8
+  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/bin/generators/routes.rb

@@ -13,6 +13,7 @@ class Roda
             generate_routes
             generate_views
             generate_tests
+            print_nested_branch_reminder
           end
 
           private
@@ -25,9 +26,19 @@ class Roda
               "    r.#{method} \"#{name}\" do#{view_line}\n    end"
             end.join("\n\n")
 
+            hash_branch_header = if branch_name.include?("/")
+              parts = branch_name.split("/")
+              sub_path = parts[0..-2].join("/")
+              namespace = sub_path.include?("/") ? ":\"#{sub_path}\"" : ":#{sub_path}"
+              branch_segment = parts.last
+              "hash_branch #{namespace}, \"#{branch_segment}\" do |r|"
+            else
+              "hash_branch \"#{branch_name}\" do |r|"
+            end
+
             content = <<~RUBY
       class #{@context.const_project_name}
-        hash_branch "#{branch_name}" do |r|
+        #{hash_branch_header}
       #{route_definitions}
         end
       end
@@ -99,6 +110,20 @@ class Roda
           def branch_name
             @branch_name ||= @args[0]
           end
+
+          def print_nested_branch_reminder
+            return unless branch_name.include?("/")
+
+            parts = branch_name.split("/")
+            sub_path = parts[0..-2].join("/")
+            namespace = sub_path.include?("/") ? ":\"#{sub_path}\"" : ":#{sub_path}"
+
+            puts "\ndont forget to add:\n\n" \
+                 "autoload_hash_branch_dir(#{namespace}, \"./app/routes/#{sub_path}\")\n\n" \
+                 "route do |r|\n" \
+                 " r.on(\"#{sub_path}\") { r.hash_branches(#{namespace}) }\n" \
+                 "end\n"
+          end
         end
       end
     end

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/templates/base/app/app.rb.erb

@@ -1,6 +1,6 @@
 class <%= context.const_project_name %> < Roda
   # Routing<% if context.fullstack? %>
-  plugin :hash_branch_view_subdir<% end %>
+  plugin :hash_branch_view_namespace<% end %>
   plugin :autoload_hash_branches
   autoload_hash_branch_dir("./app/routes")
   plugin :all_verbs

data/lib/roda/project/templates/base/scaffold/Gemfile.erb

@@ -23,6 +23,7 @@ gem "puma"
 
 # Views
 gem 'roda-assets_manifest'
+gem 'roda-hash_branch_view_namespace'
 <% end %>
 # Performance
 gem "oj"

data/lib/roda/project/version.rb

@@ -2,6 +2,6 @@
 
 class Roda
   module Project
-    VERSION = "0.1.8"
+    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.8
+  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