fae 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0f109cfeb573be9efac846742d47aa671c7c1839
-  data.tar.gz: 04c261c86d6381f25b127c254687df95bb43a6be
+  metadata.gz: 38505c6f22203783954989812a41a616301ec8fa
+  data.tar.gz: 8e12a0d7a191acf3b7ae804ae583085d601a1980
 SHA512:
-  metadata.gz: 4a28786b8b6c65b38cf8660d7368749ccf283e211308e06698bc87bc85526fd523f2bea7741295f781c280a9a1078b66c1506752ea524a1f724304c6cbc002c5
-  data.tar.gz: c6369d569cfb2a877ccb3f6c90b37070184e53dd23228cadb292bd20becbb0d896eee936cef2f998e3767a60835f18c35e64e440c958ae6d8fde73e86864e2d1
+  metadata.gz: 65a2ec14a7d609ddef1c1b96a7f64291c5bb6cfcdbc80a1a79ad68459c6469c85898ba8a592ec1a42364522034ff3d515fca760411c42a3e65afdd465ffa603e
+  data.tar.gz: 86cd4a012f81591035ab65a5736470544c7c1a69404a8d6df5e284312ca2cf913d8843830cf4d9d10fb8e8f618824868901c687654bb7fa195ed4fb5694dd823

data/README.md

@@ -18,7 +18,7 @@ Install the gem by running the following command:
 gem install fae
 ```
 
-## Evaluation Usage
+## Evaluating a Diagram
 
 The gem comes with an executable, `fae`, and can be run in two different modes, interactive or file.
 
@@ -99,7 +99,9 @@ Here is an example output:
 
 ## Using the API
 
-You can also use the library directly if you'd rather run your own scripts. Here is an example usage:
+You can also use the library directly if you'd rather run your own scripts.
+
+### Basic Usage
 
 ```rb
 require 'fae'
@@ -130,8 +132,42 @@ fa.add_strings([
 
 # Run the evaluation
 fa.evaluate!
+
+# Run the evaluation with no output
+valid = fa.evaluate!(true)
+puts "Diagram is correct" if valid
+```
+
+### Generating Tests for your State Diagram
+
+If you really want to test your diagram and don't want to have to come up with all of your valid or invalid strings, you can generate valid and invalid strings by setting the `valid_block` as a lambda returning a boolean expression on your Finite Automata that represents a valid string in the language.
+
+For example, in the language of all strings that have an odd number of a's, the following code would represent a valid string:
+
+```ruby
+# If the value is one when we take away all b's and mod the 
+# length by two, then we had an odd number of a's
+string.gsub('b', '').length % 2 == 1
+```
+
+Here is a full example that would test 1000 strings against your diagram:
+
+```ruby
+require 'fae'
+
+language = Fae::Language.new(['a', 'b'])
+fa = Fae::FiniteAutomata.new(language, "strings that have an odd number of a's")
+
+# Set the valid block
+fa.valid_block = lambda { |string| string.gsub('b', '').length % 2 == 1 }
+
+# Generate 1000 strings of length 20 and evaluate:
+fa.generate_strings(1000, 20)
+fa.evaluate!
 ```
 
+For more examples, see [`examples/advanced.rb`](https://github.com/caseyscarborough/fae/blob/master/examples/advanced.rb)
+
 ## When Your State Diagram is Incorrect
 
 If your state diagram is incorrect, the program will give you feedback about your diagram:
@@ -140,11 +176,13 @@ If your state diagram is incorrect, the program will give you feedback about you
 
 This can help you figure out where your diagram is going wrong.
 
-## Generation Usage
+## Generating a Diagram
 
 You can use the gem to generate the union, intersection, or difference of two state diagrams. See the following:
 
 ```ruby
+require 'fae'
+
 fa_1 = Fae::FiniteAutomata.new(LANGUAGE, "the language of all strings where the number of a's is odd")
 fa_2 = Fae::FiniteAutomata.new(LANGUAGE, "the language of all strings that include the substring 'bb'")
 
@@ -175,7 +213,7 @@ puts intersection
 
 ![Example Intersection Output](https://raw.githubusercontent.com/caseyscarborough/fae/master/etc/example_intersection_output.png)
 
-See [`intersection_union_difference.rb`](https://github.com/caseyscarborough/fae/blob/master/examples/intersection_union_difference.rb) for an example of generating the diagram and evaluating them.
+See [`examples/intersection_union_difference.rb`](https://github.com/caseyscarborough/fae/blob/master/examples/intersection_union_difference.rb) for an example of generating the diagram and evaluating them.
 
 ## Examples
 

data/examples/advanced.rb

@@ -0,0 +1,68 @@
+require_relative '../lib/fae'
+
+CHARACTERS = ['a', 'b', 'c', 'd']
+LANGUAGE   = Fae::Language.new(CHARACTERS)
+
+def print_valid_message(valid)
+  message = valid ? "VALID".colorize(:green) : "INVALID".colorize(:red)
+  puts message
+end
+
+def run_validation(fa, block)
+  fa.valid_block = block
+  fa.generate_strings(100, 20)
+
+  valid = fa.evaluate!(true)
+  print_valid_message(valid)
+end
+
+# Language 1
+#
+# The first Finite Automata is the language of all
+# strings that contain the substring 'abcd'.
+#
+fa_1 = Fae::FiniteAutomata.new(LANGUAGE, "the language of all strings that contain the substring 'abcd'")
+
+states = [
+  { :name => 'A', :paths => { :a => 'B', :b => 'A', :c => 'A', :d => 'A'}, :accepting => false },
+  { :name => 'B', :paths => { :a => 'B', :b => 'C', :c => 'A', :d => 'A'}, :accepting => false },
+  { :name => 'C', :paths => { :a => 'B', :b => 'A', :c => 'D', :d => 'A'}, :accepting => false },
+  { :name => 'D', :paths => { :a => 'B', :b => 'A', :c => 'A', :d => 'E'}, :accepting => false },
+  { :name => 'E', :paths => { :a => 'E', :b => 'E', :c => 'E', :d => 'E'}, :accepting => true },
+]
+states.each { |s| fa_1.add_state(Fae::State.new(s[:name], s[:paths], s[:accepting])) }
+run_validation(fa_1, lambda { |string| !string.match(/abcd/).nil? })
+
+# Language 2
+#
+# The second Finite Automata is the language of all
+# strings that contain more than three c's
+#
+fa_2 = Fae::FiniteAutomata.new(LANGUAGE, "the language of all strings that contain more than 3 c's")
+
+states = [
+  { :name => 'F', :paths => { :a => 'F', :b => 'F', :c => 'G', :d => 'F' }, :accepting => false },
+  { :name => 'G', :paths => { :a => 'G', :b => 'G', :c => 'H', :d => 'G' }, :accepting => false },
+  { :name => 'H', :paths => { :a => 'H', :b => 'H', :c => 'I', :d => 'H' }, :accepting => false },
+  { :name => 'I', :paths => { :a => 'I', :b => 'I', :c => 'I', :d => 'I' }, :accepting => true },
+]
+states.each { |s| fa_2.add_state(Fae::State.new(s[:name], s[:paths], s[:accepting])) }
+run_validation(fa_2, lambda { |string| string.length - 3 >= string.gsub('c', '').length })
+
+# Intersection
+intersection = fa_1.intersection(fa_2)
+run_validation(intersection, lambda do |string|
+  (string.length - 3 >= string.gsub('c', '').length) && !string.match(/abcd/).nil?
+end)
+
+# Union
+union = fa_1.union(fa_2)
+run_validation(union, lambda do |string|
+  (string.length - 3 >= string.gsub('c', '').length) || !string.match(/abcd/).nil?
+end)
+
+# Difference
+difference = fa_1.difference(fa_2)
+run_validation(difference, lambda do |string|
+  !string.match(/abcd/).nil? && !(string.length - 3 >= string.gsub('c', '').length)
+end)

data/lib/fae/finite_automata.rb

@@ -6,6 +6,7 @@ module Fae
   # to validate a state diagram.
   class FiniteAutomata
     attr_reader :language, :description, :states, :strings
+    attr_accessor :valid_block
     
     # Initializes a new instance of the FiniteAutomata.
     #
@@ -34,6 +35,16 @@ module Fae
     def add_string(string)
       @strings << string
     end
+
+    def add_state(new_state)
+      valid = true
+      @states.each do |state|
+        if (new_state.name == state.name)
+          raise 'Duplicate state added for Finite Automata'
+        end
+      end
+      @states << new_state
+    end
     
     # Adds strings to check against when evaluating.
     #
@@ -86,34 +97,56 @@ module Fae
     end
 
     # Runs the evaluation on the finite automata.
-    def evaluate!
+    def evaluate!(suppress_output=false)
+      output = ""
       @invalids = []
       if (@states.length == 0)
         raise "You must add some states to your Finite Automata before checking strings"
       end
 
-      puts """Evaluating strings for #{@description} using language #{@language.characters}".colorize(:yellow)
+      output << "Evaluating strings for #{@description} using language #{@language.characters}".colorize(:yellow)
       @strings.each do |string|
-        valid = evaluate_string(string)
-        if (!valid)
+        result = evaluate_string(string)
+        if (!result[:valid])
           @invalids << string
         end
+        output << result[:output]
       end
 
       num_invalid = @invalids.length
-      if (num_invalid > 0)
-        puts "State diagram may be incorrect for #{@description}".colorize(:red)
-        puts "\nA total of #{num_invalid} string#{'s' if num_invalid != 1} did not meet your expectations:\n"
+      valid = num_invalid == 0
+      if (!valid)
+        output << "\nState diagram may be incorrect for #{@description}".colorize(:red)
+        output << "\n\nA total of #{num_invalid} string#{'s' if num_invalid != 1} did not meet your expectations:\n"
 
         @invalids.each do |string|
           expected_string = string.expected ? "valid".colorize(:green) : "invalid".colorize(:red)
-          puts "* You expected the string '#{string.colorize(:blue)}' to be #{expected_string}"
+          output << "\n* You expected the string '#{string.colorize(:blue)}' to be #{expected_string}"
         end
-        puts "\nIf these expectations are correct, then your state diagram needs revising. Otherwise, you've simply expected the wrong values."
+        output << "\n\nIf these expectations are correct, then your state diagram needs revising. Otherwise, you've simply expected the wrong values."
       else
-        puts "State diagram is correct.".colorize(:green)
+        output << "\nState diagram is correct.\n".colorize(:green)
+      end
+
+      if (!suppress_output)
+        puts output
+      end
+      return valid
+    end
+
+    def generate_strings(number, length)
+      if valid_block.nil?
+        raise 'You must set the valid block for the Finite Automata to generate strings'
+      end
+
+      strings = []
+      number.times do
+        string = ""
+        length.times { string << @language.characters.sample }
+        strings << String.new(string, valid_block.call(string))
       end
-      puts
+      add_strings(strings)
+      strings
     end
 
     def to_s
@@ -165,30 +198,21 @@ module Fae
       return i_fa
     end
 
-    def add_state(new_state)
-      valid = true
-      @states.each do |state|
-        if (new_state.name == state.name)
-          raise 'Duplicate state added for Finite Automata'
-        end
-      end
-      @states << new_state
-    end
-
     def evaluate_string(string)
-      print "#{string.colorize(:blue)}: "
+      output = "\n#{string.colorize(:blue)}: "
       if (@language.string_is_valid(string))
         result = @states.first.evaluate(string, self)
+        output << result[:output]
         if (result[:accepting] != string.expected)
-          puts "\u2717".encode("utf-8").colorize(:red)
-          return false
+          output << "\u2717".encode("utf-8").colorize(:red)
+          return { :valid => false, :output => output }
         else
-          puts "\u2713".encode("utf-8").colorize(:green)
-          return true
+          output << "\u2713".encode("utf-8").colorize(:green)
+          return { :valid => true, :output => output }
         end
       else
-        puts "not valid for language #{@characters}".colorize(:red)
-        return true
+        output << "not valid for language #{@characters}".colorize(:red)
+        return { :valid => true, :output => output }
       end
     end
   end

data/lib/fae/language.rb

@@ -7,7 +7,7 @@ module Fae
     # Creates a new language instance.
     #
     # @param characters [Array] an array of characters
-    def initialize(characters)
+    def initialize(characters, valid_block=nil)
       @characters = []
       @characters = characters.uniq
     end
@@ -19,7 +19,7 @@ module Fae
       # Use lookahead to check for valid string
       regex = "^(?=.*\\D)[#{@characters.join('|')}]+$"
 
-      if (string.match /#{regex}/)
+      if string.match /#{regex}/
         return true
       end
       return false

data/lib/fae/state.rb

@@ -22,16 +22,18 @@ module Fae
     # @param string [String] the string to evaluate
     # @param fa [FiniteAutomata] the finite automata that this state belongs to
     def evaluate(string, fa)
+      output = ""
       if (string.first.empty?)
-        output = @accepting ? "accepting".colorize(:green) : "not accepting".colorize(:red)
-        print "#{@name} (#{output}) "
+        output << "#{@name} (#{@accepting ? 'accepting'.colorize(:green) : 'not accepting'.colorize(:red)}) "
         return { :output => output, :accepting => @accepting }
       end
-      print "#{@name} #{'->'.colorize(:light_black)} "
+      output << "#{@name} #{'->'.colorize(:light_black)} "
       
       next_state  = fa.get_state(paths[string.first.to_sym])
       next_string = string.shift_left
-      next_state.evaluate(next_string, fa)
+      result = next_state.evaluate(next_string, fa)
+      output << result[:output]
+      return { :output => output, :accepting => result[:accepting] }
     end
   end
 end

data/lib/fae/version.rb

@@ -1,3 +1,3 @@
 module Fae
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fae
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Casey Scarborough
@@ -71,9 +71,10 @@ files:
 - etc/example_interactive_mode_output.png
 - etc/example_intersection_output.png
 - etc/example_state_diagram.png
+- examples/advanced.rb
 - examples/diagrams.yml
-- examples/example.rb
 - examples/intersection_union_difference.rb
+- examples/simple.rb
 - fae.gemspec
 - lib/fae.rb
 - lib/fae/finite_automata.rb