fae 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 38505c6f22203783954989812a41a616301ec8fa
-  data.tar.gz: 8e12a0d7a191acf3b7ae804ae583085d601a1980
+  metadata.gz: a353faa342e9405b48cfa833f5069cf5161dc7e4
+  data.tar.gz: 67eb919d556ffc2d0dbe6ad08e4f6ac1a703fbe3
 SHA512:
-  metadata.gz: 65a2ec14a7d609ddef1c1b96a7f64291c5bb6cfcdbc80a1a79ad68459c6469c85898ba8a592ec1a42364522034ff3d515fca760411c42a3e65afdd465ffa603e
-  data.tar.gz: 86cd4a012f81591035ab65a5736470544c7c1a69404a8d6df5e284312ca2cf913d8843830cf4d9d10fb8e8f618824868901c687654bb7fa195ed4fb5694dd823
+  metadata.gz: 467117d43bb395ad9c0dd1fe975014edc1a57420dc683bbd8ddf98f0f70115b115d841d7cdaf63185dfc85c909840b5b05e5836a08dedf872a8e6e3c6202808a
+  data.tar.gz: 6dd10a31af3524a001c508f0177ee2dabdc9980fe246e0a1393960699d4712ceed8ead1bcf8027202c22fde4ca3d36bec1ac9477a64a231a1f1314709c0f114f

data/README.md

@@ -138,6 +138,20 @@ valid = fa.evaluate!(true)
 puts "Diagram is correct" if valid
 ```
 
+The add and evaluate methods can be chained also:
+
+```ruby
+states = [
+  # Some states...
+]
+
+strings = [
+  # Some strings...
+]
+
+fa.add_states(states).add_strings(strings).evaluate!
+```
+
 ### 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.
@@ -166,6 +180,12 @@ fa.generate_strings(1000, 20)
 fa.evaluate!
 ```
 
+These can be chained also:
+
+```ruby
+fa.generate_strings(1000, 20).evaluate!
+```
+
 For more examples, see [`examples/advanced.rb`](https://github.com/caseyscarborough/fae/blob/master/examples/advanced.rb)
 
 ## When Your State Diagram is Incorrect

data/examples/advanced.rb

@@ -3,6 +3,17 @@ require_relative '../lib/fae'
 CHARACTERS = ['a', 'b', 'c', 'd']
 LANGUAGE   = Fae::Language.new(CHARACTERS)
 
+# Patch the string class to make valid lambdas easier to read.
+class String
+  def has_at_least_three_cs?
+    self.length - 3 >= self.gsub('c', '').length
+  end
+
+  def has_abcd_substring?
+    !self.match(/abcd/).nil?
+  end
+end
+
 def print_valid_message(valid)
   message = valid ? "VALID".colorize(:green) : "INVALID".colorize(:red)
   puts message
@@ -10,9 +21,7 @@ end
 
 def run_validation(fa, block)
   fa.valid_block = block
-  fa.generate_strings(100, 20)
-
-  valid = fa.evaluate!(true)
+  valid = fa.generate_strings(100, 20).evaluate!(true)
   print_valid_message(valid)
 end
 
@@ -51,18 +60,18 @@ run_validation(fa_2, lambda { |string| string.length - 3 >= string.gsub('c', '')
 
 # 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)
+run_validation(
+  intersection, lambda { |s| s.has_abcd_substring? && s.has_at_least_three_cs? }
+)
 
 # 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)
+run_validation(
+  union, lambda { |s| s.has_abcd_substring? || s.has_at_least_three_cs? }
+)
 
 # 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)
+run_validation(
+  difference, lambda { |s| s.has_abcd_substring? && !s.has_at_least_three_cs? }
+)

data/examples/intersection_union_difference.rb

@@ -20,32 +20,6 @@ def string_has_bb_substring?(string)
   !string.match(/bb/).nil?
 end
 
-def valid_for_intersection?(string)
-  string_has_odd_number_of_the_letter_a?(string) && string_has_bb_substring?(string)
-end
-
-def valid_for_union?(string)
-  string_has_odd_number_of_the_letter_a?(string) || string_has_bb_substring?(string)
-end
-
-def valid_for_difference?(string)
-  string_has_odd_number_of_the_letter_a?(string) && !string_has_bb_substring?(string)
-end
-
-# Returns 100 random strings in the language, 50 of length 15 and 50 of length 5.
-def get_random_strings
-  generate_string = lambda do |num|
-    string = ""
-    num.times { string << CHARACTERS.sample }
-    string
-  end
-
-  strings = []
-  50.times { strings << generate_string.call(15) }
-  50.times { strings << generate_string.call(5) }
-  strings
-end
-
 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'")
 
@@ -64,15 +38,21 @@ fa_2.add_states([
 
 # Perform the intersection
 intersection = fa_1.intersection(fa_2)
-get_random_strings.each { |s| intersection.add_string(String.new(s, valid_for_intersection?(s))) }
-intersection.evaluate!
+intersection.valid_block = lambda do |string|
+  string_has_odd_number_of_the_letter_a?(string) && string_has_bb_substring?(string)
+end
+intersection.generate_strings(100, 10).evaluate!
 
 # Perform the union
 union = fa_1.union(fa_2)
-get_random_strings.each { |s| union.add_string(String.new(s, valid_for_union?(s))) }
-union.evaluate!
+union.valid_block = lambda do |string|
+  string_has_odd_number_of_the_letter_a?(string) || string_has_bb_substring?(string)
+end
+union.generate_strings(100, 10).evaluate!
 
 # Perform the difference
 difference = fa_1.difference(fa_2)
-get_random_strings.each { |s| difference.add_string(String.new(s, valid_for_difference?(s))) }
-union.evaluate!
+difference.valid_block = lambda do |string|
+  string_has_odd_number_of_the_letter_a?(string) && !string_has_bb_substring?(string)
+end
+difference.generate_strings(100, 10).evaluate!

data/lib/fae.rb

@@ -2,6 +2,7 @@ require 'colorize'
 
 # Fae classes
 require_relative 'string'
+require_relative 'fae/exceptions'
 require_relative 'fae/language'
 require_relative 'fae/state'
 require_relative 'fae/finite_automata'

data/lib/fae/exceptions.rb

@@ -0,0 +1,24 @@
+module Fae
+  # Generic exception for the Fae library.
+  class FaeException < StandardError; end
+
+  # Raised when Finite Automata doesn't have a valid block
+  # and strings are trying to be generated
+  class MissingValidBlockException < FaeException; end
+
+  # Raised when a state couldn't be found in a diagram,
+  # which should never happen.
+  class StateNotFoundException < FaeException; end
+
+  # Raised when a duplicate state is trying to be added
+  # to a FiniteAutomata.
+  class DuplicateStateException < FaeException; end
+
+  # Raised when trying to evaluate a FiniteAutomata
+  # with no states.
+  class EmptyStatesException < FaeException; end
+
+  # Raised when trying to perform a set operation on
+  # FiniteAutomata with two different languages.
+  class LanguageMismatchException < FaeException; end
+end

data/lib/fae/finite_automata.rb

@@ -24,9 +24,8 @@ module Fae
     #
     # @param strings [Array] an array of strings
     def add_strings(strings)
-      strings.each do |string|
-        @strings << string
-      end
+      strings.each { |string| @strings << string }
+      self
     end
 
     # Adds a single string to the strings array.
@@ -35,24 +34,24 @@ 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.
     #
     # @param states [Array] an array of states
     def add_states(states)
-      states.each do |state|
-        add_state(state)
+      states.each { |state| add_state(state) }
+      self
+    end
+
+    # Adds a single state to the states array.
+    #
+    # @param new_state [State] the state to add.
+    def add_state(new_state)
+      valid = true
+      @states.each do |state|
+        raise Fae::DuplicateStateException, 'Duplicate state added for Finite Automata' if new_state.name == state.name
       end
+      @states << new_state
     end
 
     # Retrieves a state from this finite automata by name.
@@ -67,9 +66,9 @@ module Fae
         end
       end
       if (retrieved_state.nil?)
-        raise "State #{name} was not found in this Finite Automata. Ensure that all states have outputs for #{@language.characters}"
+        raise Fae::StateNotFoundException, "State #{name} was not found in this Finite Automata. Ensure that all states have outputs for #{@language.characters}"
       end
-      return retrieved_state
+      retrieved_state
     end
 
     # Generates the finite automata for the intersection
@@ -98,32 +97,28 @@ module Fae
 
     # Runs the evaluation on the finite automata.
     def evaluate!(suppress_output=false)
-      output = ""
+      raise Fae::EmptyStatesException, 'You must add some states to your Finite Automata before checking strings' if @states.length == 0
+
+      output = "Evaluating strings for #{@description} using language #{@language.characters}".colorize(:yellow)
       @invalids = []
-      if (@states.length == 0)
-        raise "You must add some states to your Finite Automata before checking strings"
-      end
 
-      output << "Evaluating strings for #{@description} using language #{@language.characters}".colorize(:yellow)
       @strings.each do |string|
         result = evaluate_string(string)
-        if (!result[:valid])
-          @invalids << string
-        end
-        output << result[:output]
+        @invalids << string if !result[:valid]
+        output    << result[:output]
       end
 
       num_invalid = @invalids.length
       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"
+      if !valid
+        output << "\nState diagram may be incorrect for #{@description}\n".colorize(:red)
+        output << "\nA total of #{num_invalid} string#{'s' if num_invalid != 1} did not meet your expectations:\n\n"
 
         @invalids.each do |string|
           expected_string = string.expected ? "valid".colorize(:green) : "invalid".colorize(:red)
-          output << "\n* You expected the string '#{string.colorize(:blue)}' to be #{expected_string}"
+          output << "* You expected the string '#{string.colorize(:blue)}' to be #{expected_string}\n"
         end
-        output << "\n\nIf these expectations are correct, then your state diagram needs revising. Otherwise, you've simply expected the wrong values."
+        output << "\nIf these expectations are correct, then your state diagram needs revising. Otherwise, you've simply expected the wrong values."
       else
         output << "\nState diagram is correct.\n".colorize(:green)
       end
@@ -131,27 +126,29 @@ module Fae
       if (!suppress_output)
         puts output
       end
-      return valid
+      valid
     end
 
+    # Generates strings for the finite automata and adds them
+    # to the strings array.
+    #
+    # @param number [Integer] number of strings
+    # @param length [Integer] length of each string
     def generate_strings(number, length)
-      if valid_block.nil?
-        raise 'You must set the valid block for the Finite Automata to generate strings'
-      end
-
+      raise Fae::MissingValidBlockException, 'You must set the valid block for the Finite Automata to generate strings' if valid_block.nil?
+      
       strings = []
       number.times do
         string = ""
         length.times { string << @language.characters.sample }
         strings << String.new(string, valid_block.call(string))
       end
-      add_strings(strings)
-      strings
+      self.add_strings(strings)
+      self
     end
 
     def to_s
-      output = ""
-      output << "Description: ".colorize(:yellow) + @description
+      output =  "Description: ".colorize(:yellow) + @description
       output << "\nLanguage: ".colorize(:yellow) + language.characters.to_s
       output << "\nStates:".colorize(:yellow)
       @states.each do |state|
@@ -162,19 +159,19 @@ module Fae
         accepting = state.accepting ? "accepting".colorize(:green) : "not accepting".colorize(:red)
         output << "\n    #{'~'.colorize(:yellow)} #{accepting}"
       end
-      return output
+      output
     end
 
   private
     def perform_set_operation(type, fa)
-      if (@language.characters.uniq.sort != fa.language.characters.uniq.sort)
-        puts "Performing the #{type.to_s} requires the languages to be the same.".colorize(:red)
-        return 
+      if @language.characters.uniq.sort != fa.language.characters.uniq.sort
+        raise LanguageMismatchException, "Performing the #{type.to_s} requires the languages to be the same.".colorize(:red)
       end
-      i_states  = []
-      i_strings = []
-      i_description = "the #{type.to_s} of #{@description} and #{fa.description}"
-      i_fa = FiniteAutomata.new(@language, i_description)
+
+      states  = []
+      strings = []
+      description = "the #{type.to_s} of #{@description} and #{fa.description}"
+      new_fa = FiniteAutomata.new(@language, description)
 
       @states.each do |state|
         fa.states.each do |fa_state|
@@ -190,30 +187,30 @@ module Fae
               (type == :union && (state.accepting || fa_state.accepting)))
             accepting = true
           end
-          i_states << State.new(name, paths, accepting)
+          states << State.new(name, paths, accepting)
         end
       end
 
-      i_fa.add_states(i_states)
-      return i_fa
+      new_fa.add_states(states)
+      new_fa
     end
 
     def evaluate_string(string)
+      valid = true
       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)
           output << "\u2717".encode("utf-8").colorize(:red)
-          return { :valid => false, :output => output }
+          valid = false
         else
           output << "\u2713".encode("utf-8").colorize(:green)
-          return { :valid => true, :output => output }
         end
       else
         output << "not valid for language #{@characters}".colorize(:red)
-        return { :valid => true, :output => output }
       end
+      return { :valid => valid, :output => output }
     end
   end
 end

data/lib/fae/language.rb

@@ -17,12 +17,7 @@ module Fae
     # @param string [String] the string to check
     def string_is_valid(string)
       # Use lookahead to check for valid string
-      regex = "^(?=.*\\D)[#{@characters.join('|')}]+$"
-
-      if string.match /#{regex}/
-        return true
-      end
-      return false
+      string.match "^(?=.*\\D)[#{@characters.join('|')}]+$"
     end
 
     # Adds a character to the language.

data/lib/fae/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fae
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Casey Scarborough
@@ -77,6 +77,7 @@ files:
 - examples/simple.rb
 - fae.gemspec
 - lib/fae.rb
+- lib/fae/exceptions.rb
 - lib/fae/finite_automata.rb
 - lib/fae/language.rb
 - lib/fae/state.rb