unmagic-icon 0.1.0

data/lib/unmagic/icon/library/source/tabler.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Unmagic
+  class Icon
+    class Library
+      class Source
+        class Tabler < Source
+          key :tabler
+          title "Tabler Icons"
+          description "Over 5400 free SVG icons"
+          url "https://github.com/tabler/tabler-icons/releases/download/v3.24.0/tabler-icons-3.24.0.zip"
+          archive :zip
+          extract "svg/*.svg"
+        end
+      end
+    end
+  end
+end

data/lib/unmagic/icon/library/source.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require "pathname"
+require "fileutils"
+require "tmpdir"
+require "open3"
+
+# Terminal progress is a nicety, not a requirement. The downloader runs fine
+# (with plain output) when these sibling gems aren't installed.
+begin
+  require "unmagic/terminal/progress_bar"
+  require "unmagic/support/monitored_enumerator"
+rescue LoadError
+  # no-op — falls back to plain iteration in #each_with_progress
+end
+
+module Unmagic
+  class Icon
+    class Library
+      # A downloadable source for an icon library: its metadata and how to fetch
+      # it. Each library is a subclass that declares metadata with the class-level
+      # DSL; the base carries the shared download/extract/manifest plumbing. A
+      # subclass overrides #write_manifest to generate a mapping, or #acquire to
+      # use a different transport.
+      class Source
+        class Error < StandardError; end
+        class DownloadError < Error; end
+        class ExtractionError < Error; end
+
+        REGISTRY = {}
+
+        class << self
+          def all
+            REGISTRY.values
+          end
+
+          def find(name)
+            REGISTRY[name.to_sym] or raise ArgumentError, "Unknown library: #{name}"
+          end
+
+          def exists?(name)
+            REGISTRY.key?(name.to_sym)
+          end
+
+          # ---- metadata DSL (each setter doubles as a reader) ----
+
+          def key(value = nil)
+            return @key unless value
+
+            @key = value.to_sym
+            REGISTRY[@key] = self
+          end
+
+          def title(value = nil)
+            value ? @title = value : @title
+          end
+
+          def description(value = nil)
+            value ? @description = value : @description
+          end
+
+          def url(value = nil)
+            value ? @url = value : @url
+          end
+
+          def archive(value = nil)
+            value ? @archive = value : @archive
+          end
+
+          # On-disk directory name; defaults to the key.
+          def dir(value = nil)
+            value ? @dir = value.to_s : (@dir || key.to_s)
+          end
+
+          # Glob patterns (relative to the extracted archive) of svgs to copy.
+          def extract(*patterns)
+            patterns.empty? ? (@extract || []) : @extract = patterns
+          end
+
+          # Map source directories to target subdirectories (e.g. heroicons sizes).
+          def extract_into(mapping = nil)
+            mapping ? @extract_into = mapping : @extract_into
+          end
+        end
+
+        def download(target_dir: default_target_dir, force: false)
+          target_dir = Pathname(target_dir)
+
+          if target_dir.exist? && !force
+            puts "→ Skipping #{self.class.title} (already exists at #{target_dir}, use force: true to re-download)"
+            return
+          end
+
+          puts "→ Downloading #{self.class.title}..."
+          puts "  #{self.class.description}"
+
+          acquire(target_dir)
+
+          puts "  ✓ Downloaded #{count_svgs(target_dir)} icons to #{target_dir}"
+        end
+
+        private
+
+        def default_target_dir
+          base = Unmagic::Icon.configuration.download_path
+          raise ArgumentError, "Set Unmagic::Icon.configuration.download_path or pass target_dir:" unless base
+
+          Pathname(base).join(self.class.dir)
+        end
+
+        # Default acquisition: download an archive, extract, copy matched svgs,
+        # then let the subclass write a manifest. Override for other transports.
+        def acquire(target_dir)
+          Dir.mktmpdir do |tmpdir|
+            archive_path = File.join(tmpdir, "#{self.class.key}#{File.extname(self.class.url)}")
+            download_file(self.class.url, archive_path)
+            extract_archive(archive_path, tmpdir, self.class.archive)
+
+            FileUtils.mkdir_p(target_dir)
+            copy_assets(tmpdir, target_dir)
+            write_manifest(tmpdir, target_dir)
+          end
+        end
+
+        # Libraries that ship a file→icon mapping override this to write a
+        # manifest.json into target_dir. Default: nothing.
+        def write_manifest(_tmpdir, _target_dir)
+        end
+
+        def copy_assets(tmpdir, target_dir)
+          if self.class.extract_into
+            copy_into_subdirs(tmpdir, target_dir)
+          else
+            copy_flat(tmpdir, target_dir)
+          end
+        end
+
+        def copy_flat(tmpdir, target_dir)
+          files = self.class.extract.flat_map do |pattern|
+            Dir.glob(File.join(tmpdir, pattern)).select { |file| File.file?(file) }
+          end
+          return if files.empty?
+
+          puts "  Extracting #{files.size} icons..."
+          each_with_progress(files) { |file| FileUtils.cp(file, target_dir) }
+        end
+
+        def copy_into_subdirs(tmpdir, target_dir)
+          files = self.class.extract_into.flat_map do |source_dir, subdir|
+            Dir.glob(File.join(tmpdir, source_dir, "*.svg")).map { |file| [ file, subdir ] }
+          end
+          return if files.empty?
+
+          puts "  Extracting #{files.size} icons..."
+          each_with_progress(files) do |(file, subdir)|
+            next unless File.file?(file)
+
+            destination = Pathname(target_dir).join(subdir)
+            FileUtils.mkdir_p(destination)
+            FileUtils.cp(file, destination)
+          end
+        end
+
+        def each_with_progress(items, show_time: false)
+          if defined?(Unmagic::Support::MonitoredEnumerator) && defined?(Unmagic::Terminal::ProgressBar)
+            bar = Unmagic::Terminal::ProgressBar.new(total: items.size, width: 40, show_time: show_time)
+            monitor = proc do |event|
+              case event.event
+              when :progress
+                bar.update(event.progress.current + 1)
+                print "\r  #{bar.render}"
+              when :finish
+                puts
+              end
+            end
+
+            Unmagic::Support::MonitoredEnumerator.new(items, monitor).each { |item| yield item }
+          else
+            items.each { |item| yield item }
+          end
+        end
+
+        def download_file(url, destination)
+          response = fetch_with_redirect(URI(url))
+          raise DownloadError, "Failed to download #{url}: HTTP #{response.code}" if response.code != "200"
+
+          File.binwrite(destination, response.body)
+        end
+
+        def fetch_with_redirect(uri, headers = {}, limit = 10)
+          raise DownloadError, "Too many redirects" if limit.zero?
+
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = (uri.scheme == "https")
+
+          request = Net::HTTP::Get.new(uri)
+          headers.each { |name, value| request[name] = value }
+
+          response = http.request(request)
+
+          case response
+          when Net::HTTPSuccess
+            response
+          when Net::HTTPRedirection
+            fetch_with_redirect(URI(response["location"]), headers, limit - 1)
+          else
+            response
+          end
+        end
+
+        def extract_archive(archive_path, destination, type)
+          case type
+          when :zip
+            _, stderr, status = Open3.capture3("unzip", "-q", "-o", archive_path, "-d", destination)
+            raise ExtractionError, "Failed to extract zip: #{stderr}" unless status.success?
+          when :tgz, :tar
+            _, stderr, status = Open3.capture3("tar", "-xzf", archive_path, "-C", destination)
+            raise ExtractionError, "Failed to extract tar: #{stderr}" unless status.success?
+          else
+            raise ExtractionError, "Unknown archive type: #{type}"
+          end
+        end
+
+        def count_svgs(directory)
+          Dir.glob(File.join(directory, "**", "*.svg")).size
+        end
+      end
+    end
+  end
+end
+
+require_relative "source/heroicons"
+require_relative "source/devicons"
+require_relative "source/feather"
+require_relative "source/tabler"
+require_relative "source/lucide"
+require_relative "source/simple_icons"
+require_relative "source/material_file_icons"
+require_relative "source/silk"

data/lib/unmagic/icon/library.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Unmagic
+  class Icon
+    class Library
+      # The optional per-set manifest. Asset-kind-agnostic: it carries metadata,
+      # a `default`, a global `aliases` map, and optional per-entry declarations
+      # (`entries`, each with its own `aliases`). Icons auto-discover from disk,
+      # so for an icon library only `default` + `aliases` are typically present.
+      MANIFEST_FILENAME = "manifest.json"
+
+      # The lone asset-kind-specific bit: which files in the directory are assets.
+      # SVG today; a future raster pack would scan png/gif here.
+      ASSET_GLOB = "*.svg"
+
+      attr_reader :name, :path
+
+      def initialize(name:, path:)
+        @name = name
+        @path = path
+      end
+
+      # Resolve a query to an icon. Order: exact icon file, then the alias index
+      # (exact alias, then longest matching glob/pattern), then the manifest's
+      # default. Raises when nothing matches and no default is declared.
+      def find(query)
+        resolve(query.to_s) or
+          raise Unmagic::Icon::IconNotFoundError.new("Can't find #{query} in #{path}")
+      end
+
+      def icons
+        icons_by_key.values
+      end
+
+      def aliases
+        alias_index
+      end
+
+      private
+
+      def resolve(query)
+        icons_by_key[query] ||
+          aliased(query) ||
+          default_icon
+      end
+
+      def aliased(query)
+        target = lookup_alias(query.downcase)
+        icons_by_key[target] if target
+      end
+
+      # Exact aliases win over patterns; patterns are tried longest-first so the
+      # most specific match wins (e.g. "*.test.tsx" beats "*.tsx").
+      def lookup_alias(key)
+        exact, patterns = alias_index
+        exact[key] ||
+          patterns.find { |pattern, _| File.fnmatch?(pattern, key, File::FNM_EXTGLOB) }&.last
+      end
+
+      def default_icon
+        target = manifest["default"]
+        icons_by_key[target] if target
+      end
+
+      def icons_by_key
+        @icons_by_key ||= Dir.glob(File.join(@path, ASSET_GLOB)).to_h do |icon_path|
+          icon_key = File.basename(icon_path, ".svg")
+          [ icon_key, Unmagic::Icon.new(name: "#{@name}/#{icon_key}", path: icon_path) ]
+        end
+      end
+
+      # The whole alias map, normalized to downcased keys and split into exact
+      # strings vs glob patterns. Built from the manifest's global `aliases` plus
+      # each entry's per-entry `aliases` (the emoji-shaped shortcuts case).
+      def alias_index
+        @alias_index ||=
+          begin
+            exact = {}
+            patterns = {}
+
+            manifest_aliases.each do |key, target|
+              normalized = key.to_s.downcase
+              if normalized.match?(/[*?\[{]/)
+                patterns[normalized] = target
+              else
+                exact[normalized] = target
+              end
+            end
+
+            [ exact, patterns.sort_by { |pattern, _| -pattern.length }.to_h ]
+          end
+      end
+
+      def manifest_aliases
+        global = manifest["aliases"] || {}
+        per_entry = Array(manifest["entries"]).each_with_object({}) do |entry, mapped|
+          Array(entry["aliases"]).each { |key| mapped[key] = entry["name"] }
+        end
+        global.merge(per_entry)
+      end
+
+      def manifest
+        @manifest ||= load_manifest
+      end
+
+      def load_manifest
+        file = File.join(@path, MANIFEST_FILENAME)
+        File.exist?(file) ? JSON.parse(File.read(file)) : {}
+      end
+    end
+  end
+end

data/lib/unmagic/icon/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Unmagic
+  class Icon
+    VERSION = "0.1.0"
+  end
+end

data/lib/unmagic/icon/web/views/layout.html.erb

@@ -0,0 +1,329 @@
+  <title>Unmagic Icon Gallery</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    
+    :root {
+      --bg: #fff;
+      --fg: #333;
+      --border: #e0e0e0;
+      --tab-bg: #f5f5f5;
+      --tab-hover: #e8e8e8;
+      --tab-border: #ddd;
+      --active-bg: #333;
+      --active-fg: #fff;
+      --icon-hover: #f8f8f8;
+      --icon-border-hover: #999;
+      --input-border: #ccc;
+      --input-border-focus: #666;
+      --muted: #666;
+      --no-results: #999;
+    }
+    
+    [data-theme="dark"] {
+      --bg: #1a1a1a;
+      --fg: #e0e0e0;
+      --border: #333;
+      --tab-bg: #2a2a2a;
+      --tab-hover: #333;
+      --tab-border: #444;
+      --active-bg: #e0e0e0;
+      --active-fg: #1a1a1a;
+      --icon-hover: #2a2a2a;
+      --icon-border-hover: #666;
+      --input-border: #444;
+      --input-border-focus: #888;
+      --muted: #999;
+      --no-results: #666;
+    }
+    
+    body { 
+      font-family: -apple-system, system-ui, sans-serif; 
+      background: var(--bg);
+      color: var(--fg);
+      padding: 20px;
+      line-height: 1.5;
+    }
+    
+    .header {
+      margin-bottom: 30px;
+      padding-bottom: 20px;
+      border-bottom: 1px solid var(--border);
+      position: relative;
+    }
+    
+    .theme-switcher {
+      position: absolute;
+      top: 0;
+      right: 0;
+      padding: 8px 12px;
+      background: var(--tab-bg);
+      border: 1px solid var(--tab-border);
+      border-radius: 4px;
+      cursor: pointer;
+      font-size: 14px;
+    }
+    
+    .theme-switcher:hover {
+      background: var(--tab-hover);
+    }
+    
+    .search-box {
+      margin-bottom: 20px;
+    }
+    
+    .search-box input {
+      width: 100%;
+      max-width: 400px;
+      padding: 8px 12px;
+      font-size: 14px;
+      border: 1px solid var(--input-border);
+      border-radius: 4px;
+      outline: none;
+    }
+    
+    .search-box input:focus {
+      border-color: var(--input-border-focus);
+    }
+    
+    .tabs {
+      display: flex;
+      gap: 10px;
+      flex-wrap: wrap;
+    }
+    
+    .tab {
+      padding: 8px 16px;
+      background: var(--tab-bg);
+      border: 1px solid var(--tab-border);
+      border-radius: 4px;
+      cursor: pointer;
+      font-size: 14px;
+      text-decoration: none;
+      color: var(--fg);
+      display: inline-block;
+    }
+    
+    .tab:hover {
+      background: var(--tab-hover);
+      text-decoration: none;
+    }
+    
+    .tab.active {
+      background: var(--active-bg);
+      color: var(--active-fg);
+      border-color: var(--active-bg);
+    }
+    
+    .icon-grid {
+      display: grid;
+      grid-template-columns: repeat(auto-fill, minmax(120px, 1fr));
+      gap: 20px;
+      margin-top: 30px;
+    }
+    
+    .icon-item {
+      text-align: center;
+      padding: 15px;
+      border: 1px solid var(--border);
+      border-radius: 4px;
+      cursor: pointer;
+    }
+    
+    .icon-item:hover {
+      background: var(--icon-hover);
+      border-color: var(--icon-border-hover);
+    }
+    
+    .icon-item svg {
+      width: 48px;
+      height: 48px;
+      margin-bottom: 8px;
+      display: block;
+      margin-left: auto;
+      margin-right: auto;
+    }
+    
+    .icon-name {
+      font-size: 12px;
+      color: var(--muted);
+      word-break: break-all;
+    }
+    
+    .stats {
+      margin-top: 20px;
+      font-size: 14px;
+      color: var(--muted);
+    }
+    
+    .copy-toast {
+      position: fixed;
+      bottom: 20px;
+      right: 20px;
+      background: var(--active-bg);
+      color: var(--active-fg);
+      padding: 12px 20px;
+      border-radius: 4px;
+      opacity: 0;
+      transform: translateY(20px);
+      transition: all 0.3s ease;
+      pointer-events: none;
+      font-size: 14px;
+    }
+    
+    .copy-toast.show {
+      opacity: 1;
+      transform: translateY(0);
+    }
+    
+    .no-results {
+      text-align: center;
+      color: var(--no-results);
+      padding: 40px;
+      font-size: 14px;
+    }
+    
+    [hidden] {
+      display: none !important;
+    }
+  </style>
+  <link rel="icon" href="<%= url "/public/favicon.png" %>" type="image/png">
+  <link rel="apple-touch-icon" href="<%= url "/public/favicon.png" %>">
+</head>
+<body>
+  <div class="header">
+    <button class="theme-switcher" id="themeSwitcher">🌙</button>
+
+    <div class="search-box">
+      <input 
+        type="text" 
+        id="searchInput"
+        placeholder="Search icons..." 
+        value="<%= escape(@search_query) %>"
+        autocomplete="off"
+      >
+    </div>
+    
+    <div class="tabs">
+      <% @libraries.each do |library| %>
+        <a href="<%= url(library.name, @request.params) %>" 
+           class="tab <%= library == @selected_library ? 'active' : '' %>">
+          <%= library.name %> (<%= library.icons.length %>)
+        </a>
+      <% end %>
+    </div>
+  </div>
+  
+  <div class="stats" id="stats"></div>
+  
+  <div class="icon-grid" id="iconGrid"></div>
+  
+  <div class="copy-toast" id="copyToast">Copied to clipboard!</div>
+  
+  <script>
+    // Icon data for current library only
+    const currentLibrary = '<%= @selected_library.name %>';
+    const iconsData = <%= @selected_library.icons.to_json %>;
+    
+    // State
+    let searchQuery = '<%= @search_query %>';
+    
+    // Elements
+    const searchInput = document.getElementById('searchInput');
+    const iconGrid = document.getElementById('iconGrid');
+    const stats = document.getElementById('stats');
+    const copyToast = document.getElementById('copyToast');
+    const themeSwitcher = document.getElementById('themeSwitcher');
+    
+    // Functions
+    function filterIcons() {
+      const query = searchQuery.toLowerCase();
+      const filtered = query 
+        ? iconsData.filter(icon => icon.name.toLowerCase().includes(query))
+        : iconsData;
+      
+      renderIcons(filtered);
+      updateStats(filtered.length);
+    }
+    
+    function renderIcons(icons) {
+      if (icons.length === 0) {
+        iconGrid.innerHTML = '<div class="no-results">No icons found</div>';
+        return;
+      }
+      
+      iconGrid.innerHTML = icons.map(icon => {
+        return `
+          <div class="icon-item" data-icon="${icon.name}">
+            ${icon.svg}
+            <div class="icon-name">${icon.name}</div>
+          </div>
+        `;
+      }).join('');
+    }
+    
+    function updateStats(count) {
+      stats.textContent = `Showing ${count} icons from ${currentLibrary}`;
+    }
+    
+    function copyIcon(iconName) {
+      const text = `${iconName}`;
+      navigator.clipboard.writeText(text).then(() => {
+        copyToast.textContent = `Copied: ${text}`;
+        copyToast.classList.add('show');
+        setTimeout(() => copyToast.classList.remove('show'), 2000);
+      });
+    }
+    
+    function updateURL() {
+      const params = new URLSearchParams();
+      if (searchQuery) {
+        params.set('q', searchQuery);
+      }
+      const queryString = params.toString();
+      const newURL = window.location.pathname + (queryString ? '?' + queryString : '');
+      window.history.replaceState({}, '', newURL);
+      
+      // Update all tab links with new query
+      document.querySelectorAll('.tab').forEach(tab => {
+        const href = tab.getAttribute('href').split('?')[0];
+        tab.setAttribute('href', href + (queryString ? '?' + queryString : ''));
+      });
+    }
+    
+    // Theme management
+    function loadTheme() {
+      const savedTheme = localStorage.getItem('theme') || 'light';
+      document.documentElement.setAttribute('data-theme', savedTheme);
+      themeSwitcher.textContent = savedTheme === 'dark' ? '☀️' : '🌙';
+    }
+    
+    function toggleTheme() {
+      const currentTheme = document.documentElement.getAttribute('data-theme') || 'light';
+      const newTheme = currentTheme === 'dark' ? 'light' : 'dark';
+      document.documentElement.setAttribute('data-theme', newTheme);
+      localStorage.setItem('theme', newTheme);
+      themeSwitcher.textContent = newTheme === 'dark' ? '☀️' : '🌙';
+    }
+    
+    // Event listeners
+    searchInput.addEventListener('input', (e) => {
+      searchQuery = e.target.value;
+      filterIcons();
+      updateURL();
+    });
+    
+    iconGrid.addEventListener('click', (e) => {
+      const iconItem = e.target.closest('.icon-item');
+      if (iconItem) {
+        copyIcon(iconItem.dataset.icon);
+      }
+    });
+    
+    themeSwitcher.addEventListener('click', toggleTheme);
+    
+    // Initialize
+    loadTheme();
+    filterIcons();
+  </script>
+</body>
+</html>