introhive_expression_language 0.6.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f1f4e06a586216b01fecc712235431ebee04bd202e3b80857599c4fa3582e55c
+  data.tar.gz: 67404a7af0a9e9618dfb10e92dd9cbb086d3b9953512cc15bb2f737c8b5473ef
+SHA512:
+  metadata.gz: ef30de77075f6c5daf27c9c0f430e286bd4100ef625dc0ee8f9a1de661cf8bc999139f8ed1df3c2561ccad338cca83b2925719d442460b78b07752611555992b
+  data.tar.gz: ee90bdc99822ecb03e8d8c7ce22637dc5f9535881981cf584b3959262d6cdfa808a490d0fc78c81d040d3d6a8c467ba19efeea2004952b819c67f3b5a8d26314

data/.github/dependabot.yml

@@ -0,0 +1,80 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+
+version: 2
+updates:
+  - package-ecosystem: "github-actions" 
+    directory: "/"
+    schedule:
+      interval: "weekly"
+
+  - package-ecosystem: "npm"
+    directory: "/"
+    open-pull-requests-limit: 0
+    schedule:
+      interval: "weekly"
+    groups:
+      npm-minor-patch:
+        applies-to: "security-updates"
+        update-types: ["minor", "patch"]
+      npm-dev-dependencies:
+        applies-to: "security-updates"
+        dependency-type: "development"
+
+  - package-ecosystem: "bundler"
+    directory: "/"
+    open-pull-requests-limit: 0
+    schedule:
+      interval: "weekly"
+    groups:
+      bundler-minor-patch:
+        applies-to: "security-updates"
+        update-types: ["minor", "patch"]
+
+  - package-ecosystem: "nuget"
+    directory: "/"
+    open-pull-requests-limit: 0
+    schedule:
+      interval: "weekly"
+    groups:
+      nuget-minor-patch:
+        applies-to: "security-updates"
+        update-types: ["minor", "patch"]
+
+  - package-ecosystem: "gomod"
+    directory: "/"
+    open-pull-requests-limit: 0
+    schedule:
+      interval: "weekly"
+    groups:
+      gomod-minor-patch:
+        applies-to: "security-updates"
+        update-types: ["minor", "patch"]
+        
+  - package-ecosystem: "pip"
+    directory: "/"
+    open-pull-requests-limit: 0
+    schedule:
+      interval: "weekly"
+    groups:
+      pip-minor-patch:
+        applies-to: "security-updates"
+        update-types: ["minor", "patch"]
+      pip-dev-dependencies:
+        applies-to: "security-updates"
+        dependency-type: "development"
+
+  - package-ecosystem: "uv"
+    directory: "/"
+    open-pull-requests-limit: 0
+    schedule:
+      interval: "weekly"
+    groups:
+      uv-minor-patch:
+        applies-to: "security-updates"
+        update-types: ["minor", "patch"]
+      uv-dev-dependencies:
+        applies-to: "security-updates"
+        dependency-type: "development"

data/.github/pull_request_template.md

@@ -0,0 +1,17 @@
+### Summary of Changes
+
+<!-- Include brief description of changes, and explanation of the business problem they solve. -->
+
+**JIRA Link**: https://introhive.atlassian.net/browse/IHS- <!-- Update this! -->
+
+### Testing Steps
+
+<!-- Include brief description of how to test the code changes if needed -->
+
+### Review Checklist
+*To be completed by the reviewer.
+
+- [ ] All affected code paths have been tested locally by the reviewer where possible.
+- [ ] Unit/functional test coverage is adequate.
+- [ ] Version updated if the current version is already in use. (version: x.y.z, x = breaking changes, y = new functionality, and z = backwards compatible bug fixes)
+- [ ] Approved for merge by a member of Suggestion Service team

data/.github/workflows/ci.yml

@@ -0,0 +1,31 @@
+name: CI
+
+# Run tests on push and pull requests
+on:
+  pull_request:
+
+jobs:
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    
+    # Set minimal permissions for the GITHUB_TOKEN
+    permissions:
+      contents: read
+    
+    steps:
+      # Check out the repository code
+      - name: Checkout code
+        uses: actions/checkout@v4
+      
+      # Set up Ruby using the version from .ruby-version file
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          bundler: 4.0.12
+          # Automatically runs bundle install and caches gems
+          bundler-cache: true
+      
+      # Run the test suite
+      - name: Run tests
+        run: bundle exec rake test

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.idea/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.DS_Store
+/vendor/bundle/
+# Ignore everything in .qlty/
+.qlty/*
+# Except qlty.toml
+!.qlty/qlty.toml

data/.qlty/qlty.toml

@@ -0,0 +1,10 @@
+config_version = "0"
+# First, use the built-in Qlty source
+[[source]]
+name = "default"
+default = true
+
+[[source]]
+name = "Introhive"
+repository = "git@github.com:Introhive/qlty-configs.git"
+branch = "master"

data/.ruby-version

@@ -0,0 +1 @@
+3.4.4

data/CLAUDE.md

@@ -0,0 +1,169 @@
+# introhive_expression_language
+
+## Project Overview
+
+IEL (Introhive Expression Language) is a Ruby gem implementing an embeddable, sandboxed programming language for end-user expression evaluation. It is designed to be safe for end users to author expressions inside Introhive's platform — they cannot escape the sandbox or call arbitrary Ruby.
+
+The language is Lisp-inspired: all expressions are s-expressions delimited by `[]`, functions are first-class, and evaluation is purely functional. Users can define their own functions via `def` and compose them with a rich standard library.
+
+IEL is the foundation that `introhive_templating_language` (ITL) builds on. The gem exposes `Platform::IEL::Evaluator` as its primary interface, which accepts an expression string and an `EvaluationContext` containing the symbols and functions available to the expression.
+
+## Project Structure
+
+- `lib/introhive_expression_language/` — All gem source code
+  - `iel.rb` — Top-level require: loads `StdLib` and `Evaluator`
+  - `iel/sexp_parser.rb` — Lexer + parser; produces `SexpParser::Node` AST nodes
+  - `iel/parser.rb` — Post-parse transforms (e.g. quote sugar `'x` → `[quote x]`)
+  - `iel/evaluator.rb` — Tree-walking evaluator and `wrap_native_function` helper
+  - `iel/evaluation_context.rb` — Scoped symbol table (supports nested/enclosing contexts)
+  - `iel/evaluation_error.rb` — Runtime error type
+  - `iel/symbol_detail.rb` — Symbol metadata helpers
+  - `iel/node_util.rb` — Node utility helpers
+  - `iel/std_lib.rb` — Aggregates all standard library modules
+  - `iel/std_lib_*.rb` — Standard library by domain (math, string, list, logic, control, etc.)
+- `test/iel/` — Minitest tests mirroring `lib/` structure (one `*_test.rb` per source file)
+- `test/test_helper.rb` — Test setup: requires gem, minitest, shoulda, mocha, pry
+
+## Core Principles
+
+1. **Every value is a Node**: All data flowing through evaluation is a `SexpParser::Node`. Never pass raw Ruby scalars between IEL functions — wrap them.
+2. **Contexts are scoped, not mutated**: Create a child `EvaluationContext` when entering a function call scope; write to `enclosing_context` when `let`/`def` should escape the current scope.
+3. **`||=` guards in stdlib declarations**: Each `declare_*` method uses `||=` so that a host application can pre-populate the context with overrides before declaring the stdlib.
+4. **Argument suffixes carry semantics**: Parameters ending in `__` are passed unevaluated (lazy/quoted). Varargs are named with a `va_` prefix; `va_foo__` means varargs + unevaluated.
+5. **Tests cover behavior, not implementation**: Test files assert on evaluated results; they do not reach into parser internals unless testing the parser specifically.
+
+## Development Commands
+
+### Setup
+```bash
+bin/setup        # installs dependencies via bundler
+```
+
+### Interactive Console
+```bash
+bin/console      # pry session with the gem loaded
+```
+
+### Testing
+```bash
+rake test                                          # run all tests
+ruby -Ilib:test test/iel/evaluator_test.rb         # run a single test file
+```
+
+### Linting
+```bash
+bundle exec rubocop                                # lint (rubocop 0.83 + rails + performance)
+```
+
+### Release
+```bash
+# 1. Bump version in lib/introhive_expression_language/version.rb
+bundle exec rake release   # tags, pushes commits + tags, pushes .gem
+```
+
+## Versioning
+
+Any change to the gem (including dependency bumps) requires a version bump in [lib/introhive_expression_language/version.rb](lib/introhive_expression_language/version.rb).
+
+Version format: `x.y.z`
+- `x` — breaking changes (removed/changed public API)
+- `y` — new backwards-compatible functionality (existing expressions and integrations continue to work unchanged; callers just gain access to something new)
+- `z` — backwards-compatible bug fixes, dependency bumps, tooling/infrastructure changes
+
+### When to bump each segment
+
+| Change type | Segment |
+|---|---|
+| Removed or changed `Evaluator`, `EvaluationContext`, or `StdLib` public API | `x` (major) |
+| New stdlib functions (e.g. adding `string-reverse` to `StdLibString`) | `y` (minor) |
+| New evaluator feature that doesn't break existing expressions | `y` (minor) |
+| New public Ruby API on `Evaluator` or `EvaluationContext` | `y` (minor) |
+| Bug fixes, dependency updates, Ruby version bumps, dev tooling | `z` (patch) |
+
+### Steps
+
+1. Increment the version in `lib/introhive_expression_language/version.rb`
+2. Run `bundle install` to update the `BUNDLED WITH` entry in `Gemfile.lock`
+3. Commit both files together in a single version bump commit
+4. Run `bundle exec rake release` to tag, push commits + tags, and push the `.gem`
+
+### Downstream
+
+Once the version bump is merged, a corresponding PR in the `introhive_templating_language` repo is required to update its reference to the new `introhive_expression_language` version. Do not deploy the downstream bump until the new gem version is available.
+
+## Testing Conventions
+
+- **Framework**: Minitest with `shoulda-context` (`should '...' do`) and `mocha` for mocking
+- **Organization**: One test file per source file, all under `test/iel/`
+- **Test helper**: `test/test_helper.rb` — always required first; provides `assert_raise_with_message`
+- **Guidelines**:
+  - Build AST nodes directly with `SexpParser::Node.*` factory methods for assertions
+  - Use `StdLib.new_context` when the test needs standard library functions; use a bare `EvaluationContext.new` when testing evaluation in isolation
+  - Test error messages exactly with `assert_raise_with_message(EvaluationError, "...")`
+  - Do not mock `Evaluator` or `SexpParser` internals — test through the public `eval_expr` / `eval_block_expr` API
+
+## Component Guide
+
+### SexpParser (`iel/sexp_parser.rb`)
+
+**What it is**: Lexer + recursive-descent parser that converts an IEL source string into a tree of `SexpParser::Node` objects.
+
+**Node kinds**: `:list`, `:symbol`, `:string_literal`, `:numeric_literal`, `:boolean`, `:nil`, `:nan`, `:native_function`
+
+**Key patterns**:
+- Parse via `SexpParser.parse(expr)` — returns the root `Node`
+- Construct test nodes with factory methods: `Node.string_literal("x")`, `Node.numeric_literal(1)`, `Node.list([...])`, `Node.symbol("name")`
+- Source positions are character offsets into the original string; `node.source_desc` renders a human-readable line/column pointer
+
+### Parser (`iel/parser.rb`)
+
+**What it is**: A thin post-processing pass over the raw s-expression AST. Currently its only job is desugaring quote syntax: `'x` → `[quote x]`.
+
+**Key patterns**:
+- Always call `Parser.parse(expr)` rather than `SexpParser.parse` directly — it runs the transforms
+- `Evaluator.eval_expr` calls `Parser.parse` internally, so callers never need to invoke the parser directly
+
+### Evaluator (`iel/evaluator.rb`)
+
+**What it is**: A tree-walking evaluator. Entry points are `eval_expr(expr_string, ctx)` and `eval_block_expr(expr_string, ctx)`.
+
+**Key patterns**:
+- `eval_expr` evaluates a single expression and returns a `Node`
+- `eval_block_expr` evaluates each top-level form in order and returns the last result (used by `def` bodies)
+- `wrap_native_function(&block)` registers a Ruby lambda as a callable IEL function; param names are introspected to build the IEL argument list
+- Arguments whose Ruby param name ends in `__` are not pre-evaluated before being passed to the native function
+
+### EvaluationContext (`iel/evaluation_context.rb`)
+
+**What it is**: A scoped symbol table. Contexts chain via `enclosing_context`, forming a lookup chain from innermost to outermost scope.
+
+**Key patterns**:
+- `ctx['symbol']` walks the chain; `ctx['symbol'] = node` writes only to the current scope
+- Symbols prefixed `C_` are constants and raise on reassignment
+- `EvaluationContext.new(parent_ctx)` creates a child scope (used automatically during function calls)
+- `ctx.root_context` traverses to the outermost context
+
+### Standard Library (`iel/std_lib_*.rb`)
+
+**What it is**: IEL built-in functions, split into domain modules. Each module has a `declare(context)` class method that registers its functions into the provided `EvaluationContext`.
+
+| Module | Functions |
+|---|---|
+| `StdLibLet` | `let` |
+| `StdLibControl` | `def`, `if`, `quote`, `block`, `eval` |
+| `StdLibMath` | arithmetic and comparison operators |
+| `StdLibString` | `concat`, `join`, `strip`, `lowercase`, `string-len`, `truncate`, `string-humanize`, `concat-list` |
+| `StdLibList` | list construction and access |
+| `StdLibAssoc` | associative list (key-value) operations |
+| `StdLibEnum` | `map`, `filter`, `reduce`, and similar |
+| `StdLibLogic` | `and`, `or`, `not` |
+| `StdLibKind` | type predicates (`string?`, `number?`, etc.) |
+| `StdLibExistence` | `nil?`, `present?` |
+| `StdLibNumber` | number coercion/formatting |
+| `StdLibJson` | JSON encode/decode |
+| `StdLibRegexp` | regular expression matching |
+
+**Key patterns**:
+- Use `StdLib.new_context` to get a fresh context with all stdlib registered
+- Add a new stdlib function by creating a `declare_<name>` private method and calling it from `declare`
+- Guard declarations with `||=` so host apps can override individual functions before calling `StdLib.declare`

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in introhive_expression_language.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,87 @@
+PATH
+  remote: .
+  specs:
+    introhive_expression_language (0.6.8)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (7.0.7.2)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    ast (2.4.1)
+    bigdecimal (4.1.0)
+    byebug (12.0.0)
+    coderay (1.1.3)
+    concurrent-ruby (1.3.5)
+    drb (2.2.3)
+    i18n (1.14.7)
+      concurrent-ruby (~> 1.0)
+    method_source (1.1.0)
+    minitest (5.25.5)
+    mocha (2.8.2)
+      ruby2_keywords (>= 0.0.5)
+    mutex_m (0.3.0)
+    parallel (1.20.0)
+    parser (2.7.2.0)
+      ast (~> 2.4.1)
+    pry (0.15.2)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    pry-byebug (3.11.0)
+      byebug (~> 12.0)
+      pry (>= 0.13, < 0.16)
+    rack (3.1.21)
+    rainbow (3.0.0)
+    rake (13.0.1)
+    rexml (3.3.9)
+    rubocop (0.83.0)
+      parallel (~> 1.10)
+      parser (>= 2.7.0.1)
+      rainbow (>= 2.2.2, < 4.0)
+      rexml
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 2.0)
+    rubocop-performance (1.5.1)
+      rubocop (>= 0.71.0)
+    rubocop-rails (2.3.2)
+      rack (>= 1.1)
+      rubocop (>= 0.72.0)
+    ruby-progressbar (1.10.1)
+    ruby2_keywords (0.0.5)
+    shoulda (4.0.0)
+      shoulda-context (~> 2.0)
+      shoulda-matchers (~> 4.0)
+    shoulda-context (2.0.0)
+    shoulda-matchers (4.4.1)
+      activesupport (>= 4.2.0)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (1.7.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport (~> 7.0.7.2)
+  bigdecimal (>= 4.1.0)
+  bundler (>= 2.2.10)
+  drb (>= 2.2.3)
+  introhive_expression_language!
+  minitest (~> 5.0)
+  mocha (~> 2.0)
+  mutex_m (>= 0.3.0)
+  pry (~> 0.14)
+  pry-byebug
+  rack (~> 3.1.21)
+  rake (~> 13.0.1)
+  rexml (~> 3.3.9)
+  rubocop (= 0.83.0)
+  rubocop-performance (= 1.5.1)
+  rubocop-rails (= 2.3.2)
+  shoulda
+
+BUNDLED WITH
+  4.0.12

data/README.md

@@ -0,0 +1,55 @@
+# IntrohiveExpressionLanguage
+
+[![CI](https://github.com/Introhive/introhive_expression_language/actions/workflows/ci.yml/badge.svg)](https://github.com/Introhive/introhive_expression_language/actions/workflows/ci.yml)
+
+IEL is a programming language built primarily for embedding into ruby software. It is designed to be a safe language for end users to use. It is in the functional style of languages like lisp which makes it very appropriate for expression evaluation. It also makes more complex logic easy to implement as users can define their own functions and call them. Its standard library contains functions to manipulate data and control execution flow.
+
+https://docs.google.com/document/d/1m1lz-jr3tgKTLjGsPPIxEsCIWHXEsmP-iZ7ogNaegZY/edit#heading=h.bq98xgbgvoii
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'introhive_expression_language'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install introhive_expression_language
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. See the [Versioning](#versioning) section for instructions on releasing a new version.
+
+## Versioning
+
+Every change to this gem — including bug fixes, new features, and dependency updates — requires a version bump in `lib/introhive_expression_language/version.rb` before merging.
+
+This project follows [Semantic Versioning](https://semver.org/):
+
+| Version segment | When to increment |
+|---|---|
+| `x` (major) | Breaking changes to the public API (e.g. removing or renaming functions in `Evaluator`, `EvaluationContext`, or `StdLib`) |
+| `y` (minor) | New backwards-compatible functionality (e.g. new stdlib functions, new evaluator features, new public Ruby API) |
+| `z` (patch) | Backwards-compatible fixes, dependency updates, Ruby version bumps, tooling changes |
+
+### Steps to release
+
+1. Bump the version in `lib/introhive_expression_language/version.rb`
+2. Run `bundle install` to update `Gemfile.lock`
+3. Commit both files and merge the PR
+4. Run `bundle exec rake release` to tag, push, and publish the `.gem`
+
+After the new version is published, update the `introhive_expression_language` reference in any downstream projects to point to the new version.
+
+## Continuous Integration
+
+This project uses GitHub Actions for continuous integration. The CI workflow runs on every push and pull request to the `master` branch. You can view the status of builds and tests in the [Actions tab](https://github.com/Introhive/introhive_expression_language/actions).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "introhive_expression_language"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/introhive_expression_language.gemspec

@@ -0,0 +1,54 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "introhive_expression_language/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "introhive_expression_language"
+  spec.version       = IntrohiveExpressionLanguage::VERSION
+  spec.authors       = ["Jacob O'Reilly"]
+  spec.email         = ["jacob.oreilly@introhive.com"]
+
+  spec.summary       = %q{A programming language built primarily for embedding into ruby software.}
+  spec.description   = %q{IEL is a programming language built primarily for embedding into ruby software. It is designed to be a safe language for end users to use. It is in the functional style of languages like lisp which makes it very appropriate for expression evaluation. It also makes more complex logic easy to implement as users can define their own functions and call them. Its standard library contains functions to manipulate data and control execution flow.}
+  # spec.homepage      = "Put your gem's website or public repo URL here."
+
+  # # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # # to allow pushing to a single host or delete this section to allow pushing to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  #   spec.metadata["homepage_uri"] = spec.homepage
+  #   spec.metadata["source_code_uri"] = "TODO: Put your gem's public repo URL here."
+  #   spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against " \
+  #     "public gem pushes."
+  # end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "activesupport", "~> 7.0.7.2"
+  spec.add_development_dependency "bigdecimal", ">= 4.1.0"
+  spec.add_development_dependency "mutex_m", ">= 0.3.0"
+  spec.add_development_dependency "drb", ">= 2.2.3"
+  spec.add_development_dependency 'bundler', '>= 2.2.10'
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "mocha", "~> 2.0"
+  spec.add_development_dependency "pry", "~> 0.14"
+  spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "rack", "~> 3.1.21"
+  spec.add_development_dependency "rake", "~> 13.0.1"
+  spec.add_development_dependency "rexml", "~> 3.3.9"
+  spec.add_development_dependency 'rubocop', '= 0.83.0'
+  spec.add_development_dependency 'rubocop-performance', '= 1.5.1'
+  spec.add_development_dependency 'rubocop-rails', '= 2.3.2'
+  spec.add_development_dependency "shoulda"
+end

data/lib/introhive_expression_language/iel/evaluation_context.rb

@@ -0,0 +1,35 @@
+module Platform
+  module IEL
+    class EvaluationContext
+      attr_reader :enclosing_context
+
+      def initialize(enclosing_context = nil)
+        @enclosing_context = enclosing_context
+        @symbols = {}
+      end
+
+      def [](symbol)
+        out = @symbols[symbol]
+        return out if out.present?
+        return @enclosing_context[symbol] if @enclosing_context
+        nil
+      end
+
+      def []=(symbol, symbol_detail)
+        raise StandardError, "Cannot write symbol '#{symbol}' value '#{symbol_detail.inspect}' as it is not of type Platform::IEL::SexpParser::Node" unless symbol_detail.is_a?(SexpParser::Node)
+        raise StandardError, "Cannot redefine constant symbol '#{symbol}' value '#{symbol_detail.inspect}'" if constant_name?(symbol) && self[symbol]
+        @symbols[symbol] = symbol_detail
+      end
+
+      def constant_name?(symbol)
+        symbol.start_with?('C_')
+      end
+
+      # Find and return the root context by following enclosing contexts.
+      def root_context
+        return enclosing_context.root_context if enclosing_context
+        self
+      end
+    end
+  end
+end

data/lib/introhive_expression_language/iel/evaluation_error.rb

@@ -0,0 +1,9 @@
+module Platform
+  module IEL
+    class EvaluationError < StandardError
+      def initialize(message, node = Platform::IEL::SexpParser::Node.nil)
+        super "#{message}#{node.try(:source_desc)}"
+      end
+    end
+  end
+end