calculator-on-ruby 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2d709e1d63066165d3a0cf0131adeac870c52ad1992b74209db9f4b9889a687c
+  data.tar.gz: 38331de1844359a2aa86135888326e6e5afe049f2872b250a747d7a9433314f3
+SHA512:
+  metadata.gz: c44172f1060712941a9f0127939b9f3c0fd7d643cefb8096643c2df866d1348142f88b3a173ba73309c926186cf6ad473bf1e2f3ee5d9e7d039ac2b4fdbcfe79
+  data.tar.gz: ea9807b4d2c09c7b6acb1e0735abb5a2b3ad84b5ff7715cbfc066e71921a2643b7b41a42a3ae93f7d8e45c5c548ecc0de4216cc90be043aba738e0f5cb168c40

data/README.md

@@ -0,0 +1,18 @@
+# Calculator on Ruby
+
+I started this project so I could learn how to code in ruby. Now I know! But was it worth 500(exact) lines?? Probably not. Oh well.
+
+# Usage
+
+- Install ruby
+  - Windows: `winget install -e --id RubyInstallerTeam.Ruby.4.0` or on ruby's website
+  - Fedora: `sudo dnf install ruby`
+  - Debian: `sudo apt install ruby-full`
+  - Mac: idk, either with brew or on their website
+- Clone this project (`git clone https://gitlab.com/peanutplays61/calculator-on-ruby.git`)
+- run `bundle config set --local without 'development'`
+- run `bundle install`
+- run `bundle exec ruby main.rb`
+- Enter some calculations! There might be some errors at the beginning - this is beyond my control. It only happened on Windows for me.
+
+Thanks for trying my project! This unfortunately took me 15 hours.

data/bin/calculator

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require 'main'
+
+main

data/lib/main.rb

@@ -0,0 +1,220 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+require 'colorize'
+
+class Module
+  include T::Sig
+  include T::Helpers
+end
+
+require_relative 'operators'
+
+extend T::Sig
+
+class InvalidOperation < StandardError; end
+
+sig do
+  params(operation: T.nilable(OperatorClass), number: T.nilable(Numeric), total_operation: T.nilable(Operator),
+         parentheses_index: Integer).returns(T.nilable(Operator))
+end
+def perform_operation(operation, number, total_operation, parentheses_index)
+  make_parentheses_setter = proc { |parentheses|
+    proc { |new_value|
+      T.let(parentheses, Parentheses).value = T.cast(new_value, Operator)
+    }
+  }
+  if total_operation.nil?
+    total_operation = if operation.nil?
+                        Number.new(T.must(number)) unless number.nil?
+                      elsif operation != Parentheses
+                        raise InvalidOperation, 'Too many operators in a row'
+                      else
+                        Parentheses.new(number.nil? ? nil : Number.new(number))
+                      end
+  else
+    raise StandardError, 'Operation is nil, but total operation is not! Impossible!' if operation.nil?
+
+    current_operation = T.let(total_operation, T.nilable(Operator))
+    set_current_operation = proc { |new_value| total_operation = T.cast(new_value, Operator) }
+    dive_operation = T.let(current_operation, T.nilable(Operator))
+    current_parentheses = (operation == Parentheses ? 1 : 0)
+    while current_parentheses < parentheses_index
+      if dive_operation.instance_of? Parentheses
+        set_current_operation = make_parentheses_setter.call(dive_operation)
+        current_operation = dive_operation.value
+
+        dive_operation = dive_operation.value
+        current_parentheses += 1
+      elsif dive_operation.instance_of?(Number)
+        # is a number, there is an issue
+        raise InvalidOperation
+      elsif dive_operation.is_a?(TwoSidedOperator)
+        dive_operation = dive_operation.right
+      end
+    end
+
+    if operation.include? TwoSidedOperator
+      operation = T.cast(operation, T.all(T::Class[TwoSidedOperator], Operator::ClassMethods))
+      raise InvalidOperation, 'Number must be first in parentheses!' if current_operation.nil?
+
+      if current_operation.priority >= operation.priority
+        set_current_operation.call(operation.new(current_operation, number ? Number.new(number) : nil))
+      else
+        dive_operation = T.cast(current_operation, TwoSidedOperator)
+
+        loop do
+          if T.must(dive_operation.right).priority > operation.priority
+            dive_operation.right = operation.new(dive_operation.right, number ? Number.new(number) : nil)
+            break
+          end
+          dive_operation = dive_operation.right
+        end
+      end
+    elsif operation == Parentheses
+      if current_operation.nil?
+        set_current_operation.call(Parentheses.new(number.nil? ? nil : Number.new(number)))
+      else
+
+        dive_operation = T.cast(current_operation, OneOrTwoOperator)
+
+        get_value = T.let(Kernel.proc do |operator|
+          case operator
+          when TwoSidedOperator
+            operator.right
+          when Number
+            raise 'Do not call this function with a number type.'
+          when Parentheses
+            operator.value
+          end
+        end, T.proc.params(operator: OneOrTwoOperator).returns(T.nilable(Operator)))
+
+        set_value = T.let(Kernel.proc do |operator, new_value|
+          case operator
+          when TwoSidedOperator
+            operator.right = new_value
+          when Number
+            raise 'Do not call this function with a number type.'
+          when Parentheses
+            operator.value = new_value
+          end
+        end, T.proc.params(operator: OneOrTwoOperator, new_value: OneOrTwoOperator).void)
+
+        loop do
+          if dive_operation.is_a?(Number)
+            raise 'This should not happen!'
+          elsif get_value.call(dive_operation).nil?
+            set_value.call(dive_operation, Parentheses.new(number.nil? ? nil : Number.new(number)))
+            break
+          elsif T.must(get_value.call(dive_operation)).priority >= Times.priority
+            new_dive = get_value.call(dive_operation)
+            loop do
+              break if new_dive.is_a? Number
+
+              next_value = get_value.call(T.cast(new_dive, OneOrTwoOperator))
+
+              if next_value.nil?
+                dive_operation = new_dive
+                break
+              end
+
+              new_dive = next_value
+            end
+            if get_value.call(T.cast(new_dive, OneOrTwoOperator)).nil?
+              # there is a nil deeper down
+              next
+            end
+
+            dive_operation = Times.new(get_value.call(T.cast(dive_operation, OneOrTwoOperator)),
+                                       Parentheses.new(number.nil? ? nil : Number.new(number)))
+            break
+          end
+
+          dive_operation = get_value.call(dive_operation)
+        end
+      end
+    end
+  end
+
+  total_operation
+end
+
+def main
+  Signal.trap('INT') do
+    puts
+    return
+  end
+
+  print 'hi! This is a calculator. '
+  loop do
+    print 'What is your equation? '
+    STDOUT.flush # rubocop:disable Style/GlobalStdStream
+
+    equation = gets.chomp
+    current_number = T.let(nil, T.nilable(Numeric))
+    total_operation = T.let(nil, T.nilable(Operator))
+    current_operation = T.let(nil, T.nilable(OperatorClass))
+    number_is_negative = T.let(false, T::Boolean)
+    in_decimal_count = 0
+
+    parentheses_index = 0
+    next_parentheses_index = 0
+
+    begin
+      equation.each_char do |char|
+        if char.match?(/\d/)
+          current_number = if current_number.nil?
+                             (char.to_i * (number_is_negative ? -1 : 1))
+                               .fdiv(in_decimal_count.positive? ? T.cast(10.pow(in_decimal_count), Integer) : 1)
+                           else
+                             (current_number * (in_decimal_count.positive? ? 1 : 10)) +
+                               (char.to_i * (number_is_negative ? -1 : 1))
+                               .fdiv(in_decimal_count.positive? ? T.cast(10.pow(in_decimal_count), Integer) : 1)
+                           end
+          in_decimal_count += 1 if in_decimal_count.positive?
+        elsif char == '-' && current_number.nil?
+          number_is_negative = true
+        elsif char == '.'
+          in_decimal_count = 1 if in_decimal_count.zero?
+        elsif CHARACTERS.include?(char)
+          in_decimal_count = 0
+          number_is_negative = false
+
+          total_operation = perform_operation(current_operation, current_number, total_operation, parentheses_index)
+          parentheses_index = next_parentheses_index
+          current_operation = CHARACTERS[char]
+          current_number = nil
+        elsif char == '('
+          next_parentheses_index += 1
+          total_operation = perform_operation(current_operation, current_number, total_operation, parentheses_index)
+          parentheses_index = next_parentheses_index
+          current_operation = Parentheses
+        elsif char == ')'
+          next_parentheses_index -= 1
+        end
+      end
+
+      raise InvalidOperation, 'No closing parenthesis!' if next_parentheses_index.positive?
+      raise InvalidOperation, 'Too many closing parentheses!' if next_parentheses_index.negative?
+
+      total_operation = perform_operation(current_operation, current_number, total_operation, parentheses_index)
+      raise InvalidOperation, 'No equation' if total_operation.nil?
+
+      raise InvalidOperation unless total_operation.can_evaluate?
+
+      puts total_operation.evaluate.round(8)
+    rescue InvalidOperation => e
+      puts 'That equation is invalid!'.colorize(:red)
+      puts "Reason: #{e.message}" if e.message != e.class.to_s
+    end
+    print 'Would you like to calculate another equation [Y/n]? '
+    STDOUT.flush # rubocop:disable Style/GlobalStdStream
+    answer = gets.strip.downcase
+    unless answer in ('y' | 'yes' | 'yeah' | 'ye' | 'sure' | 'yes.' | '')
+      break
+    end
+  end
+end
+
+main if T.let($PROGRAM_NAME, String) == __FILE__

data/lib/operators.rb

@@ -0,0 +1,285 @@
+# typed: true
+# frozen_string_literal: true
+
+extend T::Sig
+
+class Module
+  include T::Sig
+  include T::Helpers
+end
+
+# OperatorClass is courtesy of deepseek
+OperatorClass = T.type_alias { T.all(T::Class[Operator], Operator::ClassMethods) }
+OneOrTwoOperator = T.type_alias { T.any(OneSidedOperator, TwoSidedOperator) }
+
+module Operator
+  abstract!
+  include Kernel
+
+  module ClassMethods
+    interface!
+
+    sig { abstract.returns(Integer) }
+    def priority; end
+  end
+
+  mixes_in_class_methods(ClassMethods)
+
+  sig { returns(Integer) }
+  def priority
+    T.let(self.class, OperatorClass).priority
+  end
+
+  sig { abstract.returns(T::Boolean) }
+  def can_evaluate?; end
+
+  sig { abstract.returns(Numeric) }
+  def evaluate; end
+
+  sig { abstract.returns(String) }
+  def to_string; end
+end
+
+module TwoSidedOperator
+  include Operator
+  include Kernel
+
+  abstract!
+
+  mixes_in_class_methods Operator::ClassMethods
+
+  sig { returns(T.nilable(Operator)) }
+  def left = T.let(@left, T.nilable(Operator))
+
+  sig { params(left: T.nilable(Operator)).void }
+  def left=(left)
+    @left = left
+  end
+
+  sig { returns(T.nilable(Operator)) }
+  def right = T.let(@right, T.nilable(Operator))
+
+  sig { params(right: T.nilable(Operator)).void }
+  def right=(right)
+    @right = right
+  end
+
+  sig { params(left: T.nilable(Operator), right: T.nilable(Operator)).void }
+  def initialize(left, right)
+    @left = left
+    @right = right
+  end
+
+  sig { override.returns(String) }
+  def to_string
+    "(#{@left.nil? ? 'nil' : @left.to_string}" \
+      "#{" #{char}" if is_a?(CharacterOperator)} #{@right.nil? ? 'nil' : @right.to_string})"
+  end
+
+  sig { override.returns(T::Boolean) }
+  def can_evaluate?
+    !(@left.nil? || @right.nil?) && @left.can_evaluate? && @right.can_evaluate?
+  end
+end
+
+module OneSidedOperator
+  include Operator
+
+  abstract!
+
+  sig { returns(T.any(T.nilable(Operator), Numeric)) }
+  def value = T.let(@value, T.any(T.nilable(Operator), Numeric))
+
+  sig { params(value: T.any(T.nilable(Operator), Numeric)).void }
+  def value=(value)
+    @value = value
+  end
+
+  mixes_in_class_methods(Operator::ClassMethods)
+
+  sig { params(value: T.any(T.nilable(Operator), Numeric)).void }
+  def initialize(value); end
+end
+
+module CharacterOperator
+  abstract!
+  include Kernel
+
+  module ClassMethods
+    interface!
+    include Operator::ClassMethods
+
+    sig { abstract.returns(String) }
+    def char; end
+  end
+
+  sig { returns(String) }
+  def char
+    T.let(self.class, T.all(T::Class[CharacterOperator], ClassMethods)).char
+  end
+
+  mixes_in_class_methods ClassMethods
+end
+
+class Plus
+  include CharacterOperator
+  include TwoSidedOperator
+
+  sig { override.returns(String) }
+  def self.char = '+'
+  sig { override.returns(Integer) }
+  def self.priority
+    0
+  end
+
+  sig { override.returns(Numeric) }
+  def evaluate
+    T.must_because(@left) { 'Must not be null when evaluating' }.evaluate + T.must_because(@right) do
+      'Must not be null when evaluating'
+    end.evaluate
+  end
+end
+
+class Minus
+  include TwoSidedOperator
+  include CharacterOperator
+
+  sig { override.returns(String) }
+  def self.char = '-'
+  sig { override.returns(Integer) }
+  def self.priority = 0
+  sig { override.returns(Numeric) }
+  def evaluate
+    T.must_because(@left) { 'Must not be null when evaluating' }.evaluate - T.must_because(@right) {
+      'Must not be null when evaluating'
+    }.evaluate
+  end
+end
+
+class Times
+  include TwoSidedOperator
+  include CharacterOperator
+
+  sig { override.returns(String) }
+  def self.char = '*'
+  sig { override.returns(Integer) }
+  def self.priority = 1
+  sig { override.returns(Numeric) }
+  def evaluate
+    T.must_because(@left) { 'Must not be null when evaluating' }.evaluate * T.must_because(@right) {
+      'Must not be null when evaluating'
+    }.evaluate
+  end
+end
+
+class Divided
+  include TwoSidedOperator
+  include CharacterOperator
+
+  sig { override.returns(String) }
+  def self.char = '/'
+  sig { override.returns(Integer) }
+  def self.priority = 1
+  sig { override.returns(Numeric) }
+  def evaluate
+    T.must_because(@left) { 'Must not be null when evaluating' }.evaluate / T.must_because(@right) {
+      'Must not be null when evaluating'
+    }.evaluate
+  end
+end
+
+class Power
+  include TwoSidedOperator
+  include CharacterOperator
+
+  sig { override.returns(String) }
+  def self.char = '^'
+  sig { override.returns(Integer) }
+  def self.priority = 2
+  sig { override.returns(Numeric) }
+  def evaluate
+    T.cast(T.must_because(@left) do
+      'Must not be null when evaluating'
+    end.evaluate, T.any(Integer, Float))**T.must_because(@right) {
+                                            'Must not be null when evaluating'
+                                          }.evaluate
+  end
+end
+
+class Parentheses
+  include OneSidedOperator
+
+  sig { returns T.nilable(Operator) }
+  attr_accessor :value
+
+  sig { override.returns(Integer) }
+  def self.priority = 100
+
+  sig { params(value: T.nilable(Operator)).void }
+  def initialize(value)
+    @value = value
+  end
+
+  sig { override.returns(Numeric) }
+  def evaluate
+    T.must_because(@value) { 'Must not be null when evaluating' }.evaluate
+  end
+
+  sig { override.returns(String) }
+  def to_string
+    "[#{@value&.to_string}]"
+  end
+  sig { override.returns(T::Boolean) }
+  def can_evaluate? = !@value.nil? && @value.can_evaluate?
+end
+
+class Number
+  include OneSidedOperator
+
+  sig { override.returns(Integer) }
+  def self.priority = 100
+
+  sig { params(value: Numeric).void }
+  def initialize(value)
+    @value = value
+  end
+
+  sig { override.returns(Numeric) }
+  def evaluate
+    @value
+  end
+
+  sig { override.returns(String) }
+  def to_string
+    "(#{@value})"
+  end
+  sig { override.returns(T::Boolean) }
+  def can_evaluate? = true
+end
+
+OPERATORS = T.let(
+  [Plus, Minus, Times, Divided, Power, Number].freeze,
+  T::Array[OperatorClass]
+)
+
+PRIORITIES = T.let(
+  OPERATORS.group_by(&:priority),
+  T::Hash[Integer, T::Array[OperatorClass]]
+)
+
+CHARACTERS = T.let(
+  begin
+    hash = T::Hash[String, OperatorClass].new
+    OPERATORS.each do |operator|
+      next unless operator.respond_to?(:char)
+
+      char_operator = T.cast(
+        operator,
+        T.all(T::Class[CharacterOperator], CharacterOperator::ClassMethods)
+      )
+      hash[char_operator.char] = operator
+    end
+    hash
+  end,
+  T::Hash[String, OperatorClass]
+)

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: calculator-on-ruby
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Isaiah
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: sorbet-runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.13572
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.13572
+description: This is an executable script that can run any calculations in string
+  form.
+email:
+- peanutplays61@gmail.com
+executables:
+- calculator
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/calculator
+- lib/main.rb
+- lib/operators.rb
+homepage: https://gitlab.com/peanutplays61/calculator-on-ruby
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A calculator.
+test_files: []