[WIP] Ruby Implementation

Media/Ruby/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# gem 'sorbet-static-and-runtime'
+gem 'ruby2ruby'
+
+group :development, :test do
+  gem 'rspec'
+  # gem 'tapioca', require: false
+end
+

Media/Ruby/Gemfile.lock

@@ -0,0 +1,34 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.5.0)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.1)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.0)
+    ruby2ruby (2.5.0)
+      ruby_parser (~> 3.1)
+      sexp_processor (~> 4.6)
+    ruby_parser (3.20.0)
+      sexp_processor (~> 4.16)
+    sexp_processor (4.16.1)
+
+PLATFORMS
+  arm64-darwin-22
+  x86_64-linux
+
+DEPENDENCIES
+  rspec
+  ruby2ruby
+
+BUNDLED WITH
+   2.2.3

Media/Ruby/README.md

@@ -0,0 +1,122 @@
+# Ruby
+
+**This code was written and tested with Ruby 3.2.0.**
+
+## How to Execute Tests
+
+If you haven't already, install gems.
+```
+bundle install
+```
+
+Execute tests.
+```
+bundle rspec .
+```
+
+***
+
+## Table API Implementation Progress
+
+#### Assumptions
+
+**Functions:**
+
+* [x] even
+* [x] length
+* [x] schema
+* [x] range
+* [x] concat
+* [x] startsWith
+* [x] average
+* [x] filter
+* [x] map
+* [x] removeDuplicates
+* [x] removeAll
+* [x] colNameOfNumber
+
+
+**Relations:**
+
+* [ ] x has no duplicates
+* [ ] x is equal to y
+* [ ] x is (not) in y
+* [ ] x is a subsequence of y
+* [ ] x is of sort y
+* [ ] x is y
+* [ ] x is a categorical sort
+* [ ] x is (non-)negative
+* [ ] x is equal to the sort of y
+* [ ] x is the sort of elements of y
+* [ ] x is equal to y with all a_i replaced with b_i
+
+#### Constructors
+* [ ] emptyTable
+* [ ] addRows
+* [ ] addColumn
+* [ ] buildColumn
+* [ ] vcat
+* [ ] hcat
+* [ ] values
+* [ ] crossJoin
+* [ ] leftJoin
+
+#### Properties
+
+* [ ] nrows
+* [ ] ncols
+* [ ] header
+
+#### Access Subcomponents
+
+* [ ] getRow
+* [ ] getValue
+* [ ] getColumn (overloading 1 & 2)
+
+#### Subtable
+
+* [ ] selectRows (overloading 1 & 2)
+* [ ] selectColumns (overloading 1 & 2 & 3)
+* [ ] head
+* [ ] distinct
+* [ ] dropColumn
+* [ ] dropColumns
+* [ ] tfilter
+
+#### Ordering
+
+* [ ] tsort
+* [ ] sortByColumns
+* [ ] orderBy
+
+#### Aggregate
+
+* [ ] count
+* [ ] bin
+* [ ] piviotTable
+* [ ] groupBy
+
+#### Missing Values
+
+* [ ] completeCases
+* [ ] dropna
+* [ ] fillna
+
+#### Data Cleaning
+
+* [ ] pivotLonger
+* [ ] pivotWider
+
+#### Utilities
+
+* [ ] flatten
+* [ ] transformColumn
+* [ ] renameColumns
+* [ ] find
+* [ ] groupByRetentive
+* [ ] grouoBySubtractive
+* [ ] update
+* [ ] select
+* [ ] selectMany
+* [ ] groupJoin
+* [ ] join

Media/Ruby/basics.rb

@@ -0,0 +1,141 @@
+module Basics
+  # consumes an integer and returns a boolean
+  def self.even(number)
+    assert_type_number(number)
+
+    number % 2 == 0
+  end 
+
+  # consumes a sequence and measures its length
+  def self.length(sequence)
+    assert_type_sequence(sequence)
+
+    sequence.size
+  end
+
+  # extracts the schema of a table
+  def self.schema(table)
+    assert_type_table(table)
+
+    table.schema
+  end
+
+  # TODO: is this the desired definition of range?
+  # consumes a number and produces a sequence of valid indices
+  def self.range(number)
+    assert_type_number(number)
+
+    (0 ... number).to_a
+  end
+
+  # concatenates two sequences or two strings
+  def self.concat(value_a, value_b)
+    assert_types_match(value_a, value_b)
+    assert_type_sequence_or_string(value_a)
+
+    value_a.concat(value_b)
+  end
+
+  # checks whether a string starts with another string
+  def self.starts_with(string_value, start_value)
+    assert_type_string(string_value)
+    assert_type_string(start_value)
+
+    string_value.start_with?(start_value)
+  end
+
+  # computes the average of a sequence of numbers
+  def self.average(sequence_of_numbers)
+    assert_type_sequence(sequence_of_numbers)
+
+    return 0 unless sequence_of_numbers.size > 0
+
+    total = 0
+    sequence_of_numbers.each do |number|
+      assert_type_number(number)
+
+      total += number
+    end
+
+    total / sequence_of_numbers.size
+  end
+
+  # the conventional sequence (e.g. lists) filter
+  def self.filter(sequence, &block)
+    assert_type_sequence(sequence)
+
+    sequence.select { |x| block.call(x) }
+  end
+
+  # the conventional sequence (e.g. lists) map
+  def self.map(sequence, &block)
+    assert_type_sequence(sequence)
+
+    sequence.map { |x| block.call(x) }
+  end
+
+  # consumes a sequence and produces a subsequence with all duplicated elements removed
+  def self.remove_duplicates(sequence)
+    assert_type_sequence(sequence)
+
+    memoize = {}
+    sequence.select do |x|
+      next false if memoize.key?(x)
+
+      memoize[x] = true
+
+      true
+    end
+  end
+
+  # consumes two sequences and produces a subsequence of the first input, removing all elements that also appear in the second input
+  def self.remove_all(sequence_a, sequence_b)
+    assert_type_sequence(sequence_a)
+    assert_type_sequence(sequence_b)
+
+    values_in_b = sequence_b.reduce({}) { |memoize, x| memoize[x] = true; memoize }
+
+    sequence_a.select { |x| !values_in_b.key?(x) }
+  end
+
+  # TODO: figure out what the inputs should be
+  # converts a `Number` to a `ColName`
+  def self.col_name_of_number(schema, number)
+    assert_type_schema(schema)
+    assert_type_number(number)
+    raise ArgumentError.new("number is greater than number of columns") if schema.headers.size < number
+    raise ArgumentError.new("number is greater than number of columns") if number <= 0
+
+    index = number - 1
+    schema.headers[index][:column_name]
+  end
+
+  #### helpers specific to this class ####
+  def self.assert_type_number(number)
+    raise ArgumentError.new("expected an int or float") unless number.is_a?(Integer) || number.is_a?(Float)
+  end
+
+  def self.assert_type_sequence(sequence)
+    raise ArgumentError.new("expected a sequence") unless sequence.is_a?(Array)
+  end
+
+  def self.assert_type_string(string)
+    raise ArgumentError.new("expected a string") unless string.is_a?(String)
+  end
+
+  def self.assert_type_table(table)
+    raise ArgumentError.new("expected a table") unless table.is_a?(Table)
+  end
+
+  def self.assert_type_schema(schema)
+    raise ArgumentError.new("expected a schema") unless schema.is_a?(Schema)
+  end
+
+  def self.assert_type_sequence_or_string(value)
+    raise ArgumentError.new("expected a sequence or string") unless value.is_a?(Array) || value.is_a?(String)
+  end
+
+  def self.assert_types_match(value_a, value_b)
+    raise ArgumentError.new("expected types to match") unless value_a.class == value_b.class
+  end
+end