arTTY 0.9.48

data/lib/arTTY.rb

@@ -0,0 +1,78 @@
+class ArTTY
+    attr_reader :art
+
+    def cache(download = false)
+        @cache.refresh(download)
+    end
+
+    def self.current_version
+        __FILE__.match(/arTTY-(\d+\.\d+\.\d+)/) do |m|
+            return m[1]
+        end
+        return "error" # Shouldn't happen
+    end
+
+    def exclude(pattern)
+        @art.delete_if do |name|
+            name.match(/#{pattern}/)
+        end
+    end
+
+    def fits(width, height)
+        if ((height <= 0) || (width <= 0))
+            @art.clear
+        else
+            @art.keep_if do |name|
+                (@cache.get_height_for(name) <= height) &&
+                (@cache.get_width_for(name) <= width)
+            end
+        end
+    end
+
+    def get(name, sysinfo = nil)
+        case name
+        when "none"
+            img = ArTTY::Art.new
+        else
+            if (!@@all_art.include?(name))
+                raise ArTTY::Error::ArtNotFound.new(name)
+            end
+            file = @cache.get_file_for(name)
+            file = nil if (!@art.include?(name))
+            img = ArTTY::Art.new(file)
+        end
+        img.sysinfo = sysinfo
+        return img
+    end
+
+    def initialize
+        @cache = ArTTY::Cache.new
+
+        @@all_art ||= Array.new
+        @cache.art.each do |name|
+            @@all_art.push(name)
+        end
+
+        @@all_art.sort! do |a, b|
+            a.downcase <=> b.downcase
+        end
+
+        @art = @@all_art.clone
+    end
+
+    def match(pattern)
+        @art.keep_if do |name|
+            name.match(/#{pattern}/)
+        end
+    end
+
+    def random
+        return @art.shuffle[0]
+    end
+end
+
+require "arTTY/art"
+require "arTTY/cache"
+require "arTTY/error"
+require "arTTY/generator"
+require "arTTY/system_info"

data/lib/arTTY/art.rb

@@ -0,0 +1,111 @@
+# encoding: utf-8
+
+require "hilighter"
+
+class ArTTY::Art
+    attr_reader :pixels
+    attr_accessor :legend
+    attr_accessor :name
+    attr_accessor :sysinfo
+
+    def draw
+        offset = nil
+        out = ""
+        pixels = @pixels
+        sysinfo = Array.new
+        if (@sysinfo)
+            offset = @pixels[0] ? @pixels[0].length + 2 : 0
+            sysinfo = @sysinfo.info
+        end
+
+        if ((pixels.length % 2) != 0)
+            filler = " " * pixels[0].length
+            pixels.insert(0, filler)
+        end
+
+        while (!pixels.empty?)
+            out += " "
+            top = pixels.delete_at(0)
+            bottom = pixels.delete_at(0)
+
+            top += " " while (top.length < bottom.length)
+            bottom += " " while (top.length > bottom.length)
+
+            top.chars.zip(bottom.chars).each_with_index do |map, i|
+                t = map[0].strip
+                b = map[1].strip
+
+                if (
+                    (t.empty? && b.empty?) ||
+                    (!t.empty? && !@legend.include?(t)) ||
+                    (!b.empty? && !@legend.include?(b))
+                )
+                    out += " "
+                    next
+                end
+
+                if (t.empty?)
+                    c = "▄".send(@legend[b])
+                elsif (b.empty?)
+                    c = "▄".send(@legend[t]).swap
+                else
+                    c = "▄".send(@legend[b]).send("on_#{@legend[t]}")
+                end
+
+                out += c
+            end
+
+            if (offset)
+                info = sysinfo.delete_at(0)
+                if (info)
+                    filler = offset - top.length
+                    out += " " * filler if (filler > 0)
+                    out += info
+                else
+                    offset = nil
+                end
+            end
+
+            out += "\n"
+        end
+
+        if (offset)
+            loop do
+                info = sysinfo.delete_at(0)
+                break if (info.nil?)
+                out += " " * (offset + 1)
+                out += "#{info}\n"
+            end
+        end
+
+        return out
+    end
+
+    def height
+        return @json["height"]
+    end
+
+    def initialize(file = nil)
+        if (!file.nil?)
+            @file = Pathname.new(file).expand_path
+            @json = JSON.parse(File.read(@file))
+        else
+            @file = nil
+            @json = Hash.new
+        end
+
+        @debug = false
+        @legend = @json["legend"] || Hash.new
+        @name = @json["name"] || "none"
+        @pixels = @json["pixels"] || Array.new
+        @sysinfo = nil
+    end
+
+    def to_s
+        return draw
+    end
+
+    def width
+        return @json["width"]
+    end
+end

data/lib/arTTY/cache.rb

@@ -0,0 +1,117 @@
+require "fileutils"
+require "json"
+require "jsoncfg"
+require "minitar"
+require "pathname"
+require "stringio"
+require "typhoeus"
+require "zlib"
+
+class ArTTY::Cache < JSONConfig
+    extend JSONConfig::Keys
+
+    add_key("art")
+    add_key("version")
+
+    def art
+        return get_art.keys.sort
+    end
+
+    def download_and_extract
+        # Temporary working directory
+        new = Pathname.new(
+            "#{@cachedir}/#{@imagesdir}.new"
+        ).expand_path
+        FileUtils.rm_rf(new) if (new && new.exist?)
+
+        # Download newest tarball
+        request = Typhoeus::Request.new(
+            [
+                "https://gitlab.com/mjwhitta/arTTY_images/-",
+                "archive/master/arTTY_images.tgz"
+            ].join("/"),
+            timeout: 10
+        )
+        request.on_headers do |response|
+            if (response.code != 200)
+                raise ArTTY::Error::FailedToDownload.new
+            end
+        end
+        tgz = StringIO.new(request.run.body)
+        raise ArTTY::Error::FailedToDownload.new if (tgz.eof?)
+
+        # Extract new art
+        tar = Minitar::Input.new(Zlib::GzipReader.new(tgz))
+        tar.each do |entry|
+            case entry.name
+            when /.+\.json\s*$/
+                entry.name.gsub!(/^.*generated\//, "")
+                entry.prefix.gsub!(/^.*generated\//, "")
+                tar.extract_entry(new, entry)
+            end
+        end
+
+        # Move new art to final location
+        old = Pathname.new("#{@cachedir}/#{@imagesdir}").expand_path
+        if (new.exist?)
+            FileUtils.rm_rf(old) if (old.exist?)
+            FileUtils.mv(new, old)
+        end
+    rescue Interrupt
+        raise
+    ensure
+        # Cleanup
+        FileUtils.rm_rf(new) if (new && new.exist?)
+    end
+    private :download_and_extract
+
+    def get_file_for(name)
+        return get_art[name]["file"]
+    end
+
+    def get_height_for(name)
+        return get_art[name]["height"]
+    end
+
+    def get_width_for(name)
+        return get_art[name]["width"]
+    end
+
+    def initialize(file = nil)
+        file ||= "#{ENV["HOME"]}/.cache/arTTY/art.json"
+        @defaults = {
+            "art" => Hash.new,
+            "version" => ArTTY.current_version
+        }
+
+        @cachefile = Pathname.new(file).expand_path
+        @cachedir = @cachefile.dirname
+        @imagesdir = "arTTY_images"
+        super(@cachefile, false)
+
+        refresh if (get_version != ArTTY.current_version)
+    end
+
+    def refresh(download = false)
+        download_and_extract if (download)
+
+        set_art(Hash.new)
+        set_version(ArTTY.current_version)
+
+        [
+            "#{@cachedir}/#{@imagesdir}",
+            "#{ENV["HOME"]}/.config/arTTY/#{@imagesdir}"
+        ].each do |dir|
+            Dir["#{dir}/**/*.json"].each do |file|
+                img = ArTTY::Art.new(file)
+                get_art[img.name] = {
+                    "file" => file,
+                    "height" => img.height,
+                    "width" => img.width
+                }
+            end
+        end
+
+        save
+    end
+end

data/lib/arTTY/error.rb

@@ -0,0 +1,9 @@
+class ArTTY::Error < RuntimeError
+end
+
+require "arTTY/error/art_not_found"
+require "arTTY/error/failed_to_download"
+require "arTTY/error/image_magick_not_found"
+require "arTTY/error/image_named_improperly"
+require "arTTY/error/image_not_found"
+require "arTTY/error/no_pixel_data_found"

data/lib/arTTY/error/art_not_found.rb

@@ -0,0 +1,6 @@
+class ArTTY::Error::ArtNotFound < ArTTY::Error
+    def initialize(art = nil)
+        super("Art not found: #{art}") if (art && !art.empty?)
+        super("Art not found") if (art.nil?)
+    end
+end

data/lib/arTTY/error/failed_to_download.rb

@@ -0,0 +1,5 @@
+class ArTTY::Error::FailedToDownload < ArTTY::Error
+    def initialize
+        super("Failed to download arTTY_images.tgz")
+    end
+end

data/lib/arTTY/error/image_magick_not_found.rb

@@ -0,0 +1,5 @@
+class ArTTY::Error::ImageMagickNotFound < ArTTY::Error
+    def initialize
+        super("ImageMagick not found")
+    end
+end

data/lib/arTTY/error/image_named_improperly.rb

@@ -0,0 +1,6 @@
+class ArTTY::Error::ImageNamedImproperly < ArTTY::Error
+    def initialize(fn = nil)
+        super("Image named wrong: #{fn}") if (fn && !fn.empty?)
+        super("Image named wrong") if (fn.nil?)
+    end
+end

data/lib/arTTY/error/image_not_found.rb

@@ -0,0 +1,6 @@
+class ArTTY::Error::ImageNotFound < ArTTY::Error
+    def initialize(image = nil)
+        super("Image not found: #{image}") if (image && !image.empty?)
+        super("Image not found") if (image.nil?)
+    end
+end

data/lib/arTTY/error/no_pixel_data_found.rb

@@ -0,0 +1,5 @@
+class ArTTY::Error::NoPixelDataFound < ArTTY::Error
+    def initialize
+        super("No pixel data was found")
+    end
+end

data/lib/arTTY/generator.rb

@@ -0,0 +1,156 @@
+require "scoobydoo"
+
+class ArTTY::Generator
+    def generate(image, name = nil)
+        file = Pathname.new(image).expand_path
+        pixels = nil
+
+        if (!file.exist?)
+            raise ArTTY::Error::ImageNotFound.new(file.to_s)
+        end
+
+        file.to_s.match(%r{([^/]+?)(_(\d+)x(\d+))?\.}) do |m|
+            name = m[1] if (name.nil? || name.empty?)
+            width = m[3].nil? ? nil : m[3].to_i
+            height = m[4].nil? ? nil : m[4].to_i
+            pixels = get_pixel_info(file, width, height)
+        end
+
+        raise ArTTY::Error::NoPixelDataFound.new if (pixels.empty?)
+
+        legend = generate_color_map(pixels)
+        return generate_json(name, pixels, legend)
+    end
+
+    def generate_color_map(pixels)
+        legend = {"" => " "}
+
+        colors = pixels.flatten.uniq.sort.delete_if(&:empty?)
+        if (colors.length > @keys.length)
+            raise Exception.new(
+                "Too many colors: #{colors.length} > #{@keys.length}"
+            )
+        end
+
+        colors.zip(@keys) do |map|
+            legend[map[0]] = map[1]
+        end
+
+        return legend
+    end
+    private :generate_color_map
+
+    def generate_json(name, pixels, legend)
+        ret = [
+            "{",
+            "  \"height\": #{(pixels.length + 1) / 2},",
+            "  \"legend\": {",
+        ]
+
+        stop = legend.length - 1
+        legend.each_with_index do |map, i|
+            next if (i == 0)
+            clr = map[0]
+            key = map[1]
+            ret.push("    \"#{key}\": \"#{clr}\"#{"," if (i < stop)}")
+        end
+
+        ret.concat([
+            "  },",
+            "  \"name\": \"#{name}\",",
+            "  \"pixels\": ["
+        ])
+
+        stop = pixels.length - 1
+        pixels.each_with_index do |row, i|
+            line = row.map do |color|
+                legend[color]
+            end.join
+            ret.push("    \"#{line}\"#{"," if (i < stop)}")
+        end
+
+        ret.concat([
+            "  ],",
+            "  \"width\": #{pixels.map(&:length).max}",
+            "}"
+        ])
+
+        return ret
+    end
+    private :generate_json
+
+    def get_pixel_info(file, width = nil, height = nil)
+        h_increment = w_increment = 1
+        h_total = w_total = 0
+        offset = 0
+        pixels = Array.new
+
+        %x(convert #{file} txt:- 2>/dev/null).each_line do |line|
+            case line
+            when /^#\s*ImageMagick.+/
+                if (height && width)
+                    line.match(/:\s+([0-9]+),([0-9]+),/) do |m|
+                        h_total = m[2].to_i
+                        h_increment = h_total.to_f / height.to_f
+                        offset = (h_increment / 2).to_i
+                        w_total = m[1].to_i
+                        w_increment = w_total.to_f / width.to_f
+                    end
+                end
+            else
+                line.match(/^([0-9]+),([0-9]+):\s+\S+\s+(\S+)/) do |m|
+                    if (
+                        ((m[2].to_i % h_increment).to_i == offset) &&
+                        ((m[1].to_i % w_increment).to_i == offset)
+                    )
+                        c = (m[1].to_i / w_increment).to_i
+                        r = (m[2].to_i / h_increment).to_i
+
+                        clr = ""
+                        code = "[A-Fa-f0-9]{6}"
+                        vis = "[A-Fa-f4-9][A-Fa-f0-9]"
+
+                        m[3].match(/^#?(#{code})(#{vis})?$/) do |hex|
+                            clr = Hilighter.hex_to_x256(hex[1])
+                        end
+
+                        pixels.push(Array.new) if (pixels.length <= r)
+                        pixels[r].push(clr) if (pixels[r].length <= c)
+                    end
+                end
+            end
+        end
+
+        return pixels
+    end
+    private :get_pixel_info
+
+    def initialize
+        if (ScoobyDoo.where_are_you("convert").nil?)
+            raise ArTTY::Error::ImageMagickNotFound.new
+        end
+
+        @keys = Array.new
+        key = "!"
+        while key != "~" do
+            @keys.push(key.clone)
+            case key
+            when "!"
+                key = "#"
+            when "9"
+                key = ":"
+            when "Z"
+                key = "["
+            when "["
+                key = "]"
+            when "_"
+                key = "a"
+            when "z"
+                key = "{"
+            else
+                key.next!
+            end
+        end
+        @keys.push("~")
+    end
+end