skeem 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bfe901703f31ea172032969d5a52e73a99467917
-  data.tar.gz: e9ea6993d7f4f4a107e4c43dc8e342affe103439
+  metadata.gz: c9907100633d80e63603f094700423139f320600
+  data.tar.gz: 5d4b89ed16eb0c029d98ce02c88eed4cc459404d
 SHA512:
-  metadata.gz: 8b034f52223d95e8d40e3de77596b126484116f900a5890d7da6c9f9de56a0ed1cd08d0ac0e80d1e6b92acc17da6663f3da55eb7b01a2041512e109d3a423285
-  data.tar.gz: f315e8f48f9c97391df7a665fd01c2fc6ea4ed292bc9c075bec7332e2706a01cfe00c0aad0ea6d54fccc50e3fb84bc8afc10596a8cedc3726413d3824343baac
+  metadata.gz: edd237e0152cbac2cf89bd0724436db40865fddddec40eb4cd3de595909c8a1c09e424f0903903a3cbacf2e3c6fc63fb98770523acda5ffa2099a382f8eccd41
+  data.tar.gz: 3d9605b4577d2701c18cb675b4ea37907b8d7c990c3a9139b6227931b2b68ddf0be8617b6980bf03e640821a958e5d3419b423c95bda128dc6db2837dda4a21e

data/CHANGELOG.md

@@ -1,3 +1,21 @@
+## [0.0.7] - 2018-09-12
+Proof of concept of a primitive function: '+' operator.  
+Demo works but code needs some polishing and testing.  
+
+### Added
+- Class `Environment`. Holds a mapping between symbol names and their associated value.
+- Class `PrimitiveBuilder`. Builder class that seeds the default environment with primitive functions (now, limited to '+')
+- Class `PrimitiveFunc` Internal representation of primitive functions.
+- Class `Runtime`. Holds all context data of the Skeem interpreter.
+- Methods `SExprBuilder#reduce_proc_call`, `SExprBuilder#reduce_multiple_operands`, SExprBuilder#reduce_last_operand
+
+### Changed
+- Class `Tokenize` Added support for Scheme semi-colon comments.
+- File `grammar.rb` Added syntax rules for procedure calling.
+- File `s_expr_nodes.rb` Class and code refactoring.
+- File `README.md` Changed demo snippet with example plus operator.
+
+
 ## [0.0.6] - 2018-09-01
 Initial (minimalistic) interpreter implementation.
 ### Added

data/README.md

@@ -31,9 +31,12 @@ At this stage, the gem consists of a bare-bones interpreter.
   require 'skeem'
 
   schemer = Skeem::Interpreter.new
-  scheme_code = '"Hello, world"'
+  scheme_code =<<-SKEEM
+    ; Let's try the addition operator
+    (+ 3 4 5)
+  SKEEM
   result = schemer.run(scheme_code)
-  puts result.value # => "Hello, world"
+  puts result.value # => 12
 ```
 
 Roadmap:

data/lib/skeem/environment.rb

@@ -0,0 +1,19 @@
+require 'forwardable'
+
+module Skeem
+  class Environment
+    extend Forwardable
+    def_delegator :@bindings, :empty?
+    
+    attr_reader(:bindings)
+
+    def initialize()
+      @bindings = {}
+    end
+
+    def define(anIdentifier, anExpression)
+      raise StandardError, anIdentifier unless anIdentifier.kind_of?(String)
+      @bindings[anIdentifier] = anExpression
+    end
+  end # class
+end # module

data/lib/skeem/grammar.rb

@@ -30,10 +30,17 @@ module Skeem
     rule 'definition' => 'LPAREN DEFINE IDENTIFIER expression RPAREN'
     rule 'expression' =>  'IDENTIFIER'
     rule 'expression' =>  'literal'
+    rule 'expression' =>  'procedure_call'
     rule 'literal' => 'self-evaluating'
     rule 'self-evaluating' => 'BOOLEAN'
     rule 'self-evaluating' => 'number'
     rule 'self-evaluating' => 'STRING_LIT'
+    rule 'procedure_call' => 'LPAREN operator RPAREN'
+    rule('procedure_call' => 'LPAREN operator operand_plus RPAREN').as 'proc_call_args'
+    rule('operand_plus' => 'operand_plus operand').as 'multiple_operands'
+    rule('operand_plus' => 'operand').as 'last_operand'
+    rule 'operator' => 'expression'
+    rule 'operand' => 'expression'
     rule 'number' => 'INTEGER'
     rule 'number' => 'REAL'
   end

data/lib/skeem/interpreter.rb

@@ -1,16 +1,23 @@
 require_relative 'parser'
+require_relative 'environment'
+require_relative 'runtime'
+require_relative './primitive/primitive_builder'
 
 module Skeem
   class Interpreter
+    include Primitive::PrimitiveBuilder
     attr_reader(:parser)
+    attr_reader(:runtime)
     
     def initialize()
+      @runtime = Runtime.new(Environment.new)
+      add_primitives(runtime)
     end
     
     def run(source)
       @parser ||= Parser.new
       @ptree = parser.parse(source)
-      return @ptree.root.interpret
+      return @ptree.root.evaluate(runtime)
     end
   end # class
 end # module

data/lib/skeem/primitive/primitive_builder.rb

@@ -0,0 +1,38 @@
+require_relative '../primitive_func'
+
+module Skeem
+  module Primitive
+    module PrimitiveBuilder
+      def add_primitives(aRuntime)
+        add_arithmetic(aRuntime)
+      end
+      
+      private
+      
+      def add_arithmetic(aRuntime)
+        def_func(aRuntime, create_plus)
+      end
+      
+      def create_plus()
+        plus_code = ->(runtime, arglist) do
+          operands = arglist.to_eval_enum(runtime)
+          raw_result = operands.reduce(0) do |interim, elem|
+            interim += elem.value
+          end
+          SExprInteger.create(raw_result)
+        end
+
+        ['+', plus_code]
+      end
+      
+      def def_func(aRuntime, aPair)
+        func = PrimitiveFunc.new(aPair.first, aPair.last)
+        define(aRuntime, func.identifier, func)
+      end
+
+      def define(aRuntime, aKey, anEntry)
+        aRuntime.define(aKey, anEntry)
+      end
+    end # module
+  end # module
+end # module

data/lib/skeem/primitive_func.rb

@@ -0,0 +1,18 @@
+require_relative 's_expr_nodes'
+
+module Skeem
+  class PrimitiveFunc
+    attr_reader(:identifier)
+    attr_reader(:code)
+
+    def initialize(anId, aLambda)
+      @identifier = anId.kind_of?(String) ? SExprIdentifier.create(anId) : anId
+      @code = aLambda
+    end
+
+    def call(aRuntime, aProcedureCall)
+      args = aProcedureCall.operands
+      return @code.call(aRuntime, args)
+    end
+  end # class
+end # module

data/lib/skeem/runtime.rb

@@ -0,0 +1,30 @@
+module Skeem
+  class Runtime
+    attr_reader(:environment)
+
+    def initialize(anEnvironment)
+      @environment = anEnvironment
+    end
+
+    def include?(anIdentifier)
+      environment.bindings.include?(normalize_key(anIdentifier))
+    end
+
+    def define(aKey, anEntry)
+      environment.define(normalize_key(aKey), anEntry)
+    end
+
+    private
+
+    def normalize_key(aKey)
+      result = case aKey
+                 when String
+                   aKey
+                 else
+                   aKey.evaluate(self).value
+               end
+
+      result
+    end
+  end # class
+end # module

data/lib/skeem/s_expr_builder.rb

@@ -11,11 +11,11 @@ module Skeem
   # nodes) and using a step by step approach.
   class SExprBuilder < Rley::ParseRep::ASTBaseBuilder
     Terminal2NodeClass = {
-      'BOOLEAN' => SExprBooleanNode,
-      'IDENTIFIER' => SExprIdentifierNode,
-      'INTEGER' => SExprIntegerNode,
-      'REAL' => SExprRealNode,
-      'STRING_LIT' => SExprStringNode
+      'BOOLEAN' => SExprBoolean,
+      'IDENTIFIER' => SExprIdentifier,
+      'INTEGER' => SExprInteger,
+      'REAL' => SExprReal,
+      'STRING_LIT' => SExprString
     }.freeze
 
     # Create a new AST builder instance.
@@ -34,6 +34,21 @@ module Skeem
     def terminal2node
       Terminal2NodeClass
     end
+
+    # rule('proc_call_args' => 'LPAREN operator operand_plus RPAREN')
+    def reduce_proc_call_args(_production, aRange, _tokens, theChildren)
+      ProcedureCall.new(aRange, theChildren[1], theChildren[2])
+    end
+
+    # rule('operand_plus' => 'operand_plus operand').as 'multiple_operands'
+    def reduce_multiple_operands(_production, _range, _tokens, theChildren)
+      theChildren[0] << theChildren[1]
+    end
+
+    # rule('operand_plus' => 'operand').as 'last_operand'
+    def reduce_last_operand(_production, _range, _tokens, theChildren)
+      [theChildren.last]
+    end
   end # class
 end # module
 # End of file

data/lib/skeem/s_expr_nodes.rb

@@ -1,29 +1,62 @@
 # Classes that implement nodes of Abstract Syntax Trees (AST) representing
 # Skeem parse results.
 
+require 'forwardable'
+
 module Skeem
+  # Abstract class. Generalization of any S-expr element.
+  SExprElement = Struct.new(:position) do
+    def initialize(aPosition)
+      self.position = aPosition
+    end
+
+    def evaluate(_runtime)
+      raise NotImplementedError
+    end
+
+    def done!()
+      # Do nothing
+    end
+
+    # Abstract method.
+    # Part of the 'visitee' role in Visitor design pattern.
+    # @param _visitor[ParseTreeVisitor] the visitor
+    def accept(_visitor)
+      raise NotImplementedError
+    end
+  end # struct
+
   # Abstract class. Root of class hierarchy needed for Interpreter
   # design pattern
-  SExprTerminalNode = Struct.new(:token, :value, :position) do
+  class SExprTerminal < SExprElement
+    attr_reader :token
+    attr_reader :value
+
     def initialize(aToken, aPosition)
-      self.token = aToken
-      self.position = aPosition
+      super(aPosition)
+      @token = aToken
       init_value(aToken.lexeme)
     end
 
+    def self.create(aValue)
+      lightweight = self.allocate
+      lightweight.init_value(aValue)
+      return lightweight
+    end
+
     # This method can be overriden
     def init_value(aValue)
-      self.value = aValue
+      @value = aValue
     end
 
     def symbol()
       token.terminal
     end
 
-    def interpret()
+    def evaluate(_runtime)
       return self
     end
-    
+
     def done!()
       # Do nothing
     end
@@ -33,44 +66,65 @@ module Skeem
     def accept(aVisitor)
       aVisitor.visit_terminal(self)
     end
-  end
+  end # class
+
+  class SExprBoolean < SExprTerminal
+  end # class
 
-  class SExprBooleanNode < SExprTerminalNode
+  class SExprNumber < SExprTerminal
   end # class
-  
-  class SExprNumberNode < SExprTerminalNode
-  end # class  
-  
-  class SExprRealNode < SExprNumberNode
+
+  class SExprReal < SExprTerminal
   end # class
-  
-  class SExprIntegerNode < SExprRealNode
+
+  class SExprInteger < SExprReal
   end # class
-  
-  class SExprStringNode < SExprTerminalNode
+
+  class SExprString < SExprTerminal
     # Override
     def init_value(aValue)
-      self.value = aValue.dup
-    end  
+      super(aValue.dup)
+    end
   end # class
-  
-  class SExprIdentifierNode < SExprTerminalNode
+
+  class SExprIdentifier < SExprTerminal
     # Override
     def init_value(aValue)
-      self.value = aValue.dup
-    end  
+      super(aValue.dup)
+    end
   end # class
-  
-=begin
-  class SExprCompositeNode
-    attr_accessor(:children)
-    attr_accessor(:symbol)
-    attr_accessor(:position)
 
-    def initialize(aSymbol, aPosition)
-      @symbol = aSymbol
-      @children = []
-      @position = aPosition
+  class SExprReserved < SExprIdentifier
+  end # class
+
+
+  class SExprList < SExprElement
+    attr_accessor(:members)
+    extend Forwardable
+
+    def_delegator :@members, :first, :empty?
+
+    def initialize()
+      super(nil)
+      @members = []
+    end
+
+    def rest()
+      members.slice(1..-1)
+    end
+
+    # Factory method.
+    # Construct an Enumerator that will return iteratively the result
+    # of 'evaluate' method of each members of self.
+    def to_eval_enum(aRuntime)
+      elements = self.members
+
+      new_enum = Enumerator.new do |result|
+        context = aRuntime
+        elements.each { |elem| result << elem.evaluate(context) }
+      end
+
+      new_enum
     end
 
     # Part of the 'visitee' role in Visitor design pattern.
@@ -78,21 +132,38 @@ module Skeem
     def accept(aVisitor)
       aVisitor.visit_nonterminal(self)
     end
-    
+
     def done!()
       # Do nothing
     end
 
-    alias subnodes children
+    alias children members
+    alias subnodes members
+    alias head first
+    alias tail rest
   end # class
 
-  class SExprUnaryOpNode < SExprCompositeNode
-    def initialize(aSymbol, aPosition)
-      super(aSymbol, aPosition)
+  class ProcedureCall < SExprElement
+    attr_reader :operator
+    attr_reader :operands
+
+    def initialize(aPosition, anOperator, theOperands)
+      super(aPosition)
+      @operator = anOperator
+      @operands = SExprList.new
+      @operands.instance_variable_set(:@members, theOperands)
+    end
+
+    def evaluate(aRuntime)
+      procedure_key = operator.evaluate(aRuntime)
+      err = StandardError
+      err_msg = "Unknown function #{procedure_key}"
+      raise err, err_msg unless aRuntime.include?(procedure_key.value)
+      procedure = aRuntime.environment.bindings[procedure_key.value]
+      result = procedure.call(aRuntime, self)
     end
 
-    alias members children
+    alias children operands
   end # class
-=end
 end # module
 # End of file

data/lib/skeem/tokenizer.rb

@@ -185,6 +185,7 @@ module Skeem
 
       loop do
         ws_found = false
+        cmt_found = false
         found = scanner.skip(/[ \t\f]+/)
         ws_found = true if found
         found = scanner.skip(/(?:\r\n)|\r|\n/)
@@ -193,7 +194,12 @@ module Skeem
           @lineno += 1
           @line_start = scanner.pos
         end
-        break unless ws_found
+        next_ch = scanner.peek(1)
+        if next_ch == ';'
+          cmt_found = true
+          scanner.skip(/;[^\r\n]*(?:(?:\r\n)|\r|\n)?/)
+        end
+        break unless ws_found or cmt_found
       end
 
       curr_pos = scanner.pos

data/lib/skeem/version.rb

@@ -1,3 +1,3 @@
 module Skeem
-  VERSION = '0.0.6'.freeze
+  VERSION = '0.0.7'.freeze
 end

data/spec/skeem/environment_spec.rb

@@ -0,0 +1,27 @@
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/skeem/environment' # Load the class under test
+
+module Skeem
+  describe Environment do
+    context 'Initialization:' do
+      it 'should be initialized without argument' do
+        expect { Environment.new() }.not_to raise_error
+      end
+
+      it 'should have no bindings' do
+        expect(subject.bindings).to be_empty
+      end
+    end # context
+
+    context 'Provided services:' do
+      it 'should add entries' do
+        entry = double('dummy')
+        subject.define('dummy', entry)
+        expect(subject.bindings.size).to eq(1) 
+        expect(subject.bindings['dummy']).not_to be_nil
+        expect(subject.bindings['dummy']).to eq(entry)
+      end
+    end # context
+    
+  end # describe
+end # module

data/spec/skeem/interpreter_spec.rb

@@ -8,11 +8,19 @@ module Skeem
         expect { Interpreter.new() }.not_to raise_error
       end
 
-      it 'should not have its parser initialized' do
+      it 'should not have a parser' do
         expect(subject.parser).to be_nil
       end
+
+      it 'should have a runtime object' do
+        expect(subject.runtime).to be_kind_of(Runtime)
+      end
+      
+      it 'should come with built-in functions' do
+        expect(subject.runtime.environment).not_to be_empty
+      end
     end # context
-    
+
     context 'Interpreting self-evaluating expressions' do
       it 'should evaluate isolated booleans' do
         samples = [
@@ -23,38 +31,37 @@ module Skeem
       ]
         samples.each do |source, predicted|
           result = subject.run(source)
-          expect(result).to be_kind_of(SExprBooleanNode)
+          expect(result).to be_kind_of(SExprBoolean)
           expect(result.value).to eq(predicted)
         end
-      end      
-    end
-    
-    it 'should evaluate isolated integers' do
+      end
+
+      it 'should evaluate isolated integers' do
         samples = [
-        ['0', 0],
-        ['3', 3],
-        ['-3', -3],
-        ['+12345', 12345],
-        ['-12345', -12345]
-      ]
+          ['0', 0],
+          ['3', 3],
+          ['-3', -3],
+          ['+12345', 12345],
+          ['-12345', -12345]
+        ]
         samples.each do |source, predicted|
           result = subject.run(source)
-          expect(result).to be_kind_of(SExprIntegerNode)
+          expect(result).to be_kind_of(SExprInteger)
           expect(result.value).to eq(predicted)
         end
       end
-      
+
       it 'should evaluate isolated real numbers' do
         samples = [
-        ['0.0', 0.0],
-        ['3.14', 3.14],
-        ['-3.14', -3.14],
-        ['+123e+45', 123e+45],
-        ['-123e-45', -123e-45]
-      ]
+          ['0.0', 0.0],
+          ['3.14', 3.14],
+          ['-3.14', -3.14],
+          ['+123e+45', 123e+45],
+          ['-123e-45', -123e-45]
+        ]
         samples.each do |source, predicted|
           result = subject.run(source)
-          expect(result).to be_kind_of(SExprRealNode)
+          expect(result).to be_kind_of(SExprReal)
           expect(result.value).to eq(predicted)
         end
       end
@@ -65,20 +72,28 @@ module Skeem
       ]
         samples.each do |source, predicted|
           result = subject.run(source)
-          expect(result).to be_kind_of(SExprStringNode)
+          expect(result).to be_kind_of(SExprString)
           expect(result.value).to eq(predicted)
         end
       end
 
       it 'should evaluate isolated identifiers' do
         samples = [
-        ['the-word-recursion-has-many-meanings', 'the-word-recursion-has-many-meanings']
-      ]
+          ['the-word-recursion-has-many-meanings',
+          'the-word-recursion-has-many-meanings']
+        ]
         samples.each do |source, predicted|
           result = subject.run(source)
-          expect(result).to be_kind_of(SExprIdentifierNode)
+          expect(result).to be_kind_of(SExprIdentifier)
           expect(result.value).to eq(predicted)
         end
       end
+
+      it 'should support procedure calls' do
+        result = subject.run('(+ 3 4)')
+        expect(result).to be_kind_of(SExprInteger)
+        expect(result.value).to eq(7)
+      end
+    end # context
   end # describe
 end # module

data/spec/skeem/parser_spec.rb

@@ -23,7 +23,7 @@ module Skeem
       ]
         samples.each do |source, predicted|
           ptree = subject.parse(source)
-          expect(ptree.root).to be_kind_of(SExprBooleanNode)
+          expect(ptree.root).to be_kind_of(SExprBoolean)
           expect(ptree.root.value).to eq(predicted)
         end
       end
@@ -38,7 +38,7 @@ module Skeem
       ]
         samples.each do |source, predicted|
           ptree = subject.parse(source)
-          expect(ptree.root).to be_kind_of(SExprIntegerNode)
+          expect(ptree.root).to be_kind_of(SExprInteger)
           expect(ptree.root.value).to eq(predicted)
         end
       end
@@ -53,7 +53,7 @@ module Skeem
       ]
         samples.each do |source, predicted|
           ptree = subject.parse(source)
-          expect(ptree.root).to be_kind_of(SExprRealNode)
+          expect(ptree.root).to be_kind_of(SExprReal)
           expect(ptree.root.value).to eq(predicted)
         end
       end
@@ -64,7 +64,7 @@ module Skeem
       ]
         samples.each do |source, predicted|
           ptree = subject.parse(source)
-          expect(ptree.root).to be_kind_of(SExprStringNode)
+          expect(ptree.root).to be_kind_of(SExprString)
           expect(ptree.root.value).to eq(predicted)
         end
       end
@@ -75,7 +75,7 @@ module Skeem
       ]
         samples.each do |source, predicted|
           ptree = subject.parse(source)
-          expect(ptree.root).to be_kind_of(SExprIdentifierNode)
+          expect(ptree.root).to be_kind_of(SExprIdentifier)
           expect(ptree.root.value).to eq(predicted)
         end
       end

data/spec/skeem/primitive/primitive_builder_spec.rb

@@ -0,0 +1,15 @@
+require_relative '../../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../../lib/skeem/primitive/primitive_builder'
+
+module Skeem
+  describe Primitive::PrimitiveBuilder do
+    
+    context 'Initialization:' do
+      it 'should be initialized without argument' do
+        expect { Interpreter.new() }.not_to raise_error
+      end
+    end # context
+  end # describe
+end # module      

data/spec/skeem/runtime_spec.rb

@@ -0,0 +1,35 @@
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/skeem/environment' # Load the class under test
+require_relative '../../lib/skeem/runtime' # Load the class under test
+
+module Skeem
+  describe Runtime do
+    let(:some_env) { Environment.new }
+    subject { Runtime.new(some_env) }
+  
+    context 'Initialization:' do
+      it 'should be initialized with an environment' do
+        expect { Runtime.new(Environment.new) }.not_to raise_error
+      end
+
+      it 'should know the environment' do
+        expect(subject.environment).to eq(some_env)
+      end
+    end # context
+
+    context 'Provided services:' do
+      it 'should add entries to the environment' do
+        entry = double('dummy')
+        subject.define('dummy', entry)
+        expect(subject.environment.bindings.size).to eq(1)
+      end
+      
+      it 'should know the keys in the environment' do
+        expect(subject.include?('dummy')).to be_falsey
+        entry = double('dummy')
+        subject.define('dummy', entry)      
+        expect(subject.include?('dummy')).to be_truthy
+      end
+    end # context
+  end # describe
+end # module

data/spec/skeem/tokenizer_spec.rb

@@ -101,7 +101,7 @@ module Skeem
       it 'should tokenize strings' do
         examples = [
           # Some examples taken from R7RS document
-          '"Hello world!"',
+          '"Hello, world"',
           '"The word \"recursion\" has many meanings."'
         ]
 
@@ -114,15 +114,12 @@ module Skeem
         end
       end
     end # context
-
-
 # For later:
 # "Another example:\ntwo lines of text"
 # "Here's text \
 # containing just one line"
 # "\x03B1; is named GREEK SMALL LETTER ALPHA."
 
-
     context 'Identifier recognition:' do
       it 'should tokenize identifier' do
         examples = [
@@ -142,6 +139,37 @@ module Skeem
         end
       end
     end # context
+
+    context 'Semi-colon comments:' do
+      it 'should skip heading comments' do
+        input = "; Starting comment\n \"Some text\""
+        subject.reinitialize(input)
+        token = subject.tokens.first
+        expect(token.terminal).to eq('STRING_LIT')
+        expect(token.lexeme).to eq('Some text')
+      end
+
+      it 'should skip trailing comments' do
+        input = "\"Some text\"; Trailing comment"
+        subject.reinitialize(input)
+        token = subject.tokens.first
+        expect(token.terminal).to eq('STRING_LIT')
+        expect(token.lexeme).to eq('Some text')
+      end
+
+      it 'should skip embedded comments' do
+        input = "\"First text\"; Middle comment\n\"Second text\""
+        subject.reinitialize(input)
+        tokens = subject.tokens
+        expect(tokens.size).to eq(2)
+        token = tokens[0]
+        expect(token.terminal).to eq('STRING_LIT')
+        expect(token.lexeme).to eq('First text')
+        token = tokens[1]
+        expect(token.terminal).to eq('STRING_LIT')
+        expect(token.lexeme).to eq('Second text')
+      end
+    end
 =begin
     context 'Scanning Scheme sample code' do
       it 'should read examples from lis.py page' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skeem
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-01 00:00:00.000000000 Z
+date: 2018-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -85,17 +85,24 @@ files:
 - Rakefile
 - appveyor.yml
 - lib/skeem.rb
+- lib/skeem/environment.rb
 - lib/skeem/grammar.rb
 - lib/skeem/interpreter.rb
 - lib/skeem/parser.rb
+- lib/skeem/primitive/primitive_builder.rb
+- lib/skeem/primitive_func.rb
+- lib/skeem/runtime.rb
 - lib/skeem/s_expr_builder.rb
 - lib/skeem/s_expr_nodes.rb
 - lib/skeem/stoken.rb
 - lib/skeem/tokenizer.rb
 - lib/skeem/version.rb
 - skeem.gemspec
+- spec/skeem/environment_spec.rb
 - spec/skeem/interpreter_spec.rb
 - spec/skeem/parser_spec.rb
+- spec/skeem/primitive/primitive_builder_spec.rb
+- spec/skeem/runtime_spec.rb
 - spec/skeem/tokenizer_spec.rb
 - spec/skeem_spec.rb
 - spec/spec_helper.rb
@@ -126,7 +133,10 @@ specification_version: 4
 summary: Skeem is an interpreter of a subset of the Scheme programming language. Scheme
   is a descendent of the Lisp language.
 test_files:
+- spec/skeem/environment_spec.rb
 - spec/skeem/interpreter_spec.rb
 - spec/skeem/parser_spec.rb
+- spec/skeem/primitive/primitive_builder_spec.rb
+- spec/skeem/runtime_spec.rb
 - spec/skeem/tokenizer_spec.rb
 - spec/skeem_spec.rb