rley 0.3.11 → 0.3.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ce491e5c66dbf214e515d360d74b17215783ba1b
-  data.tar.gz: 6527418c9d5070bf69b0d0f90d9463fb3d05354b
+  metadata.gz: 3cb8a4bdff7b8a62407ea9b05f6efc807a62bcbf
+  data.tar.gz: 498be3de6c49c8b6800d5f64eb2e1237f845b405
 SHA512:
-  metadata.gz: d057009d0dccc8b7365021c6e1e1f93c1c34fac3b0b1bee16a8a0502950b5436715d0f1e7ded9f79ebcb484a43e3b1d2bd7b22b2dfe0dc64a52d47bc18745cd3
-  data.tar.gz: 92d1b41cb0ac96f65626b198920d60ab76bab3cf4925e74466083e286d9915503143424a9e63cf1593cd089ffd69ac5a25fe7ae95b8ddbbb2f9934c005a106bb
+  metadata.gz: e8ca57661728076d51e311c936698bfe603962de9041c02a686bb7cce360ad21f992437e7f3f460b7792b78c1fe30106cd955b3dbe5ecebdd8973112dc2375df
+  data.tar.gz: 984d7e2dc9f42831657f3a30d58c5e4145cc9383df894f3234dabd09c34138bdfa3bde3aa956f1b14dc8cce97dc90eaa11c85074fca21befd9a038cac95e3218

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+### 0.3.12 / 2016-12-08
+* [NEW] Directory `examples\general\calc`. A simple arithmetic expression demo parser.
+
 ### 0.3.11 / 2016-12-04
 * [NEW] Directory `examples\data_formats\JSON`. A JSON demo parser.
 

data/examples/data_formats/JSON/JSON_parser.rb

@@ -1,6 +1,5 @@
 # Purpose: to demonstrate how to build and render a parse tree for JSON
 # language
-require 'pp'
 require 'rley'  # Load the gem
 require_relative 'json_lexer'
 

data/examples/general/calc/calc_demo.rb

@@ -0,0 +1,31 @@
+require_relative 'calc_parser'
+
+# Create a calculator parser object
+parser = CalcParser.new
+
+# Parse the input expression in command-line
+if ARGV.empty?
+  msg = <<-END_MSG
+Command-line symtax:
+  ruby #{__FILE__} "arithmetic expression"
+  where:
+    the arithmetic expression is enclosed between double quotes (")
+
+  Example:
+  ruby #{__FILE__} "2 * 3 + (4 - 1)"
+END_MSG
+  puts msg
+  exit(1)
+end
+puts ARGV[0]
+result = parser.parse_expression(ARGV[0])
+
+unless result.success?
+  # Stop if the parse failed...
+  puts "Parsing of '#{file_name}' failed"
+  exit(1)
+end
+
+# Generate a parse forest from the parse result
+pforest = result.parse_forest
+# End of file

data/examples/general/calc/calc_grammar.rb

@@ -0,0 +1,28 @@
+# Grammar for simple arithmetical expressions
+require 'rley'  # Load the gem
+
+########################################
+# Define a grammar for basic arithmetical expressions
+builder = Rley::Syntax::GrammarBuilder.new do
+  add_terminals('NUMBER')
+  add_terminals('LPAREN', 'RPAREN') # For '(', ')' delimiters
+  add_terminals('PLUS', 'MINUS') # For '+', '-' operators or sign
+  add_terminals('STAR', 'DIVIDE') # For '*', '/' operators
+  rule 'expression' => %w(sign simple_expression)
+  rule 'simple_expression' => 'term'
+  rule 'simple_expression' => %w(simple_expression add_operator term)
+  rule 'term' => 'factor'
+  rule 'term' => %w(term mul_operator factor)
+  rule 'factor' => 'NUMBER'
+  rule 'factor' => %w(LPAREN expression RPAREN)
+  rule 'sign' => 'PLUS'
+  rule 'sign' => 'MINUS'
+  rule 'sign' => []
+  rule 'add_operator' => 'PLUS'
+  rule 'add_operator' => 'MINUS'  
+  rule 'mul_operator' => 'STAR'
+  rule 'mul_operator' => 'DIVIDE'   
+end
+
+# And now build the grammar...
+CalcGrammar = builder.grammar

data/examples/general/calc/calc_lexer.rb

@@ -0,0 +1,93 @@
+# File: calc_lexer.rb
+# Lexer for a basic arithmetical expression parser
+require 'strscan'
+require 'rley'  # Load the gem
+
+
+class CalcLexer
+  attr_reader(:scanner)
+  attr_reader(:lineno)
+  attr_reader(:line_start)
+  attr_reader(:name2symbol)
+
+  @@lexeme2name = {
+    '(' => 'LPAREN',
+    ')' => 'RPAREN',
+    '+' => 'PLUS',
+    '-' => 'MINUS',
+    '*' => 'STAR',
+    '/' => 'DIVIDE',
+  }
+
+  class ScanError < StandardError ; end
+
+public
+  def initialize(source, aGrammar)
+    @scanner = StringScanner.new(source)
+    @name2symbol = aGrammar.name2symbol
+    @lineno =  1
+  end
+
+  def tokens()
+    tok_sequence = []
+    until @scanner.eos? do
+      token = _next_token
+      tok_sequence << token unless token.nil?
+    end
+
+    return tok_sequence
+  end
+
+private
+  def _next_token()
+    token = nil
+    skip_whitespaces
+    curr_ch = scanner.getch # curr_ch is at start of token or eof reached...
+
+    begin
+      break if curr_ch.nil?
+
+      case curr_ch
+        when '(', ')', '+', '-', '*', '/'
+          type_name = @@lexeme2name[curr_ch]
+          token_type = name2symbol[type_name]
+          token = Rley::Parser::Token.new(curr_ch, token_type)
+
+        # LITERALS
+        when /[-0-9]/ # Start character of number literal found
+          @scanner.pos = scanner.pos - 1 # Simulate putback
+          value = scanner.scan(/-?[0-9]+(\.[0-9]+)?([eE][-+]?[0-9])?/)
+          token_type = name2symbol['NUMBER']
+          token = Rley::Parser::Token.new(value, token_type)
+
+
+        else # Unknown token
+          erroneous = curr_ch.nil? ? '' : curr_ch
+          sequel = scanner.scan(/.{1,20}/)
+          erroneous += sequel unless sequel.nil?
+          raise ScanError.new("Unknown token #{erroneous}")
+      end #case
+
+
+    end while (token.nil? && curr_ch = scanner.getch())
+
+    return token
+  end
+
+
+  def skip_whitespaces()
+    matched = scanner.scan(/[ \t\f\n\r]+/)
+    return if matched.nil?
+
+    newline_count = 0
+    matched.scan(/\n\r?|\r/) { |_| newline_count += 1 }
+    newline_detected(newline_count)
+  end
+
+
+  def newline_detected(count)
+    @lineno += count
+    @line_start = scanner.pos()
+  end
+
+end # class

data/examples/general/calc/calc_parser.rb

@@ -0,0 +1,24 @@
+# Purpose: to demonstrate how to build and render a parse tree for JSON
+# language
+require_relative 'calc_lexer'
+require_relative 'calc_grammar'
+
+# A parser for arithmetic expressions
+class CalcParser < Rley::Parser::GFGEarleyParser
+  attr_reader(:source_file)
+
+  # Constructor
+  def initialize()
+    # Builder the Earley parser with the calculator grammar
+    super(CalcGrammar)
+  end
+
+  def parse_expression(aText)
+    lexer = CalcLexer.new(aText, self.grammar)
+    result = parse(lexer.tokens)
+
+    return result
+  end
+end # class
+
+# End of file

data/lib/rley/constants.rb

@@ -3,7 +3,7 @@
 
 module Rley # Module used as a namespace
   # The version number of the gem.
-  Version = '0.3.11'.freeze
+  Version = '0.3.12'.freeze
 
   # Brief description of the gem.
   Description = "Ruby implementation of the Earley's parsing algorithm".freeze

data/lib/rley/syntax/grammar.rb

@@ -3,11 +3,11 @@ require 'set'
 module Rley # This module is used as a namespace
   module Syntax # This module is used as a namespace
     # A grammar specifies the syntax of a language.
-    #   Formally, a grammar has:
-    #   One start symbol,
-    #   One or more other production rules,
-    #   Each production has a rhs that is a sequence of grammar symbols.
-    #   Grammar symbols are categorized into
+    #   Formally, a grammar has: 
+    #   * One start symbol,
+    #   * One or more other production rules,
+    #   * Each production has a rhs that is a sequence of grammar symbols.
+    #   * Grammar symbols are categorized into 
     #   -terminal symbols
     #   -non-terminal symbols
     class Grammar
@@ -24,8 +24,7 @@ module Rley # This module is used as a namespace
       # A Hash with pairs of the kind: symbol name => grammar symbol
       attr_reader(:name2symbol)
 
-      # @param theProductions [Array of Production] the list of productions
-      # of the grammar.
+      # @param theProductions [Array<Production>] productions of the grammar.
       def initialize(theProductions)
         @rules = []
         @symbols = []

data/lib/rley/syntax/grammar_builder.rb

@@ -34,25 +34,23 @@ module Rley # This module is used as a namespace
         return symbols[aSymbolName]
       end
 
-      # Add the terminal symbols of the language
-      # @param terminalSymbols [String or Terminal] one or more 
-      # terminal symbols to add to the grammar.
+      # Add the given terminal symbols to the grammar of the language
+      # @param terminalSymbols [String or Terminal] 1..* terminal symbols.
       def add_terminals(*terminalSymbols)
         new_symbs = build_symbols(Terminal, terminalSymbols)
         symbols.merge!(new_symbs)
       end
 
 
-      # Add a production rule in the grammar.
-      # @param aProductionRepr [Hash] A Hash-based representation of the 
-      # production. It consists of a key-value pair of the form: 
-      # String => Array.
+      # Add a production rule in the grammar given one 
+      # key-value pair of the form: String => Array.
       #   Where the key is the name of the non-terminal appearing in the 
       #   left side of the rule. 
       #   The value, an Array, is a sequence of grammar symbol names.
       # The rule is created and inserted in the grammar.
       # Example:
-      #   builder.add_production('A' => ['a', 'A', 'c'])
+      #   builder.add_production('A' => ['a', 'A', 'c'])      
+      # @param aProductionRepr [Hash] A Hash-based representation of production 
       def add_production(aProductionRepr)
         aProductionRepr.each_pair do |(lhs_name, rhs_repr)|
           lhs = get_nonterminal(lhs_name)

data/spec/rley/parser/gfg_earley_parser_spec.rb

@@ -358,13 +358,14 @@ SNIPPET
           t_plus = Syntax::VerbatimSymbol.new('+')
           t_star = Syntax::VerbatimSymbol.new('*')
 
-          builder = Syntax::GrammarBuilder.new
-          builder.add_terminals(t_int, t_plus, t_star)
-          builder.add_production('P' => 'S')
-          builder.add_production('S' => %w(S + S))
-          builder.add_production('S' => %w(S * S))
-          builder.add_production('S' => 'L')
-          builder.add_production('L' => 'integer')
+          builder = Syntax::GrammarBuilder.new do
+            add_terminals(t_int, t_plus, t_star)
+            rule 'P' => 'S'
+            rule 'S' => %w(S + S)
+            rule 'S' => %w(S * S)
+            rule 'S' => 'L'
+            rule 'L' => 'integer'
+          end
           input_sequence = [
             { '2' => 'integer' },
             '+',
@@ -603,12 +604,13 @@ MSG
           t_lparen = Syntax::VerbatimSymbol.new('(')
           t_rparen = Syntax::VerbatimSymbol.new(')')
 
-          builder = Syntax::GrammarBuilder.new
-          builder.add_terminals(t_int, t_plus, t_lparen, t_rparen)
-          builder.add_production('S' => 'E')
-          builder.add_production('E' => 'int')
-          builder.add_production('E' => %w(( E + E )))
-          builder.add_production('E' => %w(E + E))
+          builder = Syntax::GrammarBuilder.new do
+            add_terminals(t_int, t_plus, t_lparen, t_rparen)
+            rule 'S' => 'E'
+            rule 'E' => 'int'
+            rule 'E' => %w(( E + E ))
+            rule 'E' => %w(E + E)
+          end
           input_sequence = [
             { '7' => 'int' },
             '+',
@@ -713,15 +715,16 @@ MSG
           t_star = Syntax::VerbatimSymbol.new('*')
           t_slash = Syntax::VerbatimSymbol.new('/')
 
-          builder = Syntax::GrammarBuilder.new
-          builder.add_terminals(t_a, t_star, t_slash)
-          builder.add_production('Z' => 'E')
-          builder.add_production('E' => %w(E Q F))
-          builder.add_production('E' => 'F')
-          builder.add_production('F' => t_a)
-          builder.add_production('Q' => t_star)
-          builder.add_production('Q' => t_slash)
-          builder.add_production('Q' => []) # Empty production
+          builder = Syntax::GrammarBuilder.new do
+            add_terminals(t_a, t_star, t_slash)
+            rule 'Z' => 'E'
+            rule 'E' => %w(E Q F)
+            rule 'E' => 'F'
+            rule 'F' => t_a
+            rule 'Q' => t_star
+            rule 'Q' => t_slash
+            rule 'Q' => [] # Empty production
+          end
 
           tokens = build_token_sequence(%w(a a / a), builder.grammar)
           instance = GFGEarleyParser.new(builder.grammar)

data/spec/rley/parser/groucho_spec.rb

@@ -20,16 +20,17 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       include ExpectationHelper # Mix-in with expectation on parse entry sets
 
       let(:sample_grammar) do
-        builder = Rley::Syntax::GrammarBuilder.new
-        builder.add_terminals('N', 'V', 'Pro')  # N(oun), V(erb), Pro(noun)
-        builder.add_terminals('Det', 'P')       # Det(erminer), P(reposition)
-        builder.add_production('S' => %w(NP VP))
-        builder.add_production('NP' => %w(Det N))
-        builder.add_production('NP' => %w(Det N PP))
-        builder.add_production('NP' => 'Pro')
-        builder.add_production('VP' => %w(V NP))
-        builder.add_production('VP' => %w(VP PP))
-        builder.add_production('PP' => %w(P NP))
+        builder = Rley::Syntax::GrammarBuilder.new do
+          add_terminals('N', 'V', 'Pro')  # N(oun), V(erb), Pro(noun)
+          add_terminals('Det', 'P')       # Det(erminer), P(reposition)
+          rule 'S' => %w(NP VP)
+          rule 'NP' => %w(Det N)
+          rule 'NP' => %w(Det N PP)
+          rule 'NP' => 'Pro'
+          rule 'VP' => %w(V NP)
+          rule 'VP' => %w(VP PP)
+          rule 'PP' => %w(P NP)
+        end
         builder.grammar
       end
 

data/spec/rley/parser/parse_forest_builder_spec.rb

@@ -21,15 +21,16 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # "SPPF=Style Parsing From Earley Recognizers" in
           # Notes in Theoretical Computer Science 203, (2008), pp. 53-67
           # contains a hidden left recursion and a cycle
-          builder = Syntax::GrammarBuilder.new
-          builder.add_terminals('a', 'b')
-          builder.add_production('Phi' => 'S')
-          builder.add_production('S' => %w(A T))
-          builder.add_production('S' => %w(a T))
-          builder.add_production('A' => 'a')
-          builder.add_production('A' => %w(B A))
-          builder.add_production('B' => [])
-          builder.add_production('T' => %w(b b b))
+          builder = Syntax::GrammarBuilder.new do
+            add_terminals('a', 'b')
+            rule 'Phi' => 'S'
+            rule 'S' => %w(A T)
+            rule 'S' => %w(a T)
+            rule 'A' => 'a'
+            rule 'A' => %w(B A)
+            rule 'B' => []
+            rule 'T' => %w(b b b)
+          end
           builder.grammar
       end
 

data/spec/rley/parser/parse_forest_factory_spec.rb

@@ -20,15 +20,16 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # "SPPF-Style Parsing From Earley Recognizers" in
           # Notes in Theoretical Computer Science 203, (2008), pp. 53-67
           # contains a hidden left recursion and a cycle
-          builder = Syntax::GrammarBuilder.new
-          builder.add_terminals('a', 'b')
-          builder.add_production('Phi' => 'S')
-          builder.add_production('S' => %w(A T))
-          builder.add_production('S' => %w(a T))
-          builder.add_production('A' => 'a')
-          builder.add_production('A' => %w(B A))
-          builder.add_production('B' => [])
-          builder.add_production('T' => %w(b b b))
+          builder = Syntax::GrammarBuilder.new do
+            add_terminals('a', 'b')
+            rule 'Phi' => 'S'
+            rule 'S' => %w(A T)
+            rule 'S' => %w(a T)
+            rule 'A' => 'a'
+            rule 'A' => %w(B A)
+            rule 'B' => []
+            rule 'T' => %w(b b b)
+          end
           builder.grammar
       end
 

data/spec/rley/support/ambiguous_grammar_helper.rb

@@ -8,11 +8,12 @@ module AmbiguousGrammarHelper
   # expression grammar.
   # (based on an example from Fisher and LeBlanc: "Crafting a Compiler")
   def grammar_builder()
-    builder = Rley::Syntax::GrammarBuilder.new
-    builder.add_terminals('+', 'id')
-    builder.add_production('S' => 'E')
-    builder.add_production('E' => %w(E + E))
-    builder.add_production('E' => 'id')
+    builder = Rley::Syntax::GrammarBuilder.new do
+      add_terminals('+', 'id')
+      rule 'S' => 'E'
+      rule 'E' => %w(E + E)
+      rule 'E' => 'id'
+    end
     builder
   end
 

data/spec/rley/support/grammar_abc_helper.rb

@@ -5,11 +5,12 @@ module GrammarABCHelper
   # Factory method. Creates a grammar builder for a simple grammar.
   # (based on example in N. Wirth "Compiler Construction" book, p. 6)
   def grammar_abc_builder()
-    builder = Rley::Syntax::GrammarBuilder.new
-    builder.add_terminals('a', 'b', 'c')
-    builder.add_production('S' => 'A')
-    builder.add_production('A' => %w(a A c))
-    builder.add_production('A' => 'b')
+    builder = Rley::Syntax::GrammarBuilder.new do
+      add_terminals('a', 'b', 'c')
+      rule 'S' => 'A'
+      rule 'A' => %w(a A c)
+      rule 'A' => 'b'
+    end
 
     return builder
   end

data/spec/rley/support/grammar_ambig01_helper.rb

@@ -9,13 +9,14 @@ module GrammarAmbig01Helper
   # Grammar 3: An ambiguous arithmetic expression language
   # (based on example in article on Earley's algorithm in Wikipedia)
   def grammar_ambig01_builder()
-    builder = Rley::Syntax::GrammarBuilder.new
-    builder.add_terminals('integer', '+', '*')
-    builder.add_production('P' => 'S')
-    builder.add_production('S' => %w(S + S))
-    builder.add_production('S' => %w(S * S))
-    builder.add_production('S' => 'L')
-    builder.add_production('L' => 'integer')
+    builder = Rley::Syntax::GrammarBuilder.new do
+      add_terminals('integer', '+', '*')
+      rule 'P' => 'S'
+      rule 'S' => %w(S + S)
+      rule 'S' => %w(S * S)
+      rule 'S' => 'L'
+      rule 'L' => 'integer'
+    end
     builder
   end
 

data/spec/rley/support/grammar_b_expr_helper.rb

@@ -8,14 +8,15 @@ module GrammarBExprHelper
   # expression grammar.
   # (based on the article about Earley's algorithm in Wikipedia)
   def grammar_expr_builder()
-    builder = Rley::Syntax::GrammarBuilder.new
-    builder.add_terminals('+', '*', 'integer')
-    builder.add_production('P' => 'S')
-    builder.add_production('S' => %w(S + M))
-    builder.add_production('S' => 'M')
-    builder.add_production('M' => %w(M * T))
-    builder.add_production('M' => 'T')
-    builder.add_production('T' => 'integer')
+    builder = Rley::Syntax::GrammarBuilder.new do
+      add_terminals('+', '*', 'integer')
+      rule 'P' => 'S'
+      rule 'S' => %w(S + M)
+      rule 'S' => 'M'
+      rule 'M' => %w(M * T)
+      rule 'M' => 'T'
+      rule 'T' => 'integer'
+    end
     builder
   end
 

data/spec/rley/support/grammar_l0_helper.rb

@@ -10,20 +10,21 @@ module GrammarL0Helper
   # It defines the syntax of a sentence in a language with a
   # very limited syntax and lexicon in the context of airline reservation.
   def grammar_l0_builder()
-    builder = Rley::Syntax::GrammarBuilder.new
-    builder.add_terminals('Noun', 'Verb', 'Pronoun', 'Proper-Noun')
-    builder.add_terminals('Determiner', 'Preposition')
-    builder.add_production('S' => %w(NP VP))
-    builder.add_production('NP' => 'Pronoun')
-    builder.add_production('NP' => 'Proper-Noun')
-    builder.add_production('NP' => %w(Determiner Nominal))
-    builder.add_production('Nominal' => %w(Nominal Noun))
-    builder.add_production('Nominal' => 'Noun')
-    builder.add_production('VP' => 'Verb')
-    builder.add_production('VP' => %w(Verb NP))
-    builder.add_production('VP' => %w(Verb NP PP))
-    builder.add_production('VP' => %w(Verb PP))
-    builder.add_production('PP' => %w(Preposition PP))
+    builder = Rley::Syntax::GrammarBuilder.new do
+      add_terminals('Noun', 'Verb', 'Pronoun', 'Proper-Noun')
+      add_terminals('Determiner', 'Preposition')
+      rule 'S' => %w(NP VP)
+      rule 'NP' => 'Pronoun'
+      rule 'NP' => 'Proper-Noun'
+      rule 'NP' => %w(Determiner Nominal)
+      rule 'Nominal' => %w(Nominal Noun)
+      rule 'Nominal' => 'Noun'
+      rule 'VP' => 'Verb'
+      rule 'VP' => %w(Verb NP)
+      rule 'VP' => %w(Verb NP PP)
+      rule 'VP' => %w(Verb PP)
+      rule 'PP' => %w(Preposition PP)
+    end
     builder
   end
 

data/spec/rley/support/grammar_sppf_helper.rb

@@ -9,15 +9,16 @@ module GrammarSPPFHelper
   # Notes in Theoretical Computer Science 203, (2008), pp. 53-67
   # contains a hidden left recursion and a cycle
   def grammar_sppf_builder()
-    builder = Rley::Syntax::GrammarBuilder.new
-    builder.add_terminals('a', 'b')
-    builder.add_production('Phi' => 'S')
-    builder.add_production('S' => %w(A T))
-    builder.add_production('S' => %w(a T))
-    builder.add_production('A' => 'a')
-    builder.add_production('A' => %w(B A))
-    builder.add_production('B' => [])
-    builder.add_production('T' => %w(b b b))
+    builder = Rley::Syntax::GrammarBuilder.new do
+      add_terminals('a', 'b')
+      rule 'Phi' => 'S'
+      rule 'S' => %w(A T)
+      rule 'S' => %w(a T)
+      rule 'A' => 'a'
+      rule 'A' => %w(B A)
+      rule 'B' => []
+      rule 'T' => %w(b b b)
+    end
 
     return builder
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rley
 version: !ruby/object:Gem::Version
-  version: 0.3.11
+  version: 0.3.12
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-04 00:00:00.000000000 Z
+date: 2016-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -130,10 +130,14 @@ files:
 - README.md
 - Rakefile
 - examples/NLP/mini_en_demo.rb
+- examples/data_formats/JSON/JSON_demo.rb
 - examples/data_formats/JSON/JSON_grammar.rb
 - examples/data_formats/JSON/JSON_lexer.rb
 - examples/data_formats/JSON/JSON_parser.rb
-- examples/data_formats/JSON/demo_json.rb
+- examples/general/calc/calc_demo.rb
+- examples/general/calc/calc_grammar.rb
+- examples/general/calc/calc_lexer.rb
+- examples/general/calc/calc_parser.rb
 - lib/rley.rb
 - lib/rley/constants.rb
 - lib/rley/formatter/base_formatter.rb