basic101 0.1.0

data/lib/basic101/transcript.rb

@@ -0,0 +1,37 @@
+module Basic101
+
+  class Transcript
+
+    def self.make(source_path)
+      base_path = source_path.chomp('.bas')
+      input_file = File.open(base_path + '.input', 'w')
+      output_file = File.open(base_path + '.output', 'w')
+      new(input_file, output_file)
+    end
+
+    def initialize(input_file, output_file)
+      @input_file = input_file
+      @output_file = output_file
+    end
+
+    def save_input(s)
+      @input_file.print s
+    end
+
+    def save_output(s)
+      @output_file.print s
+    end
+
+    def save_output_lines(*lines)
+      lines.flatten.each do |line|
+        save_output "#{line}\n"
+      end
+    end
+
+    def echo?
+      true
+    end
+
+  end
+
+end

data/lib/basic101/transform.rb

@@ -0,0 +1,264 @@
+require_relative 'remark_statement'
+require_relative 'print_statement'
+
+module Basic101
+
+  class Transform < Parslet::Transform
+
+    rule(:integer => simple(:i)) do
+      BasicInteger.new(i.to_i)
+    end
+
+    rule(:float => simple(:s)) do
+      BasicFloat.from_s(s)
+    end
+
+    rule(:string => simple(:s)) do
+      BasicString.new(s)
+    end
+
+    rule(:function_identifier => simple(:name)) do
+      FunctionIdentifier.new(name)
+    end
+
+    rule(:numeric_identifier => simple(:name)) do
+      NumericIdentifier.new(name)
+    end
+
+    rule(:string_identifier => simple(:name)) do
+      StringIdentifier.new(name)
+    end
+
+    rule(:function_identifier => simple(:identifier),
+         :argument_list => subtree(:arguments)) do
+      FunctionCall.new(identifier, Array(arguments))
+    end
+
+    rule(:subscript_base => simple(:identifier), 
+         :argument_list => subtree(:args)) do
+      ArrayReference.new(identifier, Array(args))
+    end
+
+    rule(:scalar_reference => simple(:identifier)) do
+      ScalarReference.new(identifier)
+    end
+
+    rule(:negation => simple(:expression)) do
+      NegateOperation.new(expression)
+    end
+
+    rule(:multiply => simple(:_)) do
+      :*
+    end
+
+    rule(:divide => simple(:_)) do
+      :/
+    end
+
+    rule(:add => simple(:_)) do
+      :+
+    end
+
+    rule(:subtract => simple(:_)) do
+      :-
+    end
+
+    rule(:eq => simple(:_)) do
+      :eq
+    end
+
+    rule(:ne => simple(:_)) do
+      :ne
+    end
+
+    rule(:lt => simple(:_)) do
+      :lt
+    end
+
+    rule(:le => simple(:_)) do
+      :le
+    end
+
+    rule(:gt => simple(:_)) do
+      :gt
+    end
+
+    rule(:ge => simple(:_)) do
+      :ge
+    end
+
+    rule(:and => simple(:_)) do
+      :and
+    end
+
+    rule(:or => simple(:_)) do
+      :or
+    end
+
+    rule(:operator => simple(:operator),
+         :right => simple(:right)) do
+      BinaryOperation.new(operator, right)
+    end
+
+    rule(:left => simple(:left),
+         :operations => sequence(:operations)) do
+      BinaryOperations.new(left, operations)
+    end
+
+    rule(:left => simple(:left)) do
+      left
+    end
+
+    rule(:left => subtree(:left),
+         :power => simple(:_),
+         :right => subtree(:right)) do
+      PowerOperation.new(left, right)
+    end
+
+     rule(:not => simple(:expression)) do
+      NotOperation.new(expression)
+    end
+
+    rule(:remark => simple(:_)) do
+      RemarkStatement.new
+    end
+
+    rule(:print_separator => ';') do
+      PrintSemicolon.new
+    end
+
+    rule(:print_separator => ',') do
+      PrintComma.new
+    end
+
+    rule(:print => simple(:_),
+         :print_arguments => subtree(:args)) do
+      PrintStatement.new(Array(args))
+    end
+
+    rule(:lvalue => simple(:lvalue), :rvalue => simple(:rvalue)) do
+      LetStatement.new(lvalue, rvalue)
+    end
+
+    rule(:goto => simple(:_), :integer => simple(:line_number)) do
+      GotoStatement.new(line_number.to_i)
+    end
+
+    rule(:randomize => simple(:_)) do
+      RandomizeStatement.new
+    end
+
+    rule(:end => simple(:_)) do
+      EndStatement.new
+    end
+
+    rule(:prompt_delimeter => simple(:_)) do
+      PromptDelimeter.new
+    end
+
+    rule(:null_prompt_delimeter => simple(:_)) do
+      NullPromptDelimeter.new
+    end
+
+    rule(:input => simple(:_),
+         :references => subtree(:references)) do
+      InputStatement.new(nil, PromptDelimeter.new, Array(references))
+    end
+
+    rule(:input => simple(:_),
+         :prompt => simple(:prompt),
+         :prompt_delimeter => simple(:prompt_delimeter),
+         :references => subtree(:references)) do
+      InputStatement.new(prompt, prompt_delimeter, Array(references))
+    end
+
+    rule(:dim => simple(:_),
+         :references => subtree(:references)) do
+      DimStatement.new(Array(references))
+    end
+
+    rule(:reference => simple(:reference),
+         :from => simple(:from),
+         :to => simple(:to),
+         :step => simple(:step)) do
+      ForStatement.new(reference, from, to, step)
+    end
+
+    rule(:next => simple(:_),
+         :references => subtree(:references)) do
+      Array(references || [nil]).map do |reference|
+        NextStatement.new(reference)
+      end
+    end
+
+    rule(:on_goto => simple(:_),
+         :expression => simple(:expression),
+         :line_numbers => subtree(:line_numbers)) do
+      OnGotoStatement.new(expression, Array(line_numbers))
+    end
+
+    rule(:data_items => subtree(:data_items)) do
+      DataStatement.new(Array(data_items))
+    end
+
+    rule(:read => simple(:_),
+         :references => subtree(:references)) do
+      ReadStatement.new(Array(references))
+    end
+
+    rule(:if_line_number => simple(:line_number)) do
+      GotoStatement.new(line_number.to_i)
+    end
+
+    rule(:if => simple(:_),
+         :condition => simple(:condition),
+         :then_block => subtree(:then_block),
+         :else_block => subtree(:else_block)) do
+      [
+        IfStatement.new(condition),
+        then_block,
+        ElseStatement.new,
+        else_block,
+        EndifStatement.new,
+      ].flatten.compact
+    end
+
+    rule(:integer => simple(:line_number),
+         :statements => subtree(:statements)) do
+      Line.new(line_number.to_i, Array(statements).flatten)
+    end
+
+    rule(:gosub => simple(:_),
+         :line_number => simple(:line_number)) do
+      GosubStatement.new(line_number.to_i)
+    end
+
+    rule(:stop => simple(:_)) do
+      StopStatement.new
+    end
+
+    rule(:return => simple(:_)) do
+      ReturnStatement.new
+    end
+
+    rule(:restore => simple(:_),
+         :line_number => simple(:line_number)) do
+      RestoreStatement.new(line_number)
+    end
+
+    rule(:def => simple(:x),
+         :identifier => simple(:identifier),
+         :parameters => subtree(:parameters),
+         :expression => simple(:expression)) do
+      DefineFunctionStatement.new(identifier,
+                                  Array(parameters),
+                                  expression)
+    end
+
+    rule(:program => subtree(:lines)) do
+      Program.new(Array(lines))
+    end
+
+  end
+
+end

data/lib/basic101/user_defined_function.rb

@@ -0,0 +1,54 @@
+module Basic101
+
+  class UserDefinedFunction < Function
+
+    include Identity
+
+    def initialize(identifier, parameters, expression)
+      @identifier = identifier
+      @parameters = parameters
+      @expression = expression
+    end
+
+    def name
+      @identifier.to_s
+    end
+
+    def call(runtime, args)
+      raise InvalidArgumentError unless args.size == @parameters.size
+      save_parameters(runtime)
+      bind_arguments(runtime, args)
+      result = @expression.eval(runtime)
+      restore_parameters(runtime)
+      result
+    end
+
+    protected
+
+    def state
+      [@identifier, @parameters, @expression]
+    end
+
+    private
+
+    def save_parameters(runtime)
+      @original_parameter_values = @parameters.map do |parameter|
+        parameter.eval(runtime)
+      end
+    end
+
+    def bind_arguments(runtime, args)
+      @parameters.zip(args).each do |parameter, arg|
+        parameter.assign(runtime, arg.eval(runtime))
+      end
+    end
+
+    def restore_parameters(runtime)
+      @parameters.zip(@original_parameter_values) do |parameter, value|
+        parameter.assign(runtime, value)
+      end
+    end
+
+  end
+
+end

data/lib/basic101/val_function.rb

@@ -0,0 +1,16 @@
+module Basic101
+
+  class ValFunction < Function
+
+    def name
+      'VAL'
+    end
+
+    def call(runtime, args)
+      check_args args, [BasicString]
+      args.first.eval(runtime).val
+    end
+
+  end
+
+end

data/lib/basic101.rb

@@ -0,0 +1,93 @@
+require 'csv'
+require 'optparse'
+require 'pp'
+
+require 'parslet'
+
+require_relative 'basic101/abs_function'
+require_relative 'basic101/argument_checker'
+require_relative 'basic101/arguments'
+require_relative 'basic101/array_reference'
+require_relative 'basic101/asc_function'
+require_relative 'basic101/basic_array'
+require_relative 'basic101/basic_comparisons'
+require_relative 'basic101/basic_float'
+require_relative 'basic101/basic_integer'
+require_relative 'basic101/basic_math'
+require_relative 'basic101/basic_numeric'
+require_relative 'basic101/basic_object'
+require_relative 'basic101/basic_string'
+require_relative 'basic101/binary_operation'
+require_relative 'basic101/binary_operations'
+require_relative 'basic101/built_in_functions'
+require_relative 'basic101/chr_function'
+require_relative 'basic101/cos_function'
+require_relative 'basic101/data_statement'
+require_relative 'basic101/define_function_statement'
+require_relative 'basic101/dim_statement'
+require_relative 'basic101/else_statement'
+require_relative 'basic101/end_statement'
+require_relative 'basic101/endif_statement'
+require_relative 'basic101/errors'
+require_relative 'basic101/exp_function'
+require_relative 'basic101/for_stack'
+require_relative 'basic101/for_statement'
+require_relative 'basic101/function'
+require_relative 'basic101/function_call'
+require_relative 'basic101/function_identifier'
+require_relative 'basic101/functions'
+require_relative 'basic101/gosub_statement'
+require_relative 'basic101/goto_statement'
+require_relative 'basic101/identifier'
+require_relative 'basic101/identity'
+require_relative 'basic101/if_statement'
+require_relative 'basic101/input'
+require_relative 'basic101/input_reader'
+require_relative 'basic101/input_statement'
+require_relative 'basic101/int_function'
+require_relative 'basic101/left_function'
+require_relative 'basic101/len_function'
+require_relative 'basic101/let_statement'
+require_relative 'basic101/line'
+require_relative 'basic101/log_function'
+require_relative 'basic101/main'
+require_relative 'basic101/mid_function'
+require_relative 'basic101/negate_operation'
+require_relative 'basic101/next_statement'
+require_relative 'basic101/not_operation'
+require_relative 'basic101/null_prompt_delimeter'
+require_relative 'basic101/null_transcript'
+require_relative 'basic101/numeric_identifier'
+require_relative 'basic101/on_goto_statement'
+require_relative 'basic101/output'
+require_relative 'basic101/parser'
+require_relative 'basic101/power_operation'
+require_relative 'basic101/print_comma'
+require_relative 'basic101/print_semicolon'
+require_relative 'basic101/print_statement'
+require_relative 'basic101/program'
+require_relative 'basic101/program_counter'
+require_relative 'basic101/prompt_delimeter'
+require_relative 'basic101/randomize_statement'
+require_relative 'basic101/read_statement'
+require_relative 'basic101/reference'
+require_relative 'basic101/remark_statement'
+require_relative 'basic101/restore_statement'
+require_relative 'basic101/return_statement'
+require_relative 'basic101/right_function'
+require_relative 'basic101/rnd_function'
+require_relative 'basic101/runtime'
+require_relative 'basic101/scalar_reference'
+require_relative 'basic101/sgn_function'
+require_relative 'basic101/sin_function'
+require_relative 'basic101/sqr_function'
+require_relative 'basic101/statement'
+require_relative 'basic101/stop_statement'
+require_relative 'basic101/str_function'
+require_relative 'basic101/string_identifier'
+require_relative 'basic101/tab'
+require_relative 'basic101/tab_function'
+require_relative 'basic101/tan_function'
+require_relative 'basic101/transcript'
+require_relative 'basic101/transform'
+require_relative 'basic101/user_defined_function'

data/rake_tasks/default.rake

@@ -0,0 +1 @@
+task :default => [:test]

data/rake_tasks/integration.rake

@@ -0,0 +1,8 @@
+desc 'Run integration tests'
+namespace :test do
+  task :integration do
+    command = File.expand_path('../test/integration/integration_test.rb',
+                               __dir__)
+    sh command
+  end
+end

data/rake_tasks/jeweler.rake

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'jeweler'
+
+README_PATH = File.expand_path('../README.md', File.dirname(__FILE__))
+
+def extract_description_from_readme
+  readme = File.open(README_PATH, 'r', &:read)
+  s = readme[/^# basic101.*\n+((?:.*\n)+?)\n*##/i, 1]
+  unless s
+    raise 'Unable to extract description from readme'
+  end     
+  s.gsub(/\n/, ' ').strip
+end
+
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see
+  # http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = 'basic101'
+  gem.homepage = 'http://github.com/wconrad/basic101'
+  gem.license = 'MIT'
+  gem.summary = %Q{Circa 1980 basic intepreter}
+  gem.description = extract_description_from_readme
+  gem.email = 'wconrad@yagni.com'
+  gem.authors = ['Wayne Conrad']
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new

data/rake_tasks/spec.rake

@@ -0,0 +1,8 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new 'test:spec' do |t|
+  t.pattern = File.join('test', t.pattern)
+  t.verbose = false
+end
+
+task :spec => ['test:spec']

data/rake_tasks/test.rake

@@ -0,0 +1,2 @@
+desc 'Run all tests'
+task :test => ['test:spec', 'test:integration']

data/rake_tasks/yard.rake

@@ -0,0 +1,3 @@
+require 'yard'
+YARD::Rake::YardocTask.new do |t|
+end

data/test/integration/arguments.rb

@@ -0,0 +1,25 @@
+module Integration
+
+  class Arguments
+
+    attr_reader :patterns
+    attr_reader :train
+
+    def initialize(argv)
+      @train = false
+      @patterns = []
+      OptionParser.new do |opts|
+        opts.banner << " [patterns]"
+        opts.on('-t', '--train', 'Train tests') do |v|
+          @train = v
+        end
+      end.parse!(argv)
+      @patterns = argv
+    rescue OptionParser::ParseError => e
+      $stderr.puts e
+      exit 1
+    end
+
+  end
+
+end

data/test/integration/errors.rb

@@ -0,0 +1,7 @@
+module Integration
+
+  class Error < StandardError ; end
+
+  class MaxOutputLines < Error ; end
+
+end

data/test/integration/integration_test.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+# Must come first
+require 'simplecov'
+SimpleCov.command_name 'Integration'
+
+lib_path = File.expand_path('../../lib', __dir__)
+unless $LOAD_PATH.include?(lib_path)
+  $:.unshift lib_path
+end
+
+require 'fileutils'
+require 'forwardable'
+require 'optparse'
+require 'pathname'
+require 'stringio'
+require 'tempfile'
+require 'yaml'
+
+require 'basic101'
+
+require_relative 'arguments'
+require_relative 'errors'
+require_relative 'main'
+require_relative 'output_file'
+require_relative 'test'
+
+Integration::Main.new(ARGV).run if $0 == __FILE__

data/test/integration/main.rb

@@ -0,0 +1,49 @@
+module Integration
+
+  class Main
+
+    def initialize(argv)
+      @args = Arguments.new(argv)
+    end
+
+    def run
+      tests = load_tests
+      tests.each do |test|
+        test.run
+        test.print_progress
+      end
+      puts
+      if @args.train
+        tests.each(&:train)
+      else
+        tests.each(&:print_failure)
+      end
+      exit exitcode(tests)
+    end
+
+    private
+
+    def load_tests
+      glob = File.join(test_dir, '**', '*' + Test::BASIC_EXTENSION)
+      Dir[glob].map do |basic_path|
+        Test.new(basic_path)
+      end.select do |test|
+        test.matches_patterns?(@args.patterns)
+      end
+    end
+
+    def test_dir
+      File.expand_path('tests', __dir__)
+    end
+
+    def exitcode(tests)
+      if tests.all?(&:passed?)
+        0
+      else
+        1
+      end
+    end
+
+  end
+
+end

data/test/integration/output_file.rb

@@ -0,0 +1,40 @@
+module Integration
+
+  class OutputFile
+
+    extend Forwardable
+
+    attr_accessor :max_lines
+
+    def initialize
+      @out = StringIO.new
+      @total_lines = 0
+      @max_lines = nil
+    end
+
+    def print(*s)
+      raise_if_too_many_lines(s)
+      @out.print(*s)
+    end
+
+    def puts(*s)
+      raise_if_too_many_lines(s)
+      puts_unchecked(*s)
+    end
+
+    def_delegator :@out, :isatty
+    def_delegator :@out, :flush
+    def_delegator :@out, :string
+    def_delegator :@out, :puts, :puts_unchecked
+
+    def raise_if_too_many_lines(*s)
+      num_lines = s.join.scan(/\n/).size
+      @total_lines += num_lines
+      if max_lines && @total_lines >= max_lines
+        raise MaxOutputLines, "Maximum output lines reached"
+      end
+    end
+
+  end
+
+end