cofgratx 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MTZkNzBmZjkzZDllZjY3YjQxYWY5NTFkYmNmYjcyYWQ2ZDEyMDJjMQ==
+  data.tar.gz: !binary |-
+    MDBmMWVlNDRiOGJlMGU3ZDdhNmJmZjlmMzM0NGY4MzRhZjkzYTM3OQ==
+SHA512:
+  metadata.gz: !binary |-
+    YjhmOTdjMzk5ZDlhZjViMzQzNzVlMzdhZTcyYjk5ZGNkMjdiMzg3NmI2M2Vi
+    MDRjOTQwOTUzNTNiOThiZDQ4ODY5NzRhNWUxNjljMDE5NTIwZmQzZmMwM2U1
+    MWU4ZTM4NDQwODc4YmRlNmM0ODJkNzY0ZmYxZjBiZTE4ODAzYzM=
+  data.tar.gz: !binary |-
+    ZTQyNDJkMTBmM2VjNjcwMzRiNWYwMTllNGJiYzVkOGJkZmQ1NzI2MDg4NWI4
+    MmVlNDI5YzZiODA5OWIxYmVmYmY2ZDljODNkOWVjNTlmYjI0YTY2MTIwODY3
+    YWUyYzYwY2Q0Mzg3OGNmZmJkYjlmNGY0NzJhMGFkYTE0MzkzYTk=

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cofgratx.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 callahat
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,64 @@
+# Cofgratx
+
+This is a context free grammar translation gem. Define a grammar (with or without some translations),
+feed it a string with a starting rule, and it returns a array of possible translations.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'cofgratx'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cofgratx
+
+## Usage
+
+The Grammar class is the main entry point. This class is where rules/productions are defined.
+
+### Adding rules and translations
+
+Rules are made up of Terminals, Repetitions (a special kind of terminal), and other rules.
+
+Terminals can be defined as a string, or regular expression.
+
+    Terminal.new "a"
+    Terminal.new /a/
+
+Repetitions can only be defined as a string. These will be the last part of a rule and indicate that the rule may repeat when this is found.
+
+    Repetition.new ","
+
+Translations are made up of Translation Repetition Sets (if the rule has a repetition), integers and strings. The Translation Repetition Set (TRS) is also made up of an offset (which repeated set to begin with), followed by integers and strings. The strings are straight up substitution, and the integers represent a smaller part of the rule.
+
+For example, given:
+
+    abc = Terminal.new /a|b|c/
+    comma = Repetition.new ","
+
+    trs = TranslationRepetitionSet.new(2, " third:", 3)
+
+    g = Grammar.new
+    g.add_rules :S, [ [ abc, abc, abc, comma ], [4,3,2,1,":",trs] ]
+
+    g.translate "abc,cba,bac,acb", :S
+
+     => [[",cba: third:a third:c third:b", ""]]
+
+The TRS adds to the translated string by starting with the second repeated match ("cba,") and prints the string "third:" followed by the third character from the match set.
+
+
+## Contributing
+
+1. Fork it ( https://github.com/callahat/cofgratx/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/cofgratx.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cofgratx/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cofgratx"
+  spec.version       = Cofgratx::VERSION
+  spec.authors       = ["callahat"]
+  spec.email         = ["tim.callahan25@yahoo.com"]
+  spec.summary       = "A context free grammar validator and translator"
+  spec.description   = "The CFG class can be used to create a specification for a context free grammar and define translations for it"
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/cofgratx.rb

@@ -0,0 +1,10 @@
+require "cofgratx/version"
+require "cofgratx/cfg/terminal"
+require "cofgratx/cfg/repetition"
+require "cofgratx/cfg/translation_repetition_set_error"
+require "cofgratx/cfg/translation_repetition_set"
+require "cofgratx/cfg/rule_error"
+require "cofgratx/cfg/grammar_error"
+require "cofgratx/cfg/rule"
+require "cofgratx/cfg/non_terminal"
+require "cofgratx/cfg/grammar"

data/lib/cofgratx/cfg/grammar.rb

@@ -0,0 +1,46 @@
+class Grammar
+  attr_reader :rules
+
+  def initialize
+    @rules = { }
+  end
+
+  def add_rules non_terminal_symbol, *rules
+    @rules[non_terminal_symbol.to_sym] ||= NonTerminal.new
+    good_rules = []
+
+    rules.each do |rule, translation|
+      0.upto(rule.size) do |index|
+        if rule[index].class == Symbol
+          rule[index] = (@rules[rule[index]] ||= NonTerminal.new)
+        end
+      end
+      new_rule = Rule.new( rule, translation )
+      if new_rule.valid_translation?
+        good_rules << Rule.new( rule, translation )
+      else
+        raise GrammarError.new(new_rule.translation_error_message)
+      end
+    end
+
+    @rules[non_terminal_symbol.to_sym].add_rules *good_rules
+  end
+
+  def clear_rule non_terminal_symbol
+    @rules[non_terminal_symbol.to_sym] = NonTerminal.new
+  end
+
+  def match? string, starting_non_terminal
+    #the grammar only matches if the string has no remainder
+    raise "Unknown initial non terminal: '#{starting_non_terminal}'" unless @rules[starting_non_terminal.to_sym]
+    candidate_matches = @rules[starting_non_terminal.to_sym].extract(string)
+    candidate_matches.select{|m| m[1] == "" and m[0] != nil}.size > 0
+  end
+
+  def translate string, starting_non_terminal
+    raise "Unknown initial non terminal: '#{starting_non_terminal}'" unless @rules[starting_non_terminal.to_sym]
+    candidate_matches = @rules[starting_non_terminal.to_sym].translate(string)
+    candidate_matches.select{|m| m[1] == "" and m[0] != nil}
+  end
+
+end

data/lib/cofgratx/cfg/grammar_error.rb

@@ -0,0 +1,2 @@
+class GrammarError < Exception
+end

data/lib/cofgratx/cfg/non_terminal.rb

@@ -0,0 +1,54 @@
+class NonTerminal
+  attr_reader :rules
+
+  def initialize *rules
+    validate_list_of_rules *rules
+    @rules = rules.to_a
+    @rules.uniq!{|r| [r.rule, r.translation]}
+  end
+
+  def add_rules *rules
+    validate_list_of_rules *rules
+    @rules.push *rules
+    @rules.uniq!{|r| [r.rule, r.translation]}
+  end
+
+  def match? string
+    @rules.each do |rule|
+      return true if rule.match? string
+    end
+    false
+  end
+
+  def extract string
+    matches = @rules.inject([]) do |matches, rule|
+      rule_matches = rule.extract string
+      matches.concat rule_matches if rule_matches.first[0]
+      matches
+    end
+
+    return [ [nil, string, [[]]] ] if matches.length == 0
+    matches
+  end
+
+  def translate string
+    translations = @rules.inject([]) do |translations, rule|
+      rule.translate( string ).each do |translation, remainder|
+        translations << [translation, remainder] if translation and remainder
+      end
+      translations
+    end
+    return [ [nil, string] ] if translations.length == 0
+    translations
+  end
+
+  protected
+  def validate_list_of_rules *params
+    bad_args = params.inject([]){|bad_args, param| bad_args << param unless param.class == Rule; bad_args}
+    if bad_args.to_a.size > 0
+      raise ArgumentError.new("expected a list of Rules; found bad items: " +
+                               bad_args.map{|bad_arg| "#{bad_arg.class.name} #{bad_arg}"}.join("\n") )
+    end
+  end
+
+end

data/lib/cofgratx/cfg/repetition.rb

@@ -0,0 +1,9 @@
+class Repetition < Terminal
+  def initialize param
+    unless %w{String}.include? param.class.name
+      raise ArgumentError.new("expected String; got #{param.class.name}")
+    end
+
+    @terminal = Regexp.compile "^(" + Regexp.escape(param) +")"
+  end
+end

data/lib/cofgratx/cfg/rule.rb

@@ -0,0 +1,160 @@
+class Rule
+  attr_reader :rule, :translation, :translation_error_message
+
+  def initialize subrules = [], translations = []
+    @translation_error_message = nil
+    @rule = set_rule subrules
+    @translation = set_translation translations
+  end
+
+  def set_rule *rule
+    good_parts = []
+    rule.flatten(2).each do |part|
+      if ! [Repetition, Terminal, NonTerminal].include? part.class
+        raise ArgumentError.new("expected Terminal, NonTerminal or Repetition; got #{part.class.name}")
+      elsif part.class == Repetition and good_parts.size == 0
+        raise RuleError.new("cannot have repetition as the first part of the rule")
+      elsif good_parts.last.class == Repetition
+        raise RuleError.new("nothing can follow the repetition")
+      end
+      good_parts << part
+    end
+    @rule = good_parts
+  end
+
+  def set_translation *translation
+    good_parts = []
+    translation.flatten.each do |part|
+      if ! [Fixnum, String, TranslationRepetitionSet].include? part.class
+        raise ArgumentError.new("expected Fixnum, String or TranslationRepetitionSet; got #{part.class.name}")
+      end
+      good_parts << part
+    end
+    @translation = good_parts
+  end
+
+  def valid_translation?
+    @translation.each do |part|
+      if part.class == TranslationRepetitionSet
+        if @rule.last.class != Repetition
+          @translation_error_message = "rule does not contain repetition"
+          return false
+        elsif part.translations.select{|tx| tx.class == Fixnum and tx > @rule.size}.count > 0
+          @translation_error_message = "rule contains fewer parts than the TranslationRepetitionSet has for a translation: #{part.translations.inspect}"
+          return false
+        end
+      elsif part.class == Fixnum
+        @translation_error_message = "rule contains fewer parts than translation number: #{part.inspect}"
+        return false if part > @rule.size
+      end
+    end
+    true
+  end
+
+  def match? candidate
+    extract(candidate).first[0] != nil
+  end
+
+  def extract candidate, translate_non_terminals = false
+    working_matches = [ ["",candidate.dup,[[]]] ]
+
+    @rule.each do |subrule|
+      surviving_matches = []
+      working_matches.each do |current_match, working_candidate, current_set|
+
+        if subrule.class == Repetition
+          surviving_matches.concat extract_repetition_character subrule, current_match.dup, deep_clone_a_set(current_set), working_candidate.dup, translate_non_terminals
+        elsif subrule.class == Terminal
+          match, working_candidate = subrule.extract working_candidate
+          if match
+            current_set.first << match
+            surviving_matches << [ current_match + match, working_candidate.dup, deep_clone_a_set(current_set) ]
+          end
+        elsif subrule.class == NonTerminal
+          matches = if translate_non_terminals
+                      translations = subrule.translate(working_candidate).select{|tx| tx[0]}
+                      translations.map{|tx| tx[2] = deep_clone_a_set(current_set); tx[2].first << tx[0].dup; tx }
+                      translations
+                    else
+                      subrule.extract(working_candidate)
+                    end
+
+          if matches.size > 0 and matches.first[0]
+            surviving_matches.concat matches
+          end
+        else
+          raise "Rule is corrupt, found a bad subrule:#{subrule} with class:#{subrule.class}"
+        end
+      end
+      working_matches = surviving_matches.dup
+    end
+    return [ [nil,candidate,[[]]] ] if working_matches.size == 0
+
+    working_matches
+  end
+
+  def translate candidate
+    matches = extract candidate, true
+    translations = matches.inject([]) do |txs, match|
+      current_match, working_candidate, current_set = match
+      next txs << [nil, candidate] unless current_match
+      next txs << [current_set.join(""), working_candidate.dup] unless @translation.size > 0
+      current_translation = ""
+      @translation.each do |sub_translation|
+        if sub_translation.class == TranslationRepetitionSet
+          current_set[(sub_translation.offset-1)..-1].to_a.each do |current|
+            sub_translation.translations.each do |translation|
+              current_translation += translation_helper current, translation
+            end
+          end
+        else
+          current_translation += translation_helper current_set.first, sub_translation
+        end
+      end
+      txs << [current_translation, working_candidate]
+    end
+    return [ [nil, candidate] ] unless translations.size > 0
+    translations
+  end
+
+  protected
+    def translation_helper current_set, translation
+      if translation.class == Fixnum
+        current_set[translation-1].to_s
+      else
+        translation
+      end
+    end
+
+    def extract_repetition_character subrule, current_match, current_set, working_candidate, translate_non_terminals
+      match, temp_working_candidate = subrule.extract(working_candidate)
+      additional_productions = []
+      if match
+        matches = self.extract(temp_working_candidate,translate_non_terminals)
+        matches.each do |more_match, repetition_working_candidate, repetition_current_set|
+          if more_match
+            first_current_set = current_set.first.dup
+
+            first_current_set << match
+
+            repetition_current_set.unshift first_current_set
+
+            working_candidate = repetition_working_candidate
+            additional_productions << [ current_match + match + more_match,
+                                         repetition_working_candidate.dup,
+                                         deep_clone_a_set(repetition_current_set) ]
+          end
+        end
+      end
+      return [ [current_match, working_candidate, deep_clone_a_set(current_set)] ] if additional_productions.size == 0
+      additional_productions
+    end
+
+    def deep_clone_a_set set
+      set.inject([]){ |s, subset|
+        s << subset.inject([]){ |ss, string|
+          ss << string.dup
+        }
+      }
+    end
+end