mvinl 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e1464b5085d8cd24dc9b43f22063e675a8f6d249a2c3d716e29367726032e16
-  data.tar.gz: 0f8ee1fa140bf083afda23c1004e02bf3a8b3e0fcccd55f19d39135305b6b2dd
+  metadata.gz: 7c681f294e44a200c6fb8c66aed4ac1c50fce869c1c12f0a64b891b0ee720842
+  data.tar.gz: 94acd6d0220cb2fbfa05c839e8081e19b6d8ef3c3f4bd549dec217653b53fe0a
 SHA512:
-  metadata.gz: 449b3f884f41165b9892fa70e9a776dbd7208261ad1d237189d252fcec7f09fe6688873324b8045b9a85b1fdf7e707591057f4e1e7bf899fa48170f8e2cbf9a4
-  data.tar.gz: 0a09d81f07dcbc1c9253048526b3e60606b7a48c657f040c4a76e7d639d104b14148d5e2e640574429f4d1181eb85974543f74ec2b87077c29f3befe07aa2d76
+  metadata.gz: 2d2df258513050c3c8b982865df1e60e2d84aa253b09070f65ae0775d9a07f90231480130d5e9b645b0ee761460d66acf097a35e878894f7b30d3eda62ab23ed
+  data.tar.gz: 5eaa3496bef0fc23371cf449e12264873fa6455bff81f88c70c454a903b09b2860252feec4e07515d3eb37a637f2fdad7ffabfd1ad4dd5758e19844641cbf868

data/bin/imvnl

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 # frozen-string-literal: true
 
-=begin engine.rb
+=begin imvnl
 Copyright (c) 2018, 2024, Daniel Sierpiński All rights reserved.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -24,23 +24,28 @@ THE SOFTWARE.
 =end
 
 require 'readline'
-require 'pry'
+require 'mvinl/context'
 require 'mvinl/lexer'
 require 'mvinl/parser'
 require 'mvinl/info'
 
-PSL = "mvnl(#{MVinl::Version})".freeze
-PS1 = "#{PSL}>".freeze
-
 module MVinl::REPL
-  LEXER = MVinl::Lexer.new('')
-  PARSER = MVinl::Parser.new(LEXER)
+  PSL = "mvnl(#{MVinl::Version})".freeze
+  PS1 = "#{PSL}>".freeze
+  HISTORY_FILE = File.expand_path('.imvnl_history')
+  CONTEXT = MVinl::Context.new
+  LEXER = MVinl::Lexer.new(CONTEXT, '')
+  PARSER = MVinl::Parser.new(LEXER, CONTEXT)
 
   def self.run
+    load_history
+
     while (input = Readline.readline("#{PS1} ", true))
-      Readline::HISTORY.pop if input.strip.empty?
+      if Readline::HISTORY.size > 1 && Readline::HISTORY[-1] == Readline::HISTORY[-2]
+        Readline::HISTORY.pop
+      end
 
-      if input == '^' || input == 'exit'
+      if ['^', 'exit'].include? input
         PARSER.finalize!
         break if PARSER.parsing_done?
       else
@@ -59,6 +64,22 @@ module MVinl::REPL
         warn e.message
       end
     end
+
+    save_history
+  end
+
+  private_class_method def self.load_history
+    return unless File.exist? HISTORY_FILE
+
+    File.foreach(HISTORY_FILE) do |line|
+      Readline::HISTORY << line.chomp
+    end
+  end
+
+  private_class_method def self.save_history
+    File.open(HISTORY_FILE, 'w') do |file|
+      Readline::HISTORY.each { |entry| file.puts(entry) }
+    end
   end
 end
 

data/lib/mvinl/context.rb

@@ -0,0 +1,54 @@
+# frozen-string-literal: true
+
+require 'pry'
+
+module MVinl
+  # Lexer and parser shared context
+  class Context
+    attr_accessor :variables, :functions, :state
+
+    RESERVED = %I[def]
+    CONSTANTS = {}
+
+    def initialize
+      reset
+    end
+
+    def reset
+      @variables = {}
+      @functions = {}
+      @state = {
+        in_prop: false,
+        in_var: false,
+        in_keyword_arg: false,
+        keyword_arg_depth: 0,
+        lines: 0,
+        depth: 0
+      }
+    end
+
+    def define_function(name, args, body)
+      @functions[name] = { args: args, body: body }
+    end
+
+    def define_constant(name, value)
+      if RESERVED.include? name
+        nil
+      elsif CONSTANTS[name]
+        false
+      else
+        @state[:in_var] = false
+        CONSTANTS[name] = value
+      end
+    end
+
+    def define_variable(name, value)
+      if RESERVED.include? name
+        nil
+      else
+        @state[:in_var] = false
+        @variables[name] = value
+      end
+    end
+  end
+end

data/lib/mvinl/info.rb

@@ -1,12 +1,12 @@
 # frozen-string-literal: true
 
-# engine.rb
+# info.rb
 # Copyright (c) 2024, Daniel Sierpiński All rights reserved.
 #
 # See Copyright Notice in mvnil.rb
 
 module MVinl
-  VERSION = '0.1.4'
+  VERSION = '0.1.6'
   Version = VERSION
   Copyright = 'Copyright (c) 2024, Daniel Sierpiński'
 end

data/lib/mvinl/lexer.rb

@@ -1,6 +1,6 @@
 # frozen-string-literal: true
 
-=begin engine.rb
+=begin lexer.rb
 Copyright (c) 2024, Daniel Sierpiński All rights reserved.
 
 See Copyright Notice in mvnil.rb
@@ -16,11 +16,8 @@ module MVinl
     attr_reader :eos
 
     ID_REGEX = /[a-zA-Z_][a-zA-Z0-9_]*/
-
-    RESERVED = %w[def as style].freeze
-
     TOKENS = {
-      KEYWORD: /#{RESERVED[0]}|#{RESERVED[1]}|#{RESERVED[2]}/,
+      KEYWORD: Regexp.union(Context::RESERVED),
       OPEN_PAREN: /\(/,
       CLOSE_PAREN: /\)/,
       NEW_LINE: /(?:[ \t]*(?:\r?\n)[ \t]*)+/,
@@ -28,6 +25,8 @@ module MVinl
       KEYWORD_ARG: /(#{ID_REGEX}):/,
       ID: ID_REGEX,
       GROUP: /@(#{ID_REGEX})/,
+      CONSTANT: /!([A-Z][A-Z0-9_]*)/,
+      VARIABLE: /!(#{ID_REGEX})/,
       FLOAT: /[+-]?\d+\.\d+/,
       NUMBER: /[+-]?\d+/,
       MULTILINE_STRING: /"((?:\\.|[^"\\])*)"\s*\\\s*/,
@@ -38,7 +37,8 @@ module MVinl
       END_TAG: /\./
     }.freeze
 
-    def initialize(input)
+    def initialize(context, input = '')
+      @context = context
       @ss = StringScanner.new(input)
       @args_n = 0
       @in_group = false
@@ -52,6 +52,14 @@ module MVinl
     def next_token
       return process_eos if @ss.eos?
 
+      # Check if variable name been used
+      MVinl::Context::CONSTANTS.each_key do |const_name|
+        return [:CONSTANT_CALL, const_name] if @ss.scan(/\A#{Regexp.escape const_name.to_s}\b/)
+      end
+      @context.variables.each_key do |var_name|
+        return [:VARIABLE_CALL, var_name] if @ss.scan(/\A#{Regexp.escape var_name.to_s}\b/)
+      end
+
       TOKENS.each do |type, regex|
         if @ss.scan regex
           @last_type = type
@@ -60,6 +68,7 @@ module MVinl
       end
       case @last_type
       when :NEW_LINE
+        @context.state[:lines] += 1
         return next_token if continuation_line?
 
         [:END_TAG, "\n"]
@@ -72,13 +81,13 @@ module MVinl
         next_token
       when :OPEN_PAREN then [:OPEN_PAREN, '(']
       when :CLOSE_PAREN
-        unless Parser::STATE[:depth].positive?
+        unless @context.state[:depth].positive?
           raise UnexpectedTokenError, 'CLOSE_PARAM found with no matching OPEN_PARAM'
         end
 
         [:CLOSE_PAREN, ')']
       when :OPER
-        unless Parser::STATE[:depth].positive?
+        unless @context.state[:depth].positive?
           raise UnexpectedTokenError, 'OPER found with no matching OPEN_PARAM'
         end
 
@@ -88,30 +97,30 @@ module MVinl
 
         [:KEYWORD, @ss.matched]
       when :KEYWORD_ARG
-        if !Parser::STATE[:in_prop]
+        if !@context.state[:in_prop]
           raise UnexpectedTokenError, 'Looking for identifier but found KEYWORD_ARG'
-        elsif Parser::STATE[:in_keyword_arg]
+        elsif @context.state[:in_keyword_arg]
           raise UnexpectedTokenError, 'Looking for a keyword argument value but found KEYWORD_ARG'
         end
 
         [:KEYWORD_ARG, @ss[1]]
       when :GROUP
         # Group gets canceled whenever encountered another group id or a matching end tag
-        if Parser::STATE[:in_keyword_arg]
+        if @context.state[:in_keyword_arg]
           raise UnexpectedTokenError, 'Looking for a keyword argument value but found GROUP'
         end
 
         @in_group = true
         [:GROUP, @ss[1]]
+      when :CONSTANT then [:CONSTANT, @ss[1]]
+      when :VARIABLE then [:VARIABLE, @ss[1]]
       when :ID then [:ID, @ss.matched]
-      when :MULTILINE_STRING
-        [:MULTILINE_STRING, @ss[1]]
-      when :NUMBER, :FLOAT, :STRING, :SYMBOL
+      when :NUMBER, :FLOAT, :STRING, :SYMBOL, :MULTILINE_STRING
         # Values can't be used outside an property or a lambda
-        if !Parser::STATE[:in_prop] && !Parser::STATE[:depth].positive?
+        if !@context.state[:in_prop] && !@context.state[:depth].positive? && !@context.state[:in_var]
           raise UnexpectedTokenError, "Looking for ID or OPEN_PAREN but found #{@last_type}"
-        elsif !Parser::STATE[:in_keyword_arg] && Parser::STATE[:keyword_arg_depth].positive? &&
-            !Parser::STATE[:depth].positive?
+        elsif !@context.state[:in_keyword_arg] && @context.state[:keyword_arg_depth].positive? &&
+              !@context.state[:depth].positive? && !@context.state[:in_var]
           raise UnexpectedTokenError, "Looking for END_TAG or KEYWORD_ARG but found #{@last_type}"
         end
 
@@ -140,8 +149,8 @@ module MVinl
 
       # Auto end properties
       lookahead = @ss.check(/\A(?:#{TOKENS[:GROUP]}|#{TOKENS[:ID]}$|#{TOKENS[:END_TAG]}|#{TOKENS[:NEW_LINE]})/)
-      warn "Continue? in_prop?: #{Parser::STATE[:in_prop].inspect}, lookahead: #{lookahead.inspect}"
-      Parser::STATE[:in_prop] ? !lookahead : true
+      warn "Continue? in_prop?: #{@context.state[:in_prop].inspect}, lookahead: #{lookahead.inspect}"
+      @context.state[:in_prop] ? !lookahead : true
     end
 
     # Move the cursor to the next new line tag

data/lib/mvinl/parser.rb

@@ -1,6 +1,6 @@
 # frozen-string-literal: true
 
-=begin engine.rb
+=begin parser.rb
 Copyright (c) 2024, Daniel Sierpiński All rights reserved.
 
 See Copyright Notice in mvnil.rb
@@ -8,15 +8,28 @@ See Copyright Notice in mvnil.rb
 
 require 'mvinl.tab'
 
+# Generated parser class
 class MVinl::Parser < MVinl::Program
-  def initialize(lexer, debug: false)
-    @yydebug = debug
+  def initialize(lexer, context, debug: false)
     @lexer = lexer
+    @context = context
+    @yydebug = debug
     @tokens = []
     @done = false
     super()
   end
 
+  def parse
+    do_parse
+  rescue Racc::ParseError => e
+    puts "Parsing error at #{@context.state[:lines]}: #{e.message}"
+    nil
+  end
+
+  def feed(input)
+    @lexer.feed input
+  end
+
   def next_token
     if @tokens.empty?
       @lexer.next_token
@@ -36,8 +49,4 @@ class MVinl::Parser < MVinl::Program
   def parsing_done?
     @done && @tokens.empty?
   end
-
-  def parse
-    do_parse
-  end
 end

data/lib/mvinl.rb

@@ -1,6 +1,6 @@
 # frozen-string-literal: true
 
-=begin engine.rb
+=begin mvinl.rb
 Copyright (c) 2018, 2024, Daniel Sierpiński All rights reserved.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -22,16 +22,29 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 =end
 
+require 'mvinl/context'
 require 'mvinl/parser'
 require 'mvinl/lexer'
 
+# Library entry point
 module MVinl
+  @context = Context.new
+  @parser = Parser.new(Lexer.new(@context, ''), @context)
+
   def self.eval(input)
-    parser = Parser.new(Lexer.new(input))
-    parser.parse
+    @parser.feed input
+    @parser.parse
   end
 
   def self.eval_from_file(path)
     self.eval File.read(path)
   end
+
+  def self.context
+    @context
+  end
+
+  def self.reset
+    @context.reset
+  end
 end

data/rakelib/build.rake

@@ -1,32 +1,11 @@
 # frozen-string-literal: true
 
-require 'rubygems/package'
-require 'mvinl/info'
+require 'bundler/gem_tasks'
 
-require 'pry'
-require 'shellwords'
-
-GRAMMAR_FILE = 'syntax/mvinl.y'
-COMPILED_FILE = 'syntax/mvinl.tab.rb'
-
-gemspec = Gem::Specification.load 'mvinl.gemspec'
-gemfile = "#{gemspec.name}-#{gemspec.version}.gem"
-
-task push: [:build] do
-  #binding.pry
-  system('gem', 'push', '-v', Shellwords.escape(gemspec.version.to_s), Shellwords.escape(gemspec.name))
-end
-
-task install: [:build] do
-  Gem.install(gemfile)
-  puts "Installed #{gemfile}"
-end
-
-task build: [:compile] do
-  Gem::Package.build(gemspec)
-  puts "Build #{gemfile}"
-end
+desc 'Push MVinl gem; use this task in stead of \'release\''
+task push: %I[compile build release]
 
+desc 'Compile the grammar file'
 task :compile do
   system('racc', GRAMMAR_FILE, '-o', COMPILED_FILE)
 end

data/spec/complex_vars.mvnl

@@ -0,0 +1,5 @@
+!a 5
+def (foo (* a 2))
+!a 10
+
+x (foo)

data/spec/multiline_string.mvnl

@@ -0,0 +1,5 @@
+!a "Hello," \
+   "MVinl" \
+   "!"
+
+x a

data/spec/program_spec.rb

@@ -1,7 +1,6 @@
 # frozen-string-literal: true
 
 require_relative 'spec_helper'
-require 'mvinl'
 
 describe MVinl, '#eval' do
   context 'no input' do
@@ -10,78 +9,132 @@ describe MVinl, '#eval' do
       expect(result).to eq({})
     end
   end
+
   context 'groups' do
     it 'retruns a single group' do
       result = MVinl.eval('@x')
       expect(result).to eq({ x: {} })
     end
-
     it 'returns two groups' do
       result = MVinl.eval('@x @y')
       expect(result).to eq({ x: {}, y: {} })
     end
   end
+
   context 'properties' do
     it 'return a single property' do
       result = MVinl.eval('@x a')
       expect(result).to eq({ x: { a: [[], {}] } })
     end
-
     it 'returns two properties' do
       result = MVinl.eval('@x a b')
       expect(result).to eq({ x: { a: [[], {}], b: [[], {}] } })
     end
   end
 
+  context 'variables' do
+    it 'stores a single variable' do
+      MVinl.eval('!n 0')
+      expect(MVinl.context.variables[:n]).to be_truthy
+    end
+    it 'stores two variables' do
+      MVinl.eval('!n 3 !m 6')
+      expect(MVinl.context.variables[:n] && MVinl.context.variables[:m]).to be_truthy
+    end
+    it 'stores a single variable with it\'s value' do
+      MVinl.eval('!n 5')
+      expect(MVinl.context.variables[:n]).to eq 5
+    end
+    it 'evaluates a single variable' do
+      result = MVinl.eval('!n 5 x n')
+      expect(result).to eq({ x: [[5], {}] })
+    end
+  end
+
+  context 'constants' do
+    it 'stores a single constant' do
+      MVinl.eval('!N 50')
+      expect(MVinl::Context::CONSTANTS[:N]).to be_truthy
+    end
+    it 'evaluates a single constant' do
+      result = MVinl.eval('x N')
+      expect(result).to eq({ x: [[50], {}] })
+    end
+  end
+
   context 'functions' do
-    it 'Stores function definition with \'+\' OPER and no arguments' do
+    it 'stores function definition with \'+\' OPER and no arguments' do
       MVinl.eval('def (f (+ 1))')
-      expect(MVinl::Parser::FUNCTIONS).to eq({ f: { args: [], body: [:+, 1] } })
+      expect(MVinl.context.functions).to eq({ f: { args: [], body: [:+, 1] } })
     end
-
-    it 'Stores function definition with \'-\' OPER and no arguments' do
+    it 'stores function definition with \'-\' OPER and no arguments' do
       MVinl.eval('def (f (- 1))')
-      expect(MVinl::Parser::FUNCTIONS).to eq({ f: { args: [], body: [:-, 1] } })
+      expect(MVinl.context.functions).to eq({ f: { args: [], body: [:-, 1] } })
     end
-
-    it 'Stores function definition with \'*\' OPER and no arguments' do
+    it 'stores function definition with \'*\' OPER and no arguments' do
       MVinl.eval('def (f (* 1))')
-      expect(MVinl::Parser::FUNCTIONS).to eq({ f: { args: [], body: [:*, 1] } })
+      expect(MVinl.context.functions).to eq({ f: { args: [], body: [:*, 1] } })
     end
-
-    it 'Stores function definition with \'/\' OPER and no arguments' do
+    it 'stores function definition with \'/\' OPER and no arguments' do
       MVinl.eval('def (f (/ 1))')
-      expect(MVinl::Parser::FUNCTIONS).to eq({ f: { args: [], body: [:/, 1] } })
+      expect(MVinl.context.functions).to eq({ f: { args: [], body: [:/, 1] } })
     end
-
-    it 'Stores function definition with \'%\' OPER and no arguments' do
+    it 'stores function definition with \'%\' OPER and no arguments' do
       MVinl.eval('def (f (% 1))')
-      expect(MVinl::Parser::FUNCTIONS).to eq({ f: { args: [], body: [:%, 1] } })
+      expect(MVinl.context.functions).to eq({ f: { args: [], body: [:%, 1] } })
     end
-
-    it 'Stores function definition with a single argument' do
+    it 'stores function definition with a single argument' do
       MVinl.eval('def (f a (+ a a))')
-      expect(MVinl::Parser::FUNCTIONS).to eq({ f: { args: %I[a], body: %I[+ a a] } })
+      expect(MVinl.context.functions).to eq({ f: { args: %I[a], body: %I[+ a a] } })
     end
-
-    it 'Stores function definition with two arguments' do
+    it 'stores function definition with two arguments' do
       MVinl.eval('def (f a b (+ a b))')
-      expect(MVinl::Parser::FUNCTIONS).to eq({ f: { args: %I[a b], body: %I[+ a b] } })
+      expect(MVinl.context.functions).to eq({ f: { args: %I[a b], body: %I[+ a b] } })
     end
-
-    it 'Evaluate anonimous function' do
-      result = MVinl.eval('@x x (+ 2 2)')
-      expect(result).to eq({ x: { x: [[4], {}] } })
+    it 'evaluates anonimous function' do
+      result = MVinl.eval('x (+ 2 2)')
+      expect(result).to eq({ x: [[4], {}] })
     end
-
-    it 'Evaluate function' do
-      result = MVinl.eval('def (foo (+ 5)) @x x (foo)')
-      expect(result).to eq({ x: { x: [[5], {}] } })
+    it 'evaluates function' do
+      result = MVinl.eval('def (foo (+ 5)) x (foo)')
+      expect(result).to eq({ x: [[5], {}] })
     end
+    it 'evaluates function calling another function' do
+      result = MVinl.eval('def (foo (+ 5)) def (bar (foo)) x (bar)')
+      expect(result).to eq({ x: [[5], {}] })
+    end
+    it 'evaluates function inside a variable' do
+      MVinl.eval('def (foo (+ 7)) !n (foo)')
+      expect(MVinl.context.variables[:n]).to eq 7
+    end
+  end
+end
 
-    it 'Evaluate function calling another function' do
-      result = MVinl.eval('def (foo (+ 5)) def (bar (foo)) @x x (bar)')
-      expect(result).to eq({ x: { x: [[5], {}] } })
+describe MVinl, '#eval_from_file' do
+  context 'stack example' do
+    it 'evaluates a basic example' do
+      MVinl.reset
+      result = MVinl.eval_from_file('spec/stack.mvnl')
+      expect(result).to eq({ menu: { Menu: [[], { New_Game: :state_next, Exit: :abord }] },
+                             game: { Mouse: [[], {}], Board: [[3, 3], {}],
+                                     Button: [['󰮱  Hello Vinl!'], {
+                                       line_height: 25, padding: 8
+                                     }] } })
+    end
+    it 'evaluates an example with variables' do
+      MVinl.reset
+      result = MVinl.eval_from_file('spec/vars.mvnl')
+      expect(result).to eq({ x: [[5], { fun: 10 }] })
+    end
+    it 'function respects variable change' do
+      MVinl.reset
+      result = MVinl.eval_from_file('spec/complex_vars.mvnl')
+      expect(result).to eq({ x: [[20], {}] })
+    end
+    it 'evaluates multiline string' do
+      MVinl.reset
+      result = MVinl.eval_from_file('spec/multiline_string.mvnl')
+      expect(result).to eq({ x: [['Hello, MVinl !'], {}] })
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
 # frozen-string-literal: true
 
 $LOAD_PATH.unshift File.expand_path('lib', __dir__)
+
+require 'mvinl'

data/spec/vars.mvnl

@@ -0,0 +1,4 @@
+!a 5
+def (foo (* 2 a))
+
+x a fun: (foo)