rename and shit

omkarmoghe · omkarmoghe · commit 94654c40e6b3 · 2024-03-27T10:51:26.000-07:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,4 +1,4 @@
 ## [Unreleased]
 
-## [0.1.0] - 2024-03-XX
+## [0.1.0] - 2024-03-27
 - Initial release
diff --git a/Gemfile b/Gemfile
@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-# Specify your gem's dependencies in expressive.gemspec
+# Specify your gem's dependencies in portable_expressions.gemspec
 gemspec
 
 gem "rake", "~> 13.0"
diff --git a/Gemfile.lock b/Gemfile.lock
@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    expressive (0.1.0)
+    portable_expressions (0.1.0)
 
 GEM
   remote: https://rubygems.org/
@@ -40,7 +40,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  expressive!
+  portable_expressions!
   minitest (~> 5.16)
   rake (~> 13.0)
   rubocop (~> 1.21)
diff --git a/README.md b/README.md
@@ -1,21 +1,21 @@
-# Expressive 🧠
+# PortableExpressions 🍱
 
-A simple and flexible pure Ruby library for building and evaluating expressions.
+A simple and flexible pure Ruby library for building and evaluating expressions. Expressions can be serialized to and built from JSON strings for portability.
 
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:
 
-  `bundle add expressive`
+  `bundle add portable_expressions`
 
 If bundler is not being used to manage dependencies, install the gem by executing:
 
-  `gem install expressive`
+  `gem install portable_expressions`
 
 ## Usage
 
 > [!IMPORTANT]
-> When using the gem, all references to the models below must be prefixed with `Expressive::`. This is omitted in the README for simplicity.
+> When using the gem, all references to the models below must be prefixed with `PortableExpressions::`. This is omitted in the README for simplicity.
 
 ### Scalar
 
@@ -43,9 +43,15 @@ environment.evaluate(variable_b) #=> MissingVariableError
 
 ### Expression
 
-An expression represents 2 or more `operands` that are reduced using a defined `operator`. The `operands` of an `Expression` can be `Scalars`, `Variables`, or other `Expressions`. All `operands` must respond to the symbol (i.e. support the method) defined by the `Expression#operator`.
+An expression represents 2 or more `operands` that are reduced using a defined `operator`. The `operands` of an `Expression` can be `Scalars`, `Variables`, or other `Expressions`. All `operands` must respond to the symbol (i.e. support the method) defined by the `Expression#operator`. Just like `Variables`, `Expressions` have non value until they're evaluated by an `Environment`.
 
-And `Expression` can store its result back into the `Environment` by defining an `output`.
+Evaluating an `Expression` does the following:
+1. all `operands` are first evaluated in order
+1. all resulting _values_ are reduced using the symbol defined by the `operator`
+
+In this way evaluation is "lazy"; it won't evaluate a `Variable` or `Expression` until the `operand` is about to be used.
+
+An `Expression` can store its result back into the `Environment` by defining an `output`.
 
 ```ruby
 # addition
@@ -70,7 +76,7 @@ environment.variables
 
 #### Special `operators`
 
-Some operators, like logical `&&` and `||` are not methods in Ruby, so we pass a special string/symbol that Expressive understands.
+Some operators, like logical `&&` and `||` are not methods in Ruby, so we pass a special string/symbol that PortableExpressions understands.
 - `&&` is represented by `:and`
 - `||` is represented by `:or`
 
@@ -136,26 +142,26 @@ All models have a **required** `object` key that indicates the type of object.
 
 ### Building (from JSON)
 
-To parse a JSON string, use the `Expressive.from_json` method.
+To parse a JSON string, use the `PortableExpressions.from_json` method.
 
 ```ruby
 environment_json = <<~JSON
   {
-    "object": "Expressive::Environment",
+    "object": "PortableExpressions::Environment",
     "variables": {
       "score_a": 100
     }
   }
 JSON
 variable_json = <<~JSON
   {
-    "object": "Expressive::Variable",
+    "object": "PortableExpressions::Variable",
     "name": "score_a"
   }
 JSON
 
-environment = Expressive.from_json(environment_json)
-variable_score_a = Expressive.from_json(variable_json)
+environment = PortableExpressions.from_json(environment_json)
+variable_score_a = PortableExpressions.from_json(variable_json)
 environment.evaluate(variable_score_a) #=> 100
 ```
 
@@ -207,7 +213,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/omkarmoghe/expressive.
+Bug reports and pull requests are welcome on GitHub at https://github.com/omkarmoghe/portable_expressions.
 
 ## License
 
diff --git a/bin/console b/bin/console
@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 require "bundler/setup"
-require "expressive"
+require "portable_expressions"
 
 # 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.
diff --git a/lib/portable_expressions.rb b/lib/portable_expressions.rb
@@ -4,15 +4,15 @@
 require "delegate"
 require "json"
 
-require_relative "expressive/version"
-require_relative "expressive/modules/serializable"
-require_relative "expressive/evaluator"
-require_relative "expressive/scalar"
-require_relative "expressive/variable"
-require_relative "expressive/expression"
-require_relative "expressive/environment"
+require_relative "portable_expressions/version"
+require_relative "portable_expressions/modules/serializable"
+require_relative "portable_expressions/evaluator"
+require_relative "portable_expressions/scalar"
+require_relative "portable_expressions/variable"
+require_relative "portable_expressions/expression"
+require_relative "portable_expressions/environment"
 
-module Expressive
+module PortableExpressions
   Error = Class.new(StandardError)
 
   DeserializationError = Class.new(Error)
diff --git a/lib/portable_expressions/environment.rb b/lib/portable_expressions/environment.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Expressive
+module PortableExpressions
   # The `Environment` holds state in the form of a `variables` hash and can evaluate `Expressions`, `Scalars`, and
   # `Variables` within a context.
   class Environment
diff --git a/lib/portable_expressions/evaluator.rb b/lib/portable_expressions/evaluator.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Expressive
+module PortableExpressions
   # Used to wrap `operands` when evaluating an `Expression`. This allows us to "extend" the functionality of an object
   # without polluting the app wide definition.
   class Evaluator < SimpleDelegator
diff --git a/lib/portable_expressions/expression.rb b/lib/portable_expressions/expression.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Expressive
+module PortableExpressions
   # An expression represents 2 or more `operands` that are reduced using a defined `operator`. The `operands` of an
   # `Expression` can be `Scalars`, `Variables`, or other `Expressions`. All `operands` must respond to the symbol (i.e.
   # support the method) defined by the `Expression#operator`.
diff --git a/lib/portable_expressions/modules/serializable.rb b/lib/portable_expressions/modules/serializable.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Expressive
+module PortableExpressions
   module Serializable
     def as_json
       {
diff --git a/lib/portable_expressions/scalar.rb b/lib/portable_expressions/scalar.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Expressive
+module PortableExpressions
   # A `Scalar` is the simplest object that can be evaluated. It holds a single `value`. When used in an `Expression`,
   # this `value` must respond to the symbol (i.e. support the method) defined by the `Expression#operator`.
   class Scalar
diff --git a/lib/portable_expressions/variable.rb b/lib/portable_expressions/variable.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Expressive
+module PortableExpressions
   # A `Variable` represents a named value stored in the `Environment`. Unlike `Scalars`, `Variables` have no value
   # until they are evaluated by an `Environment`. Evaluating a `Variable` that isn't present in the `Environment` will
   # result in a `MissingVariableError`.
diff --git a/lib/portable_expressions/version.rb b/lib/portable_expressions/version.rb
@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-module Expressive
+module PortableExpressions
   VERSION = "0.1.0"
 end
diff --git a/portable_expressions.gemspec b/portable_expressions.gemspec
@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
-require_relative "lib/expressive/version"
+require_relative "lib/portable_expressions/version"
 
 Gem::Specification.new do |spec|
-  spec.name = "expressive"
-  spec.version = Expressive::VERSION
+  spec.name = "portable_expressions"
+  spec.version = PortableExpressions::VERSION
   spec.authors = ["Omkar Moghe"]
   spec.email = ["yo@omkr.dev"]
 
   spec.summary = "A simple and flexible pure Ruby library for building and evaluating expressions."
-  spec.homepage = "https://github.com/omkarmoghe/expressive"
+  spec.homepage = "https://github.com/omkarmoghe/portable_expressions"
   spec.license = "MIT"
   spec.required_ruby_version = ">= 3.0.0"
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage
-  spec.metadata["changelog_uri"] = "https://github.com/omkarmoghe/Expressive/blob/main/CHANGELOG.md"
+  spec.metadata["changelog_uri"] = "https://github.com/omkarmoghe/portable_expressions/blob/main/CHANGELOG.md"
 
   # 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.
diff --git a/test/correctness/test_elo.rb b/test/correctness/test_elo.rb
@@ -1,6 +1,6 @@
 class TestElo < Minitest::Test
   def setup
-    @env = Expressive::Environment.new(
+    @env = PortableExpressions::Environment.new(
       "rating_a" => 1000,
       "rating_b" => 1200,
       "scale_factor" => 400,
@@ -11,46 +11,46 @@ def setup
 
   def test_elo
     # starting ratings of 2 players
-    rating_a = Expressive::Variable.new("rating_a")
-    rating_b = Expressive::Variable.new("rating_b")
-    scale_factor = Expressive::Variable.new("scale_factor")
+    rating_a = PortableExpressions::Variable.new("rating_a")
+    rating_b = PortableExpressions::Variable.new("rating_b")
+    scale_factor = PortableExpressions::Variable.new("scale_factor")
 
-    rating_difference = Expressive::Expression.new(:-, rating_b, rating_a)
-    exponent = Expressive::Expression.new(:/, rating_difference, scale_factor)
-    denominator = Expressive::Expression.new(
+    rating_difference = PortableExpressions::Expression.new(:-, rating_b, rating_a)
+    exponent = PortableExpressions::Expression.new(:/, rating_difference, scale_factor)
+    denominator = PortableExpressions::Expression.new(
       :+,
-      Expressive::Scalar.new(1),
-      Expressive::Expression.new(:**, Expressive::Scalar.new(10), exponent)
+      PortableExpressions::Scalar.new(1),
+      PortableExpressions::Expression.new(:**, PortableExpressions::Scalar.new(10), exponent)
     )
-    expected_probability_a = Expressive::Expression.new(:/, Expressive::Scalar.new(1), denominator)
+    expected_probability_a = PortableExpressions::Expression.new(:/, PortableExpressions::Scalar.new(1), denominator)
 
-    k_factor = Expressive::Variable.new("k_factor")
+    k_factor = PortableExpressions::Variable.new("k_factor")
     # [0, 1] where 0 is loss, 1 is win, 0.5 is draw
-    score_a = Expressive::Variable.new("score_a")
-    k_multiplier = Expressive::Expression.new(:-, score_a, expected_probability_a)
-    rating_delta = Expressive::Expression.new(:*, k_factor, k_multiplier)
-    rating_a_new = Expressive::Expression.new(:+, rating_a, rating_delta)
+    score_a = PortableExpressions::Variable.new("score_a")
+    k_multiplier = PortableExpressions::Expression.new(:-, score_a, expected_probability_a)
+    rating_delta = PortableExpressions::Expression.new(:*, k_factor, k_multiplier)
+    rating_a_new = PortableExpressions::Expression.new(:+, rating_a, rating_delta)
 
     assert_equal(1016.0, @env.evaluate(rating_a_new))
   end
 
   def test_elo_no_local_variables
     rating_a_new = @env.evaluate(
       # starting ratings of 2 players
-      Expressive::Expression.new(:-, Expressive::Variable.new("rating_b"), Expressive::Variable.new("rating_a"), output: "rating_difference"),
-      Expressive::Expression.new(:/, Expressive::Variable.new("rating_difference"), Expressive::Variable.new("scale_factor"), output: "exponent"),
-      Expressive::Expression.new(
+      PortableExpressions::Expression.new(:-, PortableExpressions::Variable.new("rating_b"), PortableExpressions::Variable.new("rating_a"), output: "rating_difference"),
+      PortableExpressions::Expression.new(:/, PortableExpressions::Variable.new("rating_difference"), PortableExpressions::Variable.new("scale_factor"), output: "exponent"),
+      PortableExpressions::Expression.new(
         :+,
-        Expressive::Scalar.new(1),
-        Expressive::Expression.new(:**, Expressive::Scalar.new(10), Expressive::Variable.new("exponent")),
+        PortableExpressions::Scalar.new(1),
+        PortableExpressions::Expression.new(:**, PortableExpressions::Scalar.new(10), PortableExpressions::Variable.new("exponent")),
         output: "denominator"
       ),
-      Expressive::Expression.new(:/, Expressive::Scalar.new(1), Expressive::Variable.new("denominator"), output: "expected_probability_a"),
+      PortableExpressions::Expression.new(:/, PortableExpressions::Scalar.new(1), PortableExpressions::Variable.new("denominator"), output: "expected_probability_a"),
 
       # [0, 1] where 0 is loss, 1 is win, 0.5 is draw
-      Expressive::Expression.new(:-, Expressive::Variable.new("score_a"), Expressive::Variable.new("expected_probability_a"), output: "k_multiplier"),
-      Expressive::Expression.new(:*, Expressive::Variable.new("k_factor"), Expressive::Variable.new("k_multiplier"), output: "rating_delta"),
-      Expressive::Expression.new(:+, Expressive::Variable.new("rating_a"), Expressive::Variable.new("rating_delta"), output: "rating_a_new")
+      PortableExpressions::Expression.new(:-, PortableExpressions::Variable.new("score_a"), PortableExpressions::Variable.new("expected_probability_a"), output: "k_multiplier"),
+      PortableExpressions::Expression.new(:*, PortableExpressions::Variable.new("k_factor"), PortableExpressions::Variable.new("k_multiplier"), output: "rating_delta"),
+      PortableExpressions::Expression.new(:+, PortableExpressions::Variable.new("rating_a"), PortableExpressions::Variable.new("rating_delta"), output: "rating_a_new")
     )
 
     assert_equal(1016.0, rating_a_new)
diff --git a/test/correctness/test_logical_methods.rb b/test/correctness/test_logical_methods.rb
@@ -1,26 +1,26 @@
 class TestLogicalMethods < Minitest::Test
   def setup
-    @env = Expressive::Environment.new(
+    @env = PortableExpressions::Environment.new(
       "variable_true" => true,
       "variable_false" => false
     )
   end
 
   def test_logical_and
-    expression = Expressive::Expression.new(
+    expression = PortableExpressions::Expression.new(
       :and,
-      Expressive::Variable.new("variable_true"),
-      Expressive::Variable.new("variable_false")
+      PortableExpressions::Variable.new("variable_true"),
+      PortableExpressions::Variable.new("variable_false")
     )
 
     assert_equal(false, @env.evaluate(expression))
   end
 
   def test_logical_or
-    expression = Expressive::Expression.new(
+    expression = PortableExpressions::Expression.new(
       :or,
-      Expressive::Variable.new("variable_true"),
-      Expressive::Variable.new("variable_false")
+      PortableExpressions::Variable.new("variable_true"),
+      PortableExpressions::Variable.new("variable_false")
     )
 
     assert(@env.evaluate(expression))
diff --git a/test/correctness/test_parsing.rb b/test/correctness/test_parsing.rb
diff --git a/test/models/test_environment.rb b/test/models/test_environment.rb
diff --git a/test/models/test_expression.rb b/test/models/test_expression.rb
diff --git a/test/test_expressive.rb b/test/test_expressive.rb
diff --git a/test/test_helper.rb b/test/test_helper.rb

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`# frozen_string_literal: true`
`2`	`2`
`3`		`-module Expressive`
	`3`	`+module PortableExpressions`
`4`	`4`	`module Serializable`
`5`	`5`	`def as_json`
`6`	`6`	`{`