bunko 0.2.0

data/lib/tasks/bunko/setup.rake

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "helpers"
+
+namespace :bunko do
+  include Bunko::RakeHelpers
+
+  desc "Set up Bunko by creating all configured PostTypes and Collections"
+  task setup: :environment do
+    puts "Setting up Bunko..."
+    puts ""
+
+    post_types = Bunko.configuration.post_types
+    collections = Bunko.configuration.collections
+    allow_static_pages = Bunko.configuration.allow_static_pages
+
+    if post_types.empty? && !allow_static_pages
+      puts "⚠️  No post types configured and static pages are disabled."
+      puts "   Either enable static pages or add post types to config/initializers/bunko.rb"
+      puts ""
+      puts "   Example:"
+      puts "   config.allow_static_pages = true"
+      puts "   # OR"
+      puts "   config.post_type \"blog\""
+      puts "   config.post_type \"docs\" do |type|"
+      puts "     type.title = \"Documentation\""
+      puts "   end"
+      exit
+    end
+
+    # Generate shared partials once
+    puts "Generating shared partials..."
+    generate_shared_nav
+    generate_shared_styles
+    generate_shared_footer
+    puts ""
+
+    # Set up static pages if enabled
+    if allow_static_pages
+      puts "Setting up static pages..."
+      setup_static_pages
+      puts ""
+    end
+
+    # Add all post types
+    post_types.each do |pt_config|
+      Rake::Task["bunko:add"].reenable
+      Rake::Task["bunko:add"].invoke(pt_config[:name])
+    end
+
+    # Add all collections
+    collections.each do |collection_config|
+      Rake::Task["bunko:add"].reenable
+      Rake::Task["bunko:add"].invoke(collection_config[:name])
+    end
+
+    puts "=" * 79
+    puts "Setup complete!"
+    puts ""
+    puts "Next steps:"
+    puts "  1. Create your first post in the Rails console or admin panel"
+    puts "  2. Visit your collections:"
+
+    # Show PostType routes
+    post_types.each do |pt|
+      url_path = pt[:name].tr("_", "-")
+      puts "     http://localhost:3000/#{url_path}"
+    end
+
+    # Show Collection routes
+    collections.each do |c|
+      url_path = c[:name].tr("_", "-")
+      puts "     http://localhost:3000/#{url_path} (collection: #{c[:post_types].join(", ")})"
+    end
+
+    puts "=" * 79
+    puts ""
+    puts "To add more later, update your initializer and run:"
+    puts "  rails bunko:add[name]"
+    puts "=" * 79
+  end
+
+  # Helper methods
+
+  def generate_shared_nav
+    shared_dir = Rails.root.join("app/views/shared")
+    nav_file = shared_dir.join("_bunko_nav.html.erb")
+
+    if File.exist?(nav_file)
+      puts "  - _bunko_nav.html.erb already exists (skipped)"
+      return false
+    end
+
+    FileUtils.mkdir_p(shared_dir)
+
+    nav_content = render_template("views/layouts/bunko_nav.html.erb.tt", {})
+    File.write(nav_file, nav_content)
+
+    puts "  ✓ Created shared/_bunko_nav.html.erb"
+    true
+  end
+
+  def generate_shared_styles
+    shared_dir = Rails.root.join("app/views/shared")
+    styles_file = shared_dir.join("_bunko_styles.html.erb")
+
+    if File.exist?(styles_file)
+      puts "  - _bunko_styles.html.erb already exists (skipped)"
+      return false
+    end
+
+    FileUtils.mkdir_p(shared_dir)
+
+    styles_content = render_template("views/layouts/bunko_styles.html.erb.tt", {})
+    File.write(styles_file, styles_content)
+
+    puts "  ✓ Created shared/_bunko_styles.html.erb"
+    true
+  end
+
+  def generate_shared_footer
+    shared_dir = Rails.root.join("app/views/shared")
+    footer_file = shared_dir.join("_bunko_footer.html.erb")
+
+    if File.exist?(footer_file)
+      puts "  - _bunko_footer.html.erb already exists (skipped)"
+      return false
+    end
+
+    FileUtils.mkdir_p(shared_dir)
+
+    footer_content = render_template("views/layouts/bunko_footer.html.erb.tt", {})
+    File.write(footer_file, footer_content)
+
+    puts "  ✓ Created shared/_bunko_footer.html.erb"
+    true
+  end
+
+  def setup_static_pages
+    # Create "pages" PostType in database
+    PostType.find_or_create_by!(name: "pages") do |pt|
+      pt.title = "Pages"
+    end
+    puts "  ✓ Created 'pages' PostType in database"
+
+    # Generate PagesController
+    generate_pages_controller
+
+    # Generate pages/show.html.erb view
+    generate_pages_show_view
+  end
+
+  def generate_pages_controller
+    controller_path = Rails.root.join("app/controllers/pages_controller.rb")
+
+    if File.exist?(controller_path)
+      puts "  - pages_controller.rb already exists (skipped)"
+      return false
+    end
+
+    controller_content = render_template("controllers/pages_controller.rb.tt", {})
+    File.write(controller_path, controller_content)
+
+    puts "  ✓ Created app/controllers/pages_controller.rb"
+    true
+  end
+
+  def generate_pages_show_view
+    views_dir = Rails.root.join("app/views/pages")
+    show_file = views_dir.join("show.html.erb")
+
+    if File.exist?(show_file)
+      puts "  - pages/show.html.erb already exists (skipped)"
+      return false
+    end
+
+    FileUtils.mkdir_p(views_dir)
+
+    show_content = render_template("views/pages/show.html.erb.tt", {})
+    File.write(show_file, show_content)
+
+    puts "  ✓ Created app/views/pages/show.html.erb"
+    true
+  end
+end

data/lib/tasks/support/sample_data_generator.rb

@@ -0,0 +1,399 @@
+# frozen_string_literal: true
+
+module Bunko
+  # Simple sample data generator for creating realistic-looking posts
+  # No external dependencies - uses built-in Ruby randomization
+  module SampleDataGenerator
+    # Word pools for generating varied content
+    NOUNS = %w[system interface component module feature service platform application framework
+      solution architecture database network security authentication authorization deployment
+      integration workflow pipeline process functionality capability performance scalability
+      infrastructure configuration management monitoring analytics documentation implementation
+      optimization validation testing deployment].freeze
+
+    VERBS = %w[build create develop implement integrate configure optimize enhance improve streamline
+      automate manage deploy monitor analyze validate test debug refactor scale maintain
+      upgrade migrate extend customize adapt transform modernize accelerate simplify].freeze
+
+    ADJECTIVES = %w[efficient powerful flexible robust scalable secure reliable fast modern advanced
+      comprehensive intuitive seamless integrated automated intelligent dynamic responsive
+      innovative cutting-edge enterprise production-ready cloud-native distributed].freeze
+
+    TECH_TERMS = %w[API REST GraphQL microservice container orchestration Kubernetes Docker CI/CD
+      authentication JWT OAuth serverless lambda function middleware cache Redis
+      PostgreSQL MongoDB WebSocket HTTP HTTPS SSL TLS encryption algorithm].freeze
+
+    COMPANIES = %w[TechCorp DataSystems CloudWorks InnovateLabs ScaleUp DevOps Solutions
+      Enterprise Digital Ventures Analytics Group Platform Technologies
+      NetworkPro SecureBase CodeCraft BuildTools DeployFirst].freeze
+
+    LOREM_WORDS = %w[lorem ipsum dolor sit amet consectetur adipiscing elit sed do eiusmod tempor
+      incididunt ut labore et dolore magna aliqua enim ad minim veniam quis nostrud
+      exercitation ullamco laboris nisi aliquip ex ea commodo consequat duis aute
+      irure in reprehenderit voluptate velit esse cillum fugiat nulla pariatur
+      excepteur sint occaecat cupidatat non proident sunt culpa qui officia deserunt
+      mollit anim id est laborum].freeze
+
+    # Safe external links for sample content
+    SAFE_LINKS = [
+      {url: "https://github.com/kanejamison/bunko", text: "Bunko on GitHub"},
+      {url: "https://rubyonrails.org", text: "Ruby on Rails"},
+      {url: "https://www.ruby-lang.org", text: "Ruby Language"},
+      {url: "https://rubygems.org", text: "RubyGems"}
+    ].freeze
+
+    # Random image dimensions from picsum.photos
+    IMAGE_SIZES = [
+      {width: 800, height: 400, type: :hero},
+      {width: 1200, height: 600, type: :hero},
+      {width: 700, height: 500, type: :content},
+      {width: 600, height: 400, type: :content},
+      {width: 500, height: 350, type: :content},
+      {width: 400, height: 300, type: :inline}
+    ].freeze
+
+    # Supported content formats
+    FORMATS = [:markdown, :html].freeze
+
+    class << self
+      # Generate a random word from various pools
+      def word(type = :general)
+        case type
+        when :noun then NOUNS.sample
+        when :verb then VERBS.sample
+        when :adjective then ADJECTIVES.sample
+        when :tech then TECH_TERMS.sample
+        when :company then COMPANIES.sample
+        else LOREM_WORDS.sample
+        end
+      end
+
+      # Generate a sentence with specified word count and optional formatting
+      def sentence(word_count: nil, capitalize: true, format: :plain)
+        # Vary sentence length: 20% short (3-5 words), 80% medium (8-15 words)
+        word_count ||= (rand < 0.2) ? rand(3..5) : rand(8..15)
+
+        words = Array.new(word_count) { LOREM_WORDS.sample }
+        sentence = words.join(" ")
+        sentence = sentence.capitalize if capitalize
+        sentence = "#{sentence}."
+
+        # Randomly apply inline formatting (30% chance)
+        if format != :plain && rand < 0.3
+          sentence = apply_inline_formatting(sentence, format)
+        end
+
+        sentence
+      end
+
+      # Generate a paragraph with specified sentence count and optional formatting
+      def paragraph(sentence_count: nil, format: :plain)
+        # Vary paragraph length: 25% short (1-2 sentences), 75% medium (4-8 sentences)
+        sentence_count ||= (rand < 0.25) ? rand(1..2) : rand(4..8)
+
+        text = Array.new(sentence_count) { sentence(format: format) }.join(" ")
+
+        # Wrap in paragraph tags for HTML (20% chance for class)
+        if format == :html
+          css_class = (rand < 0.2) ? " class=\"content-paragraph\"" : ""
+          text = "<p#{css_class}>#{text}</p>"
+        end
+
+        text
+      end
+
+      # Generate multiple paragraphs with optional formatting
+      def paragraphs(count: 3, target_words: nil, format: :plain)
+        paras = if target_words
+          # Calculate sentences needed (avg 12 words per sentence)
+          sentences_needed = (target_words / 12.0).ceil
+          # Group into paragraphs (4-8 sentences each)
+          paragraph_count = [(sentences_needed / 6.0).ceil, 1].max
+
+          Array.new(paragraph_count) do
+            sentences_in_paragraph = [sentences_needed / paragraph_count, 1].max
+            paragraph(sentence_count: sentences_in_paragraph, format: format)
+          end
+        else
+          Array.new(count) { paragraph(format: format) }
+        end
+
+        # Randomly add special elements (lists, blockquotes, links)
+        paras = inject_special_elements(paras, format) if format != :plain
+
+        paras.join("\n\n")
+      end
+
+      # Generate a random date in the past
+      def past_date(years_ago: 2)
+        seconds_ago = rand(0..(years_ago * 365 * 24 * 60 * 60))
+        Time.now - seconds_ago
+      end
+
+      # Generate a random date in the future
+      def future_date(months_ahead: 3)
+        seconds_ahead = rand(0..(months_ahead * 30 * 24 * 60 * 60))
+        Time.now + seconds_ahead
+      end
+
+      # Generate a title
+      def title_for(post_type_name)
+        [
+          "#{VERBS.sample.capitalize} Your #{NOUNS.sample.capitalize} with #{ADJECTIVES.sample.capitalize} #{NOUNS.sample.capitalize}",
+          "How to #{VERBS.sample.capitalize} #{ADJECTIVES.sample.capitalize} #{NOUNS.sample.capitalize}",
+          "The Complete Guide to #{NOUNS.sample.capitalize} #{NOUNS.sample.capitalize}",
+          "Understanding #{ADJECTIVES.sample.capitalize} #{NOUNS.sample.capitalize}",
+          "#{rand(5..10)} Ways to #{VERBS.sample.capitalize} Your #{NOUNS.sample.capitalize}",
+          "#{ADJECTIVES.sample.capitalize} #{NOUNS.sample.capitalize} for #{NOUNS.sample.capitalize}",
+          "#{VERBS.sample.capitalize} #{NOUNS.sample.capitalize} Like a Pro",
+          "A Deep Dive into #{ADJECTIVES.sample.capitalize} #{NOUNS.sample.capitalize}"
+        ].sample
+      end
+
+      # Generate content structure
+      def content_for(post_type_name, target_words:, format: :plain)
+        default_content(target_words, format)
+      end
+
+      private
+
+      # Content generator
+      def default_content(target_words, format = :plain)
+        section_words = target_words / 5
+        [
+          paragraphs(target_words: section_words * 0.5, format: format),
+          format_hero_image(format),
+          format_heading("#{ADJECTIVES.sample.capitalize} #{NOUNS.sample.capitalize}", format),
+          paragraphs(target_words: section_words * 0.5, format: format),
+          format_subheading("Key Points", format),
+          paragraphs(target_words: section_words * 0.4, format: format),
+          format_heading("#{VERBS.sample.capitalize} #{NOUNS.sample.capitalize}", format),
+          paragraphs(target_words: section_words * 0.6, format: format),
+          format_heading("#{ADJECTIVES.sample.capitalize} Approach", format),
+          paragraphs(target_words: section_words * 0.5, format: format),
+          format_subheading("Implementation Details", format),
+          paragraphs(target_words: section_words * 0.5, format: format),
+          format_heading("Summary", format),
+          paragraphs(target_words: section_words * 0.4, format: format)
+        ].join("\n\n")
+      end
+
+      def code_example(format = :plain)
+        method = VERBS.sample
+        obj = NOUNS.sample
+        param = NOUNS.sample
+        comment = sentence(word_count: rand(5..8)).chomp(".")
+
+        code_content = "# #{comment}\n#{obj} = #{obj.capitalize}.new(#{param}: '#{word(:adjective)}')\n#{obj}.#{method}!"
+
+        case format
+        when :markdown
+          "```ruby\n#{code_content}\n```"
+        when :html
+          css_class = (rand < 0.3) ? " class=\"code-block\"" : ""
+          "<pre#{css_class}><code>#{code_content}</code></pre>"
+        else
+          code_content
+        end
+      end
+
+      # Formatting helpers
+      def format_heading(text, format)
+        if format == :html
+          css_class = (rand < 0.3) ? " class=\"section-heading\"" : ""
+          "<h2#{css_class}>#{text}</h2>"
+        else
+          "## #{text}"
+        end
+      end
+
+      def format_subheading(text, format)
+        if format == :html
+          css_class = (rand < 0.3) ? " class=\"subsection-heading\"" : ""
+          "<h3#{css_class}>#{text}</h3>"
+        else
+          "### #{text}"
+        end
+      end
+
+      def apply_inline_formatting(text, format)
+        # Pick a random formatting style
+        style = [:bold, :italic, :underline].sample
+
+        # Find words to format (avoid the last word with period)
+        words = text.chomp(".").split
+        return text if words.length < 3
+
+        # Pick 1-5 consecutive words to format
+        num_words_to_format = [rand(1..5), words.length - 2].min
+        start_index = rand(1...(words.length - num_words_to_format))
+        words_to_format = words[start_index, num_words_to_format].join(" ")
+
+        formatted_text = case format
+        when :markdown
+          case style
+          when :bold then "**#{words_to_format}**"
+          when :italic then "_#{words_to_format}_"
+          when :underline then words_to_format # Markdown doesn't have underline
+          end
+        when :html
+          case style
+          when :bold then "<strong>#{words_to_format}</strong>"
+          when :italic then "<em>#{words_to_format}</em>"
+          when :underline then "<u>#{words_to_format}</u>"
+          end
+        else
+          words_to_format
+        end
+
+        # Replace the words with formatted version
+        words[start_index, num_words_to_format] = [formatted_text]
+        "#{words.join(" ")}."
+      end
+
+      def inject_special_elements(paragraphs, format)
+        return paragraphs if paragraphs.length < 2
+
+        # Randomly inject a blockquote (20% chance)
+        if rand < 0.2
+          quote_index = rand(1...paragraphs.length)
+          quote_text = sentence(word_count: rand(10..15), format: format)
+          paragraphs.insert(quote_index, format_blockquote(quote_text, format))
+        end
+
+        # Randomly inject a list (30% chance)
+        if rand < 0.3
+          list_index = rand(1...paragraphs.length)
+          paragraphs.insert(list_index, format_list(format))
+        end
+
+        # Randomly inject a code block (25% chance)
+        if rand < 0.25
+          code_index = rand(1...paragraphs.length)
+          paragraphs.insert(code_index, code_example(format))
+        end
+
+        # Randomly inject images (50% chance for 1-2 images)
+        # Skip first 3 paragraphs to give space after hero image
+        if rand < 0.5 && paragraphs.length > 3
+          num_images = rand(1..2)
+          num_images.times do
+            # Start from index 3 to avoid hero image area
+            image_index = rand(3...paragraphs.length)
+            paragraphs.insert(image_index, format_image(format))
+          end
+        end
+
+        # Randomly inject a link into one paragraph (40% chance)
+        if rand < 0.4 && paragraphs.any?
+          link_para_index = rand(0...paragraphs.length)
+          paragraphs[link_para_index] = inject_link(paragraphs[link_para_index], format)
+        end
+
+        paragraphs
+      end
+
+      def format_blockquote(text, format)
+        case format
+        when :markdown
+          "> #{text}"
+        when :html
+          css_class = (rand < 0.3) ? " class=\"content-quote\"" : ""
+          "<blockquote#{css_class}>#{text}</blockquote>"
+        else
+          text
+        end
+      end
+
+      def format_list(format)
+        items = rand(3..5).times.map { "#{VERBS.sample.capitalize} #{NOUNS.sample}" }
+        # 50% chance for ordered list, 50% for unordered
+        ordered = rand < 0.5
+
+        case format
+        when :markdown
+          if ordered
+            items.map.with_index(1) { |item, i| "#{i}. #{item}" }.join("\n")
+          else
+            items.map { |item| "- #{item}" }.join("\n")
+          end
+        when :html
+          css_class = (rand < 0.3) ? " class=\"content-list\"" : ""
+          list_items = items.map { |item| "<li>#{item}</li>" }.join("\n")
+          if ordered
+            "<ol#{css_class}>\n#{list_items}\n</ol>"
+          else
+            "<ul#{css_class}>\n#{list_items}\n</ul>"
+          end
+        else
+          items.join(", ")
+        end
+      end
+
+      def inject_link(text, format)
+        link_data = SAFE_LINKS.sample
+
+        case format
+        when :markdown
+          # Append link after paragraph
+          "#{text} Learn more about [#{link_data[:text]}](#{link_data[:url]})."
+        when :html
+          # Inject link inside the paragraph tag (before closing </p>)
+          if text.include?("</p>")
+            text.sub("</p>", " Learn more about <a href=\"#{link_data[:url]}\">#{link_data[:text]}</a>.</p>")
+          else
+            # Fallback for non-paragraph HTML
+            "#{text} Learn more about <a href=\"#{link_data[:url]}\">#{link_data[:text]}</a>."
+          end
+        else
+          text
+        end
+      end
+
+      def format_hero_image(format)
+        # Hero images are always the largest sizes
+        hero_sizes = IMAGE_SIZES.select { |img| img[:type] == :hero }
+        image = hero_sizes.sample
+        width = image[:width]
+        height = image[:height]
+
+        # Generate random seed for consistent random image
+        seed = rand(1..1000)
+        image_url = "https://picsum.photos/#{width}/#{height}?random=#{seed}"
+        alt_text = "#{ADJECTIVES.sample.capitalize} #{NOUNS.sample}"
+
+        case format
+        when :markdown
+          "![#{alt_text}](#{image_url})"
+        when :html
+          "<img src=\"#{image_url}\" alt=\"#{alt_text}\" width=\"#{width}\" height=\"#{height}\" class=\"hero-image\">"
+        else
+          ""
+        end
+      end
+
+      def format_image(format)
+        # Select a random image size (excluding hero sizes for inline images)
+        non_hero_sizes = IMAGE_SIZES.reject { |img| img[:type] == :hero }
+        image = non_hero_sizes.sample
+        width = image[:width]
+        height = image[:height]
+
+        # Generate random seed for consistent random image
+        seed = rand(1..1000)
+        image_url = "https://picsum.photos/#{width}/#{height}?random=#{seed}"
+        alt_text = "#{ADJECTIVES.sample.capitalize} #{NOUNS.sample}"
+
+        case format
+        when :markdown
+          "![#{alt_text}](#{image_url})"
+        when :html
+          css_class = (rand < 0.3) ? " class=\"content-image\"" : ""
+          "<img src=\"#{image_url}\" alt=\"#{alt_text}\" width=\"#{width}\" height=\"#{height}\"#{css_class}>"
+        else
+          ""
+        end
+      end
+    end
+  end
+end

data/lib/tasks/templates/INSTALL.md

@@ -0,0 +1,62 @@
+===============================================================================
+
+Bunko has been installed!
+
+Migrations, models, and initializer have been created.
+
+Next steps:
+
+1. (Optional) Customize your post types in config/initializers/bunko.rb
+
+   We've configured "blog" for you, but you can change that or add more:
+
+   config.post_type "blog"  # Title auto-generated as "Blog"
+
+   config.post_type "docs" do |type|
+     type.title = "Documentation"
+   end
+
+   config.post_type "changelog"
+
+2. Run the migrations:
+
+   $ rails db:migrate
+
+3. Run the setup task:
+
+   $ rails bunko:setup
+
+   This will:
+   - Create PostTypes from your config
+   - Generate controllers for each post type
+   - Generate views (index, show) for each post type
+   - Add routes for each post type
+
+   Safe to re-run if you add more types later!
+
+4. Create your first post (Rails console or admin panel):
+
+   blog_type = PostType.find_by(name: "blog")
+   Post.create!(
+     title: "Welcome to Bunko",
+     content: "Your first blog post!",
+     post_type: blog_type,
+     status: "published",
+     published_at: Time.current
+   )
+
+5. Start your server and visit:
+
+   http://localhost:3000/blog
+
+Want to add more collections later?
+   1. Add the post type to config/initializers/bunko.rb
+   2. Run either:
+      - rails bunko:setup[product]  (set up just the new "product" collection)
+      - rails bunko:setup           (set up all collections, safe to re-run unless you delete any setup files on other models)
+   3. Done! Controllers, views, and routes are generated automatically.
+
+Need help? Check out the documentation at:
+https://github.com/kanejamison/bunko
+
+===============================================================================

data/lib/tasks/templates/config/initializers/bunko.rb.tt

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+Bunko.configure do |config|
+  # Define your post types (use lowercase with underscores)
+  # These will be created when you run: rails bunko:setup
+  config.post_type "blog" # Title will be auto-generated as "Blog"
+
+  # Want more? Add additional post types:
+  # config.post_type "docs" do |type|
+  #   type.title = "Documentation" # Custom title (optional)
+  # end
+  #
+  # config.post_type "changelog" # Title: "Changelog"
+  #
+  # config.post_type "case_studies" do |type|
+  #   type.title = "Case Studies" # Custom title
+  # end
+  #
+  # Note: Names use underscores, URLs automatically use hyphens (/case-studies/)
+
+  # Smart collections - aggregate or filter posts from multiple post types
+  # config.collection "resources", post_types: ["articles", "videos", "tutorials"]
+  # config.collection "long_reads" do |c|
+  #   c.post_types = ["articles", "tutorials"]
+  #   c.scope = -> { where("word_count > ?", 1500) }
+  # end
+
+  # Enable standalone pages feature (About, Contact, Privacy, etc.)
+  # When enabled, rails bunko:setup creates a PagesController and pages PostType
+  # Use bunko_page :about in routes to create single-page routes
+  # Default: true
+  # config.allow_static_pages = true
+
+  # Reading speed for calculating estimated reading time (in words per minute)
+  # Default: 250
+  # config.reading_speed = 250
+
+  # Excerpt length for post.excerpt method (in characters)
+  # Default: 160
+  # config.excerpt_length = 160
+
+  # Automatically update word_count when content changes
+  # Default: true
+  # config.auto_update_word_count = true
+end