strsyntax 0.1.2

data/bin/strsyntax

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'strsyntax'
+
+options = {
+  :command => :structure
+}
+
+opts = OptionParser.new do |opts|
+  opts.banner = "Usage: string_structure [options] word"
+  opts.separator ""
+  
+  opts.on( "-y", "--syntax", "Splits string into syntax elements: [:cv,:vc,:vc]" ) do
+    options[:command] = :syntax
+  end
+  
+  opts.on( "-p", "--parts", "Splits string into syntax instances: ['ro','ut','er']" ) do
+    options[:command] = :parts
+  end
+  
+  opts.on( "-s", "--structure", "Splits string into syntax structure: [[:cv,'ro'],[:vc,'ut'],[:vc,'er']]" ) do
+    options[:command] = :structure
+  end
+  
+  opts.separator ""
+  
+  opts.parse!( ARGV )
+end
+
+str = opts.default_argv.first
+
+case options[:command]
+when :syntax
+  puts str.syntax.inspect
+when :parts
+  puts str.parts.inspect
+when :structure
+  puts str.structure.inspect
+else
+  puts opts
+end

data/lib/strsyntax.rb

@@ -0,0 +1,2 @@
+require 'strsyntax/strsyntax'
+require 'strsyntax/stdlib_ext'

data/lib/strsyntax/stdlib_ext.rb

@@ -0,0 +1,53 @@
+#
+# Extend standard library classes with methods required by Ngrams
+#
+if !String.respond_to? :syntax
+  class String
+    # Returns an array containing the syntax of the string in terms of consonant and vowel
+    # groups. The groups are CVC, VCV, CV, VC, C, and V. For example:
+    #
+    # "groucho".syntax => [:c,:cv,:vc,:cv]
+    # "harpo".syntax => [:cvc,:cv]
+    # "chico".syntax => [:c,:cvc,:v]
+    # "zeppo".syntax => [:cvc,:cv]
+    # "teasdale".syntax => [:cv,:vc,:cvc,:v]
+    def syntax
+      StringSyntax::Parser.parse( self )
+    end
+  end
+else
+  raise "Cannot patch in String#syntax as it is already defined!"
+end
+
+if !String.respond_to? :parts
+  class String
+    # Return an array containing the constituent parts of the string as represented by
+    # its syntax. For example:
+    #
+    # "groucho".parts => ["g","ro","uc","ho"]
+    # "harpo".parts => ["har","po"]
+    # "chico".parts => ["c","hic", "o"]
+    # "zeppo".parts => ["zep","po"]
+    # "teasdale".parts => ["te","as","dal","e"]
+    def parts
+      StringSyntax::Parser.split( self )
+    end
+  end
+else
+  raise "Cannot patch in String#parts as it is already defined!"
+end
+
+if !String.respond_to? :structure
+  class String
+    # Returns an array containing an amalgam of the syntax and parts of the string
+    # See #syntax and #parts for more information. Example
+    #
+    # "groucho".stmap => [[:c,"g"],[:cv,"ro"],[:vc,"uc"],[:cv,"ho"]]
+    #
+    def structure
+      self.syntax.zip( self.parts )
+    end
+  end
+else
+  raise "Cannot patch in String#structure as it is already defined!"
+end

data/lib/strsyntax/strsyntax.rb

@@ -0,0 +1,119 @@
+#!/usr/bin/env ruby
+#
+# Can we decode any word into some combination of
+# CV, VC, CVC, VCV 
+# ?
+#
+
+module StringSyntax
+  class Parser
+      C = /^([bcdfghjklmnpqrstvwxyz])/
+      V = /^([aeiou])/
+      CV = /^([bcdfghjklmnpqrstvwxyz][aeiou])/
+      CVC = /^([bcdfghjklmnpqrstvwxyz][aeiou][bcdfghjklmnpqrstvwxyz])/
+      VC = /^([aeiou][bcdfghjklmnpqrstvwxyz])/
+      VCV = /^([aeiou][bcdfghjklmnpqrstvwxyz][aeiou])/
+
+      SCHEMA_TEMPLATES = {
+        C => :c,
+        V => :v,
+        CV => :cv,
+        CVC => :cvc,
+        VC => :vc,
+        VCV => :vcv
+      }
+      
+      # Returns an array containing the components of the string in terms of consonant
+      # and vowel groupings: CVC, VCV, CV, VC, C, V.
+      def self.parse( s )
+        s = s.downcase
+        
+        structure = case s
+          when CVC
+            [ parse_subpart( CVC, s[0,3], s[(3..-1)] ), parse_subpart( CV, s[0,2], s[(2..-1)] ) ]
+          when CV
+            [ parse_subpart( CV, s[0,2], s[(2..-1)] ), parse_subpart( C, s[0,1], s[(1..-1)] ) ]
+          when C
+            [ parse_subpart( C, s[0,1], s[(1..-1)] ) ]
+          when VCV
+            [ parse_subpart( VCV, s[0,3], s[(3..-1)] ), parse_subpart( VC, s[0,2], s[(2..-1)] ) ]
+          when VC
+            [ parse_subpart( VC, s[0,2], s[(2..-1)] ), parse_subpart( V, s[0,1], s[(1..-1)] ) ]
+          when V
+            [ parse_subpart( V, s[0,1], s[(1..-1)] ) ]
+          else
+            []
+        end
+        
+        # Return the sub-structure containing the least number of stray :c and :v
+        structure.sort_by { |s| score( s ) }.first
+      end
+      
+      # Return the number of :c and :v components in the structure
+      def self.score( s )
+        s.inject( 0 ) { |sum, e| e == :c || e == :v ? sum + 1 : sum }
+      end
+      
+      def self.split( s, structure = parse( s ) )
+        templates = structure.map { |schema| template_from_schema( schema ) }
+        templates.map do |template|
+          match_data = template.match( s )
+          s = match_data.post_match
+          match_data[1]
+        end
+      end
+
+      def self.schema_from_template( template )
+        SCHEMA_TEMPLATES[template]
+      end
+      
+      def self.template_from_schema( schema )
+        case schema
+        when :cvc
+          CVC
+        when :vcv
+          VCV
+        when :cv
+          CV
+        when :vc
+          VC
+        when :c
+          C
+        when :v
+          V
+        else
+          raise "Unknown schema: #{schema}"
+        end
+      end
+
+      def self.schema_from_string( s )
+        case s
+        when CVC
+          :cvc
+        when CV
+          :cv
+        when VCV
+          :vcv
+        when VC
+          :vc
+        when C
+          :c
+        when V
+          :v
+        end
+      end
+
+    private
+      def self.parse_subpart( template, match, rest )
+        [ schema_from_template( template ), *parse( rest ) ].compact
+      end
+  end
+end
+
+if __FILE__ == $0
+  WORDS = %w( hello google amazon ookles paoga linguistics antidisestablishmentarianism )
+
+  WORDS.each do |word|
+    puts "#{word} -> #{ StringSyntax::Parser.parse( word ).inspect}"
+  end
+end

data/test/test_parser.rb

@@ -0,0 +1,30 @@
+$:<< File.join( File.dirname( __FILE__ ), '..', 'lib' )
+
+require 'strsyntax'
+require 'test/unit'
+
+class TestParser < Test::Unit::TestCase
+  
+  def test_syntax
+    assert_equal [:cvc,:cv], "hello".syntax
+    assert_equal [:vc,:c,:cvc,:vcv], "amplitude".syntax
+    assert_equal [:c,:cvc,:c,:cvc,:cvc], "transmitter".syntax
+    assert_equal [:cv,:vc,:cv], "google".syntax
+    assert_equal [:vcv,:cv,:cv,:vc], "aluminium".syntax
+    assert_equal [:cv,:vc,:cv,:cv], "teasdale".syntax
+  end
+  
+  def test_parts
+    assert_equal ["hel","lo"], "hello".parts
+    assert_equal ["am","p","lit","ude"], "amplitude".parts
+    assert_equal ["t","ran","s","mit","ter"], "transmitter".parts
+    assert_equal ["go","og","le"], "google".parts
+    assert_equal ["alu","mi", "ni","um"], "aluminium".parts
+    assert_equal ["te","as","da","le"], "teasdale".parts
+  end
+  
+  def test_structure
+    assert_equal [[:c,"g"],[:cv,"ro"],[:vc,"uc"],[:cv,"ho"]], "groucho".structure
+  end
+  
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: !int:Fixnum 1
+name: strsyntax
+version: !ruby/object:Gem::Version 
+  version: 0.1.2
+date: 2006-07-28 00:00:00 +01:00
+summary: A library to return the syntax/structure of a word in term of consonant and vowel groups.
+require_paths: 
+- lib
+email: self@mattmower.com
+homepage: http://rubyforge.org/projects/rubymatt/
+rubyforge_project: rubymatt
+description: 
+autorequire: strsyntax
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Matt Mower
+files: 
+- lib/strsyntax.rb
+- lib/strsyntax/stdlib_ext.rb
+- lib/strsyntax/strsyntax.rb
+- test/test_parser.rb
+- bin/strsyntax
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: 
+- strsyntax
+extensions: []
+
+requirements: []
+
+dependencies: []
+