Dev

src/methods/dataframe/filtering/index.js

@@ -18,12 +18,6 @@ export { where } from './where.js';
 export { expr$ } from './expr$.js';
 export { select } from './select.js';
 export { drop } from './drop.js';
-export { at } from './at.js';
-export { iloc } from './iloc.js';
-export { stratifiedSample } from './stratifiedSample.js';
-export { head } from './head.js';
-export { tail } from './tail.js';
-export { sample } from './sample.js';
 export { selectByPattern } from './selectByPattern.js';
-export { loc } from './loc.js';
 export { query } from './query.js';
+export { stratifiedSample } from './stratifiedSample.js';

src/methods/dataframe/index.js

@@ -7,6 +7,7 @@
 import './filtering/index.js';
 import './display/index.js';
 import './transform/index.js';
+import './indexing/index.js';
 // Import other method groups as needed
 
 // Export nothing as methods are attached to DataFrame prototype

src/methods/dataframe/indexing/index.js

@@ -0,0 +1,13 @@
+/**
+ * DataFrame indexing methods
+ * @module methods/dataframe/indexing
+ */
+
+import { DataFrame } from '../../../core/dataframe/DataFrame.js';
+import { registerDataFrameIndexing } from './register.js';
+
+// Register all indexing methods on DataFrame
+registerDataFrameIndexing(DataFrame);
+
+// Export nothing as methods are attached to DataFrame prototype
+export {};

src/methods/dataframe/indexing/register.js

@@ -13,7 +13,7 @@ import { register as registerSample } from './sample.js';
  * Register all indexing methods on DataFrame prototype
  * @param {object} DataFrame - DataFrame constructor
  */
-export function register(DataFrame) {
+export function registerDataFrameIndexing(DataFrame) {
   registerAt(DataFrame);
   registerHead(DataFrame);
   registerTail(DataFrame);

test/methods/dataframe/filtering/index.test.js

@@ -5,8 +5,15 @@
 import { describe, test, expect } from 'vitest';
 import { DataFrame } from '../../../../src/core/dataframe/DataFrame.js';
 import * as filteringMethods from '../../../../src/methods/dataframe/filtering/index.js';
-import registerDataFrameFiltering from '../../../../src/methods/dataframe/filtering/register.js';
-import { register as registerDataFrameIndexing } from '../../../../src/methods/dataframe/indexing/register.js';
+import { registerDataFrameIndexing } from '../../../../src/methods/dataframe/indexing/register.js';
+
+import {
+  testWithBothStorageTypes,
+  createDataFrameWithStorage,
+} from '../../../utils/storageTestUtils.js';
+
+// Регистрируем методы индексирования на DataFrame
+registerDataFrameIndexing(DataFrame);
 
 // Test data for use in all tests
 const testData = [
@@ -18,34 +25,42 @@ const testData = [
 ];
 
 describe('Filtering Methods Index', () => {
-  // Register filtering and indexing methods for DataFrame
-  registerDataFrameFiltering(DataFrame);
-  registerDataFrameIndexing(DataFrame);
-
-  describe('with standard storage', () => {
-    // Create DataFrame using fromRows
-    const df = DataFrame.fromRows(testData);
-
-    test('should export all filtering methods', () => {
-      // Check that all expected methods are exported
-      expect(filteringMethods).toHaveProperty('select');
-      expect(filteringMethods).toHaveProperty('drop');
-      expect(filteringMethods).toHaveProperty('selectByPattern');
-      expect(filteringMethods).toHaveProperty('filter');
-      expect(filteringMethods).toHaveProperty('query');
-      expect(filteringMethods).toHaveProperty('where');
-      expect(filteringMethods).toHaveProperty('stratifiedSample');
-    });
+  // Run tests with both storage types
+  testWithBothStorageTypes((storageType) => {
+    describe(`with ${storageType} storage`, () => {
+      // Create DataFrame with the specified storage type
+      const df = createDataFrameWithStorage(DataFrame, testData, storageType);
+
+      test('should export all filtering methods', () => {
+        // Check that all expected methods are exported
+        expect(filteringMethods).toHaveProperty('select');
+        expect(filteringMethods).toHaveProperty('drop');
+        expect(filteringMethods).toHaveProperty('selectByPattern');
+        expect(filteringMethods).toHaveProperty('filter');
+        expect(filteringMethods).toHaveProperty('query');
+        expect(filteringMethods).toHaveProperty('where');
+        expect(filteringMethods).toHaveProperty('stratifiedSample');
+      });
+
+      test('should successfully extend DataFrame with filtering methods', () => {
+        // Create a sample DataFrame
+        // df was created above using createDataFrameWithStorage
+
+        // Check that all filtering methods are available on the DataFrame instance
+        expect(typeof df.select).toBe('function');
+        expect(typeof df.drop).toBe('function');
+        expect(typeof df.selectByPattern).toBe('function');
+        expect(typeof df.filter).toBe('function');
+        expect(typeof df.query).toBe('function');
+        expect(typeof df.where).toBe('function');
+        expect(typeof df.stratifiedSample).toBe('function');
 
-    test('should successfully extend DataFrame with filtering methods', () => {
-      // Check that all filtering methods are available on the DataFrame instance
-      expect(typeof df.select).toBe('function');
-      expect(typeof df.drop).toBe('function');
-      expect(typeof df.selectByPattern).toBe('function');
-      expect(typeof df.filter).toBe('function');
-      expect(typeof df.query).toBe('function');
-      expect(typeof df.where).toBe('function');
-      expect(typeof df.stratifiedSample).toBe('function');
+        // Проверяем, что методы индексирования также доступны (они регистрируются отдельно)
+        expect(typeof df.at).toBe('function');
+        expect(typeof df.iloc).toBe('function');
+        expect(typeof df.loc).toBe('function');
+        expect(typeof df.sample).toBe('function');
+      });
     });
   });
 });

test/methods/dataframe/indexing/at.test.js

@@ -4,7 +4,7 @@
 
 import { describe, test, expect } from 'vitest';
 import { DataFrame } from '../../../../src/core/dataframe/DataFrame.js';
-import { register as registerDataFrameIndexing } from '../../../../src/methods/dataframe/indexing/register.js';
+import { registerDataFrameIndexing } from '../../../../src/methods/dataframe/indexing/register.js';
 
 // Test data for use in all tests
 const testData = [

test/methods/dataframe/indexing/head.test.js

@@ -4,7 +4,7 @@
 
 import { describe, it, expect, vi } from 'vitest';
 import { DataFrame } from '../../../../src/core/dataframe/DataFrame.js';
-import { register as registerDataFrameIndexing } from '../../../../src/methods/dataframe/indexing/register.js';
+import { registerDataFrameIndexing } from '../../../../src/methods/dataframe/indexing/register.js';
 
 // Test data for use in all tests
 const testData = [

test/methods/dataframe/indexing/iloc.test.js

@@ -4,7 +4,7 @@
 
 import { describe, test, expect } from 'vitest';
 import { DataFrame } from '../../../../src/core/dataframe/DataFrame.js';
-import { register as registerDataFrameIndexing } from '../../../../src/methods/dataframe/indexing/register.js';
+import { registerDataFrameIndexing } from '../../../../src/methods/dataframe/indexing/register.js';
 
 // Test data for use in all tests
 const testData = [

test/methods/dataframe/indexing/loc.test.js

@@ -4,7 +4,7 @@
 
 import { describe, test, expect } from 'vitest';
 import { DataFrame } from '../../../../src/core/dataframe/DataFrame.js';
-import { register as registerDataFrameIndexing } from '../../../../src/methods/dataframe/indexing/register.js';
+import { registerDataFrameIndexing } from '../../../../src/methods/dataframe/indexing/register.js';
 
 // Test data for use in all tests
 const testData = [

test/methods/dataframe/indexing/sample.test.js

@@ -4,7 +4,7 @@
 
 import { describe, test, expect } from 'vitest';
 import { DataFrame } from '../../../../src/core/dataframe/DataFrame.js';
-import { register as registerDataFrameIndexing } from '../../../../src/methods/dataframe/indexing/register.js';
+import { registerDataFrameIndexing } from '../../../../src/methods/dataframe/indexing/register.js';
 
 // Register indexing methods on DataFrame
 registerDataFrameIndexing(DataFrame);

test/methods/dataframe/indexing/tail.test.js

@@ -1,7 +1,7 @@
-// test/methods/dataframe/indexing/tail.test.js
-import { describe, it, expect } from 'vitest';
+// test/methods/filtering/tail.test.js
+import { describe, it, expect, vi } from 'vitest';
 import { DataFrame } from '../../../../src/core/dataframe/DataFrame.js';
-import { register as registerDataFrameIndexing } from '../../../../src/methods/dataframe/indexing/register.js';
+import { registerDataFrameIndexing } from '../../../../src/methods/dataframe/indexing/register.js';
 
 // Test data for use in all tests
 const testData = [

test/utils/storageTestUtils.js

@@ -1,86 +1,36 @@
 /**
- * Utilities for testing with different storage types (TypedArray and Arrow)
+ * Utilities for testing DataFrame with different storage types
  */
 
-import { VectorFactory } from '../../src/core/storage/VectorFactory.js';
+/**
+ * List of storage types to test with
+ * @type {string[]}
+ */
+export const storageTypes = ['standard', 'arrow'];
 
 /**
- * Runs tests with both storage types (TypedArray and Arrow)
- *
- * @param {Function} testFn - Test function that accepts storage type ('TypedArray' or 'Arrow')
+ * Run a test suite with both storage types
+ * @param {Function} testFn - Function to run tests with each storage type
  */
 export function testWithBothStorageTypes(testFn) {
-  // Save the original shouldUseArrow function
-  const originalShouldUseArrow = VectorFactory.shouldUseArrow;
-
-  try {
-    // Test with TypedArray
-    VectorFactory.shouldUseArrow = () => false;
-    testFn('TypedArray');
-
-    // Test with Arrow
-    VectorFactory.shouldUseArrow = () => true;
-    testFn('Arrow');
-  } finally {
-    // Restore the original function
-    VectorFactory.shouldUseArrow = originalShouldUseArrow;
-  }
+  storageTypes.forEach((storageType) => {
+    testFn(storageType);
+  });
 }
 
 /**
- * Creates DataFrame with the specified storage type
- *
- * @param {Function} DataFrameClass - DataFrame class
- * @param {Object|Array} data - Data for creating DataFrame
- * @param {string} storageType - Storage type ('TypedArray' or 'Arrow')
- * @returns {DataFrame} - Created DataFrame with the specified storage type
+ * Create a DataFrame with the specified storage type
+ * @param {Class} DataFrame - DataFrame class constructor
+ * @param {Array} data - Data to create DataFrame from
+ * @param {string} storageType - Storage type ('standard' or 'arrow')
+ * @returns {DataFrame} - DataFrame instance with the specified storage type
  */
-export function createDataFrameWithStorage(DataFrameClass, data, storageType) {
-  // Напрямую регистрируем методы фильтрации для тестов
-  try {
-    // Импортируем регистратор методов фильтрации
-    const {
-      registerDataFrameFiltering,
-    } = require('../../src/methods/dataframe/filtering/register.js');
-    registerDataFrameFiltering(DataFrameClass);
-  } catch (e) {
-    console.warn('Warning: Error registering filtering methods:', e.message);
-  }
-
-  // Save the original shouldUseArrow function
-  const originalShouldUseArrow = VectorFactory.shouldUseArrow;
+export function createDataFrameWithStorage(DataFrame, data, storageType) {
+  const options = {};
 
-  try {
-    // Set the shouldUseArrow function based on the storage type
-    VectorFactory.shouldUseArrow = () => storageType === 'Arrow';
-
-    // Convert data to a format suitable for DataFrame
-    let columns = {};
-
-    if (Array.isArray(data)) {
-      // If data is presented as an array of objects
-      if (data.length > 0) {
-        // Get a list of all keys from the first object
-        const keys = Object.keys(data[0]);
-
-        // Create columns for each key
-        for (const key of keys) {
-          columns[key] = data.map((row) => row[key]);
-        }
-      }
-    } else if (typeof data === 'object') {
-      // If data is already presented as columns
-      columns = data;
-    }
-
-    // Create DataFrame
-    const df = new DataFrameClass(columns);
-
-    // В новом коре frame это геттер, не нужно устанавливать его вручную
-    // Просто возвращаем DataFrame
-    return df;
-  } finally {
-    // Restore the original function
-    VectorFactory.shouldUseArrow = originalShouldUseArrow;
+  if (storageType === 'arrow') {
+    options.preferArrow = true;
   }
+
+  return DataFrame.fromRows(data, options);
 }