lighterpack-parser 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 443e65a776623c5e587889eecf74da63064015eae8a3d1882b3e0a5ad5864675
-  data.tar.gz: 25cb7cf2b5cea5deeadcc82a53665ac999c69895ee3754a3174929a6b43f3264
+  metadata.gz: 85fed15af6ad0ccfbba49c9960cf80e47fee71cbdce5166746e5788df489127d
+  data.tar.gz: dbf4da779516e9ba651846a1457fcdfa52142313643235f5cbc7500778d9baec
 SHA512:
-  metadata.gz: 95e5525bd874996437de92e6a486a530ca23677e035c640bb7b4d7b2a7662189a67ea97a7cfa19913973e7ae875822517b05e73a66c0e0060dc1c28d27e06128
-  data.tar.gz: 14af29e67a8f67ed1552e7e9dc2801005a214d800ab788dea0fc1add26478c7df4e780262278271a3f33945d6866f2df42fa511770df083e9c8f4383ff530bb1
+  metadata.gz: 1e35ae9d5211815cef892b469d26e4e79163698465e2b213e8f394a0d2f9546ddc007e7a182684513aff24579281fe719581d3156c3fc6323134f48af2d6067f
+  data.tar.gz: c90687504af99ace152a1bf2749362d70d004e37e3cd9baf50aee6adbe0fbce4869ba57ea7b6b7b74b617a6bac7ece5954dc4fe1c2e365377ffc110711efb8bb

data/lib/lighterpack_parser/category.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module LighterpackParser
+  # Represents a category from a Lighterpack list.
+  #
+  # @attr_reader [String] name The name of the category
+  # @attr_reader [String, nil] description Optional description of the category
+  # @attr_reader [Array<Item>] items Array of items in this category
+  class Category
+    attr_reader :name, :description, :items
+
+    # @param name [String] The name of the category
+    # @param description [String, nil] Optional description
+    # @param items [Array<Item>] Array of items in this category
+    def initialize(name:, description: nil, items: [])
+      @name = name
+      @description = description
+      @items = items
+    end
+
+    # Convert to hash for backward compatibility
+    # @return [Hash] Hash representation of the category
+    def to_h
+      {
+        name: name,
+        description: description,
+        items: items.map(&:to_h)
+      }
+    end
+  end
+end

data/lib/lighterpack_parser/category_parser.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module LighterpackParser
+  # Parser for extracting category data from Lighterpack HTML documents.
+  class CategoryParser
+    # Parse all categories from a Lighterpack HTML document.
+    #
+    # @param doc [Nokogiri::HTML::Document] The parsed HTML document
+    # @param item_parser [ItemParser] The parser to use for extracting items
+    # @return [Array<Category>] Array of extracted categories
+    def parse_all(doc, item_parser:)
+      categories = []
+
+      # Lighterpack structure: ul.lpCategories > li.lpCategory
+      doc.css('ul.lpCategories > li.lpCategory').each do |category_element|
+        category = parse(category_element, item_parser: item_parser)
+        categories << category if category
+      end
+
+      categories
+    end
+
+    # Parse a single category element.
+    #
+    # @param category_element [Nokogiri::XML::Element] The category HTML element
+    # @param item_parser [ItemParser] The parser to use for extracting items
+    # @return [Category, nil] The parsed category, or nil if name is missing
+    def parse(category_element, item_parser:)
+      # Category name is in h2.lpCategoryName
+      category_header = category_element.at_css('h2.lpCategoryName')
+      return nil unless category_header
+
+      category_name = category_header.text.strip
+      return nil if category_name.empty?
+
+      # Description is typically in the category name itself (in parentheses)
+      description = extract_description(category_name)
+
+      # Find items in this category
+      items = extract_items(category_element, item_parser: item_parser)
+
+      Category.new(
+        name: category_name,
+        description: description,
+        items: items
+      )
+    end
+
+    private
+
+    def extract_items(category_element, item_parser:)
+      items = []
+
+      # Items are in ul.lpItems within the category
+      items_list = category_element.at_css('ul.lpItems')
+      return items unless items_list
+
+      # Extract items (skip header row)
+      items_list.css('li.lpItem').each do |item_element|
+        item = item_parser.parse(item_element)
+        items << item if item
+      end
+
+      items
+    end
+
+    def extract_description(category_name)
+      # Description is often in parentheses in the category name
+      # e.g., "Big 3 (Pack, Tent, Sleep System)"
+      match = category_name.match(/\(([^)]+)\)/)
+      return match[1] if match
+
+      nil
+    end
+  end
+end

data/lib/lighterpack_parser/gram_converter.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module LighterpackParser
+  # Simple converter for weight units to grams.
+  class GramConverter
+    # Conversion factors for weight units to grams.
+    CONVERSION_FACTORS = {
+      'oz' => 28.3495,
+      'lb' => 453.592,
+      'g' => 1.0,
+      'kg' => 1000.0
+    }.freeze
+
+    # Initialize the converter with the source unit.
+    #
+    # @param source_unit [String] The unit to convert from.
+    def initialize(source_unit:)
+      @source_unit = source_unit
+    end
+
+    # Convert a value from the source unit to grams.
+    #
+    # @param value [Float] The value to convert..
+    # @return [Float] The converted value in grams.
+    def convert(value)
+      factor = CONVERSION_FACTORS[@source_unit.to_s.downcase] || 1.0
+      value * factor
+    end
+
+    # Convert a value from a unit to grams.
+    #
+    # @param value [Float] The value to convert.
+    # @param unit [String] The unit to convert from.
+    # @return [Float] The converted value in grams.
+    def self.to_grams(value, unit)
+      new(source_unit: unit).convert(value)
+    end
+  end
+end

data/lib/lighterpack_parser/item.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module LighterpackParser
+  # Represents a single item from a Lighterpack list.
+  #
+  # @attr_reader [String] name The name of the item
+  # @attr_reader [String, nil] description Optional description of the item
+  # @attr_reader [Float] weight Weight per item in grams
+  # @attr_reader [Float] total_weight Total weight (weight * quantity) in grams
+  # @attr_reader [Integer] quantity Number of items
+  # @attr_reader [String, nil] image_url Optional URL to item image
+  # @attr_reader [Boolean] consumable Whether the item is consumable
+  # @attr_reader [Float, nil] total_consumable_weight Total consumable weight
+  #   (weight * quantity) if consumable, nil otherwise
+  # @attr_reader [Boolean] worn Whether the item is worn
+  # @attr_reader [Integer, nil] worn_quantity Number of worn items (always 1 if worn, nil otherwise)
+  # @attr_reader [Float, nil] total_worn_weight Total worn weight (weight * 1) if worn, nil otherwise
+  class Item
+    attr_reader :name, :description, :weight, :total_weight, :quantity, :image_url,
+                :consumable, :total_consumable_weight, :worn, :worn_quantity, :total_worn_weight
+
+    # @param name [String] The name of the item
+    # @param description [String, nil] Optional description
+    # @param weight [Float] Weight per item in grams
+    # @param total_weight [Float] Total weight (weight * quantity) in grams
+    # @param quantity [Integer] Number of items
+    # @param image_url [String, nil] Optional URL to item image
+    # @param consumable [Boolean] Whether the item is consumable
+    # @param total_consumable_weight [Float, nil] Total consumable weight if consumable
+    # @param worn [Boolean] Whether the item is worn
+    # @param worn_quantity [Integer, nil] Number of worn items (1 if worn)
+    # @param total_worn_weight [Float, nil] Total worn weight if worn
+    # rubocop:disable Metrics/ParameterLists, Metrics/MethodLength
+    def initialize(name:, weight:, total_weight:, quantity:, description: nil,
+                   image_url: nil, consumable: false, total_consumable_weight: nil,
+                   worn: false, worn_quantity: nil, total_worn_weight: nil)
+      @name = name
+      @description = description
+      @weight = weight
+      @total_weight = total_weight
+      @quantity = quantity
+      @image_url = image_url
+      @consumable = consumable
+      @total_consumable_weight = total_consumable_weight
+      @worn = worn
+      @worn_quantity = worn_quantity
+      @total_worn_weight = total_worn_weight
+    end
+    # rubocop:enable Metrics/ParameterLists, Metrics/MethodLength
+
+    # @return [Boolean] Whether the item is worn
+    def worn? = worn
+
+    # @return [Boolean] Whether the item is consumable
+    def consumable? = consumable
+
+    # Convert to hash
+    #
+    # @return [Hash] Hash representation of the item
+    def to_h
+      {
+        name: name, description: description,
+        weight: weight, total_weight: total_weight,
+        quantity: quantity,
+        image_url: image_url,
+        consumable: consumable,
+        total_consumable_weight: total_consumable_weight,
+        worn: worn, worn_quantity: worn_quantity,
+        total_worn_weight: total_worn_weight
+      }
+    end
+    alias worn? worn
+    alias consumable? consumable
+
+    # Convert to hash
+    #
+    # @return [Hash] Hash representation of the item
+    def to_h
+      {
+        name: name, description: description,
+        weight: weight, total_weight: total_weight,
+
+        quantity: quantity,
+        image_url: image_url,
+        consumable: consumable,
+        total_consumable_weight: total_consumable_weight,
+        worn: worn, worn_quantity: worn_quantity,
+        total_worn_weight: total_worn_weight
+      }
+    end
+  end
+end

data/lib/lighterpack_parser/item_parser.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module LighterpackParser
+  # Parser for extracting item data from Lighterpack HTML elements.
+  class ItemParser
+    # Parse a single item element and return an Item object.
+    #
+    # @param element [Nokogiri::XML::Element] The item HTML element
+    # @return [Item, nil] The parsed item, or nil if name is missing
+    def parse(element)
+      name = extract_name(element)
+      return nil unless name
+
+      weight_data = extract_weight(element)
+      quantity = extract_quantity(element)
+      description = extract_description(element)
+      image_url = extract_image_url(element)
+      consumable = extract_consumable_flag(element)
+      worn = extract_worn_flag(element)
+
+      # Calculate per-item weight
+      weight_per_item = weight_data[:weight_grams]
+
+      # Calculate total weights
+      total_weight = weight_per_item * quantity
+
+      # In Lighterpack, if an item is consumable, the consumable_weight is always the full weight
+      # Calculate total consumable weight (per item * quantity)
+      total_consumable_weight = consumable ? weight_per_item * quantity : nil
+
+      # In Lighterpack, if an item is worn, only the first item is worn (worn_quantity = 1)
+      # regardless of total quantity
+      worn_quantity = worn ? 1 : nil
+      total_worn_weight = worn ? weight_per_item * 1 : nil
+
+      Item.new(
+        name: name,
+        description: description,
+        weight: weight_per_item,
+        total_weight: total_weight,
+        quantity: quantity,
+        image_url: image_url,
+        consumable: consumable,
+        total_consumable_weight: total_consumable_weight,
+        worn: worn,
+        worn_quantity: worn_quantity,
+        total_worn_weight: total_worn_weight
+      )
+    end
+
+    private
+
+    def extract_name(element)
+      # Item name is in span.lpName
+      name_elem = element.at_css('span.lpName')
+      return name_elem.text.strip if name_elem
+
+      nil
+    end
+
+    def extract_weight(element)
+      # Lighterpack stores weight in milligrams in input.lpMG
+      mg_input = element.at_css('input.lpMG')
+      if mg_input && mg_input['value']
+        # Convert from milligrams to grams
+        weight_grams = mg_input['value'].to_f / 1000.0
+        return { weight_grams: weight_grams, original_unit: 'g' }
+      end
+
+      # Fallback: try to get from span.lpWeight and unit
+      weight_elem = element.at_css('span.lpWeight')
+      unit_elem = element.at_css('span.lpDisplay, select.lpUnit option[selected]')
+
+      if weight_elem
+        weight_value = weight_elem.text.strip.to_f
+        unit = 'g' # default
+
+        if unit_elem
+          unit_text = unit_elem.text.strip.downcase
+          unit = unit_text if %w[oz lb g kg].include?(unit_text)
+        end
+
+        weight_grams = GramConverter.to_grams(weight_value, unit)
+        return { weight_grams: weight_grams, original_unit: unit }
+      end
+
+      { weight_grams: 0.0, original_unit: 'g' }
+    end
+
+    def extract_quantity(element)
+      # Quantity is in span.lpQtyCell
+      qty_elem = element.at_css('span.lpQtyCell')
+      if qty_elem
+        qty_text = qty_elem.text.strip
+        return qty_text.to_i if qty_text.match?(/^\d+$/)
+      end
+
+      # Check qty attribute
+      qty_attr = element['qty']
+      return qty_attr.to_i if qty_attr
+
+      1 # Default quantity
+    end
+
+    def extract_description(element)
+      # Description is in span.lpDescription
+      desc_elem = element.at_css('span.lpDescription')
+      return desc_elem.text.strip if desc_elem && !desc_elem.text.strip.empty?
+
+      nil
+    end
+
+    def extract_image_url(element)
+      # Image URL is in img.lpItemImage
+      img = element.at_css('img.lpItemImage')
+      if img && img['src']
+        # Decode HTML entities
+        url = img['src'].gsub('/', '/').gsub('=', '=')
+        return url
+      end
+
+      # Also check href attribute
+      if img && img['href']
+        url = img['href'].gsub('/', '/').gsub('=', '=')
+        return url
+      end
+
+      nil
+    end
+
+    # rubocop:disable Naming/PredicateMethod
+    def extract_consumable_flag(element)
+      # Check for consumable icon with lpActive class (only active items have lpActive)
+      # Try CSS selector first - Nokogiri should handle multiple classes
+      consumable_active = element.at_css('i.lpSprite.lpConsumable.lpActive')
+      return true if consumable_active
+
+      # Fallback: check class attribute directly
+      consumable_icon = element.at_css('i.lpSprite.lpConsumable')
+      return false unless consumable_icon
+
+      class_attr = consumable_icon['class'].to_s
+      # Check if lpActive appears in the class string (handles extra spaces)
+      return true if class_attr.include?('lpActive')
+
+      # Explicitly return false to ensure boolean type
+      false
+    end
+    # rubocop:enable Naming/PredicateMethod
+
+    # rubocop:disable Naming/PredicateMethod
+    def extract_worn_flag(element)
+      # Check for worn icon with lpActive class (only active items have lpActive)
+      # Try CSS selector first - Nokogiri should handle multiple classes
+      worn_active = element.at_css('i.lpSprite.lpWorn.lpActive')
+      return true if worn_active
+
+      # Fallback: check class attribute directly
+      worn_icon = element.at_css('i.lpSprite.lpWorn')
+      return false unless worn_icon
+
+      class_attr = worn_icon['class'].to_s
+      # Check if lpActive appears in the class string (handles extra spaces)
+      return true if class_attr.include?('lpActive')
+
+      # Explicitly return false to ensure boolean type
+      false
+    end
+    # rubocop:enable Naming/PredicateMethod
+  end
+end

data/lib/lighterpack_parser/list.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module LighterpackParser
+  # Represents a Lighterpack list.
+  #
+  # @attr_reader [String] name The name of the list
+  # @attr_reader [String, nil] description Optional description of the list
+  # @attr_reader [Array<Category>] categories Array of categories in this list
+  class List
+    attr_reader :name, :description, :categories
+
+    # @param name [String] The name of the list
+    # @param description [String, nil] Optional description
+    # @param categories [Array<Category>] Array of categories in this list
+    def initialize(name:, description: nil, categories: [])
+      @name = name
+      @description = description
+      @categories = categories
+    end
+
+    # Convert to hash for backward compatibility
+    # @return [Hash] Hash representation of the list
+    def to_h
+      {
+        name: name,
+        description: description,
+        categories: categories.map(&:to_h)
+      }
+    end
+  end
+end

data/lib/lighterpack_parser/list_parser.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module LighterpackParser
+  # Parser for extracting list data from Lighterpack HTML documents.
+  class ListParser
+    # Parse a Lighterpack HTML document and return a List object.
+    #
+    # @param doc [Nokogiri::HTML::Document] The parsed HTML document
+    # @param category_parser [CategoryParser] The parser to use for extracting categories
+    # @param item_parser [ItemParser] The parser to use for extracting items
+    # @return [List] The parsed list
+    def parse(doc, category_parser:, item_parser:)
+      List.new(
+        name: extract_name(doc),
+        description: extract_description(doc),
+        categories: category_parser.parse_all(doc, item_parser: item_parser)
+      )
+    end
+
+    private
+
+    def extract_name(doc)
+      # Lighterpack uses h1.lpListName
+      h1 = doc.at_css('h1.lpListName')
+      return h1.text.strip if h1
+
+      # Fallback to regular h1
+      h1 = doc.at_css('h1')
+      return h1.text.strip if h1
+
+      title = doc.at_css('title')
+      return title.text.strip if title
+
+      'Untitled List'
+    end
+
+    def extract_description(doc)
+      # Lighterpack doesn't seem to have a list description in the HTML
+      # Could be in meta tags
+      meta_desc = doc.at_css('meta[name="description"]')
+      return meta_desc['content'] if meta_desc && meta_desc['content']
+
+      nil
+    end
+  end
+end

data/lib/lighterpack_parser/parser.rb

@@ -4,6 +4,10 @@ require 'nokogiri'
 require 'httparty'
 
 module LighterpackParser
+  # Main parser for extracting data from Lighterpack list HTML pages.
+  #
+  # Orchestrates the parsing process by coordinating ListParser, CategoryParser,
+  # and ItemParser to extract structured data from Lighterpack HTML.
   class Parser
     def initialize(html: nil, url: nil)
       @html = if url
@@ -13,16 +17,14 @@ module LighterpackParser
               else
                 raise ArgumentError, 'Either html or url must be provided'
               end
+      @item_parser = ItemParser.new
+      @category_parser = CategoryParser.new
+      @list_parser = ListParser.new
     end
 
     def parse
       doc = Nokogiri::HTML(@html)
-
-      {
-        name: extract_list_name(doc),
-        description: extract_list_description(doc),
-        categories: extract_categories(doc)
-      }
+      @list_parser.parse(doc, category_parser: @category_parser, item_parser: @item_parser)
     end
 
     private
@@ -30,235 +32,8 @@ module LighterpackParser
     def fetch_html(url)
       response = HTTParty.get(url, timeout: 30)
       raise "Failed to fetch URL: #{response.code}" unless response.success?
-      response.body
-    end
-
-    def extract_list_name(doc)
-      # Lighterpack uses h1.lpListName
-      h1 = doc.at_css('h1.lpListName')
-      return h1.text.strip if h1
-
-      # Fallback to regular h1
-      h1 = doc.at_css('h1')
-      return h1.text.strip if h1
-
-      title = doc.at_css('title')
-      return title.text.strip if title
-
-      'Untitled List'
-    end
-
-    def extract_list_description(doc)
-      # Lighterpack doesn't seem to have a list description in the HTML
-      # Could be in meta tags
-      meta_desc = doc.at_css('meta[name="description"]')
-      return meta_desc['content'] if meta_desc && meta_desc['content']
-
-      nil
-    end
-
-    def extract_categories(doc)
-      categories = []
-
-      # Lighterpack structure: ul.lpCategories > li.lpCategory
-      doc.css('ul.lpCategories > li.lpCategory').each do |category_element|
-        # Category name is in h2.lpCategoryName
-        category_header = category_element.at_css('h2.lpCategoryName')
-        next unless category_header
-
-        category_name = category_header.text.strip
-        next if category_name.empty?
-
-        # Description is typically in the category name itself (in parentheses)
-        description = extract_category_description(category_name)
-
-        # Find items in this category
-        items = extract_items_for_category(category_element)
-
-        categories << {
-          name: category_name,
-          description: description,
-          items: items
-        }
-      end
-
-      categories
-    end
-
-    def extract_category_description(category_name)
-      # Description is often in parentheses in the category name
-      # e.g., "Big 3 (Pack, Tent, Sleep System)"
-      match = category_name.match(/\(([^)]+)\)/)
-      return match[1] if match
-
-      nil
-    end
-
-    def extract_items_for_category(category_element)
-      items = []
-
-      # Items are in ul.lpItems within the category
-      items_list = category_element.at_css('ul.lpItems')
-      return items unless items_list
-
-      # Extract items (skip header row)
-      items_list.css('li.lpItem').each do |item_element|
-        item = extract_item(item_element)
-        items << item if item && item[:name]
-      end
-
-      items
-    end
-
-    def extract_item(element)
-      # Extract item data from the element
-      # Lighterpack items have: name, weight, quantity, description, image
-      name = extract_item_name(element)
-      return nil unless name
-
-      weight_data = extract_weight(element)
-      quantity = extract_quantity(element)
-      description = extract_item_description(element)
-      image_url = extract_image_url(element)
-      consumable = extract_consumable_flag(element)
-      worn = extract_worn_flag(element)
-
-      {
-        name: name,
-        description: description,
-        weight: weight_data[:weight_grams],
-        quantity: quantity,
-        image_url: image_url,
-        consumable: consumable,
-        worn: worn
-      }
-    end
-
-    def extract_item_name(element)
-      # Item name is in span.lpName
-      name_elem = element.at_css('span.lpName')
-      return name_elem.text.strip if name_elem
 
-      nil
-    end
-
-    def extract_weight(element)
-      # Lighterpack stores weight in milligrams in input.lpMG
-      mg_input = element.at_css('input.lpMG')
-      if mg_input && mg_input['value']
-        # Convert from milligrams to grams
-        weight_grams = mg_input['value'].to_f / 1000.0
-        return { weight_grams: weight_grams, original_unit: 'g' }
-      end
-
-      # Fallback: try to get from span.lpWeight and unit
-      weight_elem = element.at_css('span.lpWeight')
-      unit_elem = element.at_css('span.lpDisplay, select.lpUnit option[selected]')
-
-      if weight_elem
-        weight_value = weight_elem.text.strip.to_f
-        unit = 'g' # default
-
-        if unit_elem
-          unit_text = unit_elem.text.strip.downcase
-          unit = unit_text if ['oz', 'lb', 'g', 'kg'].include?(unit_text)
-        end
-
-        weight_grams = convert_to_grams(weight_value, unit)
-        return { weight_grams: weight_grams, original_unit: unit }
-      end
-
-      { weight_grams: 0.0, original_unit: 'g' }
-    end
-
-    def convert_to_grams(value, unit)
-      case unit.downcase
-      when 'oz'
-        value * 28.3495
-      when 'lb'
-        value * 453.592
-      when 'g'
-        value
-      when 'kg'
-        value * 1000
-      else
-        value # Default to assuming grams
-      end
-    end
-
-    def extract_quantity(element)
-      # Quantity is in span.lpQtyCell
-      qty_elem = element.at_css('span.lpQtyCell')
-      if qty_elem
-        qty_text = qty_elem.text.strip
-        return qty_text.to_i if qty_text.match?(/^\d+$/)
-      end
-
-      # Check qty attribute
-      qty_attr = element['qty']
-      return qty_attr.to_i if qty_attr
-
-      1 # Default quantity
-    end
-
-    def extract_item_description(element)
-      # Description is in span.lpDescription
-      desc_elem = element.at_css('span.lpDescription')
-      return desc_elem.text.strip if desc_elem && !desc_elem.text.strip.empty?
-
-      nil
-    end
-
-    def extract_image_url(element)
-      # Image URL is in img.lpItemImage
-      img = element.at_css('img.lpItemImage')
-      if img && img['src']
-        # Decode HTML entities
-        url = img['src'].gsub('&#x2F;', '/').gsub('&#x3D;', '=')
-        return url
-      end
-
-      # Also check href attribute
-      if img && img['href']
-        url = img['href'].gsub('&#x2F;', '/').gsub('&#x3D;', '=')
-        return url
-      end
-
-      nil
-    end
-
-    def extract_consumable_flag(element)
-      # Check for consumable icon with lpActive class (only active items have lpActive)
-      # Try CSS selector first - Nokogiri should handle multiple classes
-      consumable_active = element.at_css('i.lpSprite.lpConsumable.lpActive')
-      return true if consumable_active
-
-      # Fallback: check class attribute directly
-      consumable_icon = element.at_css('i.lpSprite.lpConsumable')
-      return false unless consumable_icon
-
-      class_attr = consumable_icon['class'].to_s
-      # Check if lpActive appears in the class string (handles extra spaces)
-      return true if class_attr.include?('lpActive')
-
-      false
-    end
-
-    def extract_worn_flag(element)
-      # Check for worn icon with lpActive class (only active items have lpActive)
-      # Try CSS selector first - Nokogiri should handle multiple classes
-      worn_active = element.at_css('i.lpSprite.lpWorn.lpActive')
-      return true if worn_active
-
-      # Fallback: check class attribute directly
-      worn_icon = element.at_css('i.lpSprite.lpWorn')
-      return false unless worn_icon
-
-      class_attr = worn_icon['class'].to_s
-      # Check if lpActive appears in the class string (handles extra spaces)
-      return true if class_attr.include?('lpActive')
-
-      false
+      response.body
     end
   end
 end

data/lib/lighterpack_parser/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LighterpackParser
-  VERSION = '0.1.0'
+  VERSION = '1.0.0'
 end

data/lib/lighterpack_parser.rb

@@ -1,8 +1,20 @@
 # frozen_string_literal: true
 
 require_relative 'lighterpack_parser/version'
+require_relative 'lighterpack_parser/gram_converter'
+require_relative 'lighterpack_parser/item'
+require_relative 'lighterpack_parser/category'
+require_relative 'lighterpack_parser/list'
+require_relative 'lighterpack_parser/item_parser'
+require_relative 'lighterpack_parser/category_parser'
+require_relative 'lighterpack_parser/list_parser'
 require_relative 'lighterpack_parser/parser'
 
+# Parser for extracting data from Lighterpack list HTML pages.
+#
+# Provides classes and methods to parse Lighterpack list HTML and extract
+# structured data including list information, categories, and items with their
+# properties (weight, quantity, consumable status, etc.).
 module LighterpackParser
   # Convenience method to parse a Lighterpack URL
   def self.parse_url(url)

data/lighterpack-parser.gemspec

@@ -13,11 +13,13 @@ Gem::Specification.new do |spec|
   spec.homepage      = 'https://github.com/alex-ross/lighterpack-parser'
   spec.license       = 'MIT'
 
+  spec.required_ruby_version = '>= 3.0'
+
   spec.files         = Dir['lib/**/*', 'spec/**/*', '*.md', '*.gemspec']
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'nokogiri', '~> 1.15'
   spec.add_dependency 'httparty', '~> 0.21'
+  spec.add_dependency 'nokogiri', '~> 1.15'
 
   spec.add_development_dependency 'rspec', '~> 3.12'
 end

data/spec/parser_spec.rb

@@ -11,31 +11,71 @@ RSpec.describe LighterpackParser::Parser do
       let(:result) { described_class.new(html: html).parse }
 
       it 'extracts the list name' do
-        expect(result[:name]).to eq('Ultimate Hike 2025')
+        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
+        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
+        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
+        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(first_item).to_not be_worn
+        expect(first_item).to_not be_consumable
+      end
+
+      it 'includes total weight fields' do
+        first_category = result.categories.first
+        first_item = first_category.items.first
+
+        expect(first_item.total_weight).to be > 0
+        expect(first_item.total_weight).to eq(first_item.weight * first_item.quantity)
+
+        if first_item.consumable
+          expect(first_item.total_consumable_weight).to be > 0
+          expect(first_item.total_consumable_weight).to eq(first_item.weight * first_item.quantity)
+        else
+          expect(first_item.total_consumable_weight).to be_nil
+        end
 
-        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])
+        if first_item.worn
+          expect(first_item.worn_quantity).to eq(1)
+          expect(first_item.total_worn_weight).to be > 0
+          expect(first_item.total_worn_weight).to eq(first_item.weight * 1)
+        else
+          expect(first_item.worn_quantity).to be_nil
+          expect(first_item.total_worn_weight).to be_nil
+        end
+      end
+
+      it 'sets worn_quantity to 1 for worn items regardless of quantity' do
+        result.categories.each do |category|
+          category.items.each do |item|
+            if item.worn
+              expect(item.worn_quantity).to eq(1),
+                                            "Worn item #{item.name} should have worn_quantity=1, " \
+                                            "got #{item.worn_quantity}"
+              expect(item.total_worn_weight).to eq(item.weight * 1),
+                                                "Worn item #{item.name} should have total_worn_weight = weight * 1"
+            else
+              expect(item.worn_quantity).to be_nil, "Non-worn item #{item.name} should have worn_quantity=nil"
+            end
+          end
+        end
       end
     end
 
@@ -44,11 +84,11 @@ RSpec.describe LighterpackParser::Parser do
       let(:result) { described_class.new(html: html).parse }
 
       it 'extracts the list name' do
-        expect(result[:name]).to be_truthy
+        expect(result.name).to be_truthy
       end
 
       it 'extracts categories as an array' do
-        expect(result[:categories]).to be_a(Array)
+        expect(result.categories).to be_a(Array)
       end
     end
 
@@ -57,11 +97,11 @@ RSpec.describe LighterpackParser::Parser do
       let(:result) { described_class.new(html: html).parse }
 
       it 'extracts the list name' do
-        expect(result[:name]).to be_truthy
+        expect(result.name).to be_truthy
       end
 
       it 'extracts categories as an array' do
-        expect(result[:categories]).to be_a(Array)
+        expect(result.categories).to be_a(Array)
       end
     end
   end
@@ -71,11 +111,11 @@ RSpec.describe LighterpackParser::Parser do
     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]}"
+      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
@@ -87,9 +127,9 @@ RSpec.describe LighterpackParser::Parser do
     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]}"
+      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
@@ -100,9 +140,9 @@ RSpec.describe LighterpackParser::Parser do
     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]}"
+      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
@@ -111,62 +151,64 @@ RSpec.describe LighterpackParser::Parser do
   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] } }
+    let(:all_items) { result.categories.flat_map(&:items) }
 
     it 'correctly identifies Sea to Summit Ultrasil as worn' do
-      ultrasil = all_items.find { |item| item[:name]&.include?('Sea to Summit Ultrasil') }
+      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'
+      expect(ultrasil.worn).to be(true), 'Sea to Summit Ultrasil should be worn'
+      expect(ultrasil.consumable).to be(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') }
+      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'
+      expect(macbook.worn).to be(false), 'MacBook Pro should NOT be worn'
+      expect(macbook.consumable).to be(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] } }
+    let(:all_items) { result.categories.flat_map(&:items) }
 
     it 'correctly identifies Tandkräm as consumable' do
-      tandkram = all_items.find { |item| item[:name]&.include?('Tandkräm (innehåll)') }
+      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'
+      expect(tandkram.consumable).to be(true), 'Tandkräm should be consumable'
+      expect(tandkram.worn).to be(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') }
+      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'
+      expect(shampoo.consumable).to be(true), 'Dushtvål/Shampoo should be consumable'
+      expect(shampoo.worn).to be(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') }
+      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'
+      expect(macbook.consumable).to be(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(:all_items) { result.categories.flat_map(&: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] } }
+    let(:worn_count) { all_items.count(&:worn) }
+    let(:consumable_count) { all_items.count(&: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(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
@@ -176,10 +218,10 @@ RSpec.describe LighterpackParser::Parser do
     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]}"
+      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
@@ -191,10 +233,10 @@ RSpec.describe LighterpackParser::Parser do
 
     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]}"
+      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
@@ -209,9 +251,9 @@ RSpec.describe LighterpackParser::Parser do
     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]}"
+      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

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: lighterpack-parser
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Packlista Team
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-11-29 00:00:00.000000000 Z
+date: 2026-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: nokogiri
+  name: httparty
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '0.21'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '0.21'
 - !ruby/object:Gem::Dependency
-  name: httparty
+  name: nokogiri
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.21'
+        version: '1.15'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.21'
+        version: '1.15'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -62,6 +62,13 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/lighterpack_parser.rb
+- lib/lighterpack_parser/category.rb
+- lib/lighterpack_parser/category_parser.rb
+- lib/lighterpack_parser/gram_converter.rb
+- lib/lighterpack_parser/item.rb
+- lib/lighterpack_parser/item_parser.rb
+- lib/lighterpack_parser/list.rb
+- lib/lighterpack_parser/list_parser.rb
 - lib/lighterpack_parser/parser.rb
 - lib/lighterpack_parser/version.rb
 - lighterpack-parser.gemspec
@@ -82,7 +89,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="