bunko 0.2.0

data/lib/bunko/controllers/acts_as.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Bunko
+  module Controllers
+    module ActsAs
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def bunko_collection(collection_name, **options)
+          include Bunko::Controllers::Collection
+
+          bunko_collection(collection_name, **options)
+        end
+      end
+    end
+  end
+end
+
+# Extend ActionController::Base with bunko_collection method
+if defined?(ActionController::Base)
+  ActionController::Base.include Bunko::Controllers::ActsAs
+end

data/lib/bunko/controllers/collection.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Bunko
+  module Controllers
+    module Collection
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :bunko_collection_name
+        class_attribute :bunko_collection_options
+      end
+
+      class_methods do
+        def bunko_collection(collection_name, **options)
+          self.bunko_collection_name = collection_name.to_s
+          self.bunko_collection_options = {
+            per_page: 10,
+            order: :published_at_desc
+          }.merge(options)
+
+          # Set layout if specified
+          layout(options[:layout]) if options[:layout]
+
+          # Define index and show actions
+          define_method :index do
+            load_collection
+          end
+
+          define_method :show do
+            load_post
+          end
+
+          # Make helpers available
+          helper_method :collection_name if respond_to?(:helper_method)
+        end
+      end
+
+      private
+
+      def load_collection
+        @collection_name = bunko_collection_name
+
+        # Smart lookup: Check PostType first, then Collection
+        post_type_config = Bunko.configuration.find_post_type(@collection_name)
+        collection_config = Bunko.configuration.find_collection(@collection_name)
+
+        if post_type_config
+          # Single PostType collection
+          @post_type = PostType.find_by(name: @collection_name)
+          unless @post_type
+            render plain: "PostType '#{@collection_name}' not found in database. Run: rails bunko:setup[#{@collection_name}]", status: :not_found
+            return
+          end
+
+          base_query = post_model.published.by_post_type(@collection_name)
+        elsif collection_config
+          # Multi-type collection
+          base_query = post_model.published.where(post_type: PostType.where(name: collection_config[:post_types]))
+
+          # Apply collection scope if defined
+          if collection_config[:scope]
+            base_query = base_query.instance_exec(&collection_config[:scope])
+          end
+        else
+          render plain: "Collection '#{@collection_name}' not found. Add it to config/initializers/bunko.rb", status: :not_found
+          return
+        end
+
+        # Apply ordering
+        ordered_query = apply_ordering(base_query)
+
+        # Apply pagination
+        @posts = paginate(ordered_query)
+        @pagination = pagination_metadata
+      end
+
+      def load_post
+        @collection_name = bunko_collection_name
+
+        # Smart lookup: Check PostType first, then Collection
+        post_type_config = Bunko.configuration.find_post_type(@collection_name)
+        collection_config = Bunko.configuration.find_collection(@collection_name)
+
+        # Collections should not have show routes (posts are accessed via their canonical PostType URL)
+        if collection_config
+          render plain: "Posts in this collection can only be accessed through their PostType URL. This collection only supports index.", status: :not_found
+          return
+        end
+
+        if post_type_config
+          # Single PostType collection
+          @post_type = PostType.find_by(name: @collection_name)
+          unless @post_type
+            render plain: "PostType '#{@collection_name}' not found in database. Run: rails bunko:setup[#{@collection_name}]", status: :not_found
+            return
+          end
+
+          base_query = post_model.published.by_post_type(@collection_name)
+        else
+          render plain: "Collection '#{@collection_name}' not found. Add it to config/initializers/bunko.rb", status: :not_found
+          return
+        end
+
+        # Find post by slug within this collection
+        @post = base_query.find_by(slug: params[:slug])
+
+        unless @post
+          render plain: "Post not found", status: :not_found
+        end
+      end
+
+      def post_model
+        @post_model ||= Post
+      end
+
+      def apply_ordering(query)
+        case bunko_collection_options[:order]
+        when :published_at_desc
+          query.reorder(published_at: :desc)
+        when :published_at_asc
+          query.reorder(published_at: :asc)
+        when :created_at_desc
+          query.reorder(created_at: :desc)
+        when :created_at_asc
+          query.reorder(created_at: :asc)
+        else
+          query
+        end
+      end
+
+      def paginate(query)
+        page_number = [params[:page].to_i, 1].max
+        per_page = bunko_collection_options[:per_page]
+
+        offset = (page_number - 1) * per_page
+
+        @_total_count = query.count
+        @_current_page = page_number
+        @_per_page = per_page
+
+        query.limit(per_page).offset(offset)
+      end
+
+      def pagination_metadata
+        {
+          current_page: @_current_page,
+          per_page: @_per_page,
+          total_count: @_total_count,
+          total_pages: (@_total_count.to_f / @_per_page).ceil,
+          prev_page: (@_current_page > 1) ? @_current_page - 1 : nil,
+          next_page: (@_current_page < (@_total_count.to_f / @_per_page).ceil) ? @_current_page + 1 : nil
+        }
+      end
+
+      def collection_name
+        @collection_name
+      end
+    end
+  end
+end

data/lib/bunko/controllers.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# Load all controller concerns
+require_relative "controllers/collection"
+require_relative "controllers/acts_as"

data/lib/bunko/models/acts_as.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Bunko
+  module Models
+    module ActsAs
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def acts_as_bunko_post
+          include Bunko::Models::PostMethods
+        end
+
+        def acts_as_bunko_post_type
+          include Bunko::Models::PostTypeMethods
+        end
+      end
+    end
+  end
+end
+
+# Extend ActiveRecord::Base with acts_as methods
+if defined?(ActiveRecord::Base)
+  ActiveRecord::Base.include Bunko::Models::ActsAs
+end

data/lib/bunko/models/post_methods/publishable.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Bunko
+  module Models
+    module PostMethods
+      module Publishable
+        extend ActiveSupport::Concern
+
+        included do
+          # Validations
+          validates :status, presence: true, inclusion: {
+            in: ->(_) { Bunko.configuration.valid_statuses },
+            message: "%{value} is not a valid status"
+          }
+
+          # Callbacks
+          before_validation :set_published_at, if: :should_set_published_at?
+          validate :validate_status_value
+
+          # Scopes
+          scope :published, -> { where(status: "published").where("published_at <= ?", Time.current).order(published_at: :desc) }
+          scope :draft, -> { where(status: "draft").order(created_at: :desc) }
+          scope :scheduled, -> { where(status: "published").where("published_at > ?", Time.current).order(published_at: :asc) }
+        end
+
+        # Instance method to check if post is scheduled for future publication
+        def scheduled?
+          status == "published" && published_at.present? && published_at > Time.current
+        end
+
+        private
+
+        def should_set_published_at?
+          status == "published" && published_at.blank?
+        end
+
+        def set_published_at
+          self.published_at = Time.current
+        end
+
+        def validate_status_value
+          return if status.blank?
+
+          unless Bunko.configuration.valid_statuses.include?(status)
+            raise ArgumentError, "#{status} is not a valid status"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bunko/models/post_methods/sluggable.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Bunko
+  module Models
+    module PostMethods
+      module Sluggable
+        extend ActiveSupport::Concern
+
+        included do
+          before_validation :generate_slug, if: :should_generate_slug?
+        end
+
+        private
+
+        def should_generate_slug?
+          slug.blank? && title.present?
+        end
+
+        def generate_slug
+          return if title.blank?
+
+          # Generate slug using parameterize, then normalize:
+          # 1. Convert underscores to hyphens (parameterize keeps them in Rails 8+)
+          # 2. Remove consecutive hyphens
+          # 3. Remove leading/trailing hyphens or underscores
+          base_slug = title.parameterize
+            .tr("_", "-").squeeze("-")
+            .gsub(/^[-_]+|[-_]+$/, "")
+
+          # Skip if slug would be empty (e.g., title with only non-Latin characters)
+          return if base_slug.blank?
+
+          self.slug = base_slug
+
+          # Ensure uniqueness within post_type
+          return unless self.class.unscoped.where(
+            post_type_id: post_type_id,
+            slug: slug
+          ).where.not(id: id).exists?
+
+          # Add random suffix if slug exists
+          self.slug = "#{base_slug}-#{SecureRandom.hex(4)}"
+        end
+      end
+    end
+  end
+end

data/lib/bunko/models/post_methods/word_countable.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Bunko
+  module Models
+    module PostMethods
+      module WordCountable
+        extend ActiveSupport::Concern
+
+        included do
+          before_save :update_word_count, if: :should_update_word_count?
+        end
+
+        # Instance methods
+        def reading_time
+          return nil unless word_count.present? && word_count > 0
+
+          (word_count.to_f / Bunko.configuration.reading_speed).ceil
+        end
+
+        def reading_time_text
+          return nil unless reading_time.present?
+
+          "#{reading_time} min read"
+        end
+
+        private
+
+        def should_update_word_count?
+          # Only update word_count if:
+          # 1. Auto-update is enabled in config
+          # 2. Content changed
+          # 3. Model has word_count attribute
+          Bunko.configuration.auto_update_word_count &&
+            content_changed? &&
+            respond_to?(:word_count=)
+        end
+
+        def update_word_count
+          if content.blank?
+            self.word_count = 0
+            return
+          end
+
+          # Check if content is a text field or JSON field
+          column = self.class.columns_hash["content"]
+
+          if column && [:json, :jsonb].include?(column.type)
+            # For JSON content, try to extract text recursively
+            self.word_count = count_words_in_json(content)
+          else
+            # For text content, strip HTML tags and count words
+            text = content.to_s.gsub(/<[^>]*>/, "")
+            self.word_count = text.split(/\s+/).count(&:present?)
+          end
+        end
+
+        def count_words_in_json(data)
+          case data
+          when String
+            # Strip HTML and count words in string
+            text = data.gsub(/<[^>]*>/, "")
+            text.split(/\s+/).count(&:present?)
+          when Hash
+            # Recursively count words in hash values
+            data.values.sum { |value| count_words_in_json(value) }
+          when Array
+            # Recursively count words in array elements
+            data.sum { |element| count_words_in_json(element) }
+          else
+            0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bunko/models/post_methods.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "post_methods/sluggable"
+require_relative "post_methods/word_countable"
+require_relative "post_methods/publishable"
+
+module Bunko
+  module Models
+    module PostMethods
+      extend ActiveSupport::Concern
+
+      include Sluggable
+      include WordCountable
+      include Publishable
+
+      included do
+        # Associations
+        belongs_to :post_type
+
+        # Validations
+        validates :title, presence: true
+        validates :slug,
+          presence: true,
+          uniqueness: {scope: :post_type_id},
+          format: {
+            with: /\A[a-z0-9]+(?:-[a-z0-9]+)*\z/,
+            message: "must contain only lowercase letters, numbers, and hyphens"
+          },
+          length: {maximum: 255}
+
+        # Default scope for ordering
+        default_scope { order(created_at: :desc) }
+      end
+
+      class_methods do
+        def by_post_type(type_name)
+          joins(:post_type).where(post_types: {name: type_name})
+        end
+      end
+
+      # Instance methods
+      def to_param
+        slug
+      end
+
+      def excerpt(length: nil, omission: "...")
+        return nil unless content.present?
+
+        # Use configured default if length not specified
+        length ||= Bunko.configuration.excerpt_length
+
+        # Strip HTML tags using Rails sanitizer (more robust than regex)
+        text = ActionView::Base.full_sanitizer.sanitize(content.to_s)
+
+        # Clean up extra whitespace
+        text = text.gsub(/\s+/, " ").strip
+
+        # Return full text if shorter than length
+        return text if text.length <= length
+
+        # Truncate to word boundary
+        truncated = text[0...length]
+        last_space = truncated.rindex(" ") || length
+
+        "#{truncated[0...last_space]}#{omission}"
+      end
+
+      def published_date(format = :long)
+        return nil unless published_at.present?
+
+        I18n.l(published_at, format: format)
+      end
+    end
+  end
+end

data/lib/bunko/models/post_type_methods.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Bunko
+  module Models
+    module PostTypeMethods
+      extend ActiveSupport::Concern
+
+      included do
+        # Associations
+        has_many :posts, dependent: :restrict_with_error
+
+        # Validations
+        validates :name, presence: true, uniqueness: true
+        validates :title, presence: true
+      end
+    end
+  end
+end

data/lib/bunko/models.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Load all model concerns
+require_relative "models/post_methods"
+require_relative "models/post_type_methods"
+require_relative "models/acts_as"

data/lib/bunko/railtie.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module Bunko
+  class Railtie < Rails::Railtie
+    # Extend Rails routing DSL with bunko_collection
+    initializer "bunko.routing" do
+      ActiveSupport.on_load(:action_controller) do
+        require "bunko/routing"
+        ActionDispatch::Routing::Mapper.include Bunko::Routing::MapperMethods
+      end
+    end
+
+    rake_tasks do
+      load "tasks/bunko/install.rake"
+      load "tasks/bunko/setup.rake"
+      load "tasks/bunko/add.rake"
+      load "tasks/bunko/sample_data.rake"
+    end
+  end
+end

data/lib/bunko/routing/mapper_methods.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Bunko
+  module Routing
+    module MapperMethods
+      # Defines routes for a Bunko collection
+      #
+      # @param collection_name [Symbol] The name identifier for the collection (e.g., :blog, :case_study)
+      # @param options [Hash] Routing options
+      # @option options [String] :path Custom URL path (default: name with hyphens)
+      # @option options [String] :controller Custom controller name (default: name)
+      # @option options [Array<Symbol>] :only Actions to route (default: [:index, :show])
+      #
+      # @example Basic usage
+      #   bunko_collection :blog
+      #   # Generates: /blog -> blog#index, /blog/:slug -> blog#show
+      #
+      # @example Custom path
+      #   bunko_collection :case_study, path: "case-studies"
+      #   # Generates: /case-studies -> case_study#index, /case-studies/:slug -> case_study#show
+      #
+      # @example Custom controller
+      #   bunko_collection :blog, controller: "articles"
+      #   # Generates: /blog -> articles#index, /blog/:slug -> articles#show
+      #
+      def bunko_collection(collection_name, **options)
+        # Extract options with defaults
+        custom_path = options.delete(:path)
+        controller = options.delete(:controller) || collection_name.to_s
+
+        # Smart detection: Collections (multi-type aggregations) only get index routes
+        # PostTypes get both index and show routes
+        collection_config = Bunko.configuration.find_collection(collection_name.to_s)
+
+        # Default actions: Collections get [:index], PostTypes get [:index, :show]
+        # Users can override with :only option
+        default_actions = collection_config ? [:index] : [:index, :show]
+        actions = options.delete(:only) || default_actions
+
+        # Resource name must use underscores (for path helpers)
+        # Path can use hyphens (for URLs)
+        if custom_path
+          # User provided custom path - use it for URLs, underscored version for resource name
+          resource_name = custom_path.to_s.tr("-", "_").to_sym
+          path_value = custom_path
+        else
+          # No custom path - use collection_name for resource name, hyphenate for path
+          resource_name = collection_name
+          path_value = collection_name.to_s.dasherize
+        end
+
+        # Define the routes
+        resources resource_name,
+          controller: controller,
+          path: path_value,
+          only: actions,
+          param: :slug,
+          **options
+      end
+
+      # Defines a route for a standalone Bunko page
+      #
+      # @param page_name [Symbol] The name identifier for the page (e.g., :about, :contact)
+      # @param options [Hash] Routing options
+      # @option options [String] :path Custom URL path (default: name with hyphens)
+      # @option options [String] :controller Custom controller name (default: "pages")
+      #
+      # @example Basic usage
+      #   bunko_page :about
+      #   # Generates: GET /about -> pages#show with params[:page] = "about"
+      #
+      # @example Custom path
+      #   bunko_page :about, path: "about-us"
+      #   # Generates: GET /about-us -> pages#show with params[:page] = "about"
+      #
+      # @example Custom controller
+      #   bunko_page :contact, controller: "static_pages"
+      #   # Generates: GET /contact -> static_pages#show with params[:page] = "contact"
+      #
+      def bunko_page(page_name, **options)
+        # Extract options with defaults
+        custom_path = options.delete(:path)
+        controller = options.delete(:controller) || "pages"
+
+        # Convert to underscores for Ruby conventions (route name, helpers)
+        slug = page_name.to_s.underscore
+
+        # URL path uses hyphens (Rails convention)
+        path_value = custom_path || slug.dasherize
+
+        # Route name uses underscores for path helpers (e.g., about_path)
+        route_name = slug.to_sym
+
+        # Define single GET route
+        # Pass hyphenated slug to match Post.slug format in database
+        get path_value,
+          to: "#{controller}#show",
+          defaults: {page: slug.dasherize},
+          as: route_name
+      end
+    end
+  end
+end

data/lib/bunko/routing.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Load routing extensions
+require_relative "routing/mapper_methods"

data/lib/bunko/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Bunko
+  VERSION = "0.2.0"
+end

data/lib/bunko.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "bunko/version"
+require_relative "bunko/configuration"
+require_relative "bunko/models"
+require_relative "bunko/controllers"
+require_relative "bunko/railtie" if defined?(Rails::Railtie)
+
+module Bunko
+  class Error < StandardError; end
+end