dugway 1.1.0 → 1.3.0

data/spec/units/dugway/liquid/drops/translations_drop_spec.rb

@@ -0,0 +1,292 @@
+require 'spec_helper'
+
+describe Dugway::Drops::TranslationsDrop do
+  let(:settings) { {} }
+  let(:definitions) { {} }
+  let(:drop) { Dugway::Drops::TranslationsDrop.new(settings, definitions) }
+
+  before(:all) do
+    # Store original I18n settings to restore them later
+    @original_i18n_load_path = I18n.load_path.dup
+    @original_i18n_available_locales = I18n.config.available_locales.dup
+    @original_i18n_default_locale = I18n.default_locale
+    @original_i18n_locale = I18n.locale
+
+    # Create a unique temporary directory for theme-specific locale files for this test run
+    @theme_parent_dir = File.expand_path("../../../../tmp/translations_drop_spec_#{Time.now.to_f}", __FILE__)
+    @theme_source_dir = File.join(@theme_parent_dir, 'source') # For Dugway.source_dir mock
+    @theme_locales_dir = File.join(@theme_parent_dir, '_dugway_locales') # Theme locale files go here
+
+    FileUtils.mkdir_p(@theme_source_dir)
+    FileUtils.mkdir_p(@theme_locales_dir)
+
+    # Write theme-specific test files. These will override or supplement gem locales.
+    # Using 'navigation.cart' as a key that exists in actual gem locales (e.g., storefront.en-US.yml)
+    # and 'farewell' as a theme-only key.
+    # We use 'en-US' for the theme file to directly override the gem's 'en-US' translations.
+    File.write(File.join(@theme_locales_dir, 'storefront.en-US.yml'), <<~YAML)
+      en-US:
+        storefront:
+          navigation:
+            cart: "Theme Cart" # Override gem's "Cart"
+          farewell: "Goodbye Theme" # Theme-only
+    YAML
+    File.write(File.join(@theme_locales_dir, 'storefront.fr.yml'), <<~YAML)
+      fr:
+        storefront:
+          navigation:
+            cart: "Panier du Thème"
+    YAML
+
+    # Force load gem locales first (mimicking initial gem load)
+    # The main lib/dugway.rb (required via spec_helper) should have already configured
+    # I18n.load_path and I18n.config.available_locales with the gem's actual files.
+    # We are capturing this initial state and then augmenting it for theme-specific test files.
+
+    @theme_locale_files = Dir.glob(File.join(@theme_locales_dir, 'storefront.*.yml'))
+    
+    # Augment the load path: original gem paths + new theme paths.
+    # Theme files are added last so their definitions override gem's if keys conflict.
+    I18n.load_path = (@original_i18n_load_path + @theme_locale_files).uniq
+    
+    # Augment available locales: original gem locales + new theme locales.
+    theme_locale_codes = @theme_locale_files.map do |file|
+      name = File.basename(file, '.yml')
+      locale_code = name.match(/^storefront\.(.+)$/)&.captures&.first
+      locale_code&.to_sym
+    end.compact
+    
+    current_available_locales = (@original_i18n_available_locales.to_a + theme_locale_codes).uniq
+    
+    if current_available_locales.any? { |loc| loc.to_s.start_with?('en-') } && !current_available_locales.include?(:en)
+      current_available_locales << :en
+    end
+    
+    I18n.config.available_locales = current_available_locales
+
+    # Force a clean slate for translations before reloading.
+    # This ensures that the load path order is strictly respected for overrides.
+    I18n.backend.send(:init_translations) if I18n.backend.respond_to?(:init_translations, true)
+    
+    # Reload the backend to process all files in the (now augmented) I18n.load_path
+    # and to recognize all locales in I18n.config.available_locales.
+    I18n.backend.reload!
+    
+    # Verify that :'en-US' (which should come from the gem's original setup) is recognized.
+    # If this fails, it means :'en-US' was not in @original_i18n_available_locales or was lost.
+    unless I18n.config.available_locales.include?(:'en-US') && I18n.backend.available_locales.include?(:'en-US')
+      error_message = "I18n Setup Issue: :en-US is not available after setup.\n"
+      error_message += "I18n.config.available_locales: #{I18n.config.available_locales.inspect}\n"
+      error_message += "I18n.backend.available_locales: #{I18n.backend.available_locales.inspect}\n"
+      error_message += "I18n.load_path: #{I18n.load_path.inspect}\n"
+      error_message += "@original_i18n_available_locales: #{@original_i18n_available_locales.inspect}\n"
+      error_message += "@original_i18n_load_path: #{@original_i18n_load_path.inspect}"
+      raise error_message
+    end
+    
+    I18n.default_locale = :'en-US'
+    I18n.locale = :'en-US'
+  end
+
+  after(:all) do
+    # Clean up temporary theme directory
+    FileUtils.rm_rf(@theme_parent_dir)
+
+    # Restore original I18n settings
+    I18n.load_path = @original_i18n_load_path
+    I18n.config.available_locales = @original_i18n_available_locales
+    I18n.default_locale = @original_i18n_default_locale
+    I18n.locale = @original_i18n_locale
+    I18n.backend.reload!
+  end
+  let(:logger_double) { double('Logger', warn: nil) }
+
+  before(:each) do
+    allow(Dugway).to receive(:gem_root).and_return(File.expand_path('../../../../../', __FILE__))
+    allow(Dugway).to receive(:source_dir).and_return(@theme_source_dir)
+
+    allow(Dugway).to receive(:logger).and_return(logger_double)
+  end
+
+  describe 'Automatic Mode (Default)' do
+    context "with default language ('en-US', falling back to 'en' for theme)" do
+      # These tests rely on I18n.locale being 'en-US' (set in before(:all))
+      # The theme provides 'storefront.en.yml'
+      it "returns theme override for a key also in gem locales" do
+        # Gem 'en-US' (locales/storefront.en-US.yml) has storefront.navigation.cart: "Cart"
+        # Theme 'en' (temporary file) has storefront.navigation.cart: "Theme Cart"
+        expect(drop['navigation.cart']).to eq('Theme Cart')
+      end
+
+      it "returns theme-only translation if present" do
+        # 'farewell' is only in the temporary theme 'en' file
+        expect(drop['farewell']).to eq('Goodbye Theme')
+      end
+
+      it "returns gem translation if not in theme" do
+        # 'navigation.all_products' is in gem 'en-US.yml', not in our test theme 'en.yml'
+        # The value from locales/storefront.en-US.yml is "All products"
+        expect(drop['navigation.all_products']).to eq('All products')
+      end
+
+      it "returns missing translation message for unknown key" do
+        expect(drop['unknown.key']).to eq('[MISSING TRANSLATION: unknown.key]')
+      end
+
+      it "logs a warning for missing translation with the correct locale" do
+        expect(Dugway.logger).to receive(:warn).with("Missing translation: key='unknown.key.again' locale='en-US' mode='automatic'")
+        drop['unknown.key.again']
+      end
+    end
+
+    context "with specified locale ('fr')" do
+      let(:settings) { { translation_locale: 'fr' } }
+
+      it "returns translation for the specified language from theme" do
+        # Theme 'fr' (temporary file) has storefront.navigation.cart: "Panier du Thème"
+        expect(drop['navigation.cart']).to eq('Panier du Thème')
+      end
+
+      it "returns missing translation message if key not found in specified language (and not in fallbacks)" do
+        # 'farewell' is not in theme 'fr.yml' or any 'fr' gem locale
+        expect(drop['farewell']).to eq('[MISSING TRANSLATION: farewell]')
+      end
+      
+      it "returns gem translation if key not found in specified theme language but exists in gem's version of that language" do
+        # Assuming 'locales/storefront.fr-FR.yml' (loaded by gem) has 'navigation.all': 'Tous'
+        # and our temporary theme 'fr.yml' does not have 'navigation.all'
+        # This test depends on the content of the actual gem's fr-FR file.
+        # For a more robust test, ensure 'locales/storefront.fr-FR.yml' has 'navigation: { all: "Tous" }'
+        # Or, if 'fr-FR' is not a primary test target, this test could be more generic or skipped.
+        # For now, let's assume 'navigation.all' exists in a loaded 'fr' variant from the gem.
+        # If 'locales/storefront.fr-FR.yml' exists and is loaded:
+        # expect(drop['navigation.all']).to eq(I18n.t('storefront.navigation.all', locale: :fr))
+        # If not, it will be missing. Let's test for missing if not in theme 'fr'.
+        expect(drop['navigation.all_products']).to eq('[MISSING TRANSLATION: navigation.all_products]')
+      end
+
+      it "logs a warning with the correct locale" do
+        expect(Dugway.logger).to receive(:warn).with("Missing translation: key='farewell.again' locale='fr' mode='automatic'")
+        drop['farewell.again']
+      end
+    end
+
+    context "with specified non-existent locale ('xx')" do
+      let(:settings) { { translation_locale: 'xx' } }
+
+      it "returns missing translation message for a known key" do
+        expect(drop['navigation.cart']).to eq('[MISSING TRANSLATION: navigation.cart]')
+      end
+    end
+  end
+
+  describe 'Manual Mode' do
+    let(:settings) do
+      {
+        translation_mode: 'manual',
+        greeting_tr_text: 'Hello Manual',
+        'nested_message_tr_text' => 'Manual Nested',
+        farewell_tr_text: '',
+        explicit_nil_tr_text: nil
+      }
+    end
+
+    it "returns translation from manual setting (symbol key)" do
+      expect(drop['greeting']).to eq('Hello Manual')
+    end
+
+    it "returns translation from manual setting (string key)" do
+      # Note: The drop converts the lookup key 'nested.message' to :nested_message_tr_text
+      # but the settings hash might have string keys from JSON parsing.
+      # The drop implementation checks both symbol and string keys in the settings hash.
+      expect(drop['nested.message']).to eq('Manual Nested')
+    end
+
+    it "falls back to automatic translation if manual setting is blank and allow_blank is false (default)" do
+      # No definition provided, so allow_blank defaults to false
+      # 'farewell' exists in theme 'en' locale (storefront.en.yml created by test)
+      # I18n.locale is 'en-US'. The drop will use this locale.
+      expect(I18n).to receive(:t).with('storefront.farewell', locale: 'en-US', default: nil).and_call_original
+      expect(drop['farewell']).to eq('Goodbye Theme')
+    end
+
+    it "returns missing translation message if manual setting is explicitly nil" do
+      # If the key exists in manual settings but the value is nil, treat it as missing.
+      expect(drop['explicit_nil']).to eq('[MISSING TRANSLATION: explicit_nil]')
+    end
+
+    it "returns missing translation message if manual setting is not present" do
+      expect(drop['unknown.key']).to eq('[MISSING TRANSLATION: unknown.key]')
+    end
+
+    it "logs a warning for missing translation (manual mode)" do
+      # Expect a call to the stubbed logger
+      expect(Dugway.logger).to receive(:warn).with("Missing translation: key='unknown.key.manual' mode='manual'")
+      drop['unknown.key.manual']
+    end
+
+    it "does not use I18n backend if a valid manual setting is found" do
+      expect(I18n).not_to receive(:t)
+      expect(drop['greeting']).to eq('Hello Manual') # Uses manual setting
+    end
+
+    it "uses I18n backend if manual setting is blank and allow_blank is false" do
+      expect(I18n).to receive(:t).with('storefront.farewell', locale: 'en-US', default: nil).and_call_original
+      drop['farewell'] # Trigger lookup for blank, disallowed value
+    end
+
+    it "uses I18n backend if manual setting key is not found" do
+      expect(I18n).to receive(:t).with('storefront.unknown.key', locale: 'en-US', default: nil).and_call_original
+      drop['unknown.key'] # Trigger lookup for missing key
+    end
+
+    context "with allow_blank definitions" do
+      let(:definitions) do
+        {
+          'options' => [
+            { 'variable' => 'allow_blank_true_tr_text', 'allow_blank' => true },
+            { 'variable' => 'allow_blank_false_tr_text', 'allow_blank' => false },
+            { 'variable' => 'allow_blank_missing_tr_text' }, # allow_blank defaults to false
+            { 'variable' => 'allow_blank_non_blank_val_tr_text', 'allow_blank' => false }
+          ]
+        }
+      end
+      let(:settings) do
+        {
+          translation_mode: 'manual',
+          allow_blank_true_tr_text: '',
+          allow_blank_false_tr_text: '',
+          allow_blank_missing_tr_text: '',
+          allow_blank_non_blank_val_tr_text: 'Not Blank'
+        }
+      end
+
+      it "returns blank string when allow_blank is true" do
+        expect(drop['allow_blank_true']).to eq('')
+      end
+
+      it "falls back to automatic translation when allow_blank is false" do
+        # Assuming 'allow_blank_false' doesn't exist in automatic translations
+        expect(I18n).to receive(:t).with('storefront.allow_blank_false', locale: 'en-US', default: nil).and_return(nil)
+        expect(drop['allow_blank_false']).to eq('[MISSING TRANSLATION: allow_blank_false]')
+      end
+
+      it "falls back to automatic translation when allow_blank is missing (defaults to false)" do
+        # Assuming 'allow_blank_missing' doesn't exist in automatic translations
+        expect(I18n).to receive(:t).with('storefront.allow_blank_missing', locale: 'en-US', default: nil).and_return(nil)
+        expect(drop['allow_blank_missing']).to eq('[MISSING TRANSLATION: allow_blank_missing]')
+      end
+
+      it "returns non-blank value even when allow_blank is false" do
+        expect(drop['allow_blank_non_blank_val']).to eq('Not Blank')
+      end
+    end
+  end
+
+  describe '#derive_manual_setting_key' do
+    # Test the private method indirectly via its usage or directly if needed
+    it 'converts dot notation to underscore symbol notation' do
+      expect(drop.send(:derive_manual_setting_key, 'some.key.name')).to eq(:some_key_name_tr_text)
+    end
+  end
+end

data/spec/units/dugway/liquid/filters/core_filters_spec.rb

@@ -34,12 +34,251 @@ describe Dugway::Filters::CoreFilters do
     end
 
     it "should support the 'code' format argument" do
-      rendered_template("{{ 1234.56 | money: 'code' }}").should == '1,234.56 <span class="currency_code">USD</span>'
+      rendered_template("{{ 1234.56 | money: 'code' }}").should == '<span class="currency_code">USD</span>1,234.56'
     end
 
     it "should support the 'sign_and_code' format argument" do
       rendered_template("{{ 1234.56 | money: 'sign_and_code' }}").should == '<span class="currency_sign">$</span>1,234.56 <span class="currency_code">USD</span>'
     end
+
+    it "should use theme.money_format when explicitly passed as parameter" do
+      theme_drop = Dugway::Drops::ThemeDrop.new({ 'money_format' => 'sign' }, {})
+      rendered_template("{{ 1234.56 | money: theme.money_format }}", { 'theme' => theme_drop }).should == '<span class="currency_sign">$</span>1,234.56'
+    end
+
+    it "should use theme.money_format = 'code' when explicitly passed as parameter" do
+      theme_drop = Dugway::Drops::ThemeDrop.new({ 'money_format' => 'code' }, {})
+      rendered_template("{{ 1234.56 | money: theme.money_format }}", { 'theme' => theme_drop }).should == '<span class="currency_code">USD</span>1,234.56'
+    end
+
+    it "should use theme.money_format = 'sign_and_code' when explicitly passed as parameter" do
+      theme_drop = Dugway::Drops::ThemeDrop.new({ 'money_format' => 'sign_and_code' }, {})
+      rendered_template("{{ 1234.56 | money: theme.money_format }}", { 'theme' => theme_drop }).should == '<span class="currency_sign">$</span>1,234.56 <span class="currency_code">USD</span>'
+    end
+
+    it "should use default format when no format argument is provided" do
+      theme_drop = Dugway::Drops::ThemeDrop.new({ 'money_format' => 'sign' }, {})
+      rendered_template("{{ 1234.56 | money }}", { 'theme' => theme_drop }).should == '1,234.56'
+    end
+
+    it "should fall back to default format when theme.money_format is not set" do
+      rendered_template("{{ 1234.56 | money }}").should == '1,234.56'
+    end
+
+    it "should handle money_format from dugway.json customization when explicitly passed" do
+      # Simulate how the theme would be loaded with dugway.json customization
+      customization = { 'money_format' => 'sign' }
+      theme_drop = Dugway::Drops::ThemeDrop.new(customization, {})
+      rendered_template("{{ 1234.56 | money: theme.money_format }}", { 'theme' => theme_drop }).should == '<span class="currency_sign">$</span>1,234.56'
+    end
+
+    it "should handle money: theme.money_format syntax like storefront" do
+      # Test the exact syntax the user is using: {{ price | money: theme.money_format }}
+      customization = { 'money_format' => 'sign' }
+      theme_drop = Dugway::Drops::ThemeDrop.new(customization, {})
+      rendered_template("{{ 1234.56 | money: theme.money_format }}", { 'theme' => theme_drop }).should == '<span class="currency_sign">$</span>1,234.56'
+    end
+
+    it "should handle money_format 'none' correctly returning just the number" do
+      customization = { 'money_format' => 'none' }
+      theme_drop = Dugway::Drops::ThemeDrop.new(customization, {})
+      rendered_template("{{ 1234.56 | money: theme.money_format }}", { 'theme' => theme_drop }).should == '1,234.56'
+    end
+
+    it "should support the 'rounded' format argument" do
+      rendered_template("{{ 1234.56 | money: 'rounded' }}").should == '1,235'
+    end
+
+    it "should support the 'sign_rounded' format argument" do
+      rendered_template("{{ 1234.56 | money: 'sign_rounded' }}").should == '<span class="currency_sign">$</span>1,235'
+    end
+
+    it "should support the 'code_rounded' format argument" do
+      rendered_template("{{ 1234.56 | money: 'code_rounded' }}").should == '<span class="currency_code">USD</span>1,235'
+    end
+
+    it "should round up 10.99 to 11 with rounded format" do
+      rendered_template("{{ 10.99 | money: 'rounded' }}").should == '11'
+    end
+
+    it "should round up 10.99 to $11 with sign_rounded format" do
+      rendered_template("{{ 10.99 | money: 'sign_rounded' }}").should == '<span class="currency_sign">$</span>11'
+    end
+
+    it "should round up 10.99 to 11 USD with code_rounded format" do
+      rendered_template("{{ 10.99 | money: 'code_rounded' }}").should == '<span class="currency_code">USD</span>11'
+    end
+
+    it "should handle exact amounts with rounded formats" do
+      rendered_template("{{ 10.00 | money: 'rounded' }}").should == '10'
+      rendered_template("{{ 10.00 | money: 'sign_rounded' }}").should == '<span class="currency_sign">$</span>10'
+      rendered_template("{{ 10.00 | money: 'code_rounded' }}").should == '<span class="currency_code">USD</span>10'
+    end
+  end
+
+  describe "#product_price" do
+    it "should handle fixed pricing products" do
+      product = { 'default_price' => 1234.56, 'variable_pricing' => false }
+      rendered_template("{{ product | product_price }}", { 'product' => product }).should == '1,234.56'
+    end
+
+    it "should handle fixed pricing products with format" do
+      product = { 'default_price' => 1234.56, 'variable_pricing' => false }
+      rendered_template("{{ product | product_price: 'sign' }}", { 'product' => product }).should == '<span class="currency_sign">$</span>1,234.56'
+    end
+
+    it "should handle variable pricing products with default format" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price }}", { 'product' => product }).should == '10.00 - 20.00'
+    end
+
+    it "should handle variable pricing products with sign format" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'sign' }}", { 'product' => product }).should == '<span class="currency_sign">$</span>10.00 - <span class="currency_sign">$</span>20.00'
+    end
+
+    it "should handle variable pricing products with code format" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'code' }}", { 'product' => product }).should == '<span class="currency_code">USD</span>10.00 - 20.00'
+    end
+
+    it "should return empty for nil product" do
+      rendered_template("{{ nil | product_price }}").should == ''
+    end
+
+    it "should fallback to price field if default_price is not present" do
+      product = { 'price' => 1234.56, 'variable_pricing' => false }
+      rendered_template("{{ product | product_price }}", { 'product' => product }).should == '1,234.56'
+    end
+
+    it "should work with theme.money_format for fixed pricing" do
+      product = { 'default_price' => 1234.56, 'variable_pricing' => false }
+      customization = { 'money_format' => 'sign' }
+      theme_drop = Dugway::Drops::ThemeDrop.new(customization, {})
+      rendered_template("{{ product | product_price: theme.money_format }}", { 'product' => product, 'theme' => theme_drop }).should == '<span class="currency_sign">$</span>1,234.56'
+    end
+
+    it "should work with theme.money_format for variable pricing" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      customization = { 'money_format' => 'sign' }
+      theme_drop = Dugway::Drops::ThemeDrop.new(customization, {})
+      rendered_template("{{ product | product_price: theme.money_format }}", { 'product' => product, 'theme' => theme_drop }).should == '<span class="currency_sign">$</span>10.00 - <span class="currency_sign">$</span>20.00'
+    end
+
+    it "should handle locale-specific currency formatting" do
+      # Test that the currency code position respects locale formatting
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'code' }}", { 'product' => product }).should == '<span class="currency_code">USD</span>10.00 - 20.00'
+    end
+
+    # Tests for range_format parameter
+    it "should show min price only when range_format is 'min_only'" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'sign', 'min_only' }}", { 'product' => product }).should == '<span class="currency_sign">$</span>10.00'
+    end
+
+    it "should show min price only with code format when range_format is 'min_only'" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'code', 'min_only' }}", { 'product' => product }).should == '<span class="currency_code">USD</span>10.00'
+    end
+
+    it "should show max price only when range_format is 'max_only'" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'sign', 'max_only' }}", { 'product' => product }).should == '<span class="currency_sign">$</span>20.00'
+    end
+
+    it "should show max price only with code format when range_format is 'max_only'" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'code', 'max_only' }}", { 'product' => product }).should == '<span class="currency_code">USD</span>20.00'
+    end
+
+    it "should show range when range_format is 'default'" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'sign', 'default' }}", { 'product' => product }).should == '<span class="currency_sign">$</span>10.00 - <span class="currency_sign">$</span>20.00'
+    end
+
+    it "should show range when range_format is nil" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'sign', nil }}", { 'product' => product }).should == '<span class="currency_sign">$</span>10.00 - <span class="currency_sign">$</span>20.00'
+    end
+
+    it "should show range when range_format is an invalid value" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'sign', 'invalid' }}", { 'product' => product }).should == '<span class="currency_sign">$</span>10.00 - <span class="currency_sign">$</span>20.00'
+    end
+
+    it "should show range by default when range_format is not specified" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'sign' }}", { 'product' => product }).should == '<span class="currency_sign">$</span>10.00 - <span class="currency_sign">$</span>20.00'
+    end
+
+    # Test ThemeDrop integration for real-world usage
+    it "should work with theme-based range format when 'min_only'" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      customization = { 'price_range_format' => 'min_only' }
+      theme_drop = Dugway::Drops::ThemeDrop.new(customization, {})
+      rendered_template("{{ product | product_price: 'sign', theme.price_range_format }}", { 'product' => product, 'theme' => theme_drop }).should == '<span class="currency_sign">$</span>10.00'
+    end
+
+    it "should work with theme-based range format when 'max_only'" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      customization = { 'price_range_format' => 'max_only' }
+      theme_drop = Dugway::Drops::ThemeDrop.new(customization, {})
+      rendered_template("{{ product | product_price: 'sign', theme.price_range_format }}", { 'product' => product, 'theme' => theme_drop }).should == '<span class="currency_sign">$</span>20.00'
+    end
+
+    it "should work with both theme.money_format and theme-based range format" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      customization = { 'money_format' => 'sign', 'price_range_format' => 'min_only' }
+      theme_drop = Dugway::Drops::ThemeDrop.new(customization, {})
+      rendered_template("{{ product | product_price: theme.money_format, theme.price_range_format }}", { 'product' => product, 'theme' => theme_drop }).should == '<span class="currency_sign">$</span>10.00'
+    end
+
+    # Tests for rounded formats
+    it "should handle fixed pricing products with rounded format" do
+      product = { 'default_price' => 1234.56, 'variable_pricing' => false }
+      rendered_template("{{ product | product_price: 'rounded' }}", { 'product' => product }).should == '1,235'
+    end
+
+    it "should handle fixed pricing products with sign_rounded format" do
+      product = { 'default_price' => 1234.56, 'variable_pricing' => false }
+      rendered_template("{{ product | product_price: 'sign_rounded' }}", { 'product' => product }).should == '<span class="currency_sign">$</span>1,235'
+    end
+
+    it "should handle fixed pricing products with code_rounded format" do
+      product = { 'default_price' => 1234.56, 'variable_pricing' => false }
+      rendered_template("{{ product | product_price: 'code_rounded' }}", { 'product' => product }).should == '<span class="currency_code">USD</span>1,235'
+    end
+
+    it "should handle variable pricing products with rounded format" do
+      product = { 'min_price' => 10.99, 'max_price' => 20.99, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'rounded' }}", { 'product' => product }).should == '11 - 21'
+    end
+
+    it "should handle variable pricing products with sign_rounded format" do
+      product = { 'min_price' => 10.99, 'max_price' => 20.99, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'sign_rounded' }}", { 'product' => product }).should == '<span class="currency_sign">$</span>11 - <span class="currency_sign">$</span>21'
+    end
+
+    it "should handle variable pricing products with code_rounded format" do
+      product = { 'min_price' => 10.99, 'max_price' => 20.99, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'code_rounded' }}", { 'product' => product }).should == '<span class="currency_code">USD</span>11 - 21'
+    end
+
+    it "should handle rounded formats with range_format min_only" do
+      product = { 'min_price' => 10.99, 'max_price' => 20.99, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'sign_rounded', 'min_only' }}", { 'product' => product }).should == '<span class="currency_sign">$</span>11'
+    end
+
+    it "should handle rounded formats with range_format max_only" do
+      product = { 'min_price' => 10.99, 'max_price' => 20.99, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'code_rounded', 'max_only' }}", { 'product' => product }).should == '<span class="currency_code">USD</span>21'
+    end
+
+    it "should handle exact amounts with rounded variable pricing" do
+      product = { 'min_price' => 10.00, 'max_price' => 20.00, 'variable_pricing' => true }
+      rendered_template("{{ product | product_price: 'sign_rounded' }}", { 'product' => product }).should == '<span class="currency_sign">$</span>10 - <span class="currency_sign">$</span>20'
+    end
   end
 
   describe "#money_with_sign" do
@@ -50,7 +289,62 @@ describe Dugway::Filters::CoreFilters do
 
   describe "#money_with_code" do
     it "should convert a number to currency format with a code" do
-      rendered_template("{{ 1234.56 | money_with_code }}").should == '1,234.56 <span class="currency_code">USD</span>'
+      rendered_template("{{ 1234.56 | money_with_code }}").should == '<span class="currency_code">USD</span>1,234.56'
+    end
+
+    # Tests for different currencies to ensure locale-specific formatting
+    context "with EUR currency" do
+      # TODO: The 'eu' locale is invalid and needs to be fixed in the bigcartel-currency-locales gem.
+      # Once the gem is updated to use a valid locale like 'de-DE' for EUR, we can update these tests
+      # to expect the correct European number formatting (1.200,99 instead of 1,200.99).
+      # For now, we're expecting the fallback US formatting due to the invalid locale.
+      it "should display currency code after number with space for EUR" do
+        eur_currency = { 'sign' => '€', 'name' => 'Euro', 'id' => 4, 'code' => 'EUR', 'locale' => 'eu' }
+        # Expected: '1.200,99 <span class="currency_code">EUR</span>' once locale is fixed
+        rendered_template_with_currency("{{ 1200.99 | money_with_code }}", eur_currency).should == '1,200.99 <span class="currency_code">EUR</span>'
+      end
+
+      it "should work with money: 'code' format for EUR" do
+        eur_currency = { 'sign' => '€', 'name' => 'Euro', 'id' => 4, 'code' => 'EUR', 'locale' => 'eu' }
+        # Expected: '1.200,99 <span class="currency_code">EUR</span>' once locale is fixed
+        rendered_template_with_currency("{{ 1200.99 | money: 'code' }}", eur_currency).should == '1,200.99 <span class="currency_code">EUR</span>'
+      end
+    end
+
+    context "with CHF currency" do
+      it "should display currency code before number with space for CHF" do
+        chf_currency = { 'sign' => 'CHF', 'name' => 'Swiss Franc', 'id' => 10, 'code' => 'CHF', 'locale' => 'gsw-CH' }
+        rendered_template_with_currency("{{ 1200.99 | money_with_code }}", chf_currency).should == '<span class="currency_code">CHF</span> 1\'200.99'
+      end
+
+      it "should work with money: 'code' format for CHF" do
+        chf_currency = { 'sign' => 'CHF', 'name' => 'Swiss Franc', 'id' => 10, 'code' => 'CHF', 'locale' => 'gsw-CH' }
+        rendered_template_with_currency("{{ 1200.99 | money: 'code' }}", chf_currency).should == '<span class="currency_code">CHF</span> 1\'200.99'
+      end
+    end
+
+    context "with JPY currency" do
+      it "should display currency code before number with no decimals for JPY" do
+        jpy_currency = { 'sign' => '¥', 'name' => 'Japanese Yen', 'id' => 6, 'code' => 'JPY', 'locale' => 'ja' }
+        rendered_template_with_currency("{{ 1200.99 | money_with_code }}", jpy_currency).should == '<span class="currency_code">JPY</span>1,201'
+      end
+
+      it "should work with money: 'code' format for JPY" do
+        jpy_currency = { 'sign' => '¥', 'name' => 'Japanese Yen', 'id' => 6, 'code' => 'JPY', 'locale' => 'ja' }
+        rendered_template_with_currency("{{ 1200.99 | money: 'code' }}", jpy_currency).should == '<span class="currency_code">JPY</span>1,201'
+      end
+    end
+
+    context "with GBP currency" do
+      it "should display currency code before number with no space for GBP" do
+        gbp_currency = { 'sign' => '£', 'name' => 'Pound Sterling', 'id' => 5, 'code' => 'GBP', 'locale' => 'en-GB' }
+        rendered_template_with_currency("{{ 1200.99 | money_with_code }}", gbp_currency).should == '<span class="currency_code">GBP</span>1,200.99'
+      end
+
+      it "should work with money: 'code' format for GBP" do
+        gbp_currency = { 'sign' => '£', 'name' => 'Pound Sterling', 'id' => 5, 'code' => 'GBP', 'locale' => 'en-GB' }
+        rendered_template_with_currency("{{ 1200.99 | money: 'code' }}", gbp_currency).should == '<span class="currency_code">GBP</span>1,200.99'
+      end
     end
   end
 
@@ -63,6 +357,10 @@ describe Dugway::Filters::CoreFilters do
   private
 
   def rendered_template(template, assigns={})
-    Liquid::Template.parse(template).render(assigns, :registers => { :currency => Dugway.store.currency })
+    Liquid::Template.parse(template).render(assigns, :registers => { :currency => Dugway.store.currency, :settings => {} })
+  end
+
+  def rendered_template_with_currency(template, currency, assigns={})
+    Liquid::Template.parse(template).render(assigns, :registers => { :currency => currency, :settings => {} })
   end
 end