dugway 1.1.0 → 1.3.0

data/locales/storefront.zh-TW.yml

@@ -0,0 +1,81 @@
+zh-TW:
+  storefront:
+    navigation:
+      all: "全部"
+      all_products: "所有商品"
+      back_to_site: "返回網站"
+      cart: "購物車"
+      categories: "分類"
+      contact: "聯絡我們"
+      home: "首頁"
+      item: "件商品"
+      items: "件商品"
+      more: "更多"
+      next: "下一頁"
+      newest: "最新"
+      pages: "頁面"
+      previous: "上一頁"
+      products: "商品"
+      quick_view: "快速預覽"
+      search: "搜尋"
+      shop: "商店"
+      social: "关注我们"
+      subscribe: "訂閱"
+      top_selling: "熱銷"
+      view: "查看"
+      view_all: "查看全部"
+      # "Sort By" translations are used in very few themes, and are not exposed in theme settings for sellers to configure
+      sort_by: 排序
+      sort_by_featured: 精選商品
+      sort_by_on_sale: 特價商品
+      sort_by_top_selling: 熱銷商品
+      sort_by_alphabetically_a_to_z: 英文字母 (A 到 Z)
+      sort_by_alphabetically_z_to_a: 英文字母 (Z 到 A)
+      sort_by_date_new_to_old: 日期 (最新到最舊)
+      sort_by_date_old_to_new: 日期 (最舊到最新)
+      sort_by_price_low_to_high: 價格 (低到高)
+      sort_by_price_high_to_low: 價格 (高到低)
+    home:
+      all_products: "所有商品"
+      featured: "精選"
+      featured_categories: "精選分類"
+      featured_products: "精選商品"
+      featured_video: ""
+    products:
+      add_to_cart: "加入購物車"
+      added: "已加入" # Used in few themes, intentionally not exposed in theme settings
+      adding: "加入中" # Used in few themes, intentionally not exposed in theme settings
+      almost_sold_out: "即將售罄！"
+      coming_soon: "即將上線"
+      description: "商品描述"
+      in_stock: "有庫存"
+      inventory: "庫存"
+      low_inventory: "庫存有限"
+      no_products: "未找到商品"
+      on_sale: "特價"
+      related_products: "相關商品"
+      reset: "重設"
+      search_results: "搜尋結果"
+      select: "選擇"
+      select_variant: "選擇規格"
+      sold_out: "已售罄"
+      variant: "規格"
+      variants: "規格"
+    cart:
+      checkout: "結帳"
+      continue_shopping: "繼續購物"
+      empty_cart: "您的購物車是空的"
+      quantity_abbreviated: "数量"
+      quantity: "数量"
+      remove: "移除"
+      share_this_cart: "分享購物車"
+      share_this_cart_link_copy_success: "連結已複製！"
+      subtotal: "小計"
+      view_cart: "查看購物車"
+    contact:
+      email: "電子郵件"
+      form_success: "謝謝！您的訊息已發送，我們將盡快回覆您。"
+      message: "留言"
+      name: "姓名"
+      send_button: "發送留言"
+      subject: "主題"

data/log/dugway.log

@@ -0,0 +1 @@
+# Logfile created on 2025-04-08 18:41:37 -0700 by logger.rb/v1.4.2

data/mise.toml

@@ -0,0 +1,2 @@
+[tools]
+ruby = "2.7.8"

data/spec/features/page_rendering_spec.rb

@@ -11,7 +11,7 @@ feature 'Page rendering' do
   scenario 'products.html' do
     visit '/products'
     expect(page).to have_content('Dugway') # layout.html
-    expect(page).to have_content('Products')
+    expect(page).to have_selector('[data-testid="page-name-test"]', text: 'Products', visible: :all)
     expect(page).to have_content('My Product')
     expect(page).to have_content('$10.00')
   end
@@ -19,7 +19,7 @@ feature 'Page rendering' do
   scenario 'products.html via artist' do
     visit '/artist/artist-one'
     expect(page).to have_content('Dugway') # layout.html
-    expect(page).to have_content('Artist One')
+    expect(page).to have_selector('[data-testid="page-name-test"]', text: 'Artist One', visible: :all)
     expect(page).to have_content('My Product')
     expect(page).to have_content('$10.00')
   end
@@ -27,7 +27,7 @@ feature 'Page rendering' do
   scenario 'products.html via category' do
     visit '/category/tees'
     expect(page).to have_content('Dugway') # layout.html
-    expect(page).to have_content('Tees')
+    expect(page).to have_selector('[data-testid="page-name-test"]', text: 'Tees', visible: :all)
     expect(page).to have_content('My Product')
     expect(page).to have_content('$10.00')
   end
@@ -35,7 +35,7 @@ feature 'Page rendering' do
   scenario 'product.html' do
     visit '/product/my-product'
     expect(page).to have_content('Dugway') # layout.html
-    expect(page).to have_content('My Product')
+    expect(page).to have_selector('[data-testid="page-name-test"]', text: 'My Product', visible: :all)
     expect(page).to have_content('$10.00')
   end
 

data/spec/fixtures/theme/layout.html

@@ -70,6 +70,8 @@
     {% endif %}
 
     <section>
+      {# Added for testing page.name variable #}
+      <span data-testid="page-name-test" style="display: none;">{{ page.name }}</span>
     {% if page.category == 'custom' %}
       <h1>{{ page.name }}</h1>
       {{ page_content | paragraphs }}

data/spec/fixtures/theme/settings.json

@@ -5,11 +5,13 @@
     {
       "variable": "logo",
       "label": "Logo",
+      "section": "global_navigation",
       "description": "Good for an image up to 150 pixels wide",
       "default": "logo_bc.png"
     },
     {
       "variable": "background_image",
+      "section": "general",
       "label": "Background Image",
       "description": "Adds a repeating background image"
     }
@@ -18,6 +20,7 @@
     {
       "variable": "slideshow_images",
       "label": "Slideshow",
+      "section": "homepage",
       "description": "This is a slideshow",
       "defaults": [
         "slideshow/1.gif",
@@ -30,6 +33,7 @@
     {
       "variable": "lookbook_images",
       "label": "Lookbook",
+      "section": "general",
       "description": "This is a lookbook"
     }
   ],
@@ -133,6 +137,7 @@
     {
       "variable": "show_search",
       "label": "Show search",
+      "section": "global_navigation",
       "type": "boolean",
       "default": false,
       "description": "Shows a search field"
@@ -140,6 +145,7 @@
     {
       "variable": "fixed_sidebar",
       "label": "Fixed Sidebar",
+      "section": "global_navigation",
       "type": "boolean",
       "default": true,
       "description": "Keeps the sidebar stationary while the page scrolls"

data/spec/spec_helper.rb

@@ -10,6 +10,13 @@ RSpec.configure do |config|
   fixture_path = File.join(Dir.pwd, 'spec', 'fixtures')
 
   config.before(:each) do
+    # Reset cart state between tests
+    Dugway.instance_variable_set(:@cart, nil)
+    
+    # Stub Dugway.logger to write to /dev/null before each test
+    # This prevents log file creation/modification by the test suite.
+    allow(Dugway).to receive(:logger).and_return(Logger.new(File::NULL))
+
     # Stub api calls
     stub_request(:get, /.*api\.bigcartel\.com.*/).to_return(lambda { |request|
       { :body => File.new(File.join(fixture_path, 'store', request.uri.path.split('/', 3).last)), :status => 200, :headers => {} }

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

@@ -0,0 +1,182 @@
+require 'spec_helper'
+
+describe Dugway::Drops::FeaturesDrop do
+  # Define the base source data representing the top-level 'features' block
+  # expected from the store configuration (e.g., dugway.json).
+  let(:feature_source_data) do
+    {
+      'definitions' => {
+        'feature_a' => 'enabled_by_default',  # Will be tested with no override, and with opt-out
+        'feature_b' => 'disabled_by_default' # Will be tested with no override, and with opt-in
+      },
+      # Opt-in 'feature_b' to test overriding disabled default
+      # Opt-in 'feature_a' to test conflict where opt-out wins
+      'opt_ins' => ['feature_b', 'feature_a'],
+      # Opt-out 'feature_a' to test overriding enabled default and conflict
+      'opt_outs' => ['feature_a']
+    }
+  end
+
+  # Initialize the drop with the source data
+  let(:features_drop) { described_class.new(feature_source_data) }
+
+  # Note: The 'before' block setting up theme_mock is removed as we now pass source directly.
+  # BaseDrop might still require context for other things (like request/params),
+  # but it's not needed for these specific tests focused on feature logic.
+
+  describe '#feature_definitions' do
+    it 'returns the definitions from the source hash' do
+      expect(features_drop.feature_definitions).to eq(feature_source_data['definitions'])
+    end
+
+    it 'returns empty hash if definitions are missing in source' do
+      drop = described_class.new(feature_source_data.except('definitions'))
+      expect(drop.feature_definitions).to eq({})
+    end
+
+    it 'returns empty hash if source is nil' do
+      drop = described_class.new(nil)
+      expect(drop.feature_definitions).to eq({})
+    end
+
+    it 'returns empty hash if source is empty' do
+      drop = described_class.new({})
+      expect(drop.feature_definitions).to eq({})
+    end
+  end
+
+  describe '#opt_ins' do
+    it 'returns filtered opt_ins from source' do
+      # Only includes opt-ins that are also in definitions
+      expect(features_drop.opt_ins).to match_array(['feature_a', 'feature_b'])
+    end
+
+    it 'returns empty array if opt_ins are missing in source' do
+      drop = described_class.new(feature_source_data.except('opt_ins'))
+      expect(drop.opt_ins).to eq([])
+    end
+
+    it 'returns empty array if definitions are missing in source' do
+      # Because opt_ins are filtered by defined features
+      drop = described_class.new(feature_source_data.except('definitions'))
+      expect(drop.opt_ins).to eq([])
+    end
+
+    it 'returns empty array if source is nil' do
+      drop = described_class.new(nil)
+      expect(drop.opt_ins).to eq([])
+    end
+  end
+
+  describe '#opt_outs' do
+    it 'returns filtered opt_outs from source' do
+      # Only includes opt-outs that are also in definitions
+      expect(features_drop.opt_outs).to match_array(['feature_a'])
+    end
+
+    it 'returns empty array if opt_outs are missing in source' do
+      drop = described_class.new(feature_source_data.except('opt_outs'))
+      expect(drop.opt_outs).to eq([])
+    end
+
+    it 'returns empty array if definitions are missing in source' do
+      # Because opt_outs are filtered by defined features
+      drop = described_class.new(feature_source_data.except('definitions'))
+      expect(drop.opt_outs).to eq([])
+    end
+
+    it 'returns empty array if source is nil' do
+      drop = described_class.new(nil)
+      expect(drop.opt_outs).to eq([])
+    end
+  end
+
+  describe 'dynamic feature check methods' do
+    context 'when feature is enabled by default (feature_a)' do
+      it 'returns true if not opted out' do
+        source_without_opt_out = feature_source_data.merge('opt_outs' => [])
+        drop = described_class.new(source_without_opt_out)
+        expect(drop.has_feature_a?).to be true
+        expect(drop.has_feature_a).to be true
+      end
+
+      it 'returns false if opted out' do
+        expect(features_drop.has_feature_a?).to be false
+        expect(features_drop.has_feature_a).to be false
+      end
+    end
+
+    context 'when feature is disabled by default (feature_b)' do
+      it 'returns false if not opted in' do
+        source_without_opt_in = feature_source_data.merge('opt_ins' => [])
+        drop = described_class.new(source_without_opt_in)
+        expect(drop.has_feature_b?).to be false
+        expect(drop.has_feature_b).to be false
+      end
+
+      it 'returns true if opted in' do
+        expect(features_drop.has_feature_b?).to be true
+        expect(features_drop.has_feature_b).to be true
+      end
+    end
+
+    context 'with conflicting opt-in/out (feature_a)' do
+      it 'returns false because opt-out takes precedence' do
+        expect(features_drop.has_feature_a?).to be false
+        expect(features_drop.has_feature_a).to be false
+      end
+    end
+
+    context 'when feature is not defined' do
+      it 'returns false' do
+        expect(features_drop.has_undefined_feature?).to be false
+        expect(features_drop.has_undefined_feature).to be false
+      end
+    end
+
+    context 'when source data is empty' do
+      let(:empty_source) { {} }
+      let(:drop_with_empty_source) { described_class.new(empty_source) }
+
+      it 'returns false for any feature check' do
+        expect(drop_with_empty_source.has_feature_a?).to be false
+        expect(drop_with_empty_source.has_any_other_feature).to be false
+      end
+    end
+
+    context 'when source data is nil' do
+      let(:nil_source) { nil }
+      let(:drop_with_nil_source) { described_class.new(nil_source) }
+
+      it 'returns false for any feature check' do
+        expect(drop_with_nil_source.has_feature_a?).to be false
+        expect(drop_with_nil_source.has_any_other_feature).to be false
+      end
+    end
+  end
+
+  describe '#respond_to?' do
+    # NOTE: Standard Ruby behavior means respond_to? is false for methods
+    # handled by method_missing unless respond_to_missing? is also defined.
+    it 'returns false for dynamic methods' do
+      expect(features_drop.respond_to?(:has_feature_a?)).to be false
+      expect(features_drop.respond_to?('has_feature_b?')).to be false
+      expect(features_drop.respond_to?(:has_feature_a)).to be false
+      expect(features_drop.respond_to?('has_feature_b')).to be false
+    end
+
+    it 'returns false for undefined dynamic methods' do
+      expect(features_drop.respond_to?(:has_undefined_feature?)).to be false
+      expect(features_drop.respond_to?(:has_undefined_feature)).to be false
+    end
+
+    it 'returns true for existing methods' do
+      expect(features_drop.respond_to?(:opt_ins)).to be true
+      expect(features_drop.respond_to?(:source)).to be true # From BaseDrop initialization
+    end
+
+    it 'returns false for completely unknown methods' do
+      expect(features_drop.respond_to?(:some_random_method)).to be false
+    end
+  end
+end

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

@@ -1,6 +1,12 @@
 require 'spec_helper'
 
 describe Dugway::Drops::PagesDrop do
+  before(:each) do
+    # Reset store state before each test
+    Dugway.store.instance_variable_set(:@pages, nil)
+    Dugway.store.instance_variable_set(:@external_pages, nil)
+  end
+
   let(:pages) do
     Dugway::Drops::PagesDrop.new(
       Dugway.store.pages.map do |p|
@@ -14,15 +20,58 @@ describe Dugway::Drops::PagesDrop do
     )
   end
 
+  def create_pages_with_external(external_pages_data)
+    # Mock the store before creating pages
+    allow(Dugway.store).to receive(:external_pages).and_return(external_pages_data)
+    # Clear memoized pages
+    Dugway.store.instance_variable_set(:@pages, nil)
+    
+    Dugway::Drops::PagesDrop.new(
+      Dugway.store.pages.map do |p|
+        case p["permalink"]
+        when "cart"
+          Dugway::Drops::CartDrop.new(p)
+        else
+          Dugway::Drops::PageDrop.new(p)
+        end
+      end
+    )
+  end
+
   describe "#all" do
-    it "should return an array of all pages" do
-      all = pages.all
-      all.should be_an_instance_of(Array)
-      all.size.should == 1
+    context "with only custom pages" do
+      it "should return an array of all custom pages" do
+        all = pages.all
+        all.should be_an_instance_of(Array)
+        all.size.should == 1
 
-      page = all.first
-      page.should be_an_instance_of(Dugway::Drops::PageDrop)
-      page.name.should == 'About Us'
+        page = all.first
+        page.should be_an_instance_of(Dugway::Drops::PageDrop)
+        page.name.should == 'About Us'
+      end
+    end
+
+    context "with custom and external pages" do
+      it "should return an array of all pages (custom + external)" do
+        pages_with_external = create_pages_with_external([
+          {
+            'name' => 'Subscribe',
+            'permalink' => 'subscribe',
+            'url' => 'https://example.com/subscribe',
+            'category' => 'external'
+          }
+        ])
+        
+        all = pages_with_external.all
+        all.should be_an_instance_of(Array)
+        all.size.should == 2
+
+        custom_page = all.find { |p| p.name == 'About Us' }
+        custom_page.should be_an_instance_of(Dugway::Drops::PageDrop)
+
+        external_page = all.find { |p| p.name == 'Subscribe' }
+        external_page.should be_an_instance_of(Dugway::Drops::PageDrop)
+      end
     end
   end
 
@@ -46,6 +95,136 @@ describe Dugway::Drops::PagesDrop do
     end
   end
 
+  describe "#subscribe_page" do
+    context "when subscribe_url is configured" do
+      it "should return the subscribe page" do
+        allow(Dugway.store).to receive(:subscribe_url).and_return('https://example.com/subscribe')
+        pages_with_subscribe = create_pages_with_external([
+          {
+            'name' => 'Subscribe',
+            'permalink' => 'subscribe',
+            'url' => 'https://example.com/subscribe',
+            'category' => 'external'
+          }
+        ])
+        
+        subscribe_page = pages_with_subscribe.subscribe_page
+        subscribe_page.should be_an_instance_of(Dugway::Drops::PageDrop)
+        subscribe_page.name.should == 'Subscribe'
+        subscribe_page.url.should == 'https://example.com/subscribe'
+      end
+    end
+
+    context "when subscribe_url is not configured" do
+      it "should return nil" do
+        allow(Dugway.store).to receive(:subscribe_url).and_return(nil)
+        pages_without_subscribe = create_pages_with_external([])
+        
+        pages_without_subscribe.subscribe_page.should be_nil
+      end
+    end
+  end
+
+  describe "#custom_pages" do
+    it "should return an array of custom pages" do
+      custom_pages = pages.custom_pages
+      custom_pages.should be_an_instance_of(Array)
+      custom_pages.size.should == 1
+      custom_pages.first.should be_an_instance_of(Dugway::Drops::PageDrop)
+      custom_pages.first.name.should == 'About Us'
+    end
+  end
+
+  describe "#external_pages" do
+    context "when subscribe_url is configured" do
+      it "should return an array with the subscribe page" do
+        pages_with_subscribe = create_pages_with_external([
+          {
+            'name' => 'Subscribe',
+            'permalink' => 'subscribe',
+            'url' => 'https://example.com/subscribe',
+            'category' => 'external'
+          }
+        ])
+        
+        external_pages = pages_with_subscribe.external_pages
+        external_pages.should be_an_instance_of(Array)
+        external_pages.size.should == 1
+        external_pages.first.should be_an_instance_of(Dugway::Drops::PageDrop)
+        external_pages.first.name.should == 'Subscribe'
+      end
+    end
+
+    context "when subscribe_url is not configured" do
+      it "should return an empty array" do
+        pages_without_subscribe = create_pages_with_external([])
+        
+        pages_without_subscribe.external_pages.should == []
+      end
+    end
+  end
+
+  describe "#required_pages" do
+    def create_pages_with_required(required_pages_data)
+      # Mock the store before creating pages
+      allow(Dugway.store).to receive(:required_pages).and_return(required_pages_data)
+      # Clear memoized pages
+      Dugway.store.instance_variable_set(:@pages, nil)
+      
+      Dugway::Drops::PagesDrop.new(
+        Dugway.store.pages.map do |p|
+          case p["permalink"]
+          when "cart"
+            Dugway::Drops::CartDrop.new(p)
+          else
+            Dugway::Drops::PageDrop.new(p)
+          end
+        end
+      )
+    end
+
+    context "when required pages are configured" do
+      it "should return an array with the required pages" do
+        pages_with_required = create_pages_with_required([
+          {
+            'name' => 'Terms of Service',
+            'permalink' => 'terms-of-service',
+            'url' => 'https://example.com/terms',
+            'category' => 'custom',
+            'required' => true
+          },
+          {
+            'name' => 'Privacy Policy',
+            'permalink' => 'privacy-policy',
+            'url' => 'https://example.com/privacy',
+            'category' => 'custom',
+            'required' => true
+          }
+        ])
+        
+        required_pages = pages_with_required.required_pages
+        required_pages.should be_an_instance_of(Array)
+        required_pages.size.should == 2
+        
+        terms_page = required_pages.find { |p| p.name == 'Terms of Service' }
+        terms_page.should be_an_instance_of(Dugway::Drops::PageDrop)
+        terms_page.url.should == 'https://example.com/terms'
+        
+        privacy_page = required_pages.find { |p| p.name == 'Privacy Policy' }
+        privacy_page.should be_an_instance_of(Dugway::Drops::PageDrop)
+        privacy_page.url.should == 'https://example.com/privacy'
+      end
+    end
+
+    context "when no required pages are configured" do
+      it "should return an empty array" do
+        pages_without_required = create_pages_with_required([])
+        
+        pages_without_required.required_pages.should == []
+      end
+    end
+  end
+
   private
 
   def rendered_template(template, assigns={}, registers={})

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

@@ -302,4 +302,21 @@ describe Dugway::Drops::ProductDrop do
       expect(related_products).to eq(related_products_mock)
     end
   end
+
+  describe "#price_suffix" do
+    it "should return nil when no price_suffix is configured" do
+      allow(Dugway.store).to receive(:price_suffix).and_return(nil)
+      product.price_suffix.should be_nil
+    end
+
+    it "should return the price_suffix from store configuration" do
+      allow(Dugway.store).to receive(:price_suffix).and_return(' USD')
+      product.price_suffix.should == ' USD'
+    end
+
+    it "should return the price_suffix from store options" do
+      allow(Dugway.store).to receive(:price_suffix).and_return('+ HI')
+      product.price_suffix.should == '+ HI'
+    end
+  end
 end

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

@@ -127,4 +127,49 @@ describe Dugway::Drops::ThemeDrop do
       end
     end
   end
+
+  describe '#features' do
+    let(:mock_features_config) do
+      {
+        'definitions' => { 'feat_a' => 'enabled_by_default' },
+        'opt_ins' => [],
+        'opt_outs' => ['feat_a']
+      }
+    end
+    let(:mock_options) { { 'features' => mock_features_config } }
+
+    before do
+      # Stub the global Dugway.options for these tests
+      allow(Dugway).to receive(:options).and_return(mock_options)
+      # ThemeDrop needs context to potentially access registers, even if not used by #features itself
+      theme.context = context
+    end
+
+    it 'initializes FeaturesDrop with data from Dugway.options["features"]' do
+      features_drop_instance = theme.features # Call the method under test
+
+      expect(features_drop_instance).to be_an_instance_of(Dugway::Drops::FeaturesDrop)
+      # Verify that the source passed to FeaturesDrop was correct
+      expect(features_drop_instance.instance_variable_get(:@source)).to eq(mock_features_config)
+      # Optionally, check a derived value to ensure data was processed
+      expect(features_drop_instance.feature_definitions).to eq(mock_features_config['definitions'])
+      expect(features_drop_instance.opt_outs).to eq(['feat_a']) # Check filtering based on definitions
+    end
+
+    it 'initializes FeaturesDrop with empty hash if features key is missing in options' do
+      allow(Dugway).to receive(:options).and_return({}) # No 'features' key
+      features_drop_instance = theme.features
+      expect(features_drop_instance).to be_an_instance_of(Dugway::Drops::FeaturesDrop)
+      expect(features_drop_instance.instance_variable_get(:@source)).to eq({})
+      expect(features_drop_instance.feature_definitions).to eq({})
+    end
+
+    it 'initializes FeaturesDrop with empty hash if Dugway.options is nil' do
+      allow(Dugway).to receive(:options).and_return(nil)
+      features_drop_instance = theme.features
+      expect(features_drop_instance).to be_an_instance_of(Dugway::Drops::FeaturesDrop)
+      expect(features_drop_instance.instance_variable_get(:@source)).to eq({})
+      expect(features_drop_instance.feature_definitions).to eq({})
+    end
+  end
 end