better_seo 0.14.0 → 1.0.0.2

data/lib/better_seo/analytics/google_analytics.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "json"
+
+module BetterSeo
+  module Analytics
+    class GoogleAnalytics
+      attr_reader :measurement_id, :anonymize_ip
+
+      def initialize(measurement_id, anonymize_ip: false)
+        @measurement_id = measurement_id
+        @anonymize_ip = anonymize_ip
+      end
+
+      # Generate GA4 script tag
+      def to_script_tag(nonce: nil, **config)
+        nonce_attr = nonce ? %( nonce="#{escape_html(nonce)}") : ""
+
+        config_options = { "anonymize_ip" => @anonymize_ip } if @anonymize_ip
+        config_options ||= {}
+        config_options.merge!(config.transform_keys(&:to_s))
+
+        config_json = config_options.empty? ? "" : ", #{JSON.generate(config_options)}"
+
+        <<~HTML.strip
+          <script async src="https://www.googletagmanager.com/gtag/js?id=#{@measurement_id}"#{nonce_attr}></script>
+          <script#{nonce_attr}>
+            window.dataLayer = window.dataLayer || [];
+            function gtag(){dataLayer.push(arguments);}
+            gtag('js', new Date());
+            gtag('config', '#{@measurement_id}'#{config_json});
+          </script>
+        HTML
+      end
+
+      # Track custom event
+      def track_event(event_name, **parameters)
+        params_json = parameters.empty? ? "" : ", #{JSON.generate(parameters.transform_keys(&:to_s))}"
+
+        <<~JS.strip
+          gtag('event', '#{event_name}'#{params_json});
+        JS
+      end
+
+      # Track page view
+      def track_page_view(page_path, title: nil)
+        params = { "page_path" => page_path }
+        params["page_title"] = title if title
+
+        <<~JS.strip
+          gtag('config', '#{@measurement_id}', #{JSON.generate(params)});
+        JS
+      end
+
+      # Track e-commerce purchase
+      def ecommerce_purchase(transaction_id:, value:, currency: "USD", items: [])
+        params = {
+          "transaction_id" => transaction_id,
+          "value" => value,
+          "currency" => currency,
+          "items" => items.map { |item| item.transform_keys(&:to_s) }
+        }
+
+        <<~JS.strip
+          gtag('event', 'purchase', #{JSON.generate(params)});
+        JS
+      end
+
+      private
+
+      def escape_html(text)
+        return "" if text.nil?
+
+        text.to_s
+            .gsub("&", "&amp;")
+            .gsub("<", "&lt;")
+            .gsub(">", "&gt;")
+            .gsub('"', "&quot;")
+            .gsub("'", "&#39;")
+      end
+    end
+  end
+end

data/lib/better_seo/analytics/google_tag_manager.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "json"
+
+module BetterSeo
+  module Analytics
+    class GoogleTagManager
+      attr_reader :container_id, :data_layer_name
+
+      def initialize(container_id, data_layer_name: "dataLayer")
+        @container_id = container_id
+        @data_layer_name = data_layer_name
+      end
+
+      # Generate GTM head script tag
+      def to_head_script(nonce: nil)
+        nonce_attr = nonce ? %( nonce="#{escape_html(nonce)}") : ""
+
+        <<~HTML.strip
+          <script#{nonce_attr}>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
+          new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
+          j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
+          'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
+          })(window,document,'script','#{@data_layer_name}','#{@container_id}');</script>
+        HTML
+      end
+
+      # Generate GTM body noscript tag
+      def to_body_noscript
+        <<~HTML.strip
+          <noscript><iframe src="https://www.googletagmanager.com/ns.html?id=#{@container_id}"
+          height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
+        HTML
+      end
+
+      # Push data to data layer
+      def push_data_layer(**data)
+        <<~JS.strip
+          #{@data_layer_name}.push(#{JSON.generate(data.transform_keys(&:to_s))});
+        JS
+      end
+
+      # Push e-commerce data
+      def push_ecommerce(event:, ecommerce:)
+        data = {
+          "event" => event,
+          "ecommerce" => ecommerce.transform_keys(&:to_s)
+        }
+
+        <<~JS.strip
+          #{@data_layer_name}.push(#{JSON.generate(data)});
+        JS
+      end
+
+      # Push user data
+      def push_user_data(**user_data)
+        push_data_layer(**user_data)
+      end
+
+      private
+
+      def escape_html(text)
+        return "" if text.nil?
+
+        text.to_s
+            .gsub("&", "&amp;")
+            .gsub("<", "&lt;")
+            .gsub(">", "&gt;")
+            .gsub('"', "&quot;")
+            .gsub("'", "&#39;")
+      end
+    end
+  end
+end

data/lib/better_seo/configuration.rb

@@ -0,0 +1,322 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/hash/deep_merge"
+
+module BetterSeo
+  class Configuration
+    # Default values
+    DEFAULT_CONFIG = {
+      site_name: nil,
+      default_locale: :en,
+      available_locales: [:en],
+
+      # Meta tags defaults
+      meta_tags: {
+        default_title: nil,
+        title_separator: " | ",
+        append_site_name: true,
+        default_description: nil,
+        default_keywords: [],
+        default_author: nil
+      },
+
+      # Open Graph defaults
+      open_graph: {
+        enabled: true,
+        site_name: nil,
+        default_type: "website",
+        default_locale: "en_US",
+        default_image: {
+          url: nil,
+          width: 1200,
+          height: 630
+        }
+      },
+
+      # Twitter Cards defaults
+      twitter: {
+        enabled: true,
+        site: nil,
+        creator: nil,
+        card_type: "summary_large_image"
+      },
+
+      # Structured Data defaults
+      structured_data: {
+        enabled: true,
+        organization: {},
+        website: {}
+      },
+
+      # Sitemap defaults
+      sitemap: {
+        enabled: false,
+        output_path: "public/sitemap.xml",
+        host: nil,
+        compress: false,
+        ping_search_engines: false,
+        defaults: {
+          changefreq: "weekly",
+          priority: 0.5
+        }
+      },
+
+      # Robots.txt defaults
+      robots: {
+        enabled: false,
+        output_path: "public/robots.txt",
+        user_agents: {
+          "*" => {
+            allow: ["/"],
+            disallow: [],
+            crawl_delay: nil
+          }
+        }
+      },
+
+      # Image optimization defaults
+      images: {
+        enabled: false,
+        webp: {
+          enabled: true,
+          quality: 80
+        },
+        sizes: {
+          thumbnail: { width: 150, height: 150 },
+          small: { width: 300 },
+          medium: { width: 600 },
+          large: { width: 1200 },
+          og_image: { width: 1200, height: 630, crop: true }
+        }
+      },
+
+      # I18n settings
+      i18n: {
+        load_path: "config/locales/seo/**/*.yml",
+        auto_reload: false
+      }
+    }.freeze
+
+    attr_accessor :site_name, :default_locale, :available_locales
+    attr_reader :meta_tags, :open_graph, :twitter, :structured_data,
+                :sitemap, :robots, :images, :i18n
+
+    def initialize
+      # Deep dup per evitare shared state
+      @config = deep_dup(DEFAULT_CONFIG)
+
+      # Initialize nested configurations
+      @meta_tags = NestedConfiguration.new(@config[:meta_tags])
+      @open_graph = NestedConfiguration.new(@config[:open_graph])
+      @twitter = NestedConfiguration.new(@config[:twitter])
+      @structured_data = NestedConfiguration.new(@config[:structured_data])
+      @sitemap = NestedConfiguration.new(@config[:sitemap])
+      @robots = NestedConfiguration.new(@config[:robots])
+      @images = NestedConfiguration.new(@config[:images])
+      @i18n = NestedConfiguration.new(@config[:i18n])
+
+      # Top-level attributes
+      @site_name = @config[:site_name]
+      @default_locale = @config[:default_locale]
+      @available_locales = @config[:available_locales]
+    end
+
+    # Load configuration from hash
+    def load_from_hash(hash)
+      merge_hash!(hash)
+      self
+    end
+
+    # Validate configuration
+    def validate!
+      errors = []
+
+      # Validate locales
+      unless available_locales.is_a?(Array) && available_locales.any?
+        errors << "available_locales must be a non-empty array"
+      end
+
+      if available_locales.is_a?(Array) && !available_locales.include?(default_locale)
+        errors << "default_locale must be included in available_locales"
+      end
+
+      # Validate sitemap
+      errors << "sitemap.host is required when sitemap is enabled" if sitemap.enabled && sitemap.host.nil?
+
+      # Validate meta tags lengths
+      if meta_tags.default_title && meta_tags.default_title.length > 60
+        errors << "meta_tags.default_title should be max 60 characters"
+      end
+
+      if meta_tags.default_description && meta_tags.default_description.length > 160
+        errors << "meta_tags.default_description should be max 160 characters"
+      end
+
+      raise ValidationError, errors.join(", ") if errors.any?
+
+      true
+    end
+
+    # Feature enabled checks
+    def sitemap_enabled?
+      sitemap.enabled == true
+    end
+
+    def robots_enabled?
+      robots.enabled == true
+    end
+
+    def images_enabled?
+      images.enabled == true
+    end
+
+    def open_graph_enabled?
+      open_graph.enabled == true
+    end
+
+    def twitter_enabled?
+      twitter.enabled == true
+    end
+
+    def structured_data_enabled?
+      structured_data.enabled == true
+    end
+
+    # Convert to hash
+    def to_h
+      {
+        site_name: site_name,
+        default_locale: default_locale,
+        available_locales: available_locales,
+        meta_tags: meta_tags.to_h,
+        open_graph: open_graph.to_h,
+        twitter: twitter.to_h,
+        structured_data: structured_data.to_h,
+        sitemap: sitemap.to_h,
+        robots: robots.to_h,
+        images: images.to_h,
+        i18n: i18n.to_h
+      }
+    end
+
+    private
+
+    def merge_hash!(hash)
+      hash = hash.with_indifferent_access if hash.respond_to?(:with_indifferent_access)
+
+      # Merge top-level attributes
+      @site_name = hash[:site_name] if hash.key?(:site_name)
+      @default_locale = hash[:default_locale] if hash.key?(:default_locale)
+      @available_locales = hash[:available_locales] if hash.key?(:available_locales)
+
+      # Merge nested configurations
+      @meta_tags.merge!(hash[:meta_tags]) if hash[:meta_tags]
+      @open_graph.merge!(hash[:open_graph]) if hash[:open_graph]
+      @twitter.merge!(hash[:twitter]) if hash[:twitter]
+      @structured_data.merge!(hash[:structured_data]) if hash[:structured_data]
+      @sitemap.merge!(hash[:sitemap]) if hash[:sitemap]
+      @robots.merge!(hash[:robots]) if hash[:robots]
+      @images.merge!(hash[:images]) if hash[:images]
+      @i18n.merge!(hash[:i18n]) if hash[:i18n]
+    end
+
+    def deep_dup(hash)
+      hash.transform_values do |value|
+        if value.is_a?(Hash)
+          deep_dup(value)
+        else
+          begin
+            value.dup
+          rescue StandardError
+            value
+          end
+        end
+      end
+    end
+
+    # Nested configuration object
+    class NestedConfiguration
+      def initialize(hash = {})
+        @data = hash.with_indifferent_access
+        # Wrap nested hashes in NestedConfiguration objects for deep setter support
+        @data.each do |key, value|
+          @data[key] = NestedConfiguration.new(value) if value.is_a?(Hash) && !value.is_a?(NestedConfiguration)
+        end
+        define_accessors!
+      end
+
+      def merge!(other_hash)
+        @data.deep_merge!(other_hash.with_indifferent_access)
+        # Wrap any new nested hashes in NestedConfiguration objects
+        @data.each do |key, value|
+          @data[key] = NestedConfiguration.new(value) if value.is_a?(Hash) && !value.is_a?(NestedConfiguration)
+        end
+        define_accessors!
+        self
+      end
+
+      def to_h
+        # Recursively convert NestedConfiguration objects back to plain hashes
+        convert_to_hash(@data)
+      end
+
+      def [](key)
+        @data[key]
+      end
+
+      def []=(key, value)
+        @data[key] = value.is_a?(Hash) ? NestedConfiguration.new(value) : value
+        define_accessor(key)
+      end
+
+      def method_missing(method_name, *args, &block)
+        method_str = method_name.to_s
+
+        if method_str.end_with?("=")
+          key = method_str.chomp("=").to_sym
+          value = args.first
+          @data[key] = value.is_a?(Hash) ? NestedConfiguration.new(value) : value
+          define_accessor(key)
+        elsif @data.key?(method_name)
+          @data[method_name]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        @data.key?(method_name.to_s.chomp("=").to_sym) || super
+      end
+
+      private
+
+      def convert_to_hash(value)
+        case value
+        when NestedConfiguration
+          value.to_h
+        when Hash
+          value.transform_values { |v| convert_to_hash(v) }
+        when Array
+          value.map { |v| convert_to_hash(v) }
+        else
+          value
+        end
+      end
+
+      def define_accessors!
+        @data.each_key { |key| define_accessor(key) }
+      end
+
+      def define_accessor(key)
+        # Check if method is actually defined (not just available via method_missing)
+        return if singleton_class.method_defined?(key)
+
+        singleton_class.class_eval do
+          define_method(key) { @data[key] }
+          define_method("#{key}=") { |value| @data[key] = value }
+        end
+      end
+    end
+  end
+end

data/lib/better_seo/dsl/base.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module BetterSeo
+  module DSL
+    class Base
+      attr_reader :config
+
+      def initialize
+        @config = {}
+      end
+
+      # Generic setter method
+      def set(key, value)
+        @config[key] = value
+        self
+      end
+
+      # Generic getter method
+      def get(key)
+        @config[key]
+      end
+
+      # Block evaluation
+      def evaluate(&block)
+        instance_eval(&block) if block_given?
+        self
+      end
+
+      # Build final configuration
+      def build
+        validate!
+        @config.dup
+      end
+
+      # Convert to hash
+      def to_h
+        @config.dup
+      end
+
+      # Merge another config
+      def merge!(other)
+        if other.is_a?(Hash)
+          @config.merge!(other)
+        elsif other.respond_to?(:to_h)
+          @config.merge!(other.to_h)
+        else
+          raise DSLError, "Cannot merge #{other.class}"
+        end
+        self
+      end
+
+      protected
+
+      # Override in subclasses for validation
+      def validate!
+        true
+      end
+
+      # Dynamic method handling
+      def method_missing(method_name, *args, &block)
+        method_str = method_name.to_s
+
+        if method_str.end_with?("=")
+          # Setter: title = "value"
+          key = method_str.chomp("=").to_sym
+          set(key, args.first)
+        elsif block_given?
+          # Nested block: open_graph do ... end
+          nested_builder = self.class.new
+          nested_builder.evaluate(&block)
+          set(method_name, nested_builder.build)
+        elsif args.any?
+          # Setter without =: title "value"
+          set(method_name, args.first)
+        else
+          # Getter
+          get(method_name)
+        end
+      end
+
+      def respond_to_missing?(_method_name, _include_private = false)
+        true
+      end
+    end
+  end
+end

data/lib/better_seo/dsl/meta_tags.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module BetterSeo
+  module DSL
+    class MetaTags < Base
+      def title(value = nil)
+        value ? set(:title, value) : get(:title)
+      end
+
+      def description(value = nil)
+        value ? set(:description, value) : get(:description)
+      end
+
+      def keywords(*values)
+        values.any? ? set(:keywords, values.flatten) : get(:keywords)
+      end
+
+      def author(value = nil)
+        value ? set(:author, value) : get(:author)
+      end
+
+      def canonical(value = nil)
+        value ? set(:canonical, value) : get(:canonical)
+      end
+
+      def robots(index: true, follow: true, **options)
+        set(:robots, { index: index, follow: follow }.merge(options))
+      end
+
+      def viewport(value = "width=device-width, initial-scale=1.0")
+        set(:viewport, value)
+      end
+
+      def charset(value = "UTF-8")
+        set(:charset, value)
+      end
+
+      protected
+
+      def validate!
+        errors = []
+
+        if config[:title] && config[:title].length > 60
+          errors << "Title too long (#{config[:title].length} chars, max 60 recommended)"
+        end
+
+        if config[:description] && config[:description].length > 160
+          errors << "Description too long (#{config[:description].length} chars, max 160 recommended)"
+        end
+
+        raise ValidationError, errors.join(", ") if errors.any?
+      end
+    end
+  end
+end