frepl 0.0.1

data/spec/lib/frepl/function_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+RSpec.describe Frepl::Function do
+  let(:simple_function) do
+    Frepl::Function.new([
+        'integer function m(x, y)',
+          'integer, intent(in) :: x, y', 
+          'm = x + y',
+        'end function m'])
+  end
+  context 'simple function' do
+    it 'extracts function name' do
+      expect(simple_function.name).to eq('m')
+    end
+  end
+
+  describe '#==' do
+
+    context 'when other is a `Function`' do
+
+      let(:other_same) do
+        Frepl::Function.new([
+            'integer function m(x, y)',
+              'integer, intent(in) :: x, y', 
+              'm = x * y',
+            'end function m'])
+      end
+
+      let(:other_diff) do
+        Frepl::Function.new([
+            'integer function n(x, y)',
+              'integer, intent(in) :: x, y', 
+              'm = x + y',
+            'end function m'])
+      end
+
+      it 'compares by function name' do
+        expect(simple_function).to eq(other_same)
+        expect(simple_function).not_to eq(other_diff)
+      end
+    end
+  end
+end

data/spec/lib/frepl/multi_declaration_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+RSpec.describe Frepl::MultiDeclaration do
+  context 'multi declaration' do
+    let(:d) { Frepl::MultiDeclaration.new('integer a, b') }
+
+    it 'extracts variable names' do
+      expect(d.variable_names).to eq(['a', 'b'])
+    end
+  end
+
+  context 'multi declaration with assignment' do
+    let(:d) { Frepl::MultiDeclaration.new('integer :: a = 1, b = 2') }
+
+    it 'extracts variable names' do
+      expect(d.variable_names).to eq(['a', 'b'])
+    end
+
+    it 'generates declarations with the right data' do
+      expect(d.declarations.first.variable_name).to eq('a')
+      expect(d.declarations.first.assigned_value).to eq('1')
+    end
+  end
+
+  context 'multiple F2003 array declarations' do
+    let(:d) { Frepl::MultiDeclaration.new('integer, dimension(2) :: a = [1,2], b = [2,3]') }
+
+    it 'extracts variable names' do
+      expect(d.variable_names).to eq(['a', 'b'])
+    end
+  end
+
+  context 'declarations without assignments, and with' do
+    let(:d) { Frepl::MultiDeclaration.new('integer, dimension(2) :: a, b = [2,3]') }
+
+    it 'extracts variable names' do
+      expect(d.variable_names).to eq(['a', 'b'])
+    end
+
+    it 'correctly generates declaration types' do
+      expect(d.declarations.map(&:type)).to eq(['integer', 'integer'])
+    end
+
+    it 'correctly generates declaration assignments' do
+      d1, d2 = d.declarations
+      expect(d1.variable_name).to eq('a')
+      expect(d1.assigned_value).to be_nil
+      expect(d1.output).to eq("integer, dimension(2) :: a\n")
+      expect(d2.variable_name).to eq('b')
+      expect(d2.assigned_value).to eq('[2,3]')
+      expect(d2.output).to eq("integer, dimension(2) :: b=[2,3]\n")
+    end
+  end
+
+  context 'declarations with assignments, and without' do
+    let(:d) { Frepl::MultiDeclaration.new('integer :: a = 1, b, c') }
+
+    it 'extracts variable names' do
+      expect(d.variable_names).to eq(['a', 'b', 'c'])
+    end
+
+    it 'correctly generates declaration types' do
+      expect(d.declarations.map(&:type)).to eq(['integer', 'integer', 'integer'])
+    end
+
+    it 'correctly generates declaration assignments' do
+      d1, d2, d3 = d.declarations
+      expect(d1.variable_name).to eq('a')
+      expect(d1.assigned_value).to eq('1')
+      expect(d1.output).to eq("integer :: a=1\n")
+      expect(d2.variable_name).to eq('b')
+      expect(d2.assigned_value).to be_nil
+      expect(d2.output).to eq("integer :: b\n")
+      expect(d3.variable_name).to eq('c')
+      expect(d3.assigned_value).to be_nil
+      expect(d3.output).to eq("integer :: c\n")
+    end
+  end
+
+  context 'deferred shape pointer array' do
+    let(:d) { Frepl::MultiDeclaration.new('integer, dimension(:), pointer :: row, col') }
+
+    it 'extracts variable names' do
+      expect(d.variable_names).to eq(['row', 'col'])
+    end
+
+    it 'correctly generates declaration types' do
+      expect(d.declarations.map(&:type)).to eq(['integer', 'integer'])
+    end
+
+    it 'correctly generates declaration assignments' do
+      d1, d2 = d.declarations
+      expect(d1.variable_name).to eq('row')
+      expect(d1.assigned_value).to be_nil
+      expect(d1.output).to eq("integer, dimension(:), pointer :: row\n")
+      expect(d2.variable_name).to eq('col')
+      expect(d2.assigned_value).to be_nil
+      expect(d2.output).to eq("integer, dimension(:), pointer :: col\n")
+    end
+  end
+
+  context 'targetable arrays' do
+    let(:d) { Frepl::MultiDeclaration.new('integer, dimension(2), target :: a, b') }
+
+    it 'extracts variable names' do
+      expect(d.variable_names).to eq(['a', 'b'])
+    end
+
+    it 'correctly generates declaration types' do
+      expect(d.declarations.map(&:type)).to eq(['integer', 'integer'])
+    end
+
+    it 'correctly generates declaration assignments' do
+      d1, d2 = d.declarations
+      expect(d1.variable_name).to eq('a')
+      expect(d1.assigned_value).to be_nil
+      expect(d1.output).to eq("integer, dimension(2), target :: a\n")
+      expect(d2.variable_name).to eq('b')
+      expect(d2.assigned_value).to be_nil
+      expect(d2.output).to eq("integer, dimension(2), target :: b\n")
+    end
+  end
+end

data/spec/lib/frepl/subroutine_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+RSpec.describe Frepl::Subroutine do
+  let(:simple_subroutine) do
+    Frepl::Subroutine.new([
+          'subroutine swap(x, y)',
+            'integer, intent(in) :: x', 
+            'integer, intent(out) :: y',
+            'y = x',
+          'end subroutine swap'
+        ])
+  end
+  context 'simple subroutine' do
+    it 'extracts subroutine name' do
+      expect(simple_subroutine.name).to eq('swap')
+    end
+  end
+
+  describe '#==' do
+    context 'when other is a `Subroutine`' do
+      let(:other_same) do
+        Frepl::Subroutine.new([
+          'subroutine swap(x, y)',
+            'integer, intent(in) :: x', 
+            'integer, intent(out) :: y',
+            'y = x',
+          'end subroutine swap'
+          ])
+      end
+
+      let(:other_diff) do
+        Frepl::Subroutine.new([
+          'subroutine swip(x, y)',
+            'integer, intent(in) :: x', 
+            'integer, intent(out) :: y',
+            'y = x',
+          ])
+      end
+
+      it 'compares by subroutine name' do
+        expect(simple_subroutine).to eq(other_same)
+        expect(simple_subroutine).not_to eq(other_diff)
+      end
+    end
+  end
+end

data/spec/lib/frepl_spec.rb

@@ -0,0 +1,256 @@
+require 'spec_helper'
+
+RSpec.describe Frepl do
+  let(:frepl) { Frepl::Main.new }
+  describe 'functional specs', type: :functional do
+    context 'basic program' do
+      it 'works' do
+        expect(Frepl).to receive(:output).with("           1\n").twice
+        file = [
+          'integer a',
+          'a = 1',
+          'write(*,*) a'
+        ]
+        frepl.run_file(file)
+      end
+    end
+
+    context 'declaring multiple variables on a single line' do
+      it 'works' do
+        expect(Frepl).to receive(:output).with("           6\n")
+        file = [
+          'integer :: a = 2, b = 4',
+          'write(*,*) a + b'
+        ]
+        frepl.run_file(file)
+      end
+    end
+
+    context 'defining a function' do
+      it 'works' do
+        expect(Frepl).to receive(:output).with("          12\n")
+        file = [
+          'integer :: a = 8, b = 4',
+            'integer function add(x, y)',
+            'integer, intent(in) :: x, y',
+            'add = x + y',
+          'end function add',
+          'write(*,*) add(a, b)'
+        ]
+        frepl.run_file(file)
+      end
+    end
+
+    context 'redefining the type of a variable' do
+      it 'works' do
+        expect(Frepl).to receive(:output).with("           3\n")
+        expect(Frepl).to receive(:output).with("   3.40000010    \n")
+        file = [
+          'integer :: a = 8',
+          'a = 3',
+          'real :: a = 3.4',
+          'write(*,*) a'
+        ]
+        frepl.run_file(file)
+      end
+    end
+
+    context 'redefining a scalar to vector' do
+      it 'works' do
+        expect(Frepl).to receive(:output).with("           3\n")
+        expect(Frepl).to receive(:output).with("           1           2\n")
+        file = [
+          'integer :: a = 8',
+          'a = 3',
+          'integer, dimension(2) :: a = [1,2]',
+          'write(*,*) a'
+        ]
+        frepl.run_file(file)
+      end
+    end
+
+    context 'redefining a function' do
+      it 'works' do
+        expect(Frepl).to receive(:output).with("           1\n")
+        file = [
+          'integer function m(x, y)',
+            'integer, intent(in) :: x, y', 
+            'm = x + y',
+          'end function m',
+          'integer function m(x, y)',
+            'integer, intent(in) :: x, y', 
+            'm = x - y',
+          'end function m',
+          'write(*,*) m(3, 2)'
+        ]
+        frepl.run_file(file)
+      end
+    end
+
+    context 'changing the kind of a real' do
+      it 'works' do
+        expect(Frepl).to receive(:output).with(match(/12\.\d{7}\s+/))
+        expect(Frepl).to receive(:output).with(match(/12\.\d{15}\s+/))
+        file = [
+          'real(kind=4) :: a = 3.14',
+          'write(*,*) a * 4',
+          'real(kind=8) :: a = 3.14',
+          'write(*,*) a * 4'
+        ]
+        frepl.run_file(file)
+      end
+    end
+
+    context 'redefining a subroutine' do
+      it 'works' do
+        # TODO shouldn't require this first expectation -- don't do IO
+        # unless last(current) execution is WRITE/PRINT or something
+        expect(Frepl).to receive(:output).with("")
+        expect(Frepl).to receive(:output).with("           1\n")
+        file = [
+          'integer :: a = 1, b = 1, c = 1',
+          'subroutine swap(x, y)',
+            'integer, intent(in) :: x', 
+            'integer, intent(out) :: y',
+            'y = x',
+          'end subroutine swap',
+          'subroutine swap(x, y, z)',
+            'integer, intent(in) :: x', 
+            'integer, intent(out) :: y, z',
+            'y = x',
+            'z = x',
+          'end subroutine swap',
+          'call swap(a, b, c)',
+          'write(*,*) c'
+        ]
+        frepl.run_file(file)
+      end
+    end
+
+    context 'echoing a variable value' do
+      it 'works' do
+        expect(Frepl).to receive(:output).with("           1\n").twice
+        file = [
+          'integer a',
+          'a = 1',
+          'a'
+        ]
+        frepl.run_file(file)
+      end
+    end
+
+    context 'with an if statement' do
+      it 'works' do
+        expect(Frepl).to receive(:output).with("           1\n")
+        file = [
+          'logical :: check = .true.',
+          'if (check .EQV. .TRUE.) then',
+            'write(*,*) 1',
+          'end if'
+        ]
+        frepl.run_file(file)
+      end
+    end
+
+    context 'with a do loop' do
+      it 'works' do
+        expect(Frepl).to receive(:output).with("           1\n           2\n           3\n")
+        file = [
+          'integer i',
+          'do i = 1, 3 ',
+            'write(*,*) i',
+          'end do'
+        ]
+        frepl.run_file(file)
+      end
+    end
+
+    context 'with a derived type' do
+      it 'works' do
+        expect(Frepl).to receive(:output).with("   3.40000010    \n")
+        expect(Frepl).to receive(:output).with("   4.05000019    \n")
+        expect(Frepl).to receive(:output).with("   3.40000010       4.05000019    \n")
+        file = [
+          'type point',
+            'real :: x, y',
+          'end type point',
+          'type (point) p1',
+          'p1%x = 3.4',
+          'p1%y = 4.05',
+          'write(*,*) p1'
+        ]
+        frepl.run_file(file)
+      end
+    end
+
+    context 'with multidimensional targetable array and pointers to said array' do
+      it 'works' do
+        expect(Frepl).to receive(:output).with("   1.00000000       2.00000000       3.00000000       4.00000000    \n")
+        expect(Frepl).to receive(:output).with("   1.00000000    \n   3.00000000    \n   2.00000000    \n   4.00000000    \n")
+        file = [
+          'integer i, j',
+          'integer, parameter :: m = 2, n = 2',
+          'real, dimension(m,n), target :: A',
+          'real, dimension(:), pointer:: row, column',
+          'a = reshape(([1,2,3,4]), ([2,2]))',
+          'do i = 1, 2',
+            'do j = 1, 2',
+              'write(*,*) a(i,j)',
+            'end do',
+          'end do'
+        ]
+        frepl.run_file(file)
+      end
+    end
+
+    context 'with deeply nested if statements' do
+      it 'works' do
+        expect(Frepl).to receive(:output).with("           4\n")
+        file = [
+          'if (1 < 2) then',
+            'if (2 < 3) then',
+              'if (3 < 4) then',
+                'write(*,*) 4',
+              'endif',
+            'endif',
+          'endif'
+        ]
+        frepl.run_file(file)
+      end
+    end
+
+    context 'resetting the last statement' do
+      it 'works' do
+        expect(Frepl).to receive(:output)
+        expect(Frepl).to receive(:output).with("           2\n")
+        file = [
+          'integer a',
+          'b = 2',
+          'f:z',
+          'integer :: b = 2',
+          'b'
+        ]
+        frepl.run_file(file)
+      end
+    end
+
+    context 'where statement' do
+      it 'works' do
+        expect(Frepl).to receive(:output).with("           1           2           3           4           5           6           7           8           9          10\n")
+        expect(Frepl).to receive(:output).with("           0           0           0           0           0           1           1           1           1           1\n")
+        file = [
+          'integer, dimension(10) :: a, b',
+          'integer i',
+          'a = ([ (i, i=1,10) ])',
+          'where (a > 5)',
+            'b = 1.',
+          'elsewhere',
+            'b = 0.',
+          'end where',
+          'b'
+        ]
+        frepl.run_file(file)
+      end
+    end
+  end
+end