nonsense 1.0.0

data/lib/nonsense.rb

@@ -0,0 +1,133 @@
+require 'yaml'
+
+class Nonsense
+  VERSION = '1.0.0'
+  
+  attr_accessor :template, :data, :state, :debug
+  
+  module Data
+    DEFAULT = YAML.load_file(File.dirname(__FILE__) + '/default.yml')
+  end
+    
+  def initialize(template, data = {})
+    @template = template
+    @data     = Data::DEFAULT.merge(data)
+    @state    = {}
+  end
+  
+  def result
+    parse_template self.template
+  end
+  
+  def parse_template(t) #:nodoc:
+    return '' unless t
+    t = t.dup
+    copy = t.gsub!(/\{[^}]+\}/) { |tag| parse tag[1..-2] }
+    copy ? copy : t
+  end
+  
+  def parse(tag) #:nodoc:
+    return '' unless tag
+    parse_case = nil
+    parsed = case tag
+    when /^#(\d+)-(\d+)$/            then number_in_range($1.to_i, $2.to_i).to_s
+    when /^\@([^|]+)$/               then format_current_time($1)
+    when /^\@(.*?)\|\$(\w+)\|(\d+)$/ then format_assigned_time($1, $2, $3)
+    when /^\@(.*?)\|(\d+)\|(\d+)$/   then format_current_time($1, $2.to_i, $3.to_i)
+    when /^\[(.*)$/                  then choose_from_list($1)
+    when /^\\(.*)$/                  then embed_character($1)
+    when /^(.*?):=(.*)$/             then assign_command($1, $2)
+    when /^(.*?)=(.*)$/              then assign_literal($1, $2)
+    when /^[\$<](.*)$/
+      parse_case = $1
+      retrieve_assigned($1)
+    when /^(.*?)#(\d+)-(\d+)$/
+      parse_case = $1
+      retrieve_multiple($1, $2.to_i, $3.to_i)
+    else
+      parse_case = tag
+      retrieve_data tag.gsub(/\W/, '')
+    end
+    
+    parsed = parse_template(parsed)
+
+    parsed = adjust_case parsed, parse_case
+  end
+  
+  def number_in_range(low, high) #:nodoc:
+    rand(high - low).to_i + low
+  end
+  
+  def format_current_time(format, low = nil, high = nil) #:nodoc:
+    diff = (low && high) ? number_in_range(low, high) : 0
+    (Time.now - diff).strftime format
+  end
+  
+  def format_assigned_time(format, key, high) #:nodoc:
+    existing_time = state[key.downcase]
+    elapsed = rand(high)
+    time = if existing_time
+      existing_time - elapsed
+    else
+      Time.now - elapsed
+    end
+    state[key] = time
+    time.strftime format
+  end
+  
+  def choose_from_list(list) #:nodoc:
+    items = list.split('|')
+    choice = if items.size > 1
+      items[rand(items.size)]       # pick one of the elements
+    else
+      rand(2) == 0 ? items[0] : ''  # pick it or pick nothing
+    end
+  end
+  
+  def embed_character(character)  #:nodoc:
+    case character
+    when 'n'    then "\n"               # newline
+    when '0'    then ''                 # null
+    when 'L'    then '{'                # left bracket
+    when 'R'    then '}'                # right bracket
+    when /^\d+/ then character.to_i.chr # ASCII code in decimal
+    else ''                             # not in list
+    end
+  end
+  
+  def assign_command(key, command) #:nodoc:
+    state[key.downcase] = parse(command)
+    ''
+  end
+  
+  def assign_literal(key, value)  #:nodoc:
+    state[key.downcase] = value
+    ''
+  end
+  
+  def retrieve_assigned(key)  #:nodoc:
+    value = state[key.downcase]
+    value ? value : parse(key)
+  end
+  
+  def retrieve_multiple(key, low, high)  #:nodoc:
+    n = number_in_range(low, high)
+    return '' if n == 0
+    (1..n).collect { |i| parse(key) }.join(" ")
+  end
+  
+  def retrieve_data(key)  #:nodoc:
+    return '' unless key
+    choices = data[key.downcase]
+    choices ? choices[rand(choices.size)] : ''
+  end
+  
+  def adjust_case(parsed, parse_case)  #:nodoc:
+    case parse_case
+    when /^[A-Z0-9]+$/    then parsed.upcase
+    when /^[a-z0-9]+$/    then parsed.downcase
+    when /^\^/            then parsed.capitalize
+    else                       parsed
+    end
+  end
+end

data/test/test_nonsense.rb

@@ -0,0 +1,241 @@
+require File.dirname(__FILE__) + "/../lib/nonsense"
+require 'rubygems'
+require 'test/spec'
+require 'mocha'
+require 'time'
+
+describe 'nonsense' do
+  attr_accessor :nonsense
+  
+  before do
+    @nonsense = Nonsense.new(:template)
+  end
+  
+  it "should parse the template to get the result" do
+    nonsense.expects(:parse_template).with(:template)
+    nonsense.result
+  end
+  
+  it "should parse a template" do
+    nonsense.expects(:parse).with('template')
+    nonsense.parse_template "{template}"
+  end
+  
+  it "should parse a number range" do
+    tag = "#2-5"
+    nonsense.expects(:number_in_range).with(2, 5)
+    
+    nonsense.parse tag
+  end
+  
+  it "should pick a random number in a range" do
+    nonsense.expects(:rand).with(3).returns(2)
+    number = nonsense.number_in_range(2, 5)
+    
+    number.should == 4
+  end
+  
+  it "should parse a time" do
+    tag = "@%A"
+    nonsense.expects(:format_current_time).with('%A')
+    
+    nonsense.parse tag    
+  end
+  
+  it "formats current time" do
+    time = Time.parse('2008-05-01 19:00')
+    Time.expects(:now).returns(time)
+    
+    nonsense.format_current_time('%Y').should == "2008"
+  end
+  
+  it "should parse a time and range" do
+    tag = "@%A|0|86400"
+    nonsense.expects(:format_current_time).with('%A', 0, 86400)
+    
+    nonsense.parse tag    
+  end
+  
+  it "formats current time less a random value in range" do
+    time = Time.parse('2008-05-01 19:00')
+    Time.expects(:now).returns(time)
+    nonsense.expects(:number_in_range).with(0, 86400).returns(0)
+    
+    nonsense.format_current_time('%A', 0, 86400).should == "Thursday"
+  end
+  
+  it "should parse a time and store in key" do
+    tag = "@%A|$key|86400"
+    nonsense.expects(:format_assigned_time).with('%A', 'key', '86400')
+    
+    nonsense.parse tag    
+  end
+    
+  it "stores time for later use" do
+    time = Time.parse('2008-05-01 19:00')
+    Time.expects(:now).returns(time)
+    nonsense.expects(:rand).returns(0)
+    
+    nonsense.format_assigned_time('%A', 'key', 0)
+    nonsense.state['key'].should == time
+  end
+
+  it "retrieves time from earlier" do
+    time = Time.parse('2008-05-01 19:00')
+    nonsense.state['key'] = time
+    nonsense.expects(:rand).returns(0)
+    
+    nonsense.format_assigned_time('%A', 'key', 0)
+    nonsense.state['key'].should == time
+  end
+    
+  it "should parse list of values" do
+    tag = "[list of values"
+    nonsense.expects(:choose_from_list).with('list of values')
+    
+    nonsense.parse tag    
+  end
+  
+  it "returns a random value from list of multiple values" do
+    nonsense.expects(:rand).returns(1)
+    nonsense.choose_from_list("item 1|item 2|item 3").should == "item 2"
+  end
+  
+  it "randomly returns value when list has one item" do
+    nonsense.expects(:rand).returns(0)
+    nonsense.choose_from_list("item 1").should == "item 1"
+  end
+  
+  it "randomly returns nothing when list has one item" do
+    nonsense.expects(:rand).returns(1)
+    nonsense.choose_from_list("item 1").should == ''
+  end
+  
+  it "should parse special characters" do
+    tag = '\n'
+    nonsense.expects(:embed_character).with('n')
+    
+    nonsense.parse tag
+  end
+  
+  it "returns newline from embeded n" do
+    nonsense.embed_character('n').should == "\n"
+  end
+  
+  it "returns nothing from embedded 0" do
+    nonsense.embed_character('0').should == ''
+  end
+  
+  it "returns left bracket from embedded L" do
+    nonsense.embed_character('L').should == '{'
+  end
+
+  it "returns right bracket from embedded R" do
+    nonsense.embed_character('R').should == '}'
+  end
+  
+  it "returns ASCII from embedded int" do
+    nonsense.embed_character('65').should == 'A'
+  end
+
+  it "returns nothing for unknown char" do
+    nonsense.embed_character('z').should == ''
+  end
+  
+  it "assigns a command for later use" do
+    tag = "key:=command"
+    nonsense.expects(:assign_command).with('key', 'command')
+    nonsense.parse tag
+  end
+  
+  it "returns nothing when assigning a command" do
+    nonsense.assign_command('key', 'command').should == ''
+  end
+  
+  it "parses the command for later use" do
+    nonsense.expects(:parse).returns('result')
+    nonsense.assign_command('key', 'command')
+    nonsense.state['key'].should == 'result'
+  end
+  
+  it "assigns a command for later use" do
+    tag = "key=literal"
+    nonsense.expects(:assign_literal).with('key', 'literal')
+    nonsense.parse tag
+  end
+  
+  it "returns nothing when assigning a literal" do
+    nonsense.assign_literal('key', 'literal').should == ''
+  end
+  
+  it "stores the command for later use" do
+    nonsense.assign_literal('key', 'literal')
+    nonsense.state['key'].should == 'literal'
+  end
+  
+  it "retrieves previously assigned earlier" do
+    tag = "$key"
+    nonsense.expects(:retrieve_assigned).with('key')
+    nonsense.parse tag
+  end
+  
+  it "retrieves the assigned value by the key" do
+    nonsense.state['key'] = 'value'
+    nonsense.retrieve_assigned('key').should == 'value'    
+  end
+  
+  it "retrieves value multiple times" do
+    tag = 'tag#1-4'
+    nonsense.expects(:retrieve_multiple).with('tag', 1, 4)
+    nonsense.parse tag
+  end
+  
+  it "should retrieve parsed value of tag a random number of times" do
+    nonsense.expects(:number_in_range).with(1, 4).returns(2)
+    nonsense.expects(:parse).times(2)
+    nonsense.retrieve_multiple('tag', 1, 4)
+  end
+
+  it "should retrieve parsed value of tag a random number of times" do
+    nonsense.expects(:number_in_range).with(1, 4).returns(2)
+    nonsense.stubs(:parse).returns('result')
+    nonsense.retrieve_multiple('tag', 1, 4).should == "result result"
+  end
+  
+  it "retrieves previously assigned earlier" do
+    tag = "tag"
+    nonsense.expects(:retrieve_data).with('tag')
+    nonsense.parse tag
+  end
+  
+  it "returns nothing when retrieving data with no key" do
+    nonsense.retrieve_data(nil).should == ''
+  end
+  
+  it "returns nothing when there is not data that matches key" do
+    nonsense.retrieve_data('nothing').should == ''
+  end
+  
+  it "returns random choices that matches key" do
+    nonsense.data['key'] = ['choice 1', 'choice 2']
+    nonsense.expects(:rand).returns(1)
+    nonsense.retrieve_data('key').should == 'choice 2'
+  end
+  
+  it "upcases the result when key is all caps" do
+    nonsense.adjust_case('result', 'KEY').should == 'RESULT'
+  end
+
+  it "downcases the result when key is all lowercase" do
+    nonsense.adjust_case('Result', 'key').should == 'result'
+  end
+  
+  it "capitalizes the result when key starts with ^" do
+    nonsense.adjust_case('result', '^Key').should == 'Result'
+  end
+  
+  it "returns the result when the case is not recognize" do
+    nonsense.adjust_case('RESult', 'kEy').should == 'RESult'    
+  end
+  
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: nonsense
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Geoffrey Dagley
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-25 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.6.0
+    version: 
+description: "port of http://nonsense.sourceforge.net/  Taken from Nonsense website:  Nonsense generates random (and sometimes humorous)  text from datafiles and templates using a very simple, recursive grammar. It's  like having a million monkeys sitting in front of a million typewriters, without  having to feed or clean up after them."
+email: 
+- gdagley@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- LICENSE.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- LICENSE.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/default.yml
+- lib/nonsense.rb
+- test/test_nonsense.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: nonsense
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: "port of http://nonsense.sourceforge.net/  Taken from Nonsense website:  Nonsense generates random (and sometimes humorous)  text from datafiles and templates using a very simple, recursive grammar"
+test_files: 
+- test/test_nonsense.rb