dugway 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9523e3515728a8c01fbe05baf360edad408e447b64ccb4894270029bc95b12f1
-  data.tar.gz: 80c989204781ae28db6af3b80f74fdc834c315e27f497188bfa431caabefaa2d
+  metadata.gz: 4174e554f06cf4a1a822d0cb83d503ab518d4f8b9bd7dee012a0858773268e4d
+  data.tar.gz: 9d5eafb84ff1a12b9bcddf7d8b7edeeb00de0621165114743de2de71da73df61
 SHA512:
-  metadata.gz: 35a6c9269ee9a256feb9abe34614ab9d815e6c429f3b0ab4f7ac765a2a568d85848a2c3c61f60a08e138c02da4b0d3b631384003864c29b12b4f55cada681549
-  data.tar.gz: b0b2ddd105dd648fe79c51194a0fe8e10f8c475c5f1cadd3733c94ae349124bd8c7070e47d0de1ac39986b72e5f6f94e523e00424e224fb8cc4b801ecf882bf6
+  metadata.gz: 5f8c749e06f7764d2a89ca64057ae4c736892d969d09e187fd406013b42fde0c73e738ec01bc13e15344634c108a488bb2432162cdd9bb6ed57a2cf1bd43b217
+  data.tar.gz: 8ed84a5455fc6dbea4fdb3734b80dbb081fc23972681f945b12911efcd83e7cdf2f199956893f147410e3dce890a9b6924f0d29340bffe87ea4015228fa0e9d2

data/.github/workflows/main.yml

@@ -8,7 +8,7 @@ jobs:
 
     strategy:
       matrix:
-        ruby-version: [2.7.5, 2.6.7]
+        ruby-version: [2.7]
 
     steps:
     - uses: actions/checkout@v2

data/README.md

@@ -28,11 +28,7 @@ using [RubyInstaller](http://rubyinstaller.org).
 
 Supported Ruby versions:
 
-- 2.3
-- 2.4
-- 2.5
-- 2.6
-- 2.7
+- 2.7+
 
 ### Install Dugway
 
@@ -99,12 +95,12 @@ your code into multiple files in separate directories.
 
 #### Using Sprockets
 
-[Sprockets](https://github.com/sstephenson/sprockets) allows you to bring in
+[Sprockets](https://github.com/rails/sprockets) allows you to bring in
 CSS and JavaScript from different directories into a single file. We've created
 **stylesheets** and **javascripts** directories by default that you can put
 your code in, but you could delete those and put files anywhere you'd like.
 After that, use [Sprockets
-directives](https://github.com/sstephenson/sprockets#the-directive-processor)
+directives](https://github.com/rails/sprockets#directives)
 to package them into **theme.css** and **theme.js**.
 
 ##### theme.css
@@ -193,6 +189,35 @@ dugway server
 By default this will serve your theme at http://127.0.0.1:9292/. You can then stop
 the server by hitting CTRL+C.
 
+### Running on a custom port
+
+To run Dugway on a different port, use the `--port` (or `-p`) option:
+
+```
+dugway server --port 3000
+dugway server -p 8080
+```
+
+This is particularly useful for running multiple theme instances simultaneously:
+
+```
+# Terminal 1 - Theme A
+cd /path/to/theme-a
+dugway server --port 3000
+
+# Terminal 2 - Theme B  
+cd /path/to/theme-b
+dugway server --port 3001
+```
+
+You can also customize the host address:
+
+```
+dugway server --host 0.0.0.0 --port 3000
+```
+
+### Logging
+
 If you want to run with logging, enable it via your theme's `settings.json` 
 file with `"log": true`. When Dugway is running, it will then create a log
 in `log/dugway.log` in your theme's directory.  You can then log output 

data/dugway.gemspec

@@ -16,32 +16,34 @@ Gem::Specification.new do |s|
   s.test_files   = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.platform     = Gem::Platform::RUBY
   s.require_path = 'lib'
-  s.required_ruby_version = '>= 2.3', '< 3'
+  s.required_ruby_version = '>= 2.7', '< 3'
   s.executables  << 'dugway'
 
   s.add_dependency('bundler', '>= 1.0.0')
   s.add_dependency('rack', '~> 1.4.1')
   s.add_dependency('rack-mount', '~> 0.8.3')
-  s.add_dependency('activesupport', '~> 5.2')
-  s.add_dependency('liquid', '~> 3.0.6')
+  s.add_dependency('activesupport', '~> 5.2.8')
+  s.add_dependency('liquid', '~> 5.5.1')
   s.add_dependency('bigdecimal', '~> 1.4.4')
   s.add_dependency('coffee-script', '~> 2.4.1')
   s.add_dependency('sass', '~> 3.4.25')
-  s.add_dependency('sprockets', '~> 2.0')
+  s.add_dependency('sprockets', '~> 2.12')
   s.add_dependency('sprockets-sass', '~> 1.3.1')
   s.add_dependency('compass', '~> 1.0.3')
-  s.add_dependency('httparty', '~> 0.10.0')
+  s.add_dependency('sassc', '~> 2.4')
+  s.add_dependency('httparty', '~> 0.21.0')
   s.add_dependency('better_errors', '~> 0.9.0')
   s.add_dependency('will_paginate', '~> 3.0.4')
-  s.add_dependency('i18n', '1.6')
+  s.add_dependency('i18n', '~> 1.12')
   s.add_dependency('htmlentities', '~> 4.3.1')
-  s.add_dependency('listen', '~> 3.0')
-  s.add_dependency('thor', '~> 0.20.3')
+  s.add_dependency('listen', '~> 3.8')
+  s.add_dependency('thor', '~> 1.2')
   s.add_dependency('rubyzip', '~> 0.9.9')
-  s.add_dependency('terser', '~> 1.1')
+  s.add_dependency('terser', '~> 1.2')
   s.add_dependency('thin', '~> 1.8.0')
   s.add_dependency('bigcartel-theme-fonts', '>= 1.0.0')
   s.add_dependency('bigcartel-currency-locales', '>= 1.0.0')
+  s.add_dependency('multi_json', '~> 1.15.0')
 
   s.add_development_dependency('rake', '~> 10.0.3')
   s.add_development_dependency('rspec', '~> 2.14.1')

data/lib/dugway/cli/server.rb

@@ -1,5 +1,6 @@
 require 'rack'
 require 'listen'
+require 'rbconfig'
 
 module Dugway
   module Cli
@@ -40,13 +41,72 @@ module Dugway
 
         Thread.new { listener.start }
 
-        Rack::Server.start({
-          :config => File.join(Dir.pwd, 'config.ru'),
-          :environment => 'none',
-          :Host => options[:host],
-          :Port => options[:port],
-          :server => options[:server]
-        })
+        begin
+          Rack::Server.start({
+            :config => File.join(Dir.pwd, 'config.ru'),
+            :environment => 'none',
+            :Host => options[:host],
+            :Port => options[:port],
+            :server => options[:server]
+          })
+        rescue Errno::EADDRINUSE
+          handle_port_in_use_error(options[:port])
+          exit 1
+        rescue Errno::EACCES
+          handle_permission_error(options[:port])
+          exit 1
+        rescue Errno::EADDRNOTAVAIL
+          handle_address_error(options[:host], options[:port])
+          exit 1
+        rescue StandardError => e
+          if e.message.include?("port is in use") || e.message.include?("no acceptor")
+            handle_port_in_use_error(options[:port])
+          elsif e.message.include?("requires root privileges")
+            handle_permission_error(options[:port])
+          else
+            puts "\nError starting server: #{e.message}"
+            puts "Try running with different options or check your theme configuration."
+          end
+          exit 1
+        end
+      end
+
+      private
+
+      def handle_port_in_use_error(port)
+        suggested_port = port + 1
+        puts "\nError: Port #{port} is already in use!"
+        puts "Try running with a different port:"
+        puts "   dugway server --port #{suggested_port}"
+        puts "   dugway server -p #{suggested_port}"
+        puts "\nTo see what's using port #{port}, run:"
+        puts "   #{port_check_command(port)}"
+      end
+
+      def handle_permission_error(port)
+        puts "\nError: Permission denied to bind to port #{port}!"
+        if port < 1024
+          puts "Ports below 1024 require root privileges. Try a port above 1024:"
+          puts "   dugway server --port 3000"
+          puts "   dugway server --port 8080"
+        else
+          puts "Check your system permissions or try a different port."
+        end
+      end
+
+      def handle_address_error(host, port)
+        puts "\nError: Cannot bind to address #{host}!"
+        puts "Try using a different host address:"
+        puts "   dugway server --host 0.0.0.0 --port #{port}"
+        puts "   dugway server --host 127.0.0.1 --port #{port}"
+      end
+
+      def port_check_command(port)
+        if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+          "netstat -ano | findstr :#{port}"
+        else
+          "lsof -i :#{port}"
+        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/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

@@ -8,13 +8,36 @@ module Dugway
         @definitions = definitions || {}
       end
 
-      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)
+      # 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
-
-        super
+        
+        # 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.

data/lib/dugway/liquid/filters/core_filters.rb

@@ -40,21 +40,89 @@ module Dugway
         when 'sign' then money_with_sign(amount)
         when 'code' then money_with_code(amount)
         when 'sign_and_code' then money_with_sign_and_code(amount)
-        else number_to_currency(amount, :unit => '').strip
+        when 'rounded' then
+          begin
+            number_to_currency(amount.ceil, { :unit => '', :format => '%n', :precision => 0 }).to_s.strip
+          rescue FrozenError => e
+            sprintf('%.0f', amount.ceil.to_f)
+          end
+        when 'sign_rounded' then money_with_sign(amount.ceil, 0)
+        when 'code_rounded' then money_with_code(amount.ceil, 0)
+        else
+          begin
+            number_to_currency(amount, { :unit => '', :format => '%n' }).to_s.strip
+          rescue FrozenError => e
+            # Fallback for frozen hash issues in newer Ruby versions
+            sprintf('%.2f', amount.to_f)
+          end
+        end
+      end
+
+      def product_price(product, money_format = nil, range_format = nil)
+        return unless product
+
+        if product['variable_pricing']
+          case range_format
+          when 'min_only'
+            money(product['min_price'], money_format)
+          when 'max_only'
+            money(product['max_price'], money_format)
+          else # default, nil, or any other value
+            format_price_range(product['min_price'], product['max_price'], money_format)
+          end
+        else
+          money(product['default_price'] || product['price'], money_format)
         end
       end
 
-      def money_with_sign(amount)
-        unit = I18n.translate('number.currency.format.unit')
-        number_to_currency(amount).gsub(unit, %{<span class="currency_sign">#{ HTMLEntities.new.encode(unit, :named) }</span>})
+      def money_with_sign(amount, precision = nil)
+        begin
+          unit = I18n.translate('number.currency.format.unit')
+          options = { :unit => "<span class=\"currency_sign\">#{HTMLEntities.new.encode(unit, :named)}</span>" }
+          options[:precision] = precision if precision
+          number_to_currency(amount, options)
+        rescue FrozenError => e
+          # Fallback for frozen hash issues
+          format_string = precision == 0 ? '%.0f' : '%.2f'
+          "<span class=\"currency_sign\">$</span>#{sprintf(format_string, amount.to_f)}"
+        end
       end
 
-      def money_with_code(amount)
-        %{#{ money(amount) } <span class="currency_code">#{ currency['code'] }</span>}
+      def money_with_code(amount, precision = nil)
+        begin
+          # Format number without currency unit, respecting locale's number formatting rules
+          number_locale = normalize_currency_locale_for_formatting(currency['locale'])
+          options = { :unit => '', :format => '%n', :locale => number_locale }
+          options[:precision] = precision if precision
+          formatted_number = number_to_currency(amount, options).to_s.strip
+          
+          # Use locale-specific format string to ensure proper currency code placement
+          # Keep original locale for bigcartel-currency-locales gem compatibility
+          format_string = I18n.translate('number.currency.format.format', 
+                                       :locale => currency['locale'], 
+                                       :default => '%u%n')
+          
+          code_span = "<span class=\"currency_code\">#{currency['code']}</span>"
+          format_string.gsub('%n', formatted_number).gsub('%u', code_span)
+        rescue => e
+          # Fallback for frozen hash or I18n issues
+          format_string = precision == 0 ? '%.0f' : '%.2f'
+          "<span class=\"currency_code\">#{currency['code']}</span>#{sprintf(format_string, amount.to_f)}"
+        end
       end
 
       def money_with_sign_and_code(amount)
-        %{#{ money_with_sign(amount) } <span class="currency_code">#{ currency['code'] }</span>}
+        %{#{ money_with_sign(amount).to_s } <span class="currency_code">#{ currency['code'] }</span>}
+      end
+
+      # Liquid 5.x compatibility: ensure proper JSON output
+      def to_json(input)
+        # Handle Liquid Drops specially - use as_json for serialization
+        if input.respond_to?(:as_json)
+          JSON.generate(input.as_json)
+        else
+          JSON.generate(input)
+        end
       end
 
       # Shipping Filters
@@ -137,10 +205,104 @@ module Dugway
 
       private
 
+      def currency
+        @context.registers[:currency]
+      end
+
       def contact_tab_index
         @contact_tab_index ||= 0
         @contact_tab_index += 1
       end
+
+      def format_price_range(min_price, max_price, money_format)
+        case money_format
+        when "sign"
+          format_range_with_sign(min_price, max_price)
+        when "code"
+          format_range_with_code(min_price, max_price)
+        when "sign_rounded"
+          format_range_with_sign(min_price.ceil, max_price.ceil, 0)
+        when "code_rounded"
+          format_range_with_code(min_price.ceil, max_price.ceil, 0)
+        when "rounded"
+          format_range_plain(min_price.ceil, max_price.ceil, 0)
+        else
+          format_range_plain(min_price, max_price)
+        end
+      end
+
+      def format_range_with_sign(min_price, max_price, precision = nil)
+        # Sign on both prices for clarity
+        # US: $10.00 - $20.00  |  FR: 10,00 € - 20,00 €
+        min_formatted = money_with_sign(min_price, precision)
+        max_formatted = money_with_sign(max_price, precision)
+        "#{min_formatted} - #{max_formatted}"
+      end
+
+      def format_range_with_code(min_price, max_price, precision = nil)
+        # Single code in locale-appropriate position
+        # US: $10.00 - 20.00 USD  |  FR: 10,00 - 20,00 EUR
+        code_span = "<span class=\"currency_code\">#{currency['code']}</span>"
+        range_string = build_number_range(min_price, max_price, precision)
+        apply_currency_format(range_string, code_span)
+      end
+
+      def format_range_plain(min_price, max_price, precision = nil)
+        # No currency indicators
+        begin
+          options = { :unit => '', :format => '%n' }
+          options[:precision] = precision if precision
+          min_formatted = number_to_currency(min_price, options).to_s.strip
+          max_formatted = number_to_currency(max_price, options).to_s.strip
+          "#{min_formatted} - #{max_formatted}"
+        rescue FrozenError => e
+          # Fallback for frozen hash issues
+          format_string = precision == 0 ? '%.0f' : '%.2f'
+          "#{sprintf(format_string, min_price.to_f)} - #{sprintf(format_string, max_price.to_f)}"
+        end
+      end
+
+      def build_number_range(min_price, max_price, precision = nil)
+        min_formatted = format_number_plain(min_price, precision)
+        max_formatted = format_number_plain(max_price, precision)
+        "#{min_formatted} - #{max_formatted}"
+      end
+
+      def format_number_plain(amount, precision = nil)
+        begin
+          number_locale = normalize_currency_locale_for_formatting(currency['locale'])
+          options = { :unit => '', :format => '%n', :locale => number_locale }
+          options[:precision] = precision if precision
+          number_to_currency(amount, options).to_s.strip
+        rescue FrozenError => e
+          format_string = precision == 0 ? '%.0f' : '%.2f'
+          sprintf(format_string, amount.to_f)
+        end
+      end
+
+      def apply_currency_format(range_string, currency_span)
+        # Use I18n to get locale-specific format like storefront does
+        begin
+          # Keep original locale for bigcartel-currency-locales gem compatibility
+          format_string = I18n.translate('number.currency.format.format', 
+                                       locale: currency['locale'], 
+                                       default: '%u%n')
+          format_string.gsub('%n', range_string).gsub('%u', currency_span)
+        rescue
+          # Fallback if I18n fails
+          "#{range_string} #{currency_span}"
+        end
+      end
+
+      def normalize_currency_locale_for_formatting(locale)
+        # Handle invalid 'eu' locale from production system for number formatting only
+        case locale
+        when 'eu'
+          'de-DE'  # Use German locale for EUR number formatting (1.200,99 style)
+        else
+          locale
+        end
+      end
     end
   end
 end

data/lib/dugway/liquid/filters/font_filters.rb

@@ -2,6 +2,7 @@ module Dugway
   module Filters
     module FontFilters
       def font_family(font_name)
+        return '' if font_name.nil? || font_name.to_s.strip.empty?
         ThemeFont.find_family_by_name(font_name)
       end
     end