more examples

Author: monkstone

advanced_data/Rakefile

@@ -0,0 +1,30 @@
+# Simple demo Rakefile to autorun samples in current directory
+# adjust path to jruby executable, and or opts as required
+
+SAMPLES_DIR = './'
+
+desc 'run demo'
+task default: [:demo]
+
+desc 'demo'
+task :demo do
+  samples_list.shuffle.each { |sample| run_sample sample }
+end
+
+def samples_list
+  files = []
+  Dir.chdir(SAMPLES_DIR)
+  Dir.glob('*.rb').each do |file|
+    files << File.join(SAMPLES_DIR, file)
+  end
+  files
+end
+
+def run_sample(sample_name)
+  puts "Running #{sample_name}...quit to run next sample"
+  open("|jruby #{sample_name}", 'r') do |io|
+    while l = io.gets
+      puts(l.chop)
+    end
+  end
+end

advanced_data/counting_words.rb

@@ -0,0 +1,80 @@
+#!/usr/bin/env jruby -w
+require 'picrate'
+# A helper to keep track of word frequency.
+class Word
+  attr_accessor :word
+  attr_reader :count
+  def initialize(word)
+    @word = word
+    @count = 1
+  end
+
+  def increment
+    @count += 1
+  end
+end
+
+################################
+# This sketch is translated from a vanilla processing sketch by Daniel Schiffman
+# that was designed to demonstrate the use IntHash class in vanilla processing.
+# Similar results can easily be obtained using more idiomatic ruby. Here IntHash
+# has been replaced by a String => Word hash (as used in a Schiffman prototype).
+# Read about concordance here:-
+# http://en.wikipedia.org/wiki/Concordance_(publishing)
+################################
+class CountingWords < Processing::App
+  attr_reader :concordance, :lines, :tokens, :counter
+
+  def setup
+    sketch_title 'Counting words'
+    @counter = 0
+    @concordance = {}
+    # Open a file, read its contents, and 'scan' for words using a regex.
+    # Include words with apostrophe eg Harker's
+    @tokens = File.read(data_path('dracula.txt')).scan(/[\w'-]+/)
+    text_font(create_font('Georgia', 24))
+  end
+
+  def draw
+    background 51
+    fill 255
+    s = tokens[counter] == 'I' ? tokens[counter] : tokens[counter].downcase
+    @counter = (counter + 1) % tokens.length
+    if concordance.key? s
+      # Get the word object and increase the count
+      # We access objects from a Hash via its key, the String
+      concordance[s].increment # increment word count
+    else
+      # Otherwise make a new Word instance and add it to
+      # the Hash using the word String as the key
+      concordance[s] = Word.new(s)
+    end
+    # x and y will be used to locate each word
+    x = 0
+    y = height - 10
+    # Look at each word
+    concordance.values.each do |w|
+      # Only display words that appear 3 times
+      if w.count > 3 # access word count
+        # The size is the count
+        fsize = constrain(w.count, 0, 100)
+        text_size(fsize)
+        text(w.word, x, y)
+        # Move along the x-axis
+        x += text_width(w.word) + 1
+      end
+      # If x gets to the end, move y
+      # If y == 0 we are done
+      no_loop if y.zero?
+      next unless x >= width
+      x = 0
+      y = y < 0 ? 0 : y - 100
+    end
+  end
+
+  def settings
+    size 640, 360
+  end
+end
+
+CountingWords.new