better_seo 0.14.0 → 1.0.0.2

data/lib/better_seo/generators/open_graph_generator.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module BetterSeo
+  module Generators
+    class OpenGraphGenerator
+      def initialize(config)
+        @config = config
+      end
+
+      def generate
+        tags = []
+        tags << meta_tag("og:title", @config[:title])
+        tags << meta_tag("og:description", @config[:description])
+        tags << meta_tag("og:type", @config[:type])
+        tags << meta_tag("og:url", @config[:url])
+        tags.concat(image_tags)
+        tags << meta_tag("og:site_name", @config[:site_name])
+        tags << meta_tag("og:locale", @config[:locale])
+        tags.concat(locale_alternate_tags)
+        tags.concat(article_tags)
+        tags.concat(video_tags)
+        tags << meta_tag("og:audio", @config[:audio])
+
+        tags.compact.join("\n")
+      end
+
+      private
+
+      def meta_tag(property, content)
+        return nil unless content
+
+        %(<meta property="#{property}" content="#{escape(content)}">)
+      end
+
+      def image_tags
+        image = @config[:image]
+        return [] unless image
+
+        tags = []
+
+        if image.is_a?(Hash)
+          tags << meta_tag("og:image", image[:url])
+          tags << meta_tag("og:image:width", image[:width])
+          tags << meta_tag("og:image:height", image[:height])
+          tags << meta_tag("og:image:alt", image[:alt])
+        else
+          tags << meta_tag("og:image", image)
+        end
+
+        tags.compact
+      end
+
+      def locale_alternate_tags
+        alternates = @config[:locale_alternate]
+        return [] unless alternates&.any?
+
+        Array(alternates).map do |locale|
+          meta_tag("og:locale:alternate", locale)
+        end
+      end
+
+      def article_tags
+        article = @config[:article]
+        return [] unless article
+
+        tags = []
+        tags << meta_tag("article:author", article[:author])
+        tags << meta_tag("article:published_time", article[:published_time])
+        tags << meta_tag("article:modified_time", article[:modified_time])
+        tags << meta_tag("article:expiration_time", article[:expiration_time])
+        tags << meta_tag("article:section", article[:section])
+
+        # Handle multiple tags
+        if article[:tag]
+          Array(article[:tag]).each do |tag|
+            tags << meta_tag("article:tag", tag)
+          end
+        end
+
+        tags.compact
+      end
+
+      def video_tags
+        video = @config[:video]
+        return [] unless video
+
+        tags = []
+
+        if video.is_a?(Hash)
+          tags << meta_tag("og:video", video[:url])
+          tags << meta_tag("og:video:width", video[:width])
+          tags << meta_tag("og:video:height", video[:height])
+          tags << meta_tag("og:video:type", video[:type])
+        else
+          tags << meta_tag("og:video", video)
+        end
+
+        tags.compact
+      end
+
+      def escape(text)
+        text.to_s
+            .gsub("&", "&amp;")
+            .gsub('"', "&quot;")
+            .gsub("<", "&lt;")
+            .gsub(">", "&gt;")
+      end
+    end
+  end
+end

data/lib/better_seo/generators/robots_txt_generator.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module BetterSeo
+  module Generators
+    class RobotsTxtGenerator
+      attr_reader :rules, :sitemaps
+
+      def initialize
+        @rules = []
+        @sitemaps = []
+      end
+
+      # Add rule for user agent
+      def add_rule(user_agent, allow: nil, disallow: nil)
+        rule = { user_agent: user_agent }
+        rule[:allow] = Array(allow).compact if allow
+        rule[:disallow] = Array(disallow).compact if disallow
+        @rules << rule
+        self
+      end
+
+      # Set crawl delay for user agent
+      def set_crawl_delay(user_agent, seconds)
+        rule = @rules.find { |r| r[:user_agent] == user_agent }
+
+        if rule
+          rule[:crawl_delay] = seconds
+        else
+          @rules << { user_agent: user_agent, crawl_delay: seconds }
+        end
+
+        self
+      end
+
+      # Add sitemap URL
+      def add_sitemap(url)
+        @sitemaps << url
+        self
+      end
+
+      # Clear all rules and sitemaps
+      def clear
+        @rules = []
+        @sitemaps = []
+        self
+      end
+
+      # Generate robots.txt content
+      def to_text
+        return "" if @rules.empty? && @sitemaps.empty?
+
+        lines = []
+
+        # Generate rules for each user agent
+        @rules.each_with_index do |rule, index|
+          lines << "User-agent: #{rule[:user_agent]}"
+
+          # Allow directives
+          rule[:allow]&.each do |path|
+            lines << "Allow: #{path}"
+          end
+
+          # Disallow directives
+          rule[:disallow]&.each do |path|
+            lines << "Disallow: #{path}"
+          end
+
+          # Crawl delay
+          lines << "Crawl-delay: #{rule[:crawl_delay]}" if rule[:crawl_delay]
+
+          # Add blank line between user agent sections (except last)
+          lines << "" if index < @rules.size - 1
+        end
+
+        # Add blank line before sitemaps if there are rules
+        lines << "" if @rules.any? && @sitemaps.any?
+
+        # Add sitemaps
+        @sitemaps.each do |sitemap|
+          lines << "Sitemap: #{sitemap}"
+        end
+
+        lines.join("\n")
+      end
+
+      # Write robots.txt to file
+      def write_to_file(path)
+        directory = File.dirname(path)
+        FileUtils.mkdir_p(directory) unless File.directory?(directory)
+        File.write(path, to_text)
+      end
+    end
+  end
+end

data/lib/better_seo/generators/twitter_cards_generator.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module BetterSeo
+  module Generators
+    class TwitterCardsGenerator
+      def initialize(config)
+        @config = config
+      end
+
+      def generate
+        tags = []
+        tags << meta_tag("twitter:card", @config[:card])
+        tags << meta_tag("twitter:site", @config[:site])
+        tags << meta_tag("twitter:creator", @config[:creator])
+        tags << meta_tag("twitter:title", @config[:title])
+        tags << meta_tag("twitter:description", @config[:description])
+        tags.concat(image_tags)
+        tags.concat(player_tags)
+        tags.concat(app_tags)
+
+        tags.compact.join("\n")
+      end
+
+      private
+
+      def meta_tag(name, content)
+        return nil unless content
+
+        %(<meta name="#{name}" content="#{escape(content)}">)
+      end
+
+      def image_tags
+        image = @config[:image]
+        return [] unless image
+
+        tags = []
+
+        if image.is_a?(Hash)
+          tags << meta_tag("twitter:image", image[:url])
+          tags << meta_tag("twitter:image:alt", image[:alt])
+        else
+          tags << meta_tag("twitter:image", image)
+        end
+
+        # Add separate image_alt if present
+        tags << meta_tag("twitter:image:alt", @config[:image_alt]) if @config[:image_alt]
+
+        tags.compact
+      end
+
+      def player_tags
+        return [] unless @config[:player]
+
+        tags = []
+        tags << meta_tag("twitter:player", @config[:player])
+        tags << meta_tag("twitter:player:width", @config[:player_width])
+        tags << meta_tag("twitter:player:height", @config[:player_height])
+        tags << meta_tag("twitter:player:stream", @config[:player_stream])
+
+        tags.compact
+      end
+
+      def app_tags
+        tags = []
+
+        # App name tags
+        if @config[:app_name]
+          app_name = @config[:app_name]
+          tags << meta_tag("twitter:app:name:iphone", app_name[:iphone])
+          tags << meta_tag("twitter:app:name:ipad", app_name[:ipad])
+          tags << meta_tag("twitter:app:name:googleplay", app_name[:googleplay])
+        end
+
+        # App ID tags
+        if @config[:app_id]
+          app_id = @config[:app_id]
+          tags << meta_tag("twitter:app:id:iphone", app_id[:iphone])
+          tags << meta_tag("twitter:app:id:ipad", app_id[:ipad])
+          tags << meta_tag("twitter:app:id:googleplay", app_id[:googleplay])
+        end
+
+        # App URL tags
+        if @config[:app_url]
+          app_url = @config[:app_url]
+          tags << meta_tag("twitter:app:url:iphone", app_url[:iphone])
+          tags << meta_tag("twitter:app:url:ipad", app_url[:ipad])
+          tags << meta_tag("twitter:app:url:googleplay", app_url[:googleplay])
+        end
+
+        tags.compact
+      end
+
+      def escape(text)
+        text.to_s
+            .gsub("&", "&amp;")
+            .gsub('"', "&quot;")
+            .gsub("<", "&lt;")
+            .gsub(">", "&gt;")
+      end
+    end
+  end
+end

data/lib/better_seo/image/optimizer.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+begin
+  require "mini_magick"
+rescue LoadError
+  # mini_magick is optional
+end
+
+module BetterSeo
+  module Image
+    class Optimizer
+      SUPPORTED_FORMATS = %w[jpg jpeg png webp gif].freeze
+
+      attr_reader :quality
+
+      def initialize(quality: 85)
+        @quality = quality
+        check_imagemagick!
+      end
+
+      # Validate image format
+      def validate_format!(path)
+        ext = File.extname(path).downcase.delete(".")
+        unless SUPPORTED_FORMATS.include?(ext)
+          raise ImageError, "Unsupported format: #{ext}. Supported: #{SUPPORTED_FORMATS.join(", ")}"
+        end
+
+        true
+      end
+
+      # Convert image to WebP
+      def convert_to_webp(source, destination)
+        check_imagemagick!
+        validate_source!(source)
+
+        image = MiniMagick::Image.open(source)
+        image.format "webp"
+        image.quality @quality
+        image.write destination
+
+        destination
+      rescue MiniMagick::Error => e
+        raise ImageError, "Failed to convert to WebP: #{e.message}"
+      end
+
+      # Resize image
+      def resize(source, destination, width: nil, height: nil)
+        check_imagemagick!
+        validate_source!(source)
+
+        raise ImageError, "Either width or height must be specified" if width.nil? && height.nil?
+
+        image = MiniMagick::Image.open(source)
+
+        if width && height
+          image.resize "#{width}x#{height}!"
+        elsif width
+          image.resize "#{width}x"
+        else
+          image.resize "x#{height}"
+        end
+
+        image.write destination
+
+        destination
+      rescue MiniMagick::Error => e
+        raise ImageError, "Failed to resize: #{e.message}"
+      end
+
+      # Compress image
+      def compress(source, destination)
+        check_imagemagick!
+        validate_source!(source)
+
+        image = MiniMagick::Image.open(source)
+        image.quality @quality
+        image.write destination
+
+        destination
+      rescue MiniMagick::Error => e
+        raise ImageError, "Failed to compress: #{e.message}"
+      end
+
+      # Generate responsive image sizes
+      def generate_responsive(source, output_dir, sizes: {}, prefix: "responsive")
+        check_imagemagick!
+        validate_source!(source)
+
+        FileUtils.mkdir_p(output_dir) unless File.directory?(output_dir)
+
+        results = {}
+        ext = File.extname(source)
+
+        sizes.each do |name, width|
+          output_path = File.join(output_dir, "#{prefix}_#{name}_#{width}w#{ext}")
+          resize(source, output_path, width: width)
+          results[name] = output_path
+        end
+
+        results
+      rescue MiniMagick::Error => e
+        raise ImageError, "Failed to generate responsive images: #{e.message}"
+      end
+
+      # Optimize image (resize + compress)
+      def optimize(source, destination, resize: nil)
+        check_imagemagick!
+        validate_source!(source)
+
+        original_size = File.size(source)
+
+        if resize
+          resize(source, destination, **resize)
+        else
+          compress(source, destination)
+        end
+
+        optimized_size = File.size(destination)
+        reduction = ((original_size - optimized_size).to_f / original_size * 100).round(2)
+
+        {
+          original_size: original_size,
+          optimized_size: optimized_size,
+          reduction_percent: reduction
+        }
+      rescue MiniMagick::Error => e
+        raise ImageError, "Failed to optimize: #{e.message}"
+      end
+
+      private
+
+      def check_imagemagick!
+        return if defined?(MiniMagick)
+
+        raise ImageError, "ImageMagick is not available. Please install ImageMagick and the mini_magick gem."
+      end
+
+      def validate_source!(source)
+        raise ImageError, "Source file not found: #{source}" unless File.exist?(source)
+
+        validate_format!(source)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module BetterSeo
+  module Rails
+    module Helpers
+      module ControllerHelpers
+        extend ActiveSupport::Concern
+
+        included do
+          helper_method :better_seo_data if respond_to?(:helper_method)
+        end
+
+        # Set meta tags data
+        def set_meta_tags(data = nil, &block)
+          if block_given?
+            meta_data = {}
+            yield(meta_data)
+            merge_seo_data(:meta, meta_data)
+          else
+            merge_seo_data(:meta, data)
+          end
+        end
+
+        # Set Open Graph tags data
+        def set_og_tags(data = nil, &block)
+          if block_given?
+            og_data = {}
+            yield(og_data)
+            merge_seo_data(:og, og_data)
+          else
+            merge_seo_data(:og, data)
+          end
+        end
+
+        # Set Twitter Card tags data
+        def set_twitter_tags(data = nil, &block)
+          if block_given?
+            twitter_data = {}
+            yield(twitter_data)
+            merge_seo_data(:twitter, twitter_data)
+          else
+            merge_seo_data(:twitter, data)
+          end
+        end
+
+        # Set canonical URL
+        def set_canonical(url)
+          merge_seo_data(:meta, { canonical: url })
+        end
+
+        # Set page title with optional prefix/suffix
+        def set_page_title(title, prefix: nil, suffix: nil)
+          full_title = ""
+          full_title += prefix if prefix
+          full_title += title
+          full_title += suffix if suffix
+
+          merge_seo_data(:meta, { title: full_title })
+        end
+
+        # Set page description with optional truncation
+        def set_page_description(description, max_length: nil)
+          final_description = description
+
+          # rubocop:disable Style/IfUnlessModifier
+          if max_length && description.length > max_length
+            final_description = "#{description[0...(max_length - 3)]}..."
+          end
+          # rubocop:enable Style/IfUnlessModifier
+
+          merge_seo_data(:meta, { description: final_description })
+        end
+
+        # Set page keywords (array or comma-separated string)
+        def set_page_keywords(keywords)
+          keywords_array = if keywords.is_a?(String)
+                             keywords.split(",").map(&:strip)
+                           else
+                             keywords
+                           end
+
+          merge_seo_data(:meta, { keywords: keywords_array })
+        end
+
+        # Set page image for both OG and Twitter
+        def set_page_image(url, width: nil, height: nil)
+          og_data = { image: url }
+          og_data[:image_width] = width if width
+          og_data[:image_height] = height if height
+
+          merge_seo_data(:og, og_data)
+          merge_seo_data(:twitter, { image: url })
+        end
+
+        # Set noindex robot directive
+        def set_noindex(nofollow: false)
+          robots = "noindex"
+          robots += ", nofollow" if nofollow
+
+          merge_seo_data(:meta, { robots: robots })
+        end
+
+        # Get all SEO data stored in controller
+        def better_seo_data
+          @_better_seo_data ||= {}
+        end
+
+        private
+
+        def merge_seo_data(category, data)
+          return unless data
+
+          @_better_seo_data ||= {}
+          @_better_seo_data[category] ||= {}
+          @_better_seo_data[category].merge!(data)
+        end
+      end
+    end
+  end
+end