better_seo 0.13.0 → 1.0.0.1

data/lib/better_seo/rails/helpers/seo_helper.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module BetterSeo
+  module Rails
+    module Helpers
+      module SeoHelper
+        # Generate meta tags from configuration or block
+        def seo_meta_tags(config = nil, &block)
+          if block_given?
+            builder = BetterSeo::DSL::MetaTags.new
+            builder.evaluate(&block)
+            config = builder.build
+          end
+
+          generator = BetterSeo::Generators::MetaTagsGenerator.new(config || {})
+          raw(generator.generate)
+        end
+
+        # Generate Open Graph tags from configuration or block
+        def seo_open_graph_tags(config = nil, &block)
+          if block_given?
+            builder = BetterSeo::DSL::OpenGraph.new
+            builder.evaluate(&block)
+            config = builder.build
+          end
+
+          generator = BetterSeo::Generators::OpenGraphGenerator.new(config || {})
+          raw(generator.generate)
+        end
+
+        # Generate Twitter Card tags from configuration or block
+        def seo_twitter_tags(config = nil, &block)
+          if block_given?
+            builder = BetterSeo::DSL::TwitterCards.new
+            builder.evaluate(&block)
+            config = builder.build
+          end
+
+          generator = BetterSeo::Generators::TwitterCardsGenerator.new(config || {})
+          raw(generator.generate)
+        end
+
+        # Generate all SEO tags (meta + og + twitter) from configuration or block
+        def seo_tags(config = nil, &block)
+          if block_given?
+            context = SeoTagsContext.new
+            yield(context)
+            config = context.to_h
+          end
+
+          config ||= {}
+
+          # Merge with defaults from BetterSeo configuration
+          merged_config = build_seo_config(config)
+
+          tags = []
+
+          if merged_config[:meta]
+            tags << seo_meta_tags(merged_config[:meta])
+          end
+
+          if merged_config[:og] && BetterSeo.configuration.open_graph_enabled?
+            tags << seo_open_graph_tags(merged_config[:og])
+          end
+
+          if merged_config[:twitter] && BetterSeo.configuration.twitter_enabled?
+            tags << seo_twitter_tags(merged_config[:twitter])
+          end
+
+          raw(tags.compact.join("\n"))
+        end
+
+        private
+
+        # Build SEO configuration by merging controller data with defaults
+        def build_seo_config(controller_data)
+          config = BetterSeo.configuration
+          result = {}
+
+          # Meta tags
+          meta = {}
+
+          # Start with controller data
+          if controller_data[:meta]
+            meta = controller_data[:meta].dup
+          end
+
+          # Use default title if not set
+          meta[:title] ||= config.meta_tags.default_title
+
+          # Apply site_name to title if configured
+          if meta[:title] && config.meta_tags.append_site_name && config.site_name
+            separator = config.meta_tags.title_separator || " | "
+            meta[:title] = "#{meta[:title]}#{separator}#{config.site_name}"
+          end
+
+          # Use defaults for missing values
+          meta[:description] ||= config.meta_tags.default_description
+          meta[:keywords] ||= config.meta_tags.default_keywords
+          meta[:author] ||= config.meta_tags.default_author
+
+          result[:meta] = meta if meta.any?
+
+          # Open Graph tags
+          if config.open_graph_enabled?
+            og = controller_data[:og]&.dup || {}
+
+            # Use meta title/description as fallbacks
+            og[:title] ||= meta[:title] || config.meta_tags.default_title
+            og[:description] ||= meta[:description]
+            og[:type] ||= config.open_graph.default_type
+            og[:locale] ||= config.open_graph.default_locale
+            og[:site_name] ||= config.open_graph.site_name || config.site_name
+
+            # Default image
+            if og[:image].nil? && config.open_graph.default_image&.url
+              og[:image] = config.open_graph.default_image.url
+              og[:image_width] = config.open_graph.default_image.width
+              og[:image_height] = config.open_graph.default_image.height
+              og[:image_alt] = config.open_graph.default_image.alt if config.open_graph.default_image.respond_to?(:alt)
+            end
+
+            result[:og] = og if og.any?
+          end
+
+          # Twitter Card tags
+          if config.twitter_enabled?
+            twitter = controller_data[:twitter]&.dup || {}
+
+            twitter[:card] ||= config.twitter.card_type
+            twitter[:site] ||= config.twitter.site
+            twitter[:creator] ||= config.twitter.creator
+            twitter[:title] ||= meta[:title] || config.meta_tags.default_title
+            twitter[:description] ||= meta[:description]
+
+            # Use OG image as fallback
+            twitter[:image] ||= result.dig(:og, :image)
+
+            result[:twitter] = twitter if twitter.any?
+          end
+
+          result
+        end
+
+        # Context class for building all SEO tags with block syntax
+        class SeoTagsContext
+          def initialize
+            @config = {}
+          end
+
+          def meta(&block)
+            builder = BetterSeo::DSL::MetaTags.new
+            builder.evaluate(&block)
+            @config[:meta] = builder.build
+          end
+
+          def og(&block)
+            builder = BetterSeo::DSL::OpenGraph.new
+            builder.evaluate(&block)
+            @config[:og] = builder.build
+          end
+
+          def twitter(&block)
+            builder = BetterSeo::DSL::TwitterCards.new
+            builder.evaluate(&block)
+            @config[:twitter] = builder.build
+          end
+
+          def to_h
+            @config
+          end
+        end
+      end
+    end
+  end
+end

data/lib/better_seo/rails/helpers/structured_data_helper.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module BetterSeo
+  module Rails
+    module Helpers
+      module StructuredDataHelper
+        TYPE_MAPPING = {
+          organization: BetterSeo::StructuredData::Organization,
+          article: BetterSeo::StructuredData::Article,
+          person: BetterSeo::StructuredData::Person,
+          product: BetterSeo::StructuredData::Product,
+          breadcrumb_list: BetterSeo::StructuredData::BreadcrumbList,
+          local_business: BetterSeo::StructuredData::LocalBusiness,
+          event: BetterSeo::StructuredData::Event,
+          faq_page: BetterSeo::StructuredData::FAQPage,
+          how_to: BetterSeo::StructuredData::HowTo,
+          recipe: BetterSeo::StructuredData::Recipe
+        }.freeze
+
+        def structured_data_tag(type_or_object, **properties, &block)
+          sd_object = if type_or_object.is_a?(Symbol)
+                        create_structured_data(type_or_object, properties, &block)
+                      else
+                        type_or_object
+                      end
+
+          raw(sd_object.to_script_tag)
+        end
+
+        def structured_data_tags(objects = nil, &block)
+          array = block_given? ? yield : objects
+          return "" if array.nil? || array.empty?
+
+          tags = array.map(&:to_script_tag).join("\n\n")
+          raw(tags)
+        end
+
+        def organization_sd(**properties, &block)
+          structured_data_tag(:organization, **properties, &block)
+        end
+
+        def article_sd(**properties, &block)
+          structured_data_tag(:article, **properties, &block)
+        end
+
+        def person_sd(**properties, &block)
+          structured_data_tag(:person, **properties, &block)
+        end
+
+        def product_sd(**properties, &block)
+          structured_data_tag(:product, **properties, &block)
+        end
+
+        def breadcrumb_list_sd(items: nil, &block)
+          if block_given?
+            structured_data_tag(:breadcrumb_list, &block)
+          elsif items
+            structured_data_tag(:breadcrumb_list) do |breadcrumb|
+              breadcrumb.add_items(items)
+            end
+          else
+            structured_data_tag(:breadcrumb_list)
+          end
+        end
+
+        def local_business_sd(**properties, &block)
+          structured_data_tag(:local_business, **properties, &block)
+        end
+
+        def event_sd(**properties, &block)
+          structured_data_tag(:event, **properties, &block)
+        end
+
+        def faq_page_sd(questions: nil, &block)
+          if block_given?
+            structured_data_tag(:faq_page, &block)
+          elsif questions
+            structured_data_tag(:faq_page) do |faq|
+              faq.add_questions(questions)
+            end
+          else
+            structured_data_tag(:faq_page)
+          end
+        end
+
+        def how_to_sd(steps: nil, &block)
+          if block_given?
+            structured_data_tag(:how_to, &block)
+          elsif steps
+            structured_data_tag(:how_to) do |how_to|
+              how_to.add_steps(steps)
+            end
+          else
+            structured_data_tag(:how_to)
+          end
+        end
+
+        def recipe_sd(ingredients: nil, instructions: nil, &block)
+          if block_given?
+            structured_data_tag(:recipe, &block)
+          else
+            structured_data_tag(:recipe) do |recipe|
+              recipe.add_ingredients(ingredients) if ingredients
+              recipe.add_instructions(instructions) if instructions
+              yield(recipe) if block_given?
+            end
+          end
+        end
+
+        private
+
+        def create_structured_data(type, properties, &block)
+          klass = TYPE_MAPPING[type]
+          raise ArgumentError, "Unknown structured data type: #{type}" unless klass
+
+          sd_object = klass.new(**properties)
+          yield(sd_object) if block_given?
+          sd_object
+        end
+      end
+    end
+  end
+end

data/lib/better_seo/rails/model_helpers.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module BetterSeo
+  module Rails
+    module ModelHelpers
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # Define SEO attribute mappings
+        # @example
+        #   seo_attributes(
+        #     title: :post_title,
+        #     description: :excerpt,
+        #     keywords: -> { tags.map(&:name).join(", ") },
+        #     image: :featured_image_url
+        #   )
+        def seo_attributes(mappings = {})
+          @_seo_attribute_mappings = mappings
+
+          # Define accessor methods for each SEO attribute
+          mappings.each do |seo_attr, source|
+            define_method("seo_#{seo_attr}") do
+              evaluate_seo_attribute(source)
+            end
+          end
+        end
+
+        def seo_attribute_mappings
+          @_seo_attribute_mappings || {}
+        end
+      end
+
+      # Convert model to SEO hash
+      def to_seo_hash
+        mappings = self.class.seo_attribute_mappings
+        return {} if mappings.empty?
+
+        hash = {}
+
+        mappings.each_key do |seo_attr|
+          value = send("seo_#{seo_attr}")
+          hash[seo_attr] = value if value
+        end
+
+        hash
+      end
+
+      private
+
+      def evaluate_seo_attribute(source)
+        case source
+        when Proc
+          instance_exec(&source)
+        when Symbol
+          send(source) if respond_to?(source)
+        else
+          source
+        end
+      end
+    end
+  end
+end

data/lib/better_seo/rails/railtie.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module BetterSeo
+  module Rails
+    class Railtie < ::Rails::Railtie
+      initializer "better_seo.controller_helpers" do
+        ActiveSupport.on_load(:action_controller) do
+          include BetterSeo::Rails::Helpers::ControllerHelpers
+        end
+      end
+
+      initializer "better_seo.view_helpers" do
+        ActiveSupport.on_load(:action_view) do
+          include BetterSeo::Rails::Helpers::SeoHelper
+          include BetterSeo::Rails::Helpers::StructuredDataHelper
+        end
+      end
+    end
+  end
+end

data/lib/better_seo/sitemap/builder.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module BetterSeo
+  module Sitemap
+    class Builder
+      include Enumerable
+
+      attr_reader :urls
+
+      def initialize(urls: [])
+        @urls = urls
+      end
+
+      def add_url(location, lastmod: nil, changefreq: "weekly", priority: 0.5)
+        @urls << UrlEntry.new(location, lastmod: lastmod, changefreq: changefreq, priority: priority)
+        self
+      end
+
+      def add_urls(locations, lastmod: nil, changefreq: "weekly", priority: 0.5)
+        locations.each do |location|
+          add_url(location, lastmod: lastmod, changefreq: changefreq, priority: priority)
+        end
+        self
+      end
+
+      def remove_url(location)
+        @urls.reject! { |url| url.loc == location }
+        self
+      end
+
+      def clear
+        @urls = []
+        self
+      end
+
+      def to_xml
+        xml = []
+        xml << '<?xml version="1.0" encoding="UTF-8"?>'
+        xml << '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">'
+        @urls.each do |url|
+          xml << url.to_xml
+        end
+        xml << "</urlset>"
+        xml.join("\n")
+      end
+
+      def validate!
+        @urls.each(&:validate!)
+        true
+      end
+
+      def size
+        @urls.size
+      end
+
+      def empty?
+        @urls.empty?
+      end
+
+      def each(&block)
+        @urls.each(&block)
+      end
+    end
+  end
+end

data/lib/better_seo/sitemap/generator.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module BetterSeo
+  module Sitemap
+    class Generator
+      class << self
+        def generate(&block)
+          builder = Builder.new
+          yield(builder) if block_given?
+          builder.to_xml
+        end
+
+        def generate_from(urls, lastmod: nil, changefreq: "weekly", priority: 0.5)
+          builder = Builder.new
+          builder.add_urls(urls, lastmod: lastmod, changefreq: changefreq, priority: priority)
+          builder.to_xml
+        end
+
+        def generate_from_collection(collection, url: nil, lastmod: nil, changefreq: "weekly", priority: 0.5)
+          raise ArgumentError, "url option is required" if url.nil?
+          raise ArgumentError, "url option must be callable" unless url.respond_to?(:call)
+
+          builder = Builder.new
+
+          collection.each do |item|
+            url_value = url.call(item)
+            lastmod_value = lastmod.respond_to?(:call) ? lastmod.call(item) : lastmod
+            changefreq_value = changefreq.respond_to?(:call) ? changefreq.call(item) : changefreq
+            priority_value = priority.respond_to?(:call) ? priority.call(item) : priority
+
+            builder.add_url(
+              url_value,
+              lastmod: lastmod_value,
+              changefreq: changefreq_value,
+              priority: priority_value
+            )
+          end
+
+          builder.to_xml
+        end
+
+        def write_to_file(file_path, &block)
+          xml = generate(&block)
+
+          # Create parent directories if they don't exist
+          dir = File.dirname(file_path)
+          FileUtils.mkdir_p(dir) unless File.directory?(dir)
+
+          File.write(file_path, xml)
+          file_path
+        end
+      end
+    end
+  end
+end

data/lib/better_seo/sitemap/sitemap_index.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "date"
+
+module BetterSeo
+  module Sitemap
+    class SitemapIndex
+      attr_reader :sitemaps
+
+      def initialize
+        @sitemaps = []
+      end
+
+      # Add a sitemap to the index
+      def add_sitemap(loc, lastmod: nil)
+        sitemap = { loc: loc }
+        sitemap[:lastmod] = format_date(lastmod) if lastmod
+        @sitemaps << sitemap
+        self
+      end
+
+      # Generate XML for sitemap index
+      def to_xml
+        xml = []
+        xml << '<?xml version="1.0" encoding="UTF-8"?>'
+        xml << '<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">'
+
+        @sitemaps.each do |sitemap|
+          xml << "  <sitemap>"
+          xml << "    <loc>#{escape_xml(sitemap[:loc])}</loc>"
+          xml << "    <lastmod>#{sitemap[:lastmod]}</lastmod>" if sitemap[:lastmod]
+          xml << "  </sitemap>"
+        end
+
+        xml << "</sitemapindex>"
+        xml.join("\n")
+      end
+
+      # Write sitemap index to file
+      def write_to_file(path)
+        directory = File.dirname(path)
+        FileUtils.mkdir_p(directory) unless File.directory?(directory)
+
+        File.write(path, to_xml)
+      end
+
+      private
+
+      def format_date(value)
+        case value
+        when String
+          value
+        when Date
+          value.strftime("%Y-%m-%d")
+        when Time, DateTime
+          value.strftime("%Y-%m-%d")
+        else
+          value.to_s
+        end
+      end
+
+      def escape_xml(text)
+        text.to_s
+          .gsub("&", "&amp;")
+          .gsub("<", "&lt;")
+          .gsub(">", "&gt;")
+          .gsub('"', "&quot;")
+          .gsub("'", "&apos;")
+      end
+    end
+  end
+end