frepl 0.0.1

data/lib/frepl/statements/repl_command.rb

@@ -0,0 +1,46 @@
+module Frepl
+  class ReplCommand < SinglelineStatement
+    COMMANDS = {
+      'run' => {
+        info: 'Run the current set of Fortran code',
+        l: lambda { |file| file.run },
+      },
+      'toggle_debug' => {
+        info: 'Toggle debug mode on/off',
+        l: lambda { |file| Frepl.debug = !Frepl.debug },
+      },
+      'help' => {
+        info: 'View this hopefully helpful help',
+        l: lambda do |file|
+          puts "Available Frepl commands:\n"
+          COMMANDS.each do |k, v|
+            puts "f:#{k} -- #{v[:info]}"
+          end
+        end
+      },
+      'z' => {
+        info: 'Undo last statement',
+        l: lambda do |file|
+          file.undo_last!
+        end
+      }
+    }
+
+    def accept(visitor)
+      visitor.visit_repl_command(self)
+    end
+
+    def run(file)
+      Frepl.log("running: #{cmd}")
+      if COMMANDS.key?(cmd)
+        COMMANDS[cmd][:l].call(file)
+      else
+        puts "Unknown command: `#{cmd}`. Type `f:help` for list of commands."
+      end
+    end
+
+    def cmd
+      @cmd ||= line.match(/f:(.+)/)[1]
+    end
+  end
+end

data/lib/frepl/statements/standalone_variable.rb

@@ -0,0 +1,15 @@
+module Frepl
+  class StandaloneVariable < SinglelineStatement
+    def variable_name
+      @variable_name ||= @line.match(Frepl::Classifier::VARIABLE_NAME_REGEX).to_s
+    end
+
+    def accept(visitor)
+      visitor.visit_standalone_variable(self)
+    end
+
+    def expressionize
+      "write(*,*) #{variable_name}"
+    end
+  end
+end

data/lib/frepl/statements/subroutine.rb

@@ -0,0 +1,29 @@
+module Frepl
+  class Subroutine < MultilineStatement
+    def terminal_regex
+      /end subroutine\s?#{Frepl::Classifier::VARIABLE_NAME_REGEX}/
+    end
+
+    def accept(visitor)
+      visitor.visit_subroutine(self)
+    end
+
+    def name
+      @name ||= lines.first.match(Frepl::Classifier::SUBROUTINE_REGEX)[1]
+    end
+
+    def ==(other)
+      if other.is_a?(Subroutine)
+        self.name == other.name
+      else
+        super(other)
+      end
+    end
+
+    private
+
+    def starting_regex
+      Frepl::Classifier::SUBROUTINE_REGEX
+    end
+  end
+end

data/lib/frepl/statements/where.rb

@@ -0,0 +1,17 @@
+module Frepl
+  class Where < MultilineStatement
+    def terminal_regex
+      /end where/i
+    end
+
+    def accept(visitor)
+      visitor.visit_where(self)
+    end
+
+    private
+
+    def starting_regex
+      Frepl::Classifier::WHERE_REGEX
+    end
+  end
+end

data/lib/frepl/version.rb

@@ -0,0 +1,3 @@
+module Frepl
+  VERSION = "0.0.1"
+end

data/spec/lib/frepl/assignment_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+RSpec.describe Frepl::Assignment do
+  let(:a) { Frepl::Assignment.new('a = 2') }
+
+  describe '#variable_name' do
+    subject { a.variable_name }
+
+    it 'extracts variable name from line' do
+      expect(subject).to eql('a')
+    end
+
+    context 'with no spacing' do
+      let(:a) { Frepl::Assignment.new('a=2') }
+
+      it 'extracts variable name from line' do
+        expect(subject).to eql('a')
+      end
+    end
+
+    context 'with array' do
+      let(:a) { Frepl::Assignment.new('foobar = [1,2,3,4]') }
+
+      it 'extracts variable name from line' do
+        expect(subject).to eql('foobar')
+      end
+    end
+  end
+
+  describe '#assigned_value' do
+    subject { a.assigned_value }
+
+    it 'extracts value' do
+      expect(subject).to eql('2')
+    end
+
+    context 'with no spacing' do
+      let(:a) { Frepl::Assignment.new('a=2') }
+
+      it 'extracts variable name from line' do
+        expect(subject).to eql('2')
+      end
+    end
+
+    context 'with array' do
+      let(:a) { Frepl::Assignment.new('foobar = [1,2,3,4]') }
+
+      it 'extracts variable name from line' do
+        expect(subject).to eql('[1,2,3,4]')
+      end
+    end
+  end
+end

data/spec/lib/frepl/classifier_spec.rb

@@ -0,0 +1,171 @@
+require 'spec_helper'
+
+RSpec.describe Frepl::Classifier do
+  let(:classifier) { Frepl::Classifier.new }
+  describe '#classify' do
+    context 'single declaration with assignment' do
+      let(:line) { 'integer a' }
+
+      it 'returns a single declaration' do
+        expect(classifier.classify(line)).to be_a(Frepl::Declaration)
+      end
+    end
+
+    context 'single declaration with assignment' do
+      let(:line) { 'integer :: a = 1' }
+
+      it 'returns a single declaration' do
+        expect(classifier.classify(line)).to be_a(Frepl::Declaration)
+      end
+    end
+
+    context 'single real kind declaration with assignment' do
+      let(:line) { 'real(kind=4) :: a = 1.0' }
+
+      it 'returns a single declaration' do
+        expect(classifier.classify(line)).to be_a(Frepl::Declaration)
+      end
+    end
+
+    context 'parameter dp declaration' do
+      let(:line) { 'integer, parameter :: dp=kind(1.0d0)' }
+
+      it 'returns a single declaration' do
+        expect(classifier.classify(line)).to be_a(Frepl::Declaration)
+      end
+    end
+
+    context 'real declaration using dp parameter' do
+      let(:line) { 'real(kind=dp) fk' }
+
+      it 'returns a single declaration' do
+        expect(classifier.classify(line)).to be_a(Frepl::Declaration)
+      end
+    end
+
+    context 'single character declaration' do
+      let(:line) { 'character(len=4) name' }
+
+      it 'returns a single declaration' do
+        expect(classifier.classify(line)).to be_a(Frepl::Declaration)
+      end
+    end
+
+    context 'single character declaration with assignment' do
+      let(:line) { 'character(len=4) :: name = "john"' }
+
+      it 'returns a single declaration' do
+        expect(classifier.classify(line)).to be_a(Frepl::Declaration)
+      end
+    end
+
+    context 'single character declaration with assignment, without len' do
+      let(:line) { 'character(4) :: name = "john"' }
+
+      it 'returns a single declaration' do
+        expect(classifier.classify(line)).to be_a(Frepl::Declaration)
+      end
+    end
+
+    context 'single Fortran 2003 array declaration' do
+      let(:line) { 'integer, dimension(3) :: a = [1,2,3]' }
+
+      it 'returns a single declaration' do
+        expect(classifier.classify(line)).to be_a(Frepl::Declaration)
+      end
+    end
+
+    context 'single Fortran oldskool array declaration' do
+      let(:line) { 'integer, dimension(3) :: a = /1,2,3/' }
+
+      it 'returns a single declaration' do
+        expect(classifier.classify(line)).to be_a(Frepl::Declaration)
+      end
+    end
+
+    context 'logical declaration' do
+      let(:line) { 'logical :: somecond = .TRUE.' }
+
+      it 'returns a single declaration' do
+        expect(classifier.classify(line)).to be_a(Frepl::Declaration)
+      end
+    end
+
+    context 'multiple integer declaration' do
+      let(:line) { 'real :: a, b, c' }
+
+      it 'returns an multi declaration' do
+        expect(classifier.classify(line)).to be_a(Frepl::MultiDeclaration)
+      end
+    end
+
+    context 'multiple integer declaration with assignment' do
+      let(:line) { 'real :: a = 1, b, c=2' }
+
+      it 'returns an multi declaration' do
+        expect(classifier.classify(line)).to be_a(Frepl::MultiDeclaration)
+      end
+    end
+
+    context 'multiple array declaration' do
+      let(:line) { 'integer, dimension(3) :: a = [1,2,3], b = [1,2,3]' }
+
+      it 'returns a single declaration' do
+        expect(classifier.classify(line)).to be_a(Frepl::MultiDeclaration)
+      end
+    end
+
+    context 'lone variable name' do
+      let(:line) { 'foobar' }
+
+      it 'returns a standalone variable' do
+        expect(classifier.classify(line)).to be_a(Frepl::StandaloneVariable)
+      end
+    end
+
+    context 'start of if statement' do
+      let(:line) { 'if (9 < 10) then' }
+
+      it 'returns an IfStatement' do
+        expect(classifier.classify(line)).to be_a(Frepl::IfStatement)
+      end
+    end
+
+    context 'start of do loop' do
+      let(:line) { 'do i = 1, 3' }
+
+      it 'returns an DoLoop' do
+        expect(classifier.classify(line)).to be_a(Frepl::DoLoop)
+      end
+    end
+
+    context 'targetable array declaration' do
+      let(:line) { 'real, dimension(m,n), target :: A' }
+
+      it 'returns a single declaration' do
+        expect(classifier.classify(line)).to be_a(Frepl::Declaration)
+      end
+    end
+
+    context 'pointer array declaration' do
+      let(:line) { 'real, dimension(:), pointer:: A' }
+
+      it 'returns a single declaration' do
+        expect(classifier.classify(line)).to be_a(Frepl::Declaration)
+      end
+    end
+  end
+
+  describe 'interruption' do
+    context 'in the middle of a multi-line statement' do
+      it 'should be able to be interrupted and start anew' do
+        classifier.classify('integer function add(a, b')
+        classifier.interrupt
+        classifier.classify('integer function sum(a, b')
+        classifier.classify('integer :: a, b')
+        classifier.classify('sum = a + b')
+        expect(classifier.classify('end function sum').complete?).to be true
+      end
+    end
+  end
+end

data/spec/lib/frepl/declaration_spec.rb

@@ -0,0 +1,193 @@
+require 'spec_helper'
+
+RSpec.describe Frepl::Declaration do
+  context 'simple declaration' do
+    let(:d) { Frepl::Declaration.new('integer a') }
+
+    it 'extracts variable name' do
+      expect(d.variable_name).to eq('a')
+    end
+
+    it 'returns nil value' do
+      expect(d.assigned_value).to eq(nil)
+    end
+
+    it 'extracts type' do
+      expect(d.type).to eq('integer')
+    end
+  end
+
+  context 'simple, double-colon' do
+    let(:d) { Frepl::Declaration.new('real :: a') }
+
+    it 'extracts variable name' do
+      expect(d.variable_name).to eq('a')
+    end
+
+    it 'has nil assigned value' do
+      expect(d.assigned_value).to be_nil
+    end
+
+    it 'extracts type' do
+      expect(d.type).to eq('real')
+    end
+  end
+
+  context 'double-colon plus assignmentj' do
+    let(:d) { Frepl::Declaration.new('integer :: a = 3') }
+
+    it 'extracts variable name' do
+      expect(d.variable_name).to eq('a')
+    end
+
+    it 'has assigned value 3' do
+      expect(d.assigned_value).to eq('3')
+    end
+  end
+
+  context 'dimension plus assignment' do
+    let(:d) { Frepl::Declaration.new('integer, dimension(3) :: a = [1,2,3]') }
+
+    it 'extracts variable name' do
+      expect(d.variable_name).to eq('a')
+    end
+
+    it 'has assigned value [1,2,3]' do
+      expect(d.assigned_value).to eq('[1,2,3]')
+    end
+  end
+
+  context 'real with kind' do
+    let(:d) { Frepl::Declaration.new('real(kind=4) :: a = 2.3') }
+
+    it 'extracts variable name' do
+      expect(d.variable_name).to eq('a')
+    end
+
+    it 'has assigned value [1,2,3]' do
+      expect(d.assigned_value).to eq('2.3')
+    end
+
+    it 'has kind' do
+      expect(d.kind).to eq('4')
+    end
+  end
+
+  context 'real with kind' do
+    let(:d) { Frepl::Declaration.new('real(kind=4) :: a = 2.3') }
+
+    it 'extracts variable name' do
+      expect(d.variable_name).to eq('a')
+    end
+
+    it 'has assigned value [1,2,3]' do
+      expect(d.assigned_value).to eq('2.3')
+    end
+
+    it 'has kind' do
+      expect(d.kind).to eq('4')
+    end
+  end
+
+  context 'logical' do
+    let(:d) { Frepl::Declaration.new('logical :: cond = .FALSE.') }
+
+    it 'extracts variable name' do
+      expect(d.variable_name).to eq('cond')
+    end
+
+    it 'has assigned value .FALSE.' do
+      expect(d.assigned_value).to eq('.FALSE.')
+    end
+  end
+
+  context 'character' do
+    context 'with len' do
+      let(:c) { Frepl::Declaration.new('character(len=4) :: name = "luke"') }
+      it 'extracts variable name' do
+        expect(c.variable_name).to eq('name')
+      end
+
+      it 'has assigned value luke' do
+        expect(c.assigned_value).to eq('"luke"')
+      end
+
+      it 'has len' do
+        expect(c.len).to eq('4')
+      end
+    end
+
+    context 'without len' do
+      let(:c) { Frepl::Declaration.new('character(4) :: name = "luke"') }
+      it 'extracts variable name' do
+        expect(c.variable_name).to eq('name')
+      end
+
+      it 'has assigned value luke' do
+        expect(c.assigned_value).to eq('"luke"')
+      end
+
+      it 'has len' do
+        expect(c.len).to eq('4')
+      end
+    end
+
+    context 'assignments designed to trick regex' do
+      it 'works with equals' do
+        d = Frepl::Declaration.new('character(4) :: x = "\'="')
+        expect(d.assigned_value).to eq('"\'="')
+        expect(d.len).to eq('4')
+      end
+
+      it 'works with brackets' do
+        d = Frepl::Declaration.new('character(8) :: x = "]s\"')
+        expect(d.assigned_value).to eq('"]s\"')
+        expect(d.len).to eq('8')
+      end
+
+      it 'works with spaces' do
+        d = Frepl::Declaration.new('character(len=7) :: x = "len=  f"')
+        expect(d.assigned_value).to eq('"len=  f"')
+        expect(d.len).to eq('7')
+      end
+    end
+
+    context 'targetable array' do
+      let(:c) { Frepl::Declaration.new('real, dimension(m,n), target :: A') }
+
+      it 'extracts variable name' do
+        expect(c.variable_name).to eq('A')
+      end
+
+      it 'knows it is a pointer target' do
+        expect(c.target?).to be true
+      end
+    end
+
+    context 'pointer' do
+      let(:c) { Frepl::Declaration.new('real, dimension(:), pointer:: b') }
+
+      it 'extracts variable name' do
+        expect(c.variable_name).to eq('b')
+      end
+
+      it 'knows it is a pointer' do
+        expect(c.pointer?).to be true
+      end
+    end
+  end
+
+  describe '#==' do
+    let(:d) { Frepl::Declaration.new('integer a') }
+
+    context 'when other is a `Declaration`' do
+      let(:other_same) { Frepl::Declaration.new('real a') }
+      let(:other_diff) { Frepl::Declaration.new('integer b') }
+
+      it 'compares by variable name' do
+        expect(d).to eq(other_same)
+        expect(d).not_to eq(other_diff)
+      end
+    end
+  end
+end