Allow local definitions to shadow defaults

lib/keisan/context.rb

@@ -61,8 +61,12 @@ def has_variable?(name)
       @variable_registry.has?(name)
     end
 
+    def variable_is_modifiable?(name)
+      @variable_registry.modifiable?(name)
+    end
+
     def register_variable!(name, value, local: false)
-      if !@variable_registry.shadowed.member?(name) && (transient? || !local && @parent&.has_variable?(name))
+      if !@variable_registry.shadowed.member?(name) && (transient? || !local && @parent&.variable_is_modifiable?(name))
         @parent.register_variable!(name, value)
       else
         @variable_registry.register!(name, value)
@@ -77,8 +81,12 @@ def has_function?(name)
       @function_registry.has?(name)
     end
 
+    def function_is_modifiable?(name)
+      @function_registry.modifiable?(name)
+    end
+
     def register_function!(name, function, local: false)
-      if transient? || !local && @parent&.has_function?(name)
+      if transient? || !local && @parent&.function_is_modifiable?(name)
         @parent.register_function!(name, function)
       else
         @function_registry.register!(name.to_s, function)

lib/keisan/functions/registry.rb

@@ -32,14 +32,14 @@ def has?(name)
         false
       end
 
+      def modifiable?(name)
+        !frozen? && has?(name)
+      end
+
       def register!(name, function, force: false)
         raise Exceptions::UnmodifiableError.new("Cannot modify frozen functions registry") if frozen?
         name = name.to_s
 
-        if !force && @use_defaults && default_registry.has_name?(name)
-          raise Exceptions::UnmodifiableError.new("Cannot overwrite default function")
-        end
-
         case function
         when Proc
           self[name] = ProcFunction.new(name, function)

lib/keisan/variables/registry.rb

@@ -36,14 +36,15 @@ def has?(name)
         false
       end
 
+      def modifiable?(name)
+        !frozen? && has?(name)
+      end
+
       def register!(name, value, force: false)
         name = name.to_s
         name = name.name if name.is_a?(AST::Variable)
 
         raise Exceptions::UnmodifiableError.new("Cannot modify frozen variables registry") if frozen?
-        if !force && @use_defaults && default_registry.has_name?(name)
-          raise Exceptions::UnmodifiableError.new("Cannot overwrite default variable")
-        end
         self[name.to_s] = AST::Cell.new(value.to_node)
       end
 

spec/keisan/default_functions_spec.rb

@@ -11,6 +11,14 @@
     expect { registry.register!(:bad, Proc.new { false }) }.to raise_error(Keisan::Exceptions::UnmodifiableError)
   end
 
+  it "creates local function when conflicting with function in default registry" do
+    calculator = Keisan::Calculator.new
+    calculator.evaluate("sin(theta) = theta")
+
+    expect(calculator.evaluate("sin(1)").value).to eq 1
+    expect(registry["sin"].call(nil, 1).value).to eq Math.sin(1)
+  end
+
   context "array methods" do
     it "works as expected" do
       expect(registry["min"].name).to eq "min"

spec/keisan/default_variables_spec.rb

@@ -16,4 +16,12 @@
   it "is unmodifiable" do
     expect { registry.register!(:bad, false) }.to raise_error(Keisan::Exceptions::UnmodifiableError)
   end
+
+  it "creates local variable when conflicting with variable in default registry" do
+    calculator = Keisan::Calculator.new
+    calculator.evaluate("PI = 3")
+
+    expect(calculator.evaluate("PI").value).to eq 3
+    expect(registry["PI"].value).to eq Math::PI
+  end
 end