basic101 0.1.0

data/test/spec/transform_spec.rb

@@ -0,0 +1,513 @@
+require_relative 'spec_helper'
+
+module Basic101
+
+  describe Transform do
+
+    let(:parser) {Parser.new}
+
+    def self.parse(rule, s)
+      parser = Parser.new.send(rule)
+      parser.parse(s)
+    end
+
+    def self.transform(rule, s)
+      parse_tree = parse(rule, s)
+      Transform.new.apply(parse_tree)
+    end
+
+    def transform(s, rule = rule)
+      self.class.transform(rule, s)
+    end
+
+    def self.it_should_transform(s, expected_result)
+      it "should transform #{s.inspect}" do
+        expect(transform(s)).to eq expected_result
+      end
+    end
+
+    describe 'integer' do
+      let(:rule) {:integer}
+      it_should_transform('123', BasicInteger.new(123))
+      it_should_transform('-123', BasicInteger.new(-123))
+      it_should_transform('+123', BasicInteger.new(123))
+    end
+
+    describe 'float' do
+      let(:rule) {:float}
+      it_should_transform('.2', BasicFloat.new(0.2))
+      it_should_transform('1.2', BasicFloat.new(1.2))
+      it_should_transform('-1.2', BasicFloat.new(-1.2))
+      it_should_transform('+1.2', BasicFloat.new(1.2))
+      it_should_transform('1E-10', BasicFloat.new(1E-10))
+    end
+
+    describe 'quoted_string' do
+      let(:rule) {:unquoted_string}
+      it_should_transform('abc', BasicString.new('abc'))
+    end
+
+    describe 'quoted_string' do
+      let(:rule) {:quoted_string}
+      it_should_transform('"abc"', BasicString.new('abc'))
+      it_should_transform('""', BasicString.new(''))
+    end
+
+    describe 'data_item' do
+      let(:rule) {:data_item}
+      it_should_transform('abc', BasicString.new('abc'))
+      it_should_transform('"abc"', BasicString.new('abc'))
+      it_should_transform('123', BasicInteger.new(123))
+      it_should_transform('123.45', BasicFloat.new(123.45))
+    end
+
+    describe 'data_statement' do
+      let(:rule) {:data_statement}
+      it_should_transform('DATA 1', 
+                          DataStatement.new([
+                                              BasicInteger.new(1),
+                                            ]))
+      it_should_transform('DATA 1, 2', 
+                          DataStatement.new([
+                                              BasicInteger.new(1),
+                                              BasicInteger.new(2),
+                                            ]))
+    end
+
+    describe 'read_statement' do
+      let(:rule) {:read_statement}
+      it_should_transform('READ I',
+                          ReadStatement.new([
+                                              ScalarReference.new(NumericIdentifier.new('I')),
+                                            ]))
+      it_should_transform('READ I, J',
+                          ReadStatement.new([
+                                              ScalarReference.new(NumericIdentifier.new('I')),
+                                              ScalarReference.new(NumericIdentifier.new('J')),
+                                            ]))
+    end
+
+    describe 'gosub_statement' do
+      let(:rule) {:gosub_statement}
+      it_should_transform('GOSUB 100',
+                          GosubStatement.new(100))
+    end
+
+    describe 'return_statement' do
+      let(:rule) {:return_statement}
+      it_should_transform('RETURN', ReturnStatement.new)
+    end
+
+    describe 'built_in_function_identifier' do
+      let(:rule) {:built_in_function_identifier}
+      it_should_transform('LEN', FunctionIdentifier.new('LEN'))
+      it_should_transform('STR$', FunctionIdentifier.new('STR$'))
+    end
+
+    describe 'user_defined_function_identifier' do
+      let(:rule) {:user_defined_function_identifier}
+      it_should_transform('FNA', FunctionIdentifier.new('FNA'))
+      it_should_transform('FNS$', FunctionIdentifier.new('FNS$'))
+    end
+
+    describe 'numeric_identifier' do
+      let(:rule) {:numeric_identifier}
+      it_should_transform('I', NumericIdentifier.new('I'))
+    end
+
+    describe 'string_identifier' do
+      let(:rule) {:string_identifier}
+      it_should_transform('A$', StringIdentifier.new('A$'))
+    end
+
+    describe 'scalar_reference' do
+      let(:rule) {:scalar_reference}
+      it_should_transform('A', ScalarReference.new(NumericIdentifier.new('A')))
+    end
+
+    describe 'array_reference' do
+      let(:rule) {:array_reference}
+      it_should_transform('A("a")',
+                          ArrayReference.new(NumericIdentifier.new('A'), [
+                                               BasicString.new("a")
+                                             ]))
+      it_should_transform('A("a", "b")',
+                          ArrayReference.new(NumericIdentifier.new('A'), [
+                                               BasicString.new("a"),
+                                               BasicString.new("b"),
+                                             ]))
+    end
+
+    describe 'function_call' do
+      let(:rule) {:function_call}
+      it_should_transform('LEN("a")',
+                          FunctionCall.new(FunctionIdentifier.new('LEN'), [
+                                             BasicString.new("a")
+                                           ]))
+      it_should_transform('FNA(1, 2)',
+                          FunctionCall.new(FunctionIdentifier.new('FNA'), [
+                                             BasicInteger.new(1),
+                                             BasicInteger.new(2),
+                                           ]))
+      
+    end
+
+    describe 'power' do
+      let(:rule) {:power}
+      it_should_transform('1', BasicInteger.new(1))
+      it_should_transform('1^2',
+                          PowerOperation.new(BasicInteger.new(1),
+                                             BasicInteger.new(2)))
+      it_should_transform('1^2^3',
+                          PowerOperation.new(BasicInteger.new(1),
+                                             PowerOperation.new(BasicInteger.new(2),
+                                                                BasicInteger.new(3))))
+    end
+
+    describe 'negation' do
+      let(:rule) {:negation}
+      it_should_transform('-1',
+                          NegateOperation.new(BasicInteger.new(1)))
+    end
+
+    describe 'multiply_op' do
+      let(:rule) {:multiply_op}
+      it_should_transform('*', :*)
+      it_should_transform('/', :/)
+    end
+
+    describe 'addition_op' do
+      let(:rule) {:addition_op}
+      it_should_transform('+', :+)
+      it_should_transform('-', :-)
+    end
+
+    describe 'comparison_op' do
+      let(:rule) {:comparison_op}
+      it_should_transform('=', :eq)
+      it_should_transform('<>', :ne)
+      it_should_transform('<', :lt)
+      it_should_transform('<=', :le)
+      it_should_transform('>', :gt)
+      it_should_transform('>=', :ge)
+    end
+
+    describe 'and_op' do
+      let(:rule) {:and_op}
+      it_should_transform('AND', :and)
+    end
+
+    describe 'or_op' do
+      let(:rule) {:or_op}
+      it_should_transform('OR', :or)
+    end
+
+    describe 'term' do
+      let(:rule) {:term}
+      it_should_transform("1 * 2",
+                          BinaryOperations.new(BasicInteger.new(1),
+                                               [
+                                                 BinaryOperation.new(:*,
+                                                                     BasicInteger.new(2)),
+                                               ]))
+      it_should_transform("1", BasicInteger.new(1))
+    end
+
+    describe 'simple_expression' do
+      let(:rule) {:simple_expression}
+      it_should_transform('"abc"', BasicString.new('abc'))
+      it_should_transform('1 + 2', BinaryOperations.new(BasicInteger.new(1),
+                                                        [
+                                                          BinaryOperation.new(:+,
+                                                                              BasicInteger.new(2)),
+                                                        ]))
+    end
+
+    describe 'comparison_expression' do
+      let(:rule) {:comparison_expression}
+      it_should_transform('"abc"', BasicString.new('abc'))
+      it_should_transform('1 < 2', BinaryOperations.new(BasicInteger.new(1),
+                                                        [
+                                                          BinaryOperation.new(:lt,
+                                                                              BasicInteger.new(2)),
+                                                        ]))
+    end
+
+    describe 'not_expression' do
+      let(:rule) {:not_expression}
+      it_should_transform('1', BasicInteger.new(1))
+      it_should_transform('NOT 1',
+                          NotOperation.new(BasicInteger.new(1)))
+    end
+
+    describe 'and_expression' do
+      let(:rule) {:and_expression}
+      it_should_transform('1', BasicInteger.new(1))
+      it_should_transform('1 AND 0', BinaryOperations.new(BasicInteger.new(1),
+                                                          [
+                                                            BinaryOperation.new(:and,
+                                                                                BasicInteger.new(0)),
+                                                          ]))
+    end
+
+    describe 'or_expression' do
+      let(:rule) {:or_expression}
+      it_should_transform('1', BasicInteger.new(1))
+      it_should_transform('1 OR 0', BinaryOperations.new(BasicInteger.new(1),
+                                                         [
+                                                           BinaryOperation.new(:or,
+                                                                               BasicInteger.new(0)),
+                                                         ]))
+    end
+
+    describe 'remark_statement' do
+      let(:rule) {:remark_statement}
+      it_should_transform('REM THIS IS A REMARK',
+                          RemarkStatement.new)
+    end
+
+    describe 'print_separator' do
+      let(:rule) {:print_separator}
+      it_should_transform(';', PrintSemicolon.new)
+      it_should_transform(',', PrintComma.new)
+    end
+
+    describe 'print_arguments' do
+      let(:rule) {:print_arguments}
+      it_should_transform('"a"', [BasicString.new('a')])
+      it_should_transform('"a",', [
+                            BasicString.new('a'),
+                            PrintComma.new,
+                          ])
+    end
+ 
+    describe 'print_statement' do
+      let(:rule) {:print_statement}
+      it_should_transform('PRINT',
+                          PrintStatement.new)
+      it_should_transform('PRINT ,',
+                          PrintStatement.new([
+                                               PrintComma.new
+                                             ]))
+      it_should_transform('PRINT , 1',
+                          PrintStatement.new([
+                                               PrintComma.new,
+                                               BasicInteger.new(1),
+                                             ]))
+      it_should_transform('PRINT "ABC"',
+                          PrintStatement.new([BasicString.new("ABC")]))
+      it_should_transform('PRINT 1;',
+                          PrintStatement.new([
+                                               BasicInteger.new(1),
+                                               PrintSemicolon.new,
+                                             ]))
+      it_should_transform('PRINT 1, 2',
+                          PrintStatement.new([
+                                               BasicInteger.new(1),
+                                               PrintComma.new,
+                                               BasicInteger.new(2),
+                                             ]))
+    end
+
+    describe 'let_statement' do
+      let(:rule) {:let_statement}
+      it_should_transform('I=1',
+                          LetStatement.new(ScalarReference.new(NumericIdentifier.new('I')),
+                                           transform(:expression, '1')))
+    end
+
+    describe 'goto_statement' do
+      let(:rule) {:goto_statement}
+      it_should_transform('GOTO 10', GotoStatement.new(10))
+    end
+
+    describe 'if_block' do
+      let(:rule) {:if_block}
+      it_should_transform('10', GotoStatement.new(10))
+      it_should_transform('PRINT', PrintStatement.new)
+      it_should_transform('PRINT:PRINT', [
+                            PrintStatement.new,
+                            PrintStatement.new
+                          ])
+    end
+    
+    describe 'if_statement' do
+      let(:rule) {:if_statement}
+      it_should_transform('IF 1 THEN 10', [
+                            IfStatement.new(BasicInteger.new(1)),
+                            GotoStatement.new(10),
+                            ElseStatement.new,
+                            EndifStatement.new,
+                          ])
+      it_should_transform('IF 0 THEN RANDOMIZE', [
+                            IfStatement.new(BasicInteger.new(0)),
+                            RandomizeStatement.new,
+                            ElseStatement.new,
+                            EndifStatement.new,
+                          ])
+      it_should_transform('IF 0 THEN RANDOMIZE : PRINT', [
+                            IfStatement.new(BasicInteger.new(0)),
+                            RandomizeStatement.new,
+                            PrintStatement.new,
+                            ElseStatement.new,
+                            EndifStatement.new,
+                          ])
+      it_should_transform('IF 0 THEN RANDOMIZE ELSE PRINT', [
+                            IfStatement.new(BasicInteger.new(0)),
+                            RandomizeStatement.new,
+                            ElseStatement.new,
+                            PrintStatement.new,
+                            EndifStatement.new,
+                          ])
+    end
+
+    describe 'randomize_statement' do
+      let(:rule) {:randomize_statement}
+      it_should_transform('RANDOMIZE', RandomizeStatement.new)
+    end
+
+    describe 'prompt_delimeter' do
+      let(:rule) {:prompt_delimeter}
+      it_should_transform(';', PromptDelimeter.new)
+      it_should_transform(',', NullPromptDelimeter.new)
+    end
+
+    describe 'input' do
+      let(:rule) {:input_statement}
+      it_should_transform('INPUT I',
+                          InputStatement.new(nil, PromptDelimeter.new, [
+                                               ScalarReference.new(NumericIdentifier.new('I')),
+                                             ]))
+      it_should_transform('INPUT "FOO"; I',
+                          InputStatement.new(BasicString.new('FOO'),
+                                             PromptDelimeter.new,
+                                             [
+                                               ScalarReference.new(NumericIdentifier.new('I')),
+                                             ]))
+      it_should_transform('INPUT I,J',
+                          InputStatement.new(nil, PromptDelimeter.new, [
+                                               ScalarReference.new(NumericIdentifier.new('I')),
+                                               ScalarReference.new(NumericIdentifier.new('J')),
+                                             ]))
+    end
+
+    describe 'end_statement' do
+      let(:rule) {:end_statement}
+      it_should_transform('END', EndStatement.new)
+    end
+
+    describe 'dim_statement' do
+      let(:rule) {:dim_statement}
+      it_should_transform('DIM A(10)',
+                          DimStatement.new([
+                                             ArrayReference.new(NumericIdentifier.new('A'), [
+                                                                  BasicInteger.new(10),
+                                                                ]),
+                                           ]))
+      it_should_transform('DIM A(10), B(20)',
+                          DimStatement.new([
+                                             ArrayReference.new(NumericIdentifier.new('A'), [
+                                                                  BasicInteger.new(10),
+                                                                ]),
+                                             ArrayReference.new(NumericIdentifier.new('B'), [
+                                                                  BasicInteger.new(20),
+                                                                ]),
+                                           ]))
+    end
+
+    describe 'for_statement' do
+      let(:rule) {:for_statement}
+      it_should_transform('FOR I = 1 TO 10',
+                          ForStatement.new(ScalarReference.new(NumericIdentifier.new('I')),
+                                           BasicInteger.new(1),
+                                           BasicInteger.new(10),
+                                           nil))
+      it_should_transform('FOR I = 1 TO 10 STEP 2',
+                          ForStatement.new(ScalarReference.new(NumericIdentifier.new('I')),
+                                           BasicInteger.new(1),
+                                           BasicInteger.new(10),
+                                           BasicInteger.new(2)))
+    end
+
+    describe 'next_statement' do
+      let(:rule) {:next_statement}
+      it_should_transform('NEXT', [
+                            NextStatement.new(nil),
+                          ])
+      it_should_transform('NEXT I', [
+                            NextStatement.new(ScalarReference.new(NumericIdentifier.new('I'))),
+                          ])
+      it_should_transform('NEXT I, J', [
+                            NextStatement.new(ScalarReference.new(NumericIdentifier.new('I'))),
+                            NextStatement.new(ScalarReference.new(NumericIdentifier.new('J'))),
+                          ])
+    end
+
+    describe 'on_goto_statement' do
+      let(:rule) {:on_goto_statement}
+      it_should_transform('ON I GOTO 10',
+                          OnGotoStatement.new(ScalarReference.new(NumericIdentifier.new('I')),
+                                              [
+                                                BasicInteger.new(10),
+                                              ]))
+      it_should_transform('ON I GOTO 10, 20',
+                          OnGotoStatement.new(ScalarReference.new(NumericIdentifier.new('I')),
+                                              [
+                                                BasicInteger.new(10),
+                                                BasicInteger.new(20),
+                                              ]))
+    end
+
+    describe 'stop_statement' do
+      let(:rule) {:stop_statement}
+      it_should_transform('STOP', StopStatement.new)
+    end
+
+    describe 'restore_statement' do
+      let(:rule) {:restore_statement}
+      it_should_transform('RESTORE', RestoreStatement.new(nil))
+      it_should_transform('RESTORE 10',
+                          RestoreStatement.new(BasicInteger.new(10)))
+    end
+
+    describe 'define_function_statement' do
+      let(:rule) {:define_function_statement}
+      it_should_transform('DEF FNA$(A) = "."',
+                          DefineFunctionStatement.new(FunctionIdentifier.new('FNA$'),
+                                                      [
+                                                        ScalarReference.new(NumericIdentifier.new('A')),
+                                                      ],
+                                                      BasicString.new('.')))
+      it_should_transform('DEF FNA(I, J) = 1',
+                          DefineFunctionStatement.new(FunctionIdentifier.new('FNA'),
+                                                      [
+                                                        ScalarReference.new(NumericIdentifier.new('I')),
+                                                        ScalarReference.new(NumericIdentifier.new('J')),
+                                                      ],
+                                                      BasicInteger.new(1)))
+    end
+
+    describe 'line' do
+      let(:rule) {:line}
+      it_should_transform('10 REM',
+                          Line.new(10, [RemarkStatement.new]))
+    end
+
+    describe 'program' do
+      let(:rule) {:program}
+      it_should_transform('',
+                          Program.new([]))
+      it_should_transform("10 REM\n",
+                          Program.new([
+                                        Line.new(10, [RemarkStatement.new]),
+                                      ]))
+      it_should_transform("10 REM\n20 PRINT",
+                          Program.new([
+                                        Line.new(10, [RemarkStatement.new]),
+                                        Line.new(20, [PrintStatement.new]),
+                                      ]))
+    end
+
+  end
+
+end