kotodama 0.0.3

data/bin/wordgen

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+require 'kotodama'
+
+flags = []
+files = []
+starting_rule = nil
+starting_change = nil
+number = 1
+ARGV.each do |n|
+	if n[0] == '-'
+		case n[1]
+		when 'r'
+			starting_rule = n[2..-1]
+		when 'c'
+			starting_change = n[2..-1]
+		else
+			flags |= n[1..-1].split
+		end
+	elsif n.match /\A\d+\Z/
+		number = n.to_i
+	else
+		files << n
+	end
+end
+
+if files.length == 1
+	File.open files[0] do |file|
+		result = Kotodama::Parser.new.parse file
+		if result.parsed?
+			lang = result.result
+			if flags.member? 'u'
+				trials = []
+				until trials.length == number
+					trials |= lang.generate
+				end
+				puts trials
+			else
+				number.times { puts lang.generate }
+			end
+		else
+			flags.member?('v') ? result.backtrace : STDERR.puts(result.error_message)
+		end
+	end
+elsif files.length == 2
+	File.open files[0] do |file|
+		result = Kotodama::Parser.new.parse file
+		if result.parsed?
+			lang = result.result
+			File.open files[1] do |file2|
+				puts lang.apply_to file2.to_a.collect {|n| n.chomp }
+			end
+		else
+			flags.member?('v') ? result.backtrace : STDERR.puts(result.error_message)
+		end
+	end
+else
+	STDERR.puts "wrong number of arguments (#{files.length} for 2)"
+end

data/lib/kotodama.rb

@@ -0,0 +1,23 @@
+require 'pathname'
+require 'kaiseki'
+
+module Kotodama
+	VERSION = '0.0.3'
+end
+
+dir_path = Pathname.new(__FILE__).realpath.dirname
+
+[
+	'kotodama/word',
+	'kotodama/language',
+	'kotodama/type',
+	'kotodama/rule',
+	'kotodama/change',
+	'kotodama/change_list',
+	
+	'kotodama/array',
+	'kotodama/string',
+	'kotodama/parser',
+	].each do |path|
+	require dir_path + path
+end

data/lib/kotodama/array.rb

@@ -0,0 +1,22 @@
+class Array
+	def random weights = nil
+		if weights
+			if weights.length == self.length
+				max_weight = 0
+				weights.each {|n| max_weight += n }
+				target_weight = rand max_weight
+				index = 0
+				index_weight = weights[index]
+				while index_weight <= target_weight
+					index += 1
+					index_weight += weights[index]
+				end
+				self[index]
+			else
+				raise "Array length and weights length not equal (#{self.length} and #{weights.length})"
+			end
+		else
+			self[rand(self.length)]
+		end
+	end
+end

data/lib/kotodama/change.rb

@@ -0,0 +1,103 @@
+module Kotodama
+	class Change
+		def initialize action, target, env
+			@action = action
+			@target = target
+			@env = env
+		end
+		
+		def apply_to word, options = {}
+			unless word.is_a? Word
+				word = word.to_word
+			end
+			i = 0
+			while i < word.length
+				if check_environment word, i, options
+					case @action
+					when :insert
+						@target.length.times do |i2|
+							word.insert i + i2, @target[i2]
+						end
+						i += @target.length - 1
+					when :delete
+						catch :fail do
+							@target.length.times do |i2|
+								if options[:lang].types.key? @target[i2]
+									throw :fail unless options[:lang].types[@target[i2]].has? word[i + i2]
+								else
+									throw :fail unless word[i + i2] == @target[i2]
+								end
+							end
+							@target.each { word.delete_at i }
+						end
+					when :transform
+						catch :fail do
+							insertion_string = []
+							@target[0].length.times do |i2|
+								if options[:lang].types.key? @target[0][i2]
+									if options[:lang].types[@target[0][i2]].has?(word[i + i2])
+										insertion_string << options[:lang].types[@target[0][i2]].symbols.find_index(word[i + i2])
+									else
+										throw :fail
+									end
+								else
+									throw :fail unless word[i + i2] == @target[0][i2]
+								end
+							end
+							@target[0].each { word.delete_at i }
+							insertion_string.reverse!
+							@target[1].length.times do |i2|
+								if options[:lang].types.key? @target[1][i2]
+									raise "Wrong number of type transformations" unless insertion_string.last
+									word.insert i + i2, options[:lang].types[@target[1][i2]].symbols[insertion_string.pop]
+								else
+									word.insert i + i2, @target[1][i2]
+								end
+							end
+						end
+					end
+				end
+				i += 1
+			end
+		end
+		
+		def check_environment word, index, options = {}
+			if @env
+				catch :fail do
+					@env[1].length.times do |i|
+						if @action == :insert
+							next_n = index + i
+						else
+							next_n = index + @target[0].length + i
+						end
+						if @env[1][i] == '#'
+							throw :fail unless index + 1 + i >= word.length
+						elsif options[:lang].types.key? @env[1][i]
+							throw :fail if next_n >= word.length
+							throw :fail unless options[:lang].types[@env[1][i]].has? word[next_n]
+						else
+							throw :fail if next_n >= word.length
+							throw :fail unless @env[1][i] == word[next_n]
+						end
+					end
+					@env[0].length.times do |i|
+						last_n = index - @env[0].length + i
+						if @env[0][i] == '#'
+							throw :fail unless last_n < 0
+						elsif options[:lang].types.key? @env[0][i]
+							throw :fail if last_n < 0
+							throw :fail unless options[:lang].types[@env[0][i]].has? word[last_n]
+						else
+							throw :fail if last_n < 0
+							throw :fail unless @env[0][i] == word[last_n]
+						end
+					end
+					return true
+				end
+				false
+			else
+				true
+			end
+		end
+	end
+end

data/lib/kotodama/change_list.rb

@@ -0,0 +1,31 @@
+module Kotodama
+	class ChangeList
+		attr_reader :name, :list
+		
+		def initialize name
+			@name = name
+			@list = []
+		end
+		
+		def push n
+			@list << n
+		end
+		
+		alias :<< :push
+		
+		def apply_to word, options = {}
+			@list.each do |n|
+				if n.is_a? Change
+					n.apply_to word, options
+				else
+					if options[:lang].changes.key? n
+						options[:lang].changes[n].apply_to word, options
+					else
+						raise "#{n} is not a sound change"
+					end
+				end
+			end
+			word
+		end
+	end
+end

data/lib/kotodama/language.rb

@@ -0,0 +1,62 @@
+module Kotodama
+	class Language
+		attr_reader :types, :rules, :changes, :options
+		
+		def initialize
+			@types = {}
+			@rules = {}
+			@changes = {}
+			@options = {:symbol_weight => 1, :phrase_weight => 1}
+		end
+		
+		def add_type type
+			@types[type.name] = type
+		end
+		
+		def add_rule rule
+			@rules[rule.name] = rule
+		end
+		
+		def add_change change
+			@changes[change.name] = change
+		end
+		
+		def find_type symbol
+			@types.values.find {|n| n.has? symbol }
+		end
+		
+		def generate starting_rule = nil, starting_change = nil
+			starting_rule ||= @options['rule']
+			starting_change ||= @options['change']
+			if @rules.key? starting_rule
+				word = @rules[starting_rule].generate @options.merge(:lang => self)
+				if starting_change
+					if @changes.key? starting_change
+						word.apply @changes[starting_change], @options.merge(:lang => self)
+					else
+						raise "#{starting_change || 'nil'} is not a sound change"
+					end
+				end
+				word.to_s
+			else
+				raise "#{starting_rule || 'nil'} is not a rule"
+			end
+		end
+		
+		def apply_to array, starting_change = nil
+			starting_change ||= @options['change']
+			if @changes.key? starting_change
+				array.collect do |n|
+					word = n.to_word
+					if word
+						word.apply @changes[starting_change], @options.merge(:lang => self)
+					else
+						"input `#{n}' cannot be correctly converted into a word"
+					end
+				end
+			else
+				raise "#{starting_change || 'nil'} is not a sound change"
+			end
+		end
+	end
+end

data/lib/kotodama/parser.rb

@@ -0,0 +1,151 @@
+module Kotodama
+	Parser = Kaiseki::Grammar.subclass do
+		starting :document
+		skipping /\s+/
+		simplify
+		
+		rule :document do
+			parse :options_block.optional & :content_block.zero_or_more & :EOF
+			node :params => [:options, :content]
+			action do
+				lang = Language.new
+				lang.options.merge! @options
+				@content.each do |n|
+					if n.is_a? Type
+						lang.add_type n
+					elsif n.is_a? Rule
+						lang.add_rule n
+					elsif n.is_a? ChangeList
+						lang.add_change n
+					else
+						raise "#{n.class} is not a valid Language class"
+					end
+				end
+				lang
+			end
+		end
+		
+		rule :options_block do
+			parse 'options'.skip & '{'.skip & :option.zero_or_more & '}'.skip
+			action do
+				options_hash = {}
+				@results.each {|n| options_hash.merge! n }
+				options_hash
+			end
+		end
+		
+		rule :option do
+			parse :ID & '=>'.skip & (:ID | :INT) & ';'.skip
+			node :params => [:key, :value]
+			action { {@key => @value} }
+		end
+		
+		rule :content_block do
+			parse :type_block | :rule_block | :change_block
+		end
+		
+		rule :type_block do
+			parse 'type'.skip & :ID & '{'.skip & :symbol.zero_or_more & '}'.skip
+			node :params => [:name, :symbols]
+			action do
+				type = Type.new @name
+				@symbols.each do |symbol|
+					if symbol[0].respond_to? :each
+						symbol[0].each {|n| type.add_symbol n, symbol[1] }
+					else
+						type.add_symbol symbol[0], symbol[1]
+					end
+				end
+				type
+			end
+		end
+		
+		rule :symbol do
+			parse (:ID | :LIT) >> (','.skip & (:ID | :LIT)).zero_or_more & :weight.optional & ';'.skip
+		end
+		
+		rule :rule_block do
+			parse 'rule'.skip & :ID & '{'.skip & :rule.zero_or_more & '}'.skip
+			node :params => [:name, :phrases]
+			action do
+				rule = Rule.new @name
+				@phrases.each {|phrase| rule.add_phrase phrase[0], phrase[1] }
+				rule
+			end
+		end
+		
+		rule :rule do
+			parse (:ID | :LIT).one_or_more & :weight.optional & ';'.skip
+		end
+		
+		rule :change_block do
+			parse 'change'.skip & :ID & '{'.skip & :change.zero_or_more & '}'.skip
+			node :params => [:name, :changes]
+			action do
+				change_list = ChangeList.new @name
+				@changes.each {|change| change_list.push change }
+				change_list
+			end
+		end
+		
+		rule :change do
+			parse :insertion_change | :deletion_change | :transformation_change | :change_name
+		end
+		
+		rule :insertion_change do
+			parse 'insert'.skip & (:ID | :LIT).one_or_more & :change_env.optional & ';'.skip
+			override :simplify => false
+			node :params => [:target, :env]
+			action do
+				Change.new :insert, @target, @env[0]
+			end
+		end
+		
+		rule :deletion_change do
+			parse 'delete'.skip & (:ID | :LIT).one_or_more & :change_env.optional & ';'.skip
+			override :simplify => false
+			node :params => [:target, :env]
+			action do
+				Change.new :delete, @target, @env[0]
+			end
+		end
+		
+		rule :transformation_change do
+			parse (:ID | :LIT).one_or_more & '>'.skip & (:ID | :LIT).one_or_more & :change_env.optional & ';'.skip
+			override :simplify => false
+			node :params => [:target1, :target2, :env]
+			action do
+				Change.new :transform, [@target1, @target2], @env[0]
+			end
+		end
+		
+		rule :change_name do
+			parse :ID & ';'.skip
+		end
+		
+		rule :change_env do
+			parse '/'.skip & ('#'.optional >> :ID.zero_or_more) & '_'.skip & (:ID.zero_or_more >> '#'.optional)
+			action { @results.to_a }
+		end
+		
+		rule :weight do
+			parse ':'.skip & :INT
+			override :simplify => true
+		end
+		
+		rule :ID do
+			parse /_*[a-zA-Z][a-zA-Z0-9_]*/
+			action { @results.to_s }
+		end
+		
+		rule :INT do
+			parse /\d+/
+			action { @results.to_i }
+		end
+		
+		rule :LIT do
+			parse /\'([^']*)\'/ | /\"([^"]*)\"/
+			action { @results.info[:captures][0] }
+		end
+	end
+end

data/lib/kotodama/rule.rb

@@ -0,0 +1,31 @@
+module Kotodama
+	class Rule
+		attr_reader :name, :phrases, :weights
+		
+		def initialize name
+			@name = name
+			@phrases = []
+			@weights = []
+		end
+		
+		def add_phrase rule, weight = 1
+			@phrases << rule
+			@weights << weight
+		end
+		
+		def generate options = {}
+			word = Word.new
+			phrase = @phrases.random @weights.collect {|n| n || options[:phrase_weight] || 1 }
+			phrase.each do |n|
+				if options[:lang].rules.key? n
+					word << options[:lang].rules[n].generate(options)
+				elsif options[:lang].types.key? n
+					word << options[:lang].types[n].generate(options)
+				else
+					word << n
+				end
+			end
+			word
+		end
+	end
+end

data/lib/kotodama/string.rb

@@ -0,0 +1,29 @@
+class String
+	def to_word language
+		max_symbol_length = 0
+		language.types.each_pair do |key, type|
+			type.each do |symbol|
+				max_symbol_length = symbol.length if symbol.length > max_symbol_length
+			end
+		end
+		word = Kotodama::Word.new
+		index = 0
+		catch :fail do
+			while index < self.length
+				catch :succeed do
+					max_symbol_length.downto 1 do |length|
+						type = language.find_type self[index, length]
+						if type
+							word << self[index, length]
+							index += length
+							throw :succeed
+						end
+					end
+					throw :fail
+				end
+			end
+			return word
+		end
+		nil
+	end
+end

data/lib/kotodama/type.rb

@@ -0,0 +1,33 @@
+module Kotodama
+	class Type
+		include Enumerable
+		attr_reader :name, :symbols, :weights
+		
+		def initialize name
+			@name = name
+			@symbols = []
+			@weights = []
+		end
+		
+		def add_symbol symbol, weight = 1
+			@symbols << symbol
+			@weights << weight
+		end
+		
+		def [] n
+			@symbols[n]
+		end
+		
+		def each &block
+			@symbols.each &block
+		end
+		
+		def has? symbol
+			@symbols.member? symbol
+		end
+		
+		def generate options = {}
+			@symbols.random(@weights.collect {|n| n || options[:symbol_weight] || 1 })
+		end
+	end
+end

data/lib/kotodama/word.rb

@@ -0,0 +1,66 @@
+module Kotodama
+	class Word
+		include Enumerable
+		attr_reader :letters
+		
+		def initialize
+			@letters = []
+		end
+		
+		def [] n
+			@letters[n]
+		end
+		
+		def []= n, value
+			@letters[n] = value
+		end
+		
+		def empty?
+			@letters.empty?
+		end
+		
+		def length
+			@letters.length
+		end
+		
+		def push letter
+			if letter.is_a? Word
+				letter.each {|n| @letters.push n }
+			else
+				@letters.push letter
+			end
+		end
+		
+		alias :<< :push
+		
+		def insert index, letter
+			if letter.is_a? Word
+				letter.length.times do |i|
+					@letters.insert index + i, letter[i]
+				end
+			else
+				@letters.insert index, letter
+			end
+		end
+		
+		def delete_at index
+			@letters.delete_at index
+		end
+		
+		def each &block
+			@letters.each &block
+		end
+		
+		def apply change, options = {}
+			change.apply_to self, options
+		end
+		
+		def to_s
+			@letters.join
+		end
+		
+		def to_word *args
+			self
+		end
+	end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: kotodama
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
+platform: ruby
+authors: 
+- William Hamilton-Levi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-23 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: kaiseki
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: A word generator written in Ruby.
+email: whamilt1@swarthmore.edu
+executables: 
+- wordgen
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/kotodama.rb
+- lib/kotodama/type.rb
+- lib/kotodama/word.rb
+- lib/kotodama/change.rb
+- lib/kotodama/array.rb
+- lib/kotodama/rule.rb
+- lib/kotodama/change_list.rb
+- lib/kotodama/string.rb
+- lib/kotodama/language.rb
+- lib/kotodama/parser.rb
+- bin/wordgen
+has_rdoc: true
+homepage: http://github.com/phi2dao/Kotodama
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A word generator written in Ruby.
+test_files: []
+