SEATC 0.2.25 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f4f8a08919fcf81f075f88a69a19351ee1b70b4f
-  data.tar.gz: 69a945e50c7d071f976d3b355f2be54342e681b1
+  metadata.gz: 1ee0f7663dc5ac8a81806784220d5baefe59928d
+  data.tar.gz: e63d166143186e066c83810bff146b916c86b4e0
 SHA512:
-  metadata.gz: 126bfff0a299a1a93dfa93661f1af2001d468d082fa0334e84b73acb4780dd768187797ab2702bda42293bc0f6d99b8e5c2151292a020a667ebe98d41296797d
-  data.tar.gz: 92088d3ec6ddea4f4781809ed8e8664e811fdb261a506f651de2f9d8c2461a2981450c254f932d418c2b26b3ee6b27cbea80ba785ba016b9040f3879f7241b60
+  metadata.gz: 94f842f9b803d0466d77012e132973a52c6fb63ec78dff55f2eebef5036f8f46ec70e1c6af944b557ce4e8d8053296d356a2c1dd54a33b116a825a93870ef397
+  data.tar.gz: 18c030b8a471dc94354a2223618c6ce9b37dee08eb139a0d0a1fc60257586727fa3de7c83b79eea2975a07a39898a84bcd20b5b6f23017447ea7068bd036f769

data/lib/Automaton Analyzer.rb

@@ -1,52 +1,85 @@
+# Automaton Analyzer State	
 class AutomatonState
 	@id
 	@nombre
 	@transitions
 	@final
+  # @param id [Integer] ID for the state
+  # @param nombre [String] Name of the state (JFlap Label)
+  # @param final [Boolean] Determine if the state is final state
 	def initialize(id, nombre, final)
 		@id = id
 		@nombre = nombre
 		@transitions = Hash.new
 		@final = final
 	end
+  # Add a transition to the state
+  # @param char [String] Transition value
+  # @param to [Integer] State where the transition goes
+	# @return [Void]
 	def addTrans(char, to)
 		if @transitions[char] == nil
 			@transitions[char] = Hash.new
 		end
 		@transitions[char][to] = to
 	end
+  # Return the list of transitions
+  # @param char [String] List of transitions for an specific input
+	# @return [Hash] List of transitions
 	def transAt(char)
 		ret = @transitions[char]
 	end
+	# Return all the transitions for the state
+	# @return [Hash] List of all transitions
 	def getTrans
 		return @transitions
 	end
+	# Return name of the state
+	# @return [String] Name of the state
 	def getName
 		return @nombre
 	end
+	# Return if the state is final state
+	# @return [Boolean] 1 if the state is final, 0 otherwise
 	def final()
 		ret = @final
 	end
 end
 
+# Analyzer for both kind of automatons: deterministic and non-deterministic
+# First create the analyzer with new, 
+# then use the analyze method to know if the string is accepted or not
+# @attr valid [Boolean] Determine if a string is valid or not in certain time of the instance
+# @attr errno [Integer] Identifier for some errors on the analyzer
+# @attr deterministic [Boolean] Determine if {#isDeterministic} check is needed
 class AutomatonAnalyzer
 	attr_accessor :valid, :deterministic, :errno
+	# Return errno of the analyzer
+	# @return [Boolean] 0 errno is that the analyzer completed with no error, otherwise it is different to 0
 	def errno()
 		return @errno
 	end
-    def initialize(deterministic)
+	# Initialize the analyzer
+	# @param deterministic [Boolean] Define if the Automaton will be deterministic or non-deterministic
+  def initialize(deterministic)
 		@deterministic = deterministic
 		@errno = 0
-    end
-    def isDeterministic(states)
-        return false if !@deterministic
-        states.each do |estado|
-            transiciones = estado.getTrans
-            transiciones.each do |transition|
-                return false if estado.transAt(transition[0]).length > 1
-            end
+  end
+	# Check if the automaton is deterministic
+	# @param states [Array] List of automaton's transitions
+	# @return [Boolean] 1 if the automaton is deterministic, 0 otherwise
+  def isDeterministic(states)
+    return false if !@deterministic
+    states.each do |estado|
+        transiciones = estado.getTrans
+        transiciones.each do |transition|
+             return false if estado.transAt(transition[0]).length > 1
         end
     end
+  end
+	# Return state id from a read line
+	# @param modified [String] Line where ID of the state is contained
+	# @return [Integer] State ID
 	def getStateID(modified)
 		modified.slice! "\t\t<state id=\""
 		lastQuota = true
@@ -60,7 +93,9 @@ class AutomatonAnalyzer
 		end
 		id = id
 	end
-
+	# Return state name from a read line
+	# @param modified [String] Line where name of the state is contained
+	# @return [String] State name
 	def getStateName(modified)
 		modified.slice! "\" name=\""
 		lastQuota = true
@@ -72,7 +107,9 @@ class AutomatonAnalyzer
 		end
 		id = id
 	end
-
+	# Return the next state of the transition 
+	# @param modified [String] Line where next state is contained is contained
+	# @return [Integer] Next state of a transition
 	def readTransInt(modified)
 		lastQuota = true
 		id = 0
@@ -86,7 +123,11 @@ class AutomatonAnalyzer
 		id = id
 
 	end
-
+	# Return if a string is valid for an automaton
+	# @param initial [AutomatonState] Initial state
+	# @param states [Array[AutomatonState]] List of transitions
+	# @param line [String] String to be validated
+	# @return [Boolean] True if the string is accepted, false otherwise
 	def validateString(initial, states, line)
 		st = initial
 		usedLine = String.new line
@@ -106,7 +147,10 @@ class AutomatonAnalyzer
 		end
 	end
 
-	#Returns true if the automaton ends in final state, returns false otherwise
+	# Returns true if the automaton ends in final state, returns false otherwise
+	# @param sourceFile [String] JFLAP file location
+	# @param testString [String] String to be analyzed
+	# @return [Boolean] True if the string is accepted, False otherwise
 	def analyze(sourceFile, testString)
 		file = File.new(sourceFile, "r")
 		line = file.read

data/lib/Grammar Analyzer.rb

@@ -1,34 +1,50 @@
 require 'thread'
 load 'Grammar Reader.rb'
 
+# Analyzer for grammars
+# For using it first creates the analyzer with new,
+# then use the analyze method to know if the string is accepted or not
+# @attr mutex [Object] Mutex for managing concurrency
+# @attr valid [Boolean] Determine if a string is valid or not in certain time of the instance
+# @attr errno [Integer] Identifier for some errors on the analyzer
 class GrammarAnalyzer
 	attr_accessor :mutex, :valid, :errno
-
+	# Return errno of the analyzer
+	# @return [Integer] 0 errno is that the analyzer completed with no error, otherwise it is different to 0
 	def errno()
 		return @errno
 	end
-
+	# Initialize the analyzer
 	def initialize
 		@mutex = Mutex.new
 		@valid = false
 	end
-
+	# Synchronized println in case of need
+	# @param s [String] String to be printed
+	# @return [Void]
 	def println(s)
 		@mutex.synchronize {
 			puts s
 		}
 	end
-
+	# Check if a char is non-terminal
+	# @param char Char to be checked
+	# @return [bool] True if the char is non-terminal, False otherwise
 	def isNT(char)
 		return "A" <= char && char <= "Z"
 	end
-
+	# Method for removing the first char of a string
+	# @param line [String] String to be modified
+	# @return [String] Modified string
 	def removeFirst(line)
 		line.reverse!
 		line.chop!
 		line.reverse!
 	end
-
+	# Determine if the analyzer must continue or not
+	# @param prod [String] Actual produced line
+	# @param line [String] Final line to be matched
+	# @return [Boolean] True if analyzer can continue, False otherwise
 	def canContinue(prod, line)
 		p = String.new prod
 		s = 0
@@ -38,6 +54,11 @@ class GrammarAnalyzer
 		return s <= line.length
 	end
 
+	# Threaded method to determine if the string is accepted or not
+	# @param prod [String] Actual produced line
+	# @param line [String] String to be matched
+	# @param prods [Hash] Productions of the grammar
+	# @return [Void]
 	def analyzer(prod, line, prods)
 		while canContinue(prod, line)
 			if prod.length == 0
@@ -65,7 +86,10 @@ class GrammarAnalyzer
 			end
 		end
 	end
-
+	# Determine if a string is valid for a Grammar
+	# @param file [String] JFLAP file location
+	# @param line [String] String to be checked
+	# @return [Boolean] True if the string can be matched, False otherwise
 	def analyze(file, line)
 		reader = GrammarReader.new
 		prods = reader.createProductions(reader.readFile(file))

data/lib/Grammar Reader.rb

@@ -1,16 +1,24 @@
+# Reader for JFLAP Grammar file
+# @attr error [Integer] Identifier for certain errors on reading
 class GrammarReader
-	SYNTAX_ERROR = 1
-	PRODUCTION_ERROR = 2  
+	# Grammar Reader SYNTAX ERROR
+	SYNTAX_ERROR = 100
+	# Grammar Reader PRODUCTION ERROR
+	PRODUCTION_ERROR = 101
 	attr_accessor :error
-
   def initialize()
     @error = 0
   end
+	# Return the left part of a production
+	# @param modified [String] String containing the left part of production
+	# @return [String] Left part of production
   def getLeft(modified)
   	modified.slice! "\t\t<left>"
   	ret = modified[0]
   end
-
+	# Return the right part of a production
+	# @param modified [String] String containing the right part of production
+	# @return [String] Right part of production
   def getRight(modified)
   	modified.slice! "\t\t<right>"
   	ret = ""
@@ -22,7 +30,9 @@ class GrammarReader
   	return ret
   end
 
-  #returns an Array containing the lines from the file
+  # Returns an Array containing the lines from the file
+	# @param file [String] File location
+	# @return [Array[String]] Array containing lines in file
   def readFile(file)
     file = File.new(file, "r")
     line = file.read
@@ -30,15 +40,17 @@ class GrammarReader
     lines = line.split("\n")
   end
 
-  #returns the Hash containing the productions
+  # Returns a Hash containing the productions
+	# @param lines [Array[String]] Separated lines of the file
+	# @return [Hash] Hash containing in key the left part of the production, and in value an Array with the right parts of the production
   def createProductions(lines)
     productions = Hash.new
     if !lines[0].include? "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?><!--Created with JFLAP"
-      @error = 1
+      @error = SYNTAX_ERROR
       return productions
     end
     if !lines[1].include? "\t<type>grammar</type>"
-      @error = 2
+      @error = SYNTAX_ERROR
     	return productions
     end
     counter = 3

data/lib/PDA.rb

@@ -1,51 +1,87 @@
+# Transition of Pushdown Automaton
+# @attr destination [Integer] Next state in the transition
+# @attr push [String] Elements to push in stack
+# @attr pop [String] Element to pop in stack
 class PDATransition
 	attr_accessor :destination, :push, :pop
+	# @param destination [Integer] Destination of the transition
+	# @param push [String] String to be pushed on stack
+	# @param pop [String] String to be popped of the stack
 	def initialize(destination, push, pop)
 		@destination = destination
 		@push = push
 		@pop = pop
 	end
+	# Return the destination
+	# @return [Integer] Next destination
 	def getDestination()
 		return @destination
 	end
 end
 
+# Pushdown Automaton state
+# @attr id [Integer] ID of the state
+# @attr nombre [String] Name of the state
+# @attr transitions [Hash] Transitions of the state
+# @attr final [Boolean] Determine if the state is final or not
 class PDAState
 	@id
 	@nombre
 	@transitions
 	@final
+	# @param id [Integer] ID of the state
+	# @param nombre [String] Name of the state
+	# @param final [Boolean] The state is final or not
 	def initialize(id, nombre, final)
 		@id = id
 		@nombre = nombre
 		@transitions = Hash.new
 		@final = final
 	end
+	# Add a transition with a determinated input
+	# @param char [String] Key where the transition will be added
+	# @param to [Integer] ID of the next state
+	# @param pop [String] Value to be popped of the stack
+	# @param push [String] Value to be pushed on the stack
+	# @return [Void]
 	def addTrans(char, to, pop, push)
 		if @transitions[char] == nil
 			@transitions[char] = Hash.new
 		end
 		@transitions[char][to] = PDATransition.new to, push, pop
 	end
+	# Return the transition for a determinated input
+	# @param char [String] Input to be searched
+	# @return [Hash] Transitions for the input
 	def transAt(char)
 		ret = @transitions[char]
 	end
+	
+	# Determine if the state is final or not
+	# @return [Boolean] True if the state is final, False otherwise
 	def final()
 		ret = @final
 	end
 end
 
+# Pushdown Automaton Analyzer
+# @attr valid [Boolean] Determine if the analyzer has been invalidated or not
+# @attr errno [Integer] Identifier for errors
 class PDAAnalyzer
 	@valid = false
 	attr_accessor :errno
+	# Determine error number
+	# @return [Integer] Identifier of the error (0 -> No error)
 	def errno()
 		return @errno
 	end
-
+	
 	def initialize 
 		@errno = 0
 	end
-
+	# Get a state ID
+	# @param modified [String] String containing the state ID
+	# @return [Integer] State ID
 	def getStateID(modified)
 		modified.slice! "\t\t<state id=\""
 		lastQuota = true
@@ -59,7 +95,9 @@ class PDAAnalyzer
 		end
 		id = id
 	end
-
+	# Get a state name
+	# @param modified [String] String containing the state name
+	# @return [String] State name
 	def getStateName(modified)
 		modified.slice! "\" name=\""
 		lastQuota = true
@@ -71,7 +109,9 @@ class PDAAnalyzer
 		end
 		id = id
 	end
-
+	# Get a transition push
+	# @param modified [String] String containing the transition push
+	# @return [String] Transtion push
 	def readPush(modified)
 		lastQuota = true
 		id = ""
@@ -82,7 +122,9 @@ class PDAAnalyzer
 		end
 		id = id
 	end
-
+	# Get a transition pop
+	# @param modified [String] String containing the transition pop
+	# @return [String] Transtion pop
 	def readPop(modified)
 		lastQuota = true
 		id = ""
@@ -93,7 +135,9 @@ class PDAAnalyzer
 		end
 		id = id
 	end
-
+	# Get a transition next state
+	# @param modified [String] String containing the transition next state
+	# @return [Integer] Transtion next state
 	def readTransInt(modified)
 		lastQuota = true
 		id = 0
@@ -105,9 +149,13 @@ class PDAAnalyzer
 			id = id + char.to_i
 		end
 		id = id
-
 	end
-
+	# Validate an input string
+	# @param initial [PDAState] Initial state
+	# @param states [Hash] Transitions of the automaton
+	# @param line [String] Line to be validated
+	# @param stack [Array] Stack of the automaton
+	# @return [Boolean] True if the string was accepted, False otherwise
 	def validateString(initial, states, line, stack)
 		st = initial
 		usedLine = String.new line
@@ -142,8 +190,12 @@ class PDAAnalyzer
 		end
 	end
 
-	#Returns true if the automaton ends in final state, returns false otherwise
+	# Analyze a JFLAP file for Pushdown automaton and determine if a string is valid for that automaton
+	# @param sourceFile [String] JFLAP File location
+	# @param testString [String] String to be validated
+	# @return [Boolean] True if the string was accepted, false otherwise
 	def analyze(sourceFile, testString)
+		@valid = false
 		file = File.new(sourceFile, "r")
 		line = file.read
 		file.close

data/lib/Regular Expression.rb

@@ -1,6 +1,11 @@
+# Regular Expression Analyzer
+# @attr regex [Regexp] Regular Expression
+# @attr errno [Integer] Identifier for errors
 class RegularExpression
   @regex
   attr_accessor :errno
+  # Identifier for errors
+  # @return [Integer] If there are errors value is more than 0, otherwise is 0
 	def errno()
 		return @errno
 	end
@@ -8,14 +13,18 @@ class RegularExpression
   def initialize
     @errno = 0
   end
-
+	# File reader
+	# @param file [String] File location
+	# @return [Array[String]] Array containing separated lines of the file
   def readFile(file)
     file = File.new(file, "r")
     line = file.read
     file.close
     lines = line.split("\n")
   end
-
+	# Regular expression creation
+	# @param lines [Array[String]] Lines of the file
+	# @return [Void]
   def createRegex(lines)
     regex = ""
 #    if lines[0].contains? "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>") != nil
@@ -39,6 +48,10 @@ class RegularExpression
     regex.reverse!
     @regex = Regexp.new "^" + regex + "$"
   end
+  # Determine if a string is accepted by a regular expression
+  # @param file [String] JFLAP file location
+  # @param input [String] String to be validated
+  # @return [Boolean] True if string was accepted, False otherwise
   def analyze(file, input)
     createRegex(readFile(file))
     return false if @errno != 0 

data/lib/Regular Grammar Analyzer.rb

@@ -1,3 +1,7 @@
+# Regular Grammar Production, since it is deprecated it is needed to add a Regular Grammar Checker to {#GrammarAnalyzer}
+# @deprecated
+# @attr left [String] Left part of production
+# @attr right [Array] Right part of production
 class RegularGrammarProduction
   @left
   @right
@@ -5,20 +9,32 @@ class RegularGrammarProduction
     @left = left
     @right = []
   end
+	# Add element to right production
+	# @param right [String] New production to push
+	# @return [Void]
   def addRight(right)
     @right.push(right)
   end
+	# Get elements from right production
+	# @return [Array[String]] productions
   def getRight()
     return @right
   end
 end
 
-SYNTAX_ERROR = 1
-PRODUCTION_ERROR = 2
-
+# Regular Grammar Analyzer, since it is deprecated it is needed to add a Regular Grammar Checker to {#GrammarAnalyzer}
+# @deprecated
+# @attr valid [Boolean] Determine  if the string is valid in a certain time
+# @attr errno [Integer] Identify errors
 class RegularGrammar
   @valid
   attr_accessor :errno
+	# Regular Grammar SYNTAX ERROR Identificator
+	SYNTAX_ERROR = 1
+	# Regular Grammar PRODUCTION ERROR Identificator
+	PRODUCTION_ERROR = 2
+	#Identify errors
+	# @return [Integer] 0 if no errors, different from 0 otherwise
 	def errno()
 		return @errno
 	end
@@ -27,11 +43,16 @@ class RegularGrammar
     @valid = false
     @errno = 0
   end
+	# Get left part of production
+	# @param modified [String] String containing left part of production
+	# @return [String] Left part of production
   def getLeft(modified)
   	modified.slice! "\t\t<left>"
   	ret = modified[0]
   end
-
+	# Get right part of production
+	# @param modified [String] String containing right part of production
+	# @return [String] Right part of production
   def getRight(modified)
   	modified.slice! "\t\t<right>"
   	ret = ""
@@ -43,7 +64,9 @@ class RegularGrammar
   	return ret
   end
 
-  #returns an Array containing the lines from the file
+  # Returns an Array containing the lines from the file
+	# @param file [String] File location
+	# @return [Array[String]] Separated lines of the file
   def readFile(file)
     file = File.new(file, "r")
     line = file.read
@@ -51,7 +74,9 @@ class RegularGrammar
     lines = line.split("\n")
   end
 
-  #returns the Hash containing the productions
+  # Returns the Hash containing the productions
+	# @param lines [Array[String]] Separated lines of JFLAP file
+	# @return [Hash] Productions of the grammar
   def createProductions(lines)
     productions = Hash.new
     if !lines[0].include? "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>"
@@ -87,18 +112,29 @@ class RegularGrammar
     return productions
   end
 
+	# Verify lambda production
+	# @param string [String] String to be verified
+	# @return [Void]
   def chompLambda(string)
     if !@valid
       @valid = (string.length==0)
     end
   end
-
+	
+	# Verify only terminal production
+	# @param string [String] String to be verified
+	# @return [Void]
   def chompChar(string, char)
     if !@valid
       @valid = (string.length == 1 && string[0] == char)
     end
   end
 
+	# Analyze an input
+	# @param productions [Hash] Grammar productions
+	# @param line [String] String to be verified
+	# @param state [RegularGrammarState] Actual State
+	# @return [Boolean] True if string is accepted, False otherwise
   def analyzeInput(productions, line, state)
     # Right Grammar S -> aS | a
     prods = productions[state].getRight()
@@ -174,6 +210,10 @@ class RegularGrammar
     end
   end
 
+	# Analyze a string from a JFLAP file
+	# @param file [String] JFLAP File location
+	# @param line [String] String to be verified
+	# @return [Boolean] True if string is accepted, False otherwise
   def analyze(file, line)
     productions = createProductions(readFile(file))
     @valid = analyzeInput(productions, line, "S")

data/lib/Turing Analyzer.rb

@@ -1,262 +1,306 @@
 require 'thread'
 load 'Turing Reader.rb'
+# Turing machine state
+# @attr tag [String] Tag of the state
+# @attr id [Integer] ID of the state
+# @attr name [String] Name of the state
+# @attr initial [Boolean] Determine if state is initial
+# @attr final [Boolean] Determine if the state is final
+# @attr transitions [Hash] List of transitions
 class TuringState
-    attr_accessor :tag, :id, :name, :initial, :final, :transitions
-    def initialize
-        @transitions = Hash.new
-    end
+  attr_accessor :tag, :id, :name, :initial, :final, :transitions
+  def initialize
+    @transitions = Hash.new
+  end
 end
 
+# Turing Machine Transition
+# @attr to [Integer] Next state
+# @attr write [String] Element to write on the Turing machine tape
+# @attr write [String] Position to move in the Turing machine tape
 class TuringTransition
     attr_accessor :to, :write, :move
 end
 
+# Turing Machine Analyzer
+# @attr reader [TuringReader] File reader
+# @attr lines [Array[String]] Separated lines of the file
+# @attr states [Array[TuringState]] List of states
+# @attr valid [Boolean] Determine if there is a valid string
+# @attr errno [Integer] Identifier for errors
+# @attr initial [TuringState] Initial State
 class TuringAnalyzer
-    attr_accessor :reader, :lines, :states, :valid, :errno
+  attr_accessor :reader, :lines, :states, :valid, :errno
+	@initial
 
+	# Determine the kind of error in the file
+	# @return [Integer] More than 0 for error, 0 for no error
 	def errno()
 		return @errno
-	end	
+	end
+	
+  def initialize
+    @reader = TuringReader.new
+    @states = Array.new
+    @initial = nil
+    @valid = false
+    @errno = 0
+  end
 
-    @initial
-    def initialize
-        @reader = TuringReader.new
-        @states = Array.new
-        @initial = nil
-        @valid = false
-        @errno = 0
+	# Analyze a string using a JFLAP Turing machine
+	# @param file [String] JFLAP file location
+	# @param line [String] String to be validated
+	# @return [Boolean] True if the string is accepted, False otherwise
+  def analyze(file, line)
+		@valid = false
+    @lines = @reader.readFile file
+    validateJFlap
+    deleteLine
+    validateTuringMachine
+    deleteLine
+    createStates
+    position = 0
+    until line[position] != "B"
+      position = position + 1
     end
+    validate line, @initial, position
+    return @valid
+  end
 
-    def analyze file, line
-        @lines = @reader.readFile file
-        puts "Valid" if validateJFlap
-        deleteLine
-        puts "Valid" if validateTuringMachine
+	# Check if the file is from JFLAP
+	# @return [Boolean] True if file is from JFLAP, False otherwise
+  def validateJFlap
+    return true if @lines[0].match "JFLAP"
+    @errno = 1
+    return false
+  end
+
+	# Check if the file is from JFLAP Turing Machine
+	# @return [Boolean] True if file is from JFLAP Turing machine, False otherwise
+  def validateTuringMachine
+    return true if @lines[0].match "turing"
+    @errno = 2
+    return false
+  end
+
+	# Create the list of states
+	# @return [Void]
+  def createStates
+    return false if !lines[0].match "automaton"
+    deleteLine
+    if lines[0].match "<!--The list of states.-->"
         deleteLine
-        createStates
-        position = 0
-        until line[position] != "B"
-            position = position + 1
-        end
-        validate line, @initial, position
-        return @valid
+    else
+      return false
     end
-
-    def validateJFlap
-        return true if @lines[0].match "JFLAP"
-        @errno = 1
-        return false
+    while createState 
+			i = 1
     end
-
-    def validateTuringMachine
-        return true if @lines[0].match "turing"
-        @errno = 2
-        return false
+    if lines[0].match "<!--The list of transitions.-->"
+      deleteLine
+    else
+      return false
     end
-
-    def createStates
-        return false if !lines[0].match "automaton"
-        deleteLine
-        if lines[0].match "<!--The list of states.-->"
-            deleteLine
-        else
-            return false
-        end
-        while createState 
-        end
-        if lines[0].match "<!--The list of transitions.-->"
-            deleteLine
-        else
-            return false
-        end
-        until createTransition == false
-        end
-        puts @states.to_s
+    until createTransition == false
+			i = 1
     end
+  end
 
-    def createState
-        state = TuringState.new
-        return false if !lines[0].match "block"
-        deleteTabs
-        lines[0].slice! "<block "
-        # Create id
-        state.id = 0
-        lines[0].slice! "id=\""
-        until lines[0][0] == "\""
-            state.id = state.id * 10
-            state.id = state.id + lines[0][0].to_i
-            lines[0].slice! lines[0][0]
-        end
-        lines[0].slice! "\" "
-        # Create name
-        state.name = ""
-        lines[0].slice! "name=\""
-        until lines[0][0] == "\""
-            state.name = state.name + lines[0][0]
-            lines[0].slice! lines[0][0]
-        end
-        deleteLine
-        # Tags
-        return false if !lines[0].match "tag"
-        deleteLine
-        # X position
-        deleteLine
-        # Y position
-        deleteLine
-        # Initial?
-        state.initial = false
-        if lines[0].match "initial"
-            @initial = state.id if @initial == nil
-            state.initial = true
-            deleteLine
-        end
-        # Final?
-        state.final = false
-        if lines[0].match "final"
-            state.final = true
-            deleteLine
-        end
-        # Check closing bracket
-        return false if !lines[0].match "</block>"
-        deleteLine
-        @states[state.id] = state
-        return true
+	# Create a Turing state
+	# return [Boolean] False if there is an error, True otherwise
+  def createState
+    state = TuringState.new
+    return false if !lines[0].match "block"
+    deleteTabs
+    lines[0].slice! "<block "
+    # Create id
+    state.id = 0
+    lines[0].slice! "id=\""
+    until lines[0][0] == "\""
+      state.id = state.id * 10
+      state.id = state.id + lines[0][0].to_i
+      lines[0].slice! lines[0][0]
+    end
+    lines[0].slice! "\" "
+    # Create name
+    state.name = ""
+    lines[0].slice! "name=\""
+    until lines[0][0] == "\""
+      state.name = state.name + lines[0][0]
+      lines[0].slice! lines[0][0]
     end
+    deleteLine
+    # Tags
+    return false if !lines[0].match "tag"
+    deleteLine
+    # X position
+    deleteLine
+    # Y position
+    deleteLine
+    # Initial?
+    state.initial = false
+    if lines[0].match "initial"
+      @initial = state.id if @initial == nil
+      state.initial = true
+      deleteLine
+    end
+    # Final?
+    state.final = false
+    if lines[0].match "final"
+      state.final = true
+      deleteLine
+    end
+    # Check closing bracket
+    return false if !lines[0].match "</block>"
+    deleteLine
+    @states[state.id] = state
+    return true
+  end
 
-    def createTransition
-        from = 0
-        to = 0
-        if lines[0].match "<transition>"
-            deleteLine
-        else
-            return false
-        end
-        # From
-        deleteTabs
-        lines[0].slice! "<from>"
-        until lines[0][0] == "<"
-            from = from * 10
-            from = from + lines[0][0].to_i
-            lines[0].slice! lines[0][0]
-        end
-        deleteLine
-        # To
-        deleteTabs
-        lines[0].slice! "<to>"
-        until lines[0][0] == "<"
-            to = to * 10
-            to = to + lines[0][0].to_i
-            lines[0].slice! lines[0][0]
-        end
-        deleteLine
-        # Read
-        if lines[0].match "<read/>"
-            read = nil
-        else
-            deleteTabs
-            read = 0
-            lines[0].slice! "<read>"
-            until lines[0][0] == "<"
-                read = read * 10
-                read = read + lines[0][0].to_i
-                lines[0].slice! lines[0][0]
-            end
-        end
-        deleteLine
-        # Write
-        if lines[0].match "<write/>"
-            write = nil
-        else
-            deleteTabs
-            write = 0
-            lines[0].slice! "<write>"
-            until lines[0][0] == "<"
-                write = write * 10
-                write = write + lines[0][0].to_i
-                lines[0].slice! lines[0][0]
-            end
-        end
-        deleteLine
-        if lines[0].match "<move>R"
-            move = "R"
-        elsif lines[0].match "<move>L"
-            move = "L"
-        elsif lines[0].match "<move>S"
-            move = "S"
-        else
-            move = nil
-        end
-        if @states[from].transitions[read] == nil
-            @states[from].transitions[read] = Array.new
-        end
-        trans = TuringTransition.new
-        trans.to = to
-        trans.write = write
-        trans.move = move
-        @states[from].transitions[read].push trans
-        deleteLine
-        if lines[0].match "</transition>"
-            deleteLine
-            return true
-        end
-        return false
+	# Create Turing transition
+	# return [Boolean] False if there is an error, True otherwise
+  def createTransition
+    from = 0
+    to = 0
+    if lines[0].match "<transition>"
+      deleteLine
+    else
+      return false
+    end
+    # From
+    deleteTabs
+    lines[0].slice! "<from>"
+    until lines[0][0] == "<"
+      from = from * 10
+      from = from + lines[0][0].to_i
+      lines[0].slice! lines[0][0]
+    end
+    deleteLine
+    # To
+    deleteTabs
+    lines[0].slice! "<to>"
+    until lines[0][0] == "<"
+      to = to * 10
+      to = to + lines[0][0].to_i
+      lines[0].slice! lines[0][0]
+    end
+    deleteLine
+    # Read
+    if lines[0].match "<read/>"
+      read = nil
+    else
+      deleteTabs
+      read = 0
+      lines[0].slice! "<read>"
+      until lines[0][0] == "<"
+        read = read * 10
+        read = read + lines[0][0].to_i
+        lines[0].slice! lines[0][0]
+      end
+    end
+    deleteLine
+    # Write
+    if lines[0].match "<write/>"
+      write = nil
+    else
+      deleteTabs
+      write = 0
+      lines[0].slice! "<write>"
+      until lines[0][0] == "<"
+        write = write * 10
+        write = write + lines[0][0].to_i
+        lines[0].slice! lines[0][0]
+      end
+    end
+    deleteLine
+    if lines[0].match "<move>R"
+      move = "R"
+    elsif lines[0].match "<move>L"
+      move = "L"
+    elsif lines[0].match "<move>S"
+      move = "S"
+    else
+      move = nil
     end
+    if @states[from].transitions[read] == nil
+      @states[from].transitions[read] = Array.new
+    end
+    trans = TuringTransition.new
+    trans.to = to
+    trans.write = write
+    trans.move = move
+    @states[from].transitions[read].push trans
+    deleteLine
+    if lines[0].match "</transition>"
+      deleteLine
+      return true
+    end
+    return false
+  end
 
-    def deleteLine
-        size = @lines.size
-        newLines = Array.new
-        for i in 0...size-1
-            newLines[i] = @lines[i+1]
-        end
-        @lines = newLines
+	# Delete the first line
+	# @return [Void]
+  def deleteLine
+    size = @lines.size
+    newLines = Array.new
+    for i in 0...size-1
+      newLines[i] = @lines[i+1]
     end
+    @lines = newLines
+  end
 
-    def deleteTabs
-        until !lines[0].match "\t"
-            lines[0].slice! "\t"
-        end
+	# Clear tabs of the first line
+	# @return [Void]
+  def deleteTabs
+    until !lines[0].match "\t"
+      lines[0].slice! "\t"
     end
+  end
 
-    def validate line, actual, position
-        transitions = @states[actual].transitions
-        # Launch no read transition
-        read = line[position]
-        if transitions[nil] != nil
-            transitions[nil].each do |trans|
-                if read == "B"
-                    if trans.write == nil
-                        line[position] = "B"
-                    else
-                        line[position] = trans.write
-                    end
-                    newPos = position - 1 if trans.move == "L"
-                    newPos = position + 1 if trans.move == "R"
-                    newPos = position if trans.move == "S"
-                    nilThread = Thread.new { validate(line, trans.to, newPos)}
-                    nilThread.join
-                end
-            end
-        end
-        # Launch read transition / End if no transition
-        read = line[position]
-        if transitions[read] == nil
-            if @valid == false && @states[actual].final == true
-                @valid = true
-            end
+	# Validate a string
+	# @param line [String] Tape for Turing machine
+	# @param actual [TuringState] Actual state on the turing machine
+	# @param position [Integer] Position on the tape
+	# @return [Boolean] True if string is accepted, false otherwise
+  def validate(line, actual, position)
+    transitions = @states[actual].transitions
+    # Launch no read transition
+    read = line[position]
+    if transitions[nil] != nil
+      transitions[nil].each do |trans|
+		    if read == "B"
+		      if trans.write == nil
+		        line[position] = "B"
+		      else
+		        line[position] = trans.write
+		      end
+		      newPos = position - 1 if trans.move == "L"
+		      newPos = position + 1 if trans.move == "R"
+		      newPos = position if trans.move == "S"
+		      nilThread = Thread.new { validate(line, trans.to, newPos)}
+		      nilThread.join
+		    end
+    	end
+		end
+    # Launch read transition / End if no transition
+    read = line[position]
+    if transitions[read] == nil
+      if @valid == false && @states[actual].final == true
+        @valid = true
+      end
+    else
+      transitions[read].each do |trans|
+        if trans.write == nil
+          line[position] = "B"
         else
-            transitions[read].each do |trans|
-                if trans.write == nil
-                    line[position] = "B"
-                else
-                    line[position] = trans.write
-                end
-                newPos = position - 1 if trans.move == "L"
-                newPos = position + 1 if trans.move == "R"
-                newPos = position if trans.move == "S"
-                thread = Thread.new { validate(line, trans.to, newPos)}
-                thread.join
-            end
+          line[position] = trans.write
         end
-    end
-
+		    newPos = position - 1 if trans.move == "L"
+		    newPos = position + 1 if trans.move == "R"
+		    newPos = position if trans.move == "S"
+		    thread = Thread.new { validate(line, trans.to, newPos)}
+		    thread.join
+		  end
+  	end
+	end
 end

data/lib/Turing Reader.rb

@@ -1,10 +1,12 @@
+# JFLAP Turing Machine File reader
 class TuringReader
-
+	# Lines of the file
+	# @param file [String] File location
+	# @return [Array[String]] Separated lines of the file
 	def readFile(file)
 		file = File.new file, "r"
 		line = file.read
 		file.close
 		lines = line.split "\n"
 	end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: SEATC
 version: !ruby/object:Gem::Version
-  version: 0.2.25
+  version: 0.3.0
 platform: ruby
 authors:
 - Salvador Guerra Delgado
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-08 00:00:00.000000000 Z
+date: 2018-11-01 00:00:00.000000000 Z
 dependencies: []
 description: A gem for development on SEATC, can be used for other system that requires
   automaton and grammars analysis
@@ -60,7 +60,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2.1
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 3
 summary: SEATC