lighterpack-parser 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 443e65a776623c5e587889eecf74da63064015eae8a3d1882b3e0a5ad5864675
+  data.tar.gz: 25cb7cf2b5cea5deeadcc82a53665ac999c69895ee3754a3174929a6b43f3264
+SHA512:
+  metadata.gz: 95e5525bd874996437de92e6a486a530ca23677e035c640bb7b4d7b2a7662189a67ea97a7cfa19913973e7ae875822517b05e73a66c0e0060dc1c28d27e06128
+  data.tar.gz: 14af29e67a8f67ed1552e7e9dc2801005a214d800ab788dea0fc1add26478c7df4e780262278271a3f33945d6866f2df42fa511770df083e9c8f4383ff530bb1

data/README.md

@@ -0,0 +1,108 @@
+# Lighterpack Parser
+
+A Ruby gem for parsing Lighterpack lists from HTML or URLs.
+
+## Installation
+
+This gem is used as a local dependency in the Packlista project. It's referenced in the backend `Gemfile`:
+
+```ruby
+gem 'lighterpack_parser', path: '../lighterpack-parser'
+```
+
+## Usage
+
+### Parse from HTML string
+
+```ruby
+require 'lighterpack_parser'
+
+html = File.read('path/to/lighterpack.html')
+result = LighterpackParser::Parser.new(html: html).parse
+
+# Result structure:
+# {
+#   name: "List Name",
+#   description: "List description (optional)",
+#   categories: [
+#     {
+#       name: "Category Name",
+#       description: "Category description (optional)",
+#       items: [
+#         {
+#           name: "Item Name",
+#           description: "Item description",
+#           weight: 476.0,  # in grams
+#           quantity: 1,
+#           image_url: "https://...",
+#           consumable: false,
+#           worn: false
+#         }
+#       ]
+#     }
+#   ]
+# }
+```
+
+### Parse from URL
+
+```ruby
+require 'lighterpack_parser'
+
+# Using the parser directly
+result = LighterpackParser::Parser.new(url: 'https://lighterpack.com/r/b6q1kr').parse
+
+# Or using the convenience method
+result = LighterpackParser.parse_url('https://lighterpack.com/r/b6q1kr')
+```
+
+## Running Tests
+
+To run the test suite:
+
+```bash
+rspec
+```
+
+## Test Fixtures
+
+Test fixtures are stored in `test/fixtures/` and contain HTML from example Lighterpack lists:
+- `b6q1kr.html` - Ultimate Hike 2025
+- `adbf7c.html` - Example list 2
+- `h23rxt.html` - Example list 3
+
+To update fixtures, download fresh HTML:
+
+```bash
+curl -s "https://lighterpack.com/r/b6q1kr" > test/fixtures/b6q1kr.html
+```
+
+## Features
+
+- Parses list name and description
+- Extracts categories with descriptions
+- Extracts items with:
+  - Name and description
+  - Weight (automatically converted to grams)
+  - Quantity
+  - Image URLs
+  - Consumable flag
+  - Worn flag
+- Supports weight units: oz, lb, g, kg (all converted to grams)
+- Handles both HTML strings and URLs
+
+## Weight Conversion
+
+The parser automatically converts all weights to grams:
+- `oz` → multiply by 28.3495
+- `lb` → multiply by 453.592
+- `g` → use as-is
+- `kg` → multiply by 1000
+
+## Development
+
+To install dependencies locally:
+
+```bash
+bundle install
+```

data/lib/lighterpack_parser/parser.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require 'httparty'
+
+module LighterpackParser
+  class Parser
+    def initialize(html: nil, url: nil)
+      @html = if url
+                fetch_html(url)
+              elsif html
+                html
+              else
+                raise ArgumentError, 'Either html or url must be provided'
+              end
+    end
+
+    def parse
+      doc = Nokogiri::HTML(@html)
+
+      {
+        name: extract_list_name(doc),
+        description: extract_list_description(doc),
+        categories: extract_categories(doc)
+      }
+    end
+
+    private
+
+    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
+    end
+  end
+end

data/lib/lighterpack_parser/version.rb

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

data/lib/lighterpack_parser.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'lighterpack_parser/version'
+require_relative 'lighterpack_parser/parser'
+
+module LighterpackParser
+  # Convenience method to parse a Lighterpack URL
+  def self.parse_url(url)
+    Parser.new(url: url).parse
+  end
+end

data/lighterpack-parser.gemspec

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'lib/lighterpack_parser/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lighterpack-parser'
+  spec.version       = LighterpackParser::VERSION
+  spec.authors       = ['Packlista Team']
+  spec.email         = ['team@packlista.com']
+
+  spec.summary       = 'Parser for Lighterpack lists'
+  spec.description   = 'Parse Lighterpack HTML to extract list data including categories, items, weights, and metadata'
+  spec.homepage      = 'https://github.com/alex-ross/lighterpack-parser'
+  spec.license       = 'MIT'
+
+  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_development_dependency 'rspec', '~> 3.12'
+end