bunko 0.2.0

data/lib/tasks/bunko/add.rake

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "helpers"
+
+namespace :bunko do
+  include Bunko::RakeHelpers
+
+  desc "Add a PostType or Collection (automatically detects which)"
+  task :add, [:name] => :environment do |t, args|
+    unless args[:name]
+      puts "⚠️  Please provide a name"
+      puts "   Usage: rails bunko:add[blog]"
+      exit 1
+    end
+
+    name = args[:name]
+    format = ENV.fetch("FORMAT", "html").downcase
+
+    # Validate format
+    valid_formats = %w[plain html]
+    unless valid_formats.include?(format)
+      puts "⚠️  Invalid format: #{format}"
+      puts "    Valid formats: #{valid_formats.join(", ")}"
+      exit 1
+    end
+
+    # Check if it's a PostType
+    pt_config = Bunko.configuration.post_types.find { |pt| pt[:name] == name }
+
+    # Check if it's a Collection
+    collection_config = Bunko.configuration.collections.find { |c| c[:name] == name }
+
+    unless pt_config || collection_config
+      # Not found in either
+      puts "⚠️  '#{name}' not found in configuration"
+      puts ""
+
+      available_post_types = Bunko.configuration.post_types.map { |pt| pt[:name] }
+      available_collections = Bunko.configuration.collections.map { |c| c[:name] }
+
+      if available_post_types.any?
+        puts "   Available PostTypes: #{available_post_types.join(", ")}"
+      end
+
+      if available_collections.any?
+        puts "   Available Collections: #{available_collections.join(", ")}"
+      end
+
+      puts ""
+      puts "   Add it to config/initializers/bunko.rb first:"
+      puts "   config.post_type \"#{name}\""
+      puts "   # or"
+      puts "   config.collection \"#{name}\" do |c|"
+      puts "     c.post_types = [...]"
+      puts "   end"
+      exit 1
+    end
+
+    # Step 1: If it's a PostType, create DB entry
+    if pt_config
+      create_post_type_in_database(name, pt_config[:title])
+    end
+
+    # Step 2: Always generate artifacts (for both PostTypes and Collections)
+    is_collection = collection_config.present?
+    generate_artifacts(name, format: format, is_collection: is_collection)
+
+    # Step 3: Add to nav
+    if pt_config
+      add_to_nav(name, title: pt_config[:title])
+    else
+      add_to_nav(name, title: collection_config[:title])
+    end
+
+    # Success message
+    puts ""
+    if pt_config
+      puts "PostType '#{name}' added successfully!"
+    else
+      puts "Collection '#{name}' added successfully!"
+    end
+    puts "Visit: http://localhost:3000/#{name.tr("_", "-")}"
+  end
+
+  # Helper methods
+
+  def create_post_type_in_database(name, title)
+    post_type = PostType.find_by(name: name)
+
+    if post_type
+      puts "  ✓ PostType already exists: #{title} (#{name})"
+    else
+      PostType.create!(name: name, title: title)
+      puts "  ✓ Created PostType: #{title} (#{name})"
+    end
+    puts ""
+  end
+
+  def generate_artifacts(name, format:, is_collection:)
+    # Step 1: Generate controller
+    puts "Generating controller..."
+    generate_controller(name)
+    puts ""
+
+    # Step 2: Generate views
+    puts "Generating views..."
+    generate_views(name, format: format, is_collection: is_collection)
+    puts ""
+
+    # Step 3: Add route
+    puts "Adding route..."
+    add_route(name)
+  end
+
+  def generate_controller(collection_name)
+    controller_name = "#{collection_name.camelize}Controller"
+    controller_file = Rails.root.join("app/controllers/#{collection_name}_controller.rb")
+
+    if File.exist?(controller_file)
+      puts "  - #{collection_name}_controller.rb already exists (skipped)"
+      return false
+    end
+
+    controller_content = render_template("controllers/controller.rb.tt", {
+      controller_name: controller_name,
+      collection_name: collection_name
+    })
+
+    File.write(controller_file, controller_content)
+    puts "  ✓ Created #{collection_name}_controller.rb"
+    true
+  end
+
+  def generate_views(collection_name, format:, is_collection:)
+    views_dir = Rails.root.join("app/views/#{collection_name}")
+
+    if Dir.exist?(views_dir) && Dir.glob("#{views_dir}/*").any?
+      puts "  - #{collection_name} views already exist (skipped)"
+      return false
+    end
+
+    FileUtils.mkdir_p(views_dir)
+
+    # Generate index.html.erb
+    index_content = generate_index_view(collection_name, is_collection: is_collection)
+    File.write(File.join(views_dir, "index.html.erb"), index_content)
+
+    # Collections only get index view, PostTypes get both index and show
+    if is_collection
+      puts "  ✓ Created views for #{collection_name} (index only - collection)"
+    else
+      # Generate show.html.erb for PostTypes only
+      show_content = generate_show_view(collection_name, format: format)
+      File.write(File.join(views_dir, "show.html.erb"), show_content)
+      puts "  ✓ Created views for #{collection_name} (index, show)"
+    end
+
+    true
+  end
+
+  def generate_index_view(collection_name, is_collection:)
+    is_plural = collection_name.pluralize == collection_name
+
+    render_template("views/collections/index.html.erb.tt", {
+      collection_name: collection_name,
+      collection_title: collection_name.titleize,
+      path_helper: "#{collection_name.singularize}_path",
+      index_path_helper: is_plural ? "#{collection_name}_path" : "#{collection_name}_index_path",
+      is_collection: is_collection
+    })
+  end
+
+  def generate_show_view(collection_name, format:)
+    is_plural = collection_name.pluralize == collection_name
+
+    render_template("views/collections/show.html.erb.tt", {
+      collection_name: collection_name,
+      collection_title: collection_name.titleize,
+      index_path_helper: is_plural ? "#{collection_name}_path" : "#{collection_name}_index_path",
+      format: format
+    })
+  end
+
+  def add_route(collection_name)
+    routes_file = Rails.root.join("config/routes.rb")
+    routes_content = File.read(routes_file)
+
+    route_line = "  bunko_collection :#{collection_name}"
+
+    if routes_content.include?(route_line.strip)
+      puts "  - Route for :#{collection_name} already exists (skipped)"
+      return false
+    end
+
+    # Find the last 'end' in the file and insert before it
+    lines = routes_content.lines
+    last_end_index = lines.rindex { |line| line.match?(/^end\s*$/) }
+
+    if last_end_index
+      lines.insert(last_end_index, "#{route_line}\n")
+      updated_content = lines.join
+    else
+      # Fallback: append before the last line if no 'end' found
+      updated_content = routes_content.sub(/\z/, "#{route_line}\n")
+    end
+
+    File.write(routes_file, updated_content)
+    puts "  ✓ Added route for :#{collection_name}"
+    true
+  end
+
+  def add_to_nav(name, title:)
+    shared_dir = Rails.root.join("app/views/shared")
+    nav_file = shared_dir.join("_bunko_nav.html.erb")
+
+    # If nav doesn't exist, generate from scratch (edge case)
+    unless File.exist?(nav_file)
+      FileUtils.mkdir_p(shared_dir)
+      nav_content = render_template("views/layouts/bunko_nav.html.erb.tt", {
+        post_types: Bunko.configuration.post_types,
+        collections: Bunko.configuration.collections
+      })
+      File.write(nav_file, nav_content)
+      puts "  ✓ Created shared/_bunko_nav.html.erb"
+      return true
+    end
+
+    # Nav exists - append new link to existing file
+    nav_content = File.read(nav_file)
+
+    # Generate the new link
+    is_plural = name.pluralize == name
+    path_helper = is_plural ? "#{name}_path" : "#{name}_index_path"
+    new_link = "      <%= link_to \"#{title}\", #{path_helper} %>\n"
+
+    # Check if link already exists (check for the title and path, not exact match)
+    if nav_content.match?(/link_to\s+"#{Regexp.escape(title)}",\s+#{path_helper}/)
+      puts "  - #{title} already in nav (skipped)"
+      return false
+    end
+
+    # Try to insert before the marker comment (preferred)
+    marker = "<%# bunko_collection_links - additional collections will be added here unless you delete this line %>"
+    nav_content = if nav_content.include?(marker)
+      nav_content.sub(marker, "#{new_link}      #{marker}")
+    else
+      # Fallback: Find the closing </div> before </nav> and insert the new link before it
+      nav_content.sub(/(\s*)<\/div>\s*<\/nav>/) do
+        indent = $1
+        "#{new_link}#{indent}</div>\n</nav>"
+      end
+    end
+
+    File.write(nav_file, nav_content)
+    puts "  ✓ Added #{title} to shared/_bunko_nav.html.erb"
+    true
+  end
+end

data/lib/tasks/bunko/helpers.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module Bunko
+  module RakeHelpers
+    def render_template(template_name, locals = {})
+      template_path = File.expand_path("../templates/#{template_name}", __dir__)
+
+      unless File.exist?(template_path)
+        raise "Template file not found: #{template_path}"
+      end
+
+      template_content = File.read(template_path)
+
+      # Create a context object with all local variables as methods
+      context = Object.new
+      locals.each do |key, value|
+        context.define_singleton_method(key) { value }
+      end
+
+      ERB.new(template_content, trim_mode: "-").result(context.instance_eval { binding })
+    end
+  end
+end

data/lib/tasks/bunko/install.rake

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "helpers"
+
+namespace :bunko do
+  include Bunko::RakeHelpers
+
+  desc "Install Bunko by creating migrations, models, and initializer"
+  task install: :environment do
+    puts "Installing Bunko..."
+    puts ""
+
+    # Parse options from environment variables
+    skip_seo = ENV["SKIP_SEO"] == "true"
+    json_content = ENV["JSON_CONTENT"] == "true"
+
+    # Step 1: Create migrations
+    puts "Creating migrations..."
+    create_post_types_migration(skip_seo: skip_seo, json_content: json_content)
+    sleep 1 # Ensure different timestamps
+    create_posts_migration(skip_seo: skip_seo, json_content: json_content)
+    puts ""
+
+    # Step 2: Create models
+    puts "Creating models..."
+    create_models
+    puts ""
+
+    # Step 3: Create initializer
+    puts "Creating initializer..."
+    create_initializer
+    puts ""
+
+    # Step 4: Show instructions
+    show_install_instructions
+  end
+
+  # Helper methods
+
+  def create_post_types_migration(skip_seo:, json_content:)
+    timestamp = Time.now.utc.strftime("%Y%m%d%H%M%S")
+    migration_file = Rails.root.join("db/migrate/#{timestamp}_create_post_types.rb")
+
+    if Dir.glob(Rails.root.join("db/migrate/*_create_post_types.rb")).any?
+      puts "  - create_post_types migration already exists (skipped)"
+      return false
+    end
+
+    migration_content = render_template("db/migrate/create_post_types.rb.tt", {
+      include_seo_fields?: !skip_seo,
+      use_json_content?: json_content
+    })
+
+    File.write(migration_file, migration_content)
+    puts "  ✓ Created db/migrate/#{timestamp}_create_post_types.rb"
+    true
+  end
+
+  def create_posts_migration(skip_seo:, json_content:)
+    timestamp = Time.now.utc.strftime("%Y%m%d%H%M%S")
+    migration_file = Rails.root.join("db/migrate/#{timestamp}_create_posts.rb")
+
+    if Dir.glob(Rails.root.join("db/migrate/*_create_posts.rb")).any?
+      puts "  - create_posts migration already exists (skipped)"
+      return false
+    end
+
+    migration_content = render_template("db/migrate/create_posts.rb.tt", {
+      include_seo_fields?: !skip_seo,
+      use_json_content?: json_content
+    })
+
+    File.write(migration_file, migration_content)
+    puts "  ✓ Created db/migrate/#{timestamp}_create_posts.rb"
+    true
+  end
+
+  def create_models
+    # Create Post model
+    post_file = Rails.root.join("app/models/post.rb")
+    if File.exist?(post_file)
+      puts "  - app/models/post.rb already exists (skipped)"
+    else
+      post_content = render_template("models/post.rb.tt", {})
+      File.write(post_file, post_content)
+      puts "  ✓ Created app/models/post.rb"
+    end
+
+    # Create PostType model
+    post_type_file = Rails.root.join("app/models/post_type.rb")
+    if File.exist?(post_type_file)
+      puts "  - app/models/post_type.rb already exists (skipped)"
+    else
+      post_type_content = render_template("models/post_type.rb.tt", {})
+      File.write(post_type_file, post_type_content)
+      puts "  ✓ Created app/models/post_type.rb"
+    end
+  end
+
+  def create_initializer
+    initializer_dir = Rails.root.join("config/initializers")
+    initializer_file = initializer_dir.join("bunko.rb")
+
+    if File.exist?(initializer_file)
+      puts "  - config/initializers/bunko.rb already exists (skipped)"
+      return false
+    end
+
+    FileUtils.mkdir_p(initializer_dir)
+    initializer_content = render_template("config/initializers/bunko.rb.tt", {})
+    File.write(initializer_file, initializer_content)
+    puts "  ✓ Created config/initializers/bunko.rb"
+    true
+  end
+
+  def show_install_instructions
+    instructions_path = File.expand_path("../templates/INSTALL.md", __dir__)
+    instructions = File.read(instructions_path)
+
+    puts "=" * 79
+    puts instructions
+    puts "=" * 79
+  end
+end

data/lib/tasks/bunko/sample_data.rake

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative "../support/sample_data_generator"
+
+namespace :bunko do
+  desc "Generate sample posts for all configured post types"
+  task sample_data: :environment do
+    # Warn if running in production
+    if Rails.env.production?
+      puts ""
+      puts "⚠️  WARNING: You're about to generate sample data in PRODUCTION"
+      puts "    Press Ctrl+C to cancel, or Enter to continue..."
+      $stdin.gets
+      puts ""
+    end
+
+    # Parse configuration from ENV
+    posts_per_type = ENV.fetch("COUNT", ENV.fetch("POSTS_PER_TYPE", "100")).to_i
+    min_words = ENV.fetch("MIN_WORDS", "500").to_i
+    max_words = ENV.fetch("MAX_WORDS", "2000").to_i
+    clear_existing = ENV.fetch("CLEAR", "false").downcase == "true"
+    format = ENV.fetch("FORMAT", "html").downcase.to_sym
+
+    # Validate format
+    unless Bunko::SampleDataGenerator::FORMATS.include?(format)
+      puts "⚠️  Invalid format: #{format}"
+      puts "    Valid formats: #{Bunko::SampleDataGenerator::FORMATS.join(", ")}"
+      puts ""
+      exit 1
+    end
+
+    puts "Bunko Sample Data Generator"
+    puts "=" * 79
+    puts "Configuration:"
+    puts "  Posts per type: #{posts_per_type}"
+    puts "  Word range: #{min_words}-#{max_words} words"
+    puts "  Content format: #{format}"
+    puts "  Clear existing: #{clear_existing ? "Yes" : "No"}"
+    puts ""
+
+    # Clear existing posts if requested
+    if clear_existing
+      puts "Clearing existing posts..."
+      Post.destroy_all
+      puts "✓ Cleared #{Post.count} posts"
+      puts ""
+    end
+
+    # Get all post types from database
+    post_types = PostType.all
+
+    if post_types.empty?
+      puts "⚠️  No post types found. Please run 'rails bunko:setup' first."
+      exit 1
+    end
+
+    puts "Generating posts for #{post_types.size} post types..."
+    puts ""
+
+    # Generate posts for each type
+    post_types.each do |post_type|
+      puts "#{post_type.title} (#{post_type.name}):"
+      print "  "
+
+      posts_per_type.times do |i|
+        # Create varied dates: 90% past, 10% future
+        published_at = if rand < 0.9
+          Bunko::SampleDataGenerator.past_date(years_ago: 2)
+        else
+          Bunko::SampleDataGenerator.future_date(months_ahead: 3)
+        end
+
+        # Generate title and content based on post type
+        title = Bunko::SampleDataGenerator.title_for(post_type.name)
+        target_words = rand(min_words..max_words)
+        content = Bunko::SampleDataGenerator.content_for(post_type.name, target_words: target_words, format: format)
+
+        # Create unique slug
+        base_slug = title.parameterize
+        slug = base_slug
+        counter = 1
+
+        while Post.exists?(post_type: post_type, slug: slug)
+          slug = "#{base_slug}-#{counter}"
+          counter += 1
+        end
+
+        # Create meta description
+        meta_description = Bunko::SampleDataGenerator.sentence(word_count: rand(15..25)).chomp(".")
+
+        # Create post
+        Post.create!(
+          post_type: post_type,
+          title: title,
+          slug: slug,
+          content: content,
+          meta_description: meta_description,
+          title_tag: "#{title} | Sample Site",
+          status: "published",
+          published_at: published_at
+        )
+
+        print "." if (i + 1) % 5 == 0
+      end
+
+      puts " ✓"
+    end
+
+    puts ""
+    puts "=" * 79
+    puts "Summary:"
+    post_types.each do |post_type|
+      count = Post.where(post_type: post_type).count
+      future_count = Post.where(post_type: post_type).where("published_at > ?", Time.current).count
+      avg_words = Post.where(post_type: post_type).average(:word_count).to_i
+      puts "  #{post_type.title}: #{count} posts (#{future_count} scheduled, avg #{avg_words} words)"
+    end
+    puts "=" * 79
+    puts ""
+    puts "Usage examples:"
+    puts "  rake bunko:sample_data                           # 100 posts per type (HTML with images)"
+    puts "  rake bunko:sample_data COUNT=50                  # 50 posts per type"
+    puts "  rake bunko:sample_data FORMAT=markdown           # Markdown formatted content"
+    puts "  rake bunko:sample_data MIN_WORDS=500 MAX_WORDS=1500"
+    puts "  rake bunko:sample_data CLEAR=true                # Clear existing first"
+    puts ""
+  end
+end