dugway 1.1.0 → 1.3.0

data/lib/dugway/controller.rb

@@ -95,7 +95,11 @@ module Dugway
       end
 
       def render_page(variables={})
-        render_file("#{ page['permalink'] }.html", variables.update({ :page => page }))
+        # Prioritize page object passed in variables, otherwise fetch default using Controller#page
+        current_page = variables[:page] || page
+        render_variables = variables.merge({ :page => current_page })
+        # Use the permalink from the determined page object
+        render_file("#{ current_page['permalink'] }.html", render_variables)
       end
 
       def render_json(object)

data/lib/dugway/liquid/drops/account_drop.rb

@@ -12,6 +12,10 @@ module Dugway
       def country
         @country ||= CountryDrop.new(source['country'])
       end
+
+      def website
+        Dugway.store.website
+      end
     end
   end
 end

data/lib/dugway/liquid/drops/artists_drop.rb

@@ -1,6 +1,18 @@
 module Dugway
   module Drops
     class ArtistsDrop < BaseDrop
+      # Liquid 5.x compatibility: implement liquid_method_missing for method access
+      def liquid_method_missing(method)
+        # Try to find artist by permalink
+        result = before_method(method.to_s)
+        # Wrap hash results in ArtistDrop if it looks like an artist
+        if result.is_a?(Hash) && result['permalink']
+          ArtistDrop.new(result)
+        else
+          result
+        end
+      end
+      
       def all
         @all ||= source
       end

data/lib/dugway/liquid/drops/base_drop.rb

@@ -34,9 +34,14 @@ module Dugway
           return source.send(method_or_key)
         elsif source.respond_to?('has_key?') && source.has_key?(method_or_key)
           return source[method_or_key]
-        elsif source.is_a?(Array) && source.first.has_key?('permalink')
+        elsif source.is_a?(Array) && source.first
+          # Handle both hash items and drop items in array
           for item in source
-            return item if item['permalink'] == method_or_key.to_s
+            if item.is_a?(Hash) && item['permalink'] == method_or_key.to_s
+              return item
+            elsif item.respond_to?(:source) && item.source.is_a?(Hash) && item.source['permalink'] == method_or_key.to_s
+              return item
+            end
           end
         end
 
@@ -47,6 +52,11 @@ module Dugway
         before_method(method.to_s)
       end
 
+      # Liquid 5.x compatibility: implement liquid_method_missing for property access
+      def liquid_method_missing(method_name)
+        before_method(method_name.to_s)
+      end
+
       def errors
         @context['errors']
       end
@@ -54,6 +64,21 @@ module Dugway
       def error(msg)
         errors << msg
       end
+
+      # Liquid 5.x compatibility: make drops JSON-serializable
+      # Only return source for JSON serialization, not for filter processing
+      def to_liquid
+        self
+      end
+      
+      def as_json(*args)
+        if source.is_a?(Hash)
+          # Convert Ruby hash to proper JSON-compatible format
+          source.stringify_keys
+        else
+          {}
+        end
+      end
     end
   end
 end

data/lib/dugway/liquid/drops/categories_drop.rb

@@ -1,6 +1,18 @@
 module Dugway
   module Drops
     class CategoriesDrop < BaseDrop
+      # Liquid 5.x compatibility: implement liquid_method_missing for method access
+      def liquid_method_missing(method)
+        # Try to find category by permalink
+        result = before_method(method.to_s)
+        # Wrap hash results in CategoryDrop if it looks like a category
+        if result.is_a?(Hash) && result['permalink']
+          CategoryDrop.new(result)
+        else
+          result
+        end
+      end
+      
       def all
         @all ||= source
       end

data/lib/dugway/liquid/drops/features_drop.rb

@@ -0,0 +1,144 @@
+require 'set'
+
+module Dugway
+  module Drops
+    # Provides access to specific account feature flags within Liquid templates,
+    # mirroring the behavior of the storefront's FeaturesDrop but reading
+    # configuration from the Dugway store configuration (e.g., dugway.json).
+    #
+    # Feature flags can have a default status (enabled or disabled). This status,
+    # along with the list of exposed features, opt-ins, and opt-outs, should be
+    # defined under a top-level "features" key in the store configuration file,
+    # making it a peer to "store" and "customization".
+    #
+    # Example structure expected within the store configuration (e.g., dugway.json):
+    # {
+    #   "store": { ... },
+    #   "customization": { ... },
+    #   "features": {
+    #     "definitions": {
+    #       "theme_bnpl_messaging": "enabled_by_default",
+    #       "theme_category_collages": "disabled_by_default"
+    #     },
+    #     "opt_ins": ["some_opted_in_feature"],
+    #     "opt_outs": ["some_opted_out_feature"]
+    #   }
+    # }
+    # The `FeaturesDrop` receives the top-level `features` hash as its `source`
+    # via the ThemeDrop.
+    #
+    # Usage in Liquid:
+    #   {% if features.has_theme_bnpl_messaging %} ... {% endif %}
+    #   Note: Liquid might require the trailing '?' depending on context,
+    #         but this implementation handles calls without it.
+    #
+    class FeaturesDrop < BaseDrop
+      # Memoized hash of feature definitions (name => default_status_string)
+      # read from the source (store configuration data).
+      # @return [Hash<String, String>]
+      def feature_definitions
+        @feature_definitions ||= source&.fetch('definitions', {}) || {}
+      end
+
+      # Returns a memoized list of features this account has explicitly opted *into*,
+      # filtered to only include features defined in the definitions.
+      # @return [Array<String>] List of opted-in feature names.
+      def opt_ins
+        return @opt_ins if defined?(@opt_ins)
+
+        source_opt_ins = source&.fetch('opt_ins', []) || []
+        # Ensure source data is treated as a Set for efficient intersection
+        source_set = source_opt_ins.respond_to?(:to_set) ? source_opt_ins.to_set : Set.new(Array(source_opt_ins))
+
+        # Only keep opt-ins that correspond to defined features
+        @opt_ins = (Set.new(feature_definitions.keys) & source_set).to_a
+      end
+
+      # Returns a memoized list of features this account has explicitly opted *out of*,
+      # filtered to only include features defined in the definitions.
+      # @return [Array<String>] List of opted-out feature names.
+      def opt_outs
+        return @opt_outs if defined?(@opt_outs)
+
+        source_opt_outs = source&.fetch('opt_outs', []) || []
+        # Ensure source data is treated as a Set for efficient intersection
+        source_set = source_opt_outs.respond_to?(:to_set) ? source_opt_outs.to_set : Set.new(Array(source_opt_outs))
+
+        # Only keep opt-outs that correspond to defined features
+        @opt_outs = (Set.new(feature_definitions.keys) & source_set).to_a
+      end
+
+      # Override BaseDrop's `before_method` to intercept `has_...` calls directly.
+      # This is called by BaseDrop's `method_missing` and allows us to intercept
+      # `has_...` calls before BaseDrop tries to resolve them against the source hash.
+      def before_method(method_or_key)
+        method_str = method_or_key.to_s
+
+        if method_str.start_with?('has_')
+          # Extract feature name, removing 'has_' prefix and optional trailing '?'
+          # to handle calls like `features.has_feature_name` or `features.has_feature_name?`
+          feature_name = method_str.sub(/^has_/, '').chomp('?')
+
+          # Check if this feature is defined
+          # If the extracted name doesn't match a defined feature, it's not available.
+          unless feature_definitions.key?(feature_name)
+            return false
+          end
+
+          # If defined, calculate availability based on defaults and overrides.
+          is_feature_available?(feature_name)
+        else
+          # If it's not a 'has_' method, delegate to BaseDrop's original logic.
+          super(method_or_key)
+        end
+      end
+
+      # Keep liquid_method_missing for compatibility or explicit Liquid contexts,
+      # We keep liquid_method_missing defined as it's the official Liquid hook,
+      # although our `before_method` override likely handles most cases in Liquid 3.
+      # This provides potential compatibility if Liquid internals change or call this directly.
+      def liquid_method_missing(method_name)
+        method_str = method_name.to_s
+
+        if method_str.start_with?('has_')
+          feature_name = method_str.sub(/^has_/, '').chomp('?')
+          # Check definition and calculate availability, returning false if undefined.
+          feature_definitions.key?(feature_name) ? is_feature_available?(feature_name) : false
+        else
+          # Fallback for non-'has_' methods.
+          super
+        end
+      end
+
+      private
+      # Determines if a specific feature is available for the account based on its
+      # default status (from store customization) and the account's explicit opt-ins/outs
+      # (also from store customization).
+      #
+      # @param feature_name [String] The name of the feature to check.
+      # @return [Boolean] True if the feature is available, false otherwise.
+      def is_feature_available?(feature_name)
+        default_behavior_str = feature_definitions[feature_name]
+        # Should not happen if called via before_method/liquid_method_missing,
+        # but return false if the definition was somehow missing.
+        return false unless default_behavior_str
+
+        is_opted_in = opt_ins.include?(feature_name)
+        is_opted_out = opt_outs.include?(feature_name)
+
+        # Determine final availability:
+        # - If explicitly opted in, it's available.
+        # - If explicitly opted out, it's unavailable.
+        # - Otherwise, availability depends on the defined default behavior string.
+        # Precedence: Opt-out > Opt-in > Default
+        if is_opted_out
+          false
+        elsif is_opted_in
+          true
+        else
+          default_behavior_str == 'enabled_by_default'
+        end
+      end
+    end
+  end
+end

data/lib/dugway/liquid/drops/pages_drop.rb

@@ -1,12 +1,40 @@
 module Dugway
   module Drops
     class PagesDrop < BaseDrop
+      # Liquid 5.x compatibility: implement liquid_method_missing for method access
+      def liquid_method_missing(method)
+        # Try to find page by permalink
+        result = before_method(method.to_s)
+        # Wrap hash results in PageDrop if it looks like a page
+        if result.is_a?(Hash) && result['permalink']
+          PageDrop.new(result)
+        else
+          result
+        end
+      end
+      
       def all
-        @all ||= source.select { |page| page['category'] == 'custom' }
+        @all ||= source.select { |page| (page.source['category'] == 'custom' || page.source['category'] == 'external') && !page.source['required'] }
       end
 
       def cart
-        @cart ||= source.find { |page| page['permalink'] == 'cart' }
+        @cart ||= source.find { |page| page.source['permalink'] == 'cart' }
+      end
+
+      def subscribe_page
+        @subscribe_page ||= store.subscribe_url ? source.find { |page| page.source['url'] == store.subscribe_url } : nil
+      end
+
+      def custom_pages
+        @custom_pages ||= source.select { |page| page.source['category'] == 'custom' && !page.source['required'] }
+      end
+
+      def external_pages
+        @external_pages ||= source.select { |page| page.source['category'] == 'external' && !page.source['required'] }
+      end
+
+      def required_pages
+        @required_pages ||= source.select { |page| page.source['required'] == true }
       end
     end
   end

data/lib/dugway/liquid/drops/product_drop.rb

@@ -1,6 +1,11 @@
 module Dugway
   module Drops
     class ProductDrop < BaseDrop
+      
+      # Liquid 5.x compatibility: ensure proper string representation
+      def to_s
+        name || "Product ##{id}"
+      end
       def created_at
         Time.parse(source['created_at'])
       end
@@ -112,6 +117,12 @@ module Dugway
         end
       end
 
+      # Used to simulate price suffix behavior
+      # In prod this is a per-product setting but for dugway it needs to be global
+      def price_suffix
+        store.price_suffix
+      end
+
       private
 
       def price_min_max

data/lib/dugway/liquid/drops/products_drop.rb

@@ -3,6 +3,45 @@ require 'will_paginate/array'
 module Dugway
   module Drops
     class ProductsDrop < BaseDrop
+      
+      # Liquid 5.x compatibility: implement liquid_method_missing for method access
+      def liquid_method_missing(method)
+        method_str = method.to_s
+        
+        # Handle known methods
+        case method_str
+        when 'all'
+          all
+        when 'current'
+          current
+        when 'on_sale'
+          on_sale
+        else
+          # Try to find product by permalink
+          result = before_method(method_str)
+          # Wrap hash results in ProductDrop if it looks like a product
+          if result.is_a?(Hash) && result['permalink']
+            ProductDrop.new(result)
+          else
+            result
+          end
+        end
+      end
+      
+      # Also ensure before_method works as fallback
+      def before_method(method_or_key)
+        case method_or_key.to_s
+        when 'all'
+          all
+        when 'current'
+          current
+        when 'on_sale'
+          on_sale
+        else
+          super
+        end
+      end
+
       def all
         sort_and_paginate source
       end

data/lib/dugway/liquid/drops/theme_drop.rb

@@ -1,13 +1,43 @@
 module Dugway
   module Drops
     class ThemeDrop < BaseDrop
-      def before_method(method_or_key)
-        # We should try to get away from this api and use the newer one below
-        if source.respond_to?('has_key?') && source.has_key?(method_or_key) && settings_images.find { |image| image['variable'] == method_or_key.to_s }
-          return ImageDrop.new(source[method_or_key].stringify_keys)
-        end
+      # @param customization [Hash] Theme customization values.
+      # @param definitions [Hash] Theme setting definitions (from settings.json).
+      def initialize(customization, definitions = {})
+        super(customization)
+        @definitions = definitions || {}
+      end
 
-        super
+      # Liquid 5.x compatibility: implement liquid_method_missing for property access
+      def liquid_method_missing(method)
+        method_str = method.to_s
+        method_sym = method.to_sym
+        
+        # Try different key formats - source might have string or symbol keys
+        # Use has_key? to handle false/nil values properly
+        if source.has_key?(method_str)
+          value = source[method_str]
+        elsif source.has_key?(method_sym)
+          value = source[method_sym]
+        elsif source.has_key?(method_str.to_sym)
+          value = source[method_str.to_sym]
+        elsif source.has_key?(method_sym.to_s)
+          value = source[method_sym.to_s]
+        else
+          value = nil
+        end
+        
+        # Check for image settings - need to wrap in ImageDrop
+        if !value.nil? && settings_images.find { |image| image['variable'] == method_str }
+          return ImageDrop.new(value.is_a?(Hash) ? value.stringify_keys : value)
+        end
+        
+        value
+      end
+      
+      def before_method(method_or_key)
+        # Fallback for older Liquid versions
+        liquid_method_missing(method_or_key)
       end
 
       # Newer API for theme images.
@@ -20,6 +50,22 @@ module Dugway
         Drops::ThemeImageSetsDrop.new(source)
       end
 
+      def features
+        # Fetch features config from the top-level Dugway options hash,
+        # which should contain the parsed store configuration (e.g., dugway.json).
+        # This allows 'features' to be a peer to 'store' and 'customization'.
+        feature_data = Dugway.options&.fetch('features', {}) || {}
+        Drops::FeaturesDrop.new(feature_data)
+      end
+
+      # Provides access to theme translations via theme.translations
+      def translations
+        # Instantiate and return the TranslationsDrop, passing settings.
+        # Memoize the instance for efficiency within a single render cycle.
+        # Pass both customization (source) and definitions to TranslationsDrop.
+        @translations_drop ||= Drops::TranslationsDrop.new(source, @definitions)
+      end
+
       private
       def settings_images
         @settings_images ||= settings.has_key?('images') ? settings['images'] : []

data/lib/dugway/liquid/drops/translations_drop.rb

@@ -0,0 +1,122 @@
+require 'i18n'
+
+module Dugway
+  module Drops
+    class TranslationsDrop < BaseDrop
+      class MissingTranslationError < StandardError; end
+
+      # @param settings [Hash] Theme customization values (resolved settings).
+      # @param definitions [Hash] Raw theme setting definitions (from settings.json).
+      def initialize(settings, definitions = {})
+        @settings = settings || {}
+        @definitions = definitions || {} # Store definitions
+        # Read settings using both symbol and string keys for flexibility.
+        @translation_mode = (@settings[:translation_mode] || @settings['translation_mode'])&.to_s
+        # Use explicit theme setting for locale if present, otherwise default to current I18n.locale
+        @translation_locale = (@settings[:translation_locale] || @settings['translation_locale'])&.to_s.presence || I18n.locale.to_s
+        super()
+      end
+
+      # Liquid access: `{{ translations['key.name'] }}`
+      # Returns the translation string (which could be an empty string),
+      # or a "[MISSING TRANSLATION: ...]" string if the key is not found or its value is nil.
+      #
+      # @param key [String, Symbol] The translation key.
+      # @return [String, nil] The translation or missing translation indicator.
+      def [](key)
+        key_str = key.to_s
+        translation = find_translation(key_str)
+
+        if translation.nil?
+          # Key is missing, or explicitly nil in manual mode - treat both as missing.
+          log_missing_translation(key_str)
+          return missing_translation_message(key_str)
+        end
+
+        # Key found, return its value.
+        translation
+      end
+
+      private
+
+      def manual_mode?
+        @translation_mode == 'manual'
+      end
+
+      # Looks up translation using I18n.
+      # Returns nil if the key is not found or the locale is invalid.
+      def lookup_automatic_translation(key)
+        locale_to_use = @translation_locale
+        # `default: nil` prevents I18n from raising an error on missing keys.
+        I18n.t("storefront.#{key}", locale: locale_to_use, default: nil)
+      rescue I18n::InvalidLocale
+        nil # Treat invalid locale as a missing translation.
+      end
+
+      # Converts a canonical key ('a.b.c') to the theme setting key format (:a_b_c_tr_text).
+      def derive_manual_setting_key(key)
+        "#{key.tr('.', '_')}_tr_text".to_sym
+      end
+
+      # Finds the translation based on the current mode.
+      # In manual mode, respects the 'allow_blank' setting definition.
+      # Returns the translation string, or nil if not found or disallowed blank.
+      def find_translation(key_str)
+        if manual_mode?
+          manual_setting_key_sym = derive_manual_setting_key(key_str)
+          manual_setting_key_str = manual_setting_key_sym.to_s
+          custom_value = nil
+          setting_exists = false
+
+          # Check both symbol and string keys for manual overrides.
+          if @settings.key?(manual_setting_key_sym)
+            custom_value = @settings[manual_setting_key_sym]
+            setting_exists = true
+          elsif @settings.key?(manual_setting_key_str)
+            custom_value = @settings[manual_setting_key_str]
+            setting_exists = true
+          end
+
+          if setting_exists
+            # Find the corresponding definition to check allow_blank
+            # Assuming manual translations are defined similarly to 'options'
+            definition = find_setting_definition(manual_setting_key_str) || {}
+            allow_blank = definition['allow_blank'].to_s == 'true'
+
+            # Return custom value if it's present, or if it's blank but allowed
+            return custom_value if custom_value.present? || (allow_blank && custom_value == '')
+
+            # If we reach here, the value is blank but blank is not allowed.
+            # Fall through to automatic lookup.
+          end
+
+          # If setting key didn't exist, fall through to automatic lookup.
+
+        end # End manual_mode? check
+
+        # Automatic mode or fallback from manual mode
+        lookup_automatic_translation(key_str)
+      end
+
+      # Helper to find a setting definition by its variable name across common sections.
+      def find_setting_definition(variable_name)
+        # Look primarily in 'options' as manual translations often mimic them.
+        # Add other potential sections if needed in the future.
+        (@definitions['options'] || []).find { |d| d['variable'] == variable_name }
+      end
+
+      # Logs a warning message for a missing translation.
+      def log_missing_translation(key_str)
+        mode = manual_mode? ? 'manual' : 'automatic'
+        locale_info = manual_mode? ? '' : " locale='#{@translation_locale}'"
+        message = "Missing translation: key='#{key_str}'#{locale_info} mode='#{mode}'"
+        Dugway.logger.warn(message)
+      end
+
+      # Returns the standard string indicating a missing translation.
+      def missing_translation_message(key_str)
+        "[MISSING TRANSLATION: #{key_str}]"
+      end
+    end
+  end
+end