wordgraph 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a0039b72e4ecc4059c72c226860382a4c76ce898b170b8db2c0e31c9ae854dc
-  data.tar.gz: 05a984e25ff21ddf8620dda415138e8763aeb26f60344eafd9cd9a6d7622a889
+  metadata.gz: 45813d9103ca02b5238dbfe12b4aa656da441dcbe66be0fac9e8e46f81b9744a
+  data.tar.gz: 21516d98f4aea705561d34c8a23835dc23df1d575369a0bc4a7cd225a863a7b3
 SHA512:
-  metadata.gz: bb4bba4db23d7bf136e4d2868923a1b7e6ffd3e8e3e80b1e8cccd3cb413b77df3ff671242592774b862b8daa925641a3325fdfddf345b6c66934372b3f8fa6f8
-  data.tar.gz: 6f61da0501b80dcd2c799f21da041012533301f1a7f9ac9afd3cf5f96250fba29a153fc72a08b7ffbc393f0a3d93f2b728ad6afe70d9ba55a49689fc358effe9
+  metadata.gz: 2170ee77edca8125943b3dac61aee6d0fed2a753b7d3456a7acadc5dd4cd61711663b8fc7c833f329eac5d3db8e9d1f83b2973f3e62bb8a29ad5a011e30df29b
+  data.tar.gz: b69f1a188c603e887e145720fd123db9397cb4bca03b6dbb2104b947c5ef351b175f6efd270cf8a7658b22fce68ace1f41194a5069f8079000269e529a23bdf9

data/lib/wordgraph/cli.rb

@@ -15,19 +15,46 @@ module Wordgraph
         opts.separator ""
         opts.separator "Specific options:"
 
+        opts.on("-h", "--help", "Prints this help") do
+          puts opts
+          puts args
+        end
+        
         opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
           @options[:verbose] = v
         end
 
-        opts.on("-h", "--help", "Prints this help") do
-          puts opts
-          puts args
+        opts.on("-o=STRING", "--output-directory=STRING", "Directory to output files", String) do |dir|
+          # Supports /mnt/[:drive_letter]/[:directory]
+          @options[:output_directory] = dir
+        end
+
+        opts.on("-n=STRING", "--name=STRING", "Output file name", String) do |name|
+          @options[:name] = name
+        end
+
+        opts.on("--[no-]overwrite", "Overwrite output file") do |overwrite|
+          @options[:overwrite] = overwrite
+        end
+
+        opts.on("-s=INTEGER", "--seed=INTEGER", "Deterministic word order", Integer) do |seed|
+          @options[:seed] = seed
+        end
+
+        opts.on("-m=INTEGER", "--nlargest=INTEGER", "Maximum amount of words in graph", Integer) do |nlargest|
+          @options[:nlargest] = nlargest
+        end
+
+        opts.on("--font=STRING", ["times", "georgia", "garamond", "arial", 
+                "helvetica", "verdana", "courier", "cursive", "papyrus"], 
+                "Use a web safe font", String) do |font|
+          @options[:font] = font
         end
       end
 
       begin
         files = parser.parse!(args)
-        core = Core.new(files, @options[:verbose])
+        core = Core.new(files, **@options)
         core.process
       rescue OptionParser::InvalidOption => e
         puts e.message

data/lib/wordgraph/core.rb

@@ -1,28 +1,178 @@
+require_relative "mathwg"
+
 module Wordgraph
   class Core
-    def initialize(files, verbose=false)
+    def initialize(files, verbose: false, output_directory: Dir.pwd, name: "wordgraph", 
+                    overwrite: false, seed: nil, nlargest: nil, font: "times")
       @files = files
       @verbose = verbose
+      @output_directory = output_directory
+      @name = name
+      @overwrite = overwrite
+      @seed = seed
+      @nlargest = nlargest
+      @max_size = 20
+      @min_font_size = 12;
+      @max_font_size = 48;
+      @font = font.downcase
+      if @verbose
+        puts "Proceeding with settings:"
+        self.instance_variables.each do |var|
+          puts "#{var}: #{self.instance_variable_get(var) || false}"
+        end  
+      end
     end
 
-    def process
-      puts "Processing #{@files}" if @verbose
+    def tokenize(word)
+      # Lowercase
+      word = word.downcase
+      # Strip trailing punctuation at word start
+      word = word.sub(/^[\.,;:!?'"`(\[\{<]+/, "")
+      # Strip trailing punctuation at word end
+      word = word.sub(/[\.,;:!?'"`)\]\}>]+$/, "")
+      return word
+    end
+
+    def generate_cloud(tokens)
+      # https://en.wikipedia.org/wiki/Tag_cloud
+      raise ArgumentError, "Empty tokens map" unless tokens.length > 0
+      # Linear normalization
+      # TODO: logarithmic function for larger texts
+      min_count = tokens.values.min
+      max_count = tokens.values.max
+      max_sub_min = [max_count - min_count, 1].max
+      tokens = tokens.max_by(@nlargest) { |v| v }.to_h if @nlargest
+      tokens.each do |token, count|
+        size = count <= min_count ? 
+                1 : 
+                ((@max_size * (count - min_count)) / max_sub_min).ceil 
+        tokens[token] = {
+          count: count,
+          size: size
+        }
+      end
+      self.write_html(tokens)
+    end
 
-      @files.each do |f|
+    def get_path
+      raise ArgumentError, "Output directory: #{@output_directory} not found" if !Dir.exist?(@output_directory)
+      file_name = File.basename(@name) + ".html"
+      out = File.join(@output_directory, file_name)
+      puts "Creating file: #{out}"
+      stop_exists = File.exist?(out) && !@overwrite
+      raise ArgumentError, "Output file already exists, either overwrite or change the name" if stop_exists
+      return out
+    end
+
+    def remap(from_min, from_max, to_min, to_max, value)
+      def lerp(a, b, t)
+        return (1 - t) * a + b * t
+      end
+      def invLerp(a, b, v)
+        return a === b ? 0 : (v - a).to_f / (b - a)
+      end
+      return lerp(to_min, to_max, invLerp(from_min, from_max, value))
+    end
+
+    def write_html(tokens)
+      out = self.get_path
+      File.open(out, File::RDWR | File::CREAT) do |f|
+        f.flock(File::LOCK_EX)
+        f.truncate(0)
+        document_setup = <<~HTML
+          <!DOCTYPE html>
+          <html lang="en">
+          <head>
+              <meta charset="UTF-8">
+              <meta name="viewport" content="width=device-width, initial-scale=1.0">
+              <title>wordgraph</title>
+          </head>
+          <body>
+            #{tokens.to_a.shuffle(random: Random.new(*@seed)).map { |k, v|
+              fs = remap(1, @max_size, @min_font_size, @max_font_size, v[:size]).floor
+              title = "#{v[:count].to_s} occurrence #{(v[:count] > 1 ) ? "s" : ""}"
+              <<~HTML.strip
+                <span
+                    title='#{title}'
+                    style='font-size: #{fs}px;'
+                    aria-role='listitem'
+                    aria-label='#{title}'>#{k}</span>
+              HTML
+            }.join("\n\s\s")}
+          </body>
+          <style>
+            body {
+              display: flex;
+              flex-wrap: wrap;
+              gap: 8px;
+              justify-content: center;
+              background-color: #000;
+              color: #FFFFFF;
+              line-height: 1.6;
+              margin: 0;
+              padding: 20px;
+              font-family: #{@font};
+            }
+            span {
+              display: inline-block;
+              margin: 2px 6px;
+              padding: 4px 12px;
+              border-radius: 4px;
+            }
+          </style>
+          </html>
+        HTML
+        f.write(document_setup)
+      end
+      puts File.read(out) if @verbose
+    end
+
+    def process_lines(lines)
+      count = {}
+      count.default = 0
+      lines.each do |line|
+        line.split do |word|
+          tokenized = self.tokenize(word)
+          count[tokenized] += 1
+        end
+      end
+      begin
+        puts count if @verbose
+        self.generate_cloud(count)
+      rescue ArgumentError => e
+        raise e
+      else
+        puts "Succesfully finished processing" if @verbose
+      end
+      return count
+    end
+
+    def process_text(file)
+      puts "Processing txt file #{file}" if @verbose
+      lines = IO.readlines(file)
+      return self.process_lines(lines)
+    end
+
+    def process_docx(file)
+      require "zip"
+      puts "Processing docx file #{file}" if @verbose
+      binary = File.open(file, 'rb') { |f| f.read }
+      Zip::File.open_buffer(binary) do |zip|
+        doc = zip.find { |entry| entry.name == 'word/document.xml'}
+        text = doc.get_input_stream.read
+        # TODO: check if styling is supported
+        lines = text.scan(/(?<=<w:t>).+?(?=<\/w:t>)/)
+        return self.process_lines(lines)
+      end
+    end
+
+    def process
+      Array(@files).each do |f|
         case f
         when /\.(txt|text)\z/i
-          puts "Processing txt file #{f}"
-          count = {}
-          count.default = 0
-          IO.foreach(f) do |line|
-            line.split do |word|
-              count[word] += 1
-            end
-          end
-          puts count
-          puts "Succesfully finished processing"
+          return self.process_text(f)
         when /\.docx\z/i
-          raise ArgumentError, "docx not supported yet."
+          return self.process_docx(f)
         else
           raise ArgumentError, "File type not supported."
         end

data/lib/wordgraph/mathwg.rb

@@ -0,0 +1,15 @@
+module Wordgraph
+  module Mathwg
+    def lerp(a, b, t)
+      (1 - t) * a + b * t
+    end
+
+    def invLerp(a, b, v)
+      a === b ? 0 : (v - a).to_f / (b - a)
+    end
+    
+    def remap(from_min, from_max, to_min, to_max, value)
+      lerp(to_min, to_max, invLerp(from_min, from_max, value))
+    end
+  end
+end

data/lib/wordgraph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wordgraph
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: wordgraph
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - marm00
 bindir: bin
 cert_chain: []
-date: 2025-01-19 00:00:00.000000000 Z
+date: 2025-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: optparse
@@ -39,6 +39,7 @@ files:
 - lib/wordgraph.rb
 - lib/wordgraph/cli.rb
 - lib/wordgraph/core.rb
+- lib/wordgraph/mathwg.rb
 - lib/wordgraph/version.rb
 - wordgraph.gemspec
 homepage: https://github.com/marm00/wordgraph