lighterpack-parser 0.1.0

data/spec/parser_spec.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe LighterpackParser::Parser do
+  let(:fixture_dir) { File.join(__dir__, 'fixtures') }
+
+  describe '#parse' do
+    context 'with b6q1kr.html' do
+      let(:html) { File.read(File.join(fixture_dir, 'b6q1kr.html')) }
+      let(:result) { described_class.new(html: html).parse }
+
+      it 'extracts the list name' do
+        expect(result[:name]).to eq('Ultimate Hike 2025')
+      end
+
+      it 'extracts categories as an array' do
+        expect(result[:categories]).to be_a(Array)
+        expect(result[:categories].length).to be > 0
+      end
+
+      it 'extracts the first category correctly' do
+        first_category = result[:categories].first
+        expect(first_category[:name]).to eq('Big 3 (Pack, Tent, Sleep System)')
+        expect(first_category[:items]).to be_a(Array)
+        expect(first_category[:items].length).to be > 0
+      end
+
+      it 'extracts the first item correctly' do
+        first_category = result[:categories].first
+        first_item = first_category[:items].first
+
+        expect(first_item[:name]).to eq('Bonfus Altus 38')
+        expect(first_item[:description]).to eq('With vest styled straps')
+        expect(first_item[:weight]).to be > 0
+        expect(first_item[:quantity]).to eq(1)
+        expect([true, false]).to include(first_item[:worn])
+        expect([true, false]).to include(first_item[:consumable])
+      end
+    end
+
+    context 'with adbf7c.html' do
+      let(:html) { File.read(File.join(fixture_dir, 'adbf7c.html')) }
+      let(:result) { described_class.new(html: html).parse }
+
+      it 'extracts the list name' do
+        expect(result[:name]).to be_truthy
+      end
+
+      it 'extracts categories as an array' do
+        expect(result[:categories]).to be_a(Array)
+      end
+    end
+
+    context 'with h23rxt.html' do
+      let(:html) { File.read(File.join(fixture_dir, 'h23rxt.html')) }
+      let(:result) { described_class.new(html: html).parse }
+
+      it 'extracts the list name' do
+        expect(result[:name]).to be_truthy
+      end
+
+      it 'extracts categories as an array' do
+        expect(result[:categories]).to be_a(Array)
+      end
+    end
+  end
+
+  describe 'weight conversion' do
+    let(:html) { File.read(File.join(fixture_dir, 'b6q1kr.html')) }
+    let(:result) { described_class.new(html: html).parse }
+
+    it 'converts weights to grams correctly' do
+      result[:categories].each do |category|
+        category[:items].each do |item|
+          if item[:weight] > 0
+            expect(item[:weight]).to be > 0, "Item #{item[:name]} should have weight > 0"
+            expect(item[:weight]).to be < 1_000_000, "Item #{item[:name]} weight seems too large: #{item[:weight]}"
+          end
+        end
+      end
+    end
+  end
+
+  describe 'consumable flag extraction' do
+    let(:html) { File.read(File.join(fixture_dir, 'b6q1kr.html')) }
+    let(:result) { described_class.new(html: html).parse }
+
+    it 'extracts consumable flag as boolean for all items' do
+      result[:categories].each do |category|
+        category[:items].each do |item|
+          expect([true, false]).to include(item[:consumable]), "Consumable should be boolean for #{item[:name]}"
+        end
+      end
+    end
+  end
+
+  describe 'worn flag extraction' do
+    let(:html) { File.read(File.join(fixture_dir, 'b6q1kr.html')) }
+    let(:result) { described_class.new(html: html).parse }
+
+    it 'extracts worn flag as boolean for all items' do
+      result[:categories].each do |category|
+        category[:items].each do |item|
+          expect([true, false]).to include(item[:worn]), "Worn should be boolean for #{item[:name]}"
+        end
+      end
+    end
+  end
+
+  describe 'worn flag correctness for h23rxt.html' do
+    let(:html) { File.read(File.join(fixture_dir, 'h23rxt.html')) }
+    let(:result) { described_class.new(html: html).parse }
+    let(:all_items) { result[:categories].flat_map { |cat| cat[:items] } }
+
+    it 'correctly identifies Sea to Summit Ultrasil as worn' do
+      ultrasil = all_items.find { |item| item[:name]&.include?('Sea to Summit Ultrasil') }
+      expect(ultrasil).to be_truthy, 'Should find Sea to Summit Ultrasil item'
+      expect(ultrasil[:worn]).to eq(true), 'Sea to Summit Ultrasil should be worn'
+      expect(ultrasil[:consumable]).to eq(false), 'Sea to Summit Ultrasil should NOT be consumable'
+    end
+
+    it 'correctly identifies MacBook Pro as not worn' do
+      macbook = all_items.find { |item| item[:name]&.include?('MacBook Pro') }
+      expect(macbook).to be_truthy, 'Should find MacBook Pro item'
+      expect(macbook[:worn]).to eq(false), 'MacBook Pro should NOT be worn'
+      expect(macbook[:consumable]).to eq(false), 'MacBook Pro should NOT be consumable'
+    end
+  end
+
+  describe 'consumable flag correctness for h23rxt.html' do
+    let(:html) { File.read(File.join(fixture_dir, 'h23rxt.html')) }
+    let(:result) { described_class.new(html: html).parse }
+    let(:all_items) { result[:categories].flat_map { |cat| cat[:items] } }
+
+    it 'correctly identifies Tandkräm as consumable' do
+      tandkram = all_items.find { |item| item[:name]&.include?('Tandkräm (innehåll)') }
+      expect(tandkram).to be_truthy, 'Should find Tandkräm item'
+      expect(tandkram[:consumable]).to eq(true), 'Tandkräm should be consumable'
+      expect(tandkram[:worn]).to eq(false), 'Tandkräm should NOT be worn'
+    end
+
+    it 'correctly identifies Dushtvål/Shampoo as consumable' do
+      shampoo = all_items.find { |item| item[:name]&.include?('Dushtvål') || item[:name]&.include?('Shampoo') }
+      expect(shampoo).to be_truthy, 'Should find Dushtvål/Shampoo item'
+      expect(shampoo[:consumable]).to eq(true), 'Dushtvål/Shampoo should be consumable'
+      expect(shampoo[:worn]).to eq(false), 'Dushtvål/Shampoo should NOT be worn'
+    end
+
+    it 'correctly identifies MacBook Pro as not consumable' do
+      macbook = all_items.find { |item| item[:name]&.include?('MacBook Pro') }
+      expect(macbook).to be_truthy, 'Should find MacBook Pro item'
+      expect(macbook[:consumable]).to eq(false), 'MacBook Pro should NOT be consumable'
+    end
+  end
+
+  describe 'worn and consumable counts for h23rxt.html' do
+    let(:html) { File.read(File.join(fixture_dir, 'h23rxt.html')) }
+    let(:result) { described_class.new(html: html).parse }
+    let(:all_items) { result[:categories].flat_map { |cat| cat[:items] } }
+    let(:total_items) { all_items.length }
+    let(:worn_count) { all_items.count { |item| item[:worn] } }
+    let(:consumable_count) { all_items.count { |item| item[:consumable] } }
+
+    it 'has reasonable counts of worn and consumable items' do
+      expect(worn_count).to be >= 1, "Should have at least 1 worn item, got #{worn_count}"
+      expect(worn_count).to be <= 5, "Should have at most 5 worn items (most items are not worn), got #{worn_count}"
+      expect(consumable_count).to be >= 2, "Should have at least 2 consumable items, got #{consumable_count}"
+      expect(consumable_count).to be <= 5, "Should have at most 5 consumable items (most items are not consumable), got #{consumable_count}"
+      expect(total_items).to be > 10, "Should have many items total, got #{total_items}"
+    end
+  end
+
+  describe 'quantity extraction' do
+    let(:html) { File.read(File.join(fixture_dir, 'b6q1kr.html')) }
+    let(:result) { described_class.new(html: html).parse }
+
+    it 'extracts quantities as positive integers' do
+      result[:categories].each do |category|
+        category[:items].each do |item|
+          expect(item[:quantity]).to be_a(Integer), "Quantity should be integer for #{item[:name]}"
+          expect(item[:quantity]).to be > 0, "Quantity should be > 0 for #{item[:name]}"
+        end
+      end
+    end
+  end
+
+  describe 'image URL extraction' do
+    let(:html) { File.read(File.join(fixture_dir, 'b6q1kr.html')) }
+    let(:result) { described_class.new(html: html).parse }
+
+    it 'extracts image URLs correctly' do
+      items_with_images = 0
+      result[:categories].each do |category|
+        category[:items].each do |item|
+          if item[:image_url]
+            expect(item[:image_url]).to start_with('http'), "Image URL should start with http for #{item[:name]}"
+            items_with_images += 1
+          end
+        end
+      end
+
+      expect(items_with_images).to be > 0, 'At least some items should have image URLs'
+    end
+  end
+
+  describe 'category description extraction' do
+    let(:html) { File.read(File.join(fixture_dir, 'b6q1kr.html')) }
+    let(:result) { described_class.new(html: html).parse }
+
+    it 'extracts category descriptions when available' do
+      result[:categories].each do |category|
+        expect(category[:description]).to be_nil.or(be_a(String)),
+                                          "Description should be nil or string for category #{category[:name]}"
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative '../lib/lighterpack_parser'
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = '.rspec_status'
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: lighterpack-parser
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Packlista Team
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-11-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+description: Parse Lighterpack HTML to extract list data including categories, items,
+  weights, and metadata
+email:
+- team@packlista.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/lighterpack_parser.rb
+- lib/lighterpack_parser/parser.rb
+- lib/lighterpack_parser/version.rb
+- lighterpack-parser.gemspec
+- spec/fixtures/adbf7c.html
+- spec/fixtures/b6q1kr.html
+- spec/fixtures/h23rxt.html
+- spec/parser_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/alex-ross/lighterpack-parser
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Parser for Lighterpack lists
+test_files: []