fastsheet 0.0.7 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6965671d803c3232aae8e31b15a5ac5df9c6f109
-  data.tar.gz: 8545afaf2906b9fa1fa363f2933ec29a6ded458e
+  metadata.gz: e6eb7e299b220f69ff05cb1dd1bb015409e4cc31
+  data.tar.gz: 972681080beecd7165e47d0e0ddda8305004e7a9
 SHA512:
-  metadata.gz: 418f795f3bbbc469060f81a2703fd1f60308ca25643731bb421dc2eaa025156ec562270b39b61287d53193abe34e32a10bf3c09736a52147ec0dffdaa50a9130
-  data.tar.gz: c5b02accdb8303fb3b7d4be7e74d14e69470f86ac4c0fa04d85dadcc74ea56b88623b194c4fe3d7baf47aa6549398ac83ca758eed9b8d45b7202872156558b33
+  metadata.gz: 9155761df20a035bfa2e550600db4f5daa50813dac66b6558604649a1cb22b2d07db828c96ad300c5b7213eb5213a9d7ad0e1946dbc9b709b7a51c10b373beb3
+  data.tar.gz: 730e69d383da0b13e1dafc49ea2a9e0c287ad7ea56583e08fe01ebae58f89814cd20c24e32e908ba9638a1021017af02cdaa7c8e4e666f2e0a7b0cb172774380

data/.gitignore

@@ -1,13 +1,14 @@
-/.bundle/
-/.yardoc
-/*.lock
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
-/target/
-/**/*.so
-/*.gem
-/**/*.log
+Makefile
+.yardoc
+.bundle/
+_yardoc/
+coverage/
+doc/
+pkg/
+spec/reports/
+tmp/
+**/target/
+**/*.so
+**/*.gem
+**/*.log
+**/*.lock

data/README.md

@@ -2,33 +2,10 @@
 
 Fastest ruby gem for reading Excel documents.
 
-Benchmark:
-```shell
-$ bin/benchmark
-Benchmark reading row №2991 from `./first_file.xlsx` 15 times...
-┌───────────┬───────────┐
-│   Reader  │ Real Time │
-├───────────┼───────────┤
-│    Roo    │ 161.3275  │
-├───────────┼───────────┤
-│ Fastsheet │  4.3765   │
-└───────────┴───────────┘
-Fastsheet is 37 times faster
-
-$ bin/benchmark
-Benchmark reading row №7146 from `./second_file.xlsx` 15 times...
-┌───────────┬───────────┐
-│   Reader  │ Real Time │
-├───────────┼───────────┤
-│    Roo    │ 897.4474  │
-├───────────┼───────────┤
-│ Fastsheet │  19.0869  │
-└───────────┴───────────┘
-Fastsheet is 47 times faster
-```
-
 ## Installation
 
+**You should have rust installed to use this gem.**
+
 Add this line to your application's Gemfile:
 
 ```ruby
@@ -45,24 +22,38 @@ Or install it yourself as:
 
 ## Usage
 
-This lib returns sheet as array of arrays, so you are free to use it however you want:
+Open a sheet:
 
 ```ruby
 require 'fastsheet'
 
-sheet = Xlsx.new('path/to/sheet.xlsx')
+sheet = Fastsheet::Sheet.new('path/to/sheet.xlsx')
 
- # get all rows
-sheet.rows
+# number of columns
+sheet.width
+
+# number of rows
+sheet.height
 ```
 
-That's all API for now :smile: . Feel free to [open an issue](http://github.com/dkkoval/fastsheet/issues) if you need more.
+Get rows or columns:
+
+```ruby
+sheet.rows
+sheet.columns
+
+sheet.row(42)
+sheet.column(1)
+```
 
-## Development
+Iterators (returns enumerator if no block given):
 
-After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+```ruby
+sheet.each_row { |r| ... }
+sheet.each_column { |c| ... }
+```
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+That's all API for now. Feel free to [open an issue](http://github.com/dkkoval/fastsheet/issues) if you need more.
 
 ## Contributing
 

data/Rakefile

@@ -1,11 +1,14 @@
-# frozen_string_literal: true
-
-require 'bundler/gem_tasks'
-require 'rake/clean'
-require 'rake/testtask'
 require 'bundler/setup'
-require 'thermite/tasks'
 
-Thermite::Tasks.new
+desc 'Build native extension'
+task :build do
+  ruby 'extconf.rb'
+end
+
+# TODO
+desc 'Run tests'
+task :test do
+  puts "no tests"
+end
 
-task default: 'thermite:build'
+task default: [:build, :test]

data/{Cargo.toml → ext/fastsheet/Cargo.toml}

@@ -1,16 +1,13 @@
 [package]
 name = "fastsheet"
 version = "0.1.0"
-
-[package.metadata.thermite]
-github_releases = true
-github_release_type = "latest"
+publish = false
+build = "build.rs"
 
 [lib]
 name = "fastsheet"
 crate-type = ["cdylib"]
 
 [dependencies]
-ruru = "0.9.3"
-lazy_static = "0.2.1"
 calamine = "0.11.8"
+libc = "0.2"

data/ext/fastsheet/build.rs

@@ -0,0 +1,62 @@
+use std::env;
+use std::ffi::OsStr;
+use std::process::Command;
+
+fn rbconfig(key: &str) -> Vec<u8> {
+    let ruby = match env::var_os("RUBY") {
+        Some(val) => val.to_os_string(),
+        None => OsStr::new("ruby").to_os_string(),
+    };
+    let config = Command::new(ruby)
+        .arg("-e")
+        .arg(format!("print RbConfig::CONFIG['{}']", key))
+        .output()
+        .unwrap_or_else(|e| panic!("ruby not found: {}", e));
+
+    config.stdout
+}
+
+fn use_static() {
+    let ruby_libs = rbconfig("LIBS");
+    let libs = String::from_utf8_lossy(&ruby_libs);
+
+    // Ruby gives back the libs in the form: `-lpthread -lgmp`
+    // Cargo wants them as: `-l pthread -l gmp`
+    let transformed_lib_args = libs.replace("-l", "-l ");
+
+    println!("cargo:rustc-link-lib=static=ruby-static");
+    println!("cargo:rustc-flags={}", transformed_lib_args);
+}
+
+fn use_dylib(lib: Vec<u8>) {
+    println!("cargo:rustc-link-lib=dylib={}",
+             String::from_utf8_lossy(&lib));
+}
+
+fn main() {
+    let libdir = rbconfig("libdir");
+
+    let libruby_static = rbconfig("LIBRUBY_A");
+    let libruby_so = rbconfig("RUBY_SO_NAME");
+
+    match (libruby_static.is_empty(), libruby_so.is_empty()) {
+        (false, true) => use_static(),
+        (true, false) => use_dylib(libruby_so),
+        (false, false) => {
+            if env::var_os("RUBY_STATIC").is_some() {
+                use_static()
+            } else {
+                use_dylib(libruby_so)
+            }
+        },
+        _ => {
+            let msg = "Error! Could not find LIBRUBY_A or RUBY_SO_NAME. \
+            This means that no static, or dynamic libruby was found. \
+            Possible solution: build a new Ruby with the `--enable-shared` configure opt.";
+            panic!(msg)
+        }
+    }
+
+    println!("cargo:rustc-link-search={}",
+             String::from_utf8_lossy(&libdir));
+}

data/ext/fastsheet/src/lib.rs

@@ -0,0 +1,152 @@
+extern crate libc;
+extern crate calamine;
+
+use std::ffi::{CString, CStr};
+use libc::{c_int, c_void, c_char, c_double, uintptr_t};
+
+use calamine::{Sheets, DataType};
+
+//
+// Prepare Ruby bindings
+//
+
+// VALUE (pointer to a ruby object)
+type Value = uintptr_t;
+
+// Some ruby constant values
+const NIL: usize   = 0x08;
+const TRUE: usize  = 0x14;
+const FALSE: usize = 0x00;
+
+// Load some Ruby API functions
+extern "C" {
+    // Object class
+    static rb_cObject: Value;
+
+    // Modules and classes
+    fn rb_define_module(name: *const c_char) -> Value;
+    fn rb_define_class_under(outer: Value, name: *const c_char, superclass: Value) -> Value;
+    fn rb_define_method(class: Value, name: *const c_char, method: *const c_void, argc: c_int) -> Value;
+
+    // Set instance variables
+    fn rb_iv_set(object: Value, name: *const c_char, value: Value) -> Value;
+
+    // Array
+    fn rb_ary_new() -> Value;
+    fn rb_ary_push(array: Value, elem: Value) -> Value;
+
+    // C data to Ruby
+    fn rb_int2big(num: c_int) -> Value;
+    fn rb_float_new(num: c_double) -> Value;
+    fn rb_utf8_str_new_cstr(str: *const c_char) -> Value;
+
+    // Ruby string to C string
+    fn rb_string_value_cstr(str: *const Value) -> *const c_char;
+}
+
+//
+// Utils
+//
+
+// C string from Rust string
+pub fn cstr(string: &str) -> CString {
+    CString::new(string).unwrap()
+}
+
+// Rust string from Ruby string
+pub fn rstr(string: Value) -> String {
+    unsafe {
+        let s = rb_string_value_cstr(&string);
+        CStr::from_ptr(s).to_string_lossy().into_owned()
+    }
+}
+
+//
+// Functions to use in Ruby
+//
+
+// Read the sheet
+unsafe fn read(this: Value, rb_file_name: Value) -> Value {
+    let mut document =
+        Sheets::open(rstr(rb_file_name))
+        .expect("Cannot open file!");
+
+    // Open first worksheet by default
+    //
+    // TODO: allow use different worksheets
+    let sheet = document.worksheet_range_by_index(0).unwrap();
+
+    let rows = rb_ary_new();
+
+    for row in sheet.rows() {
+        let new_row = rb_ary_new();
+
+        for (_, c) in row.iter().enumerate() {
+            rb_ary_push(
+                new_row,
+                match *c {
+                    // vba error
+                    DataType::Error(_) => NIL,
+                    DataType::Empty => NIL,
+                    DataType::Float(ref f) => rb_float_new(*f as c_double),
+                    DataType::Int(ref i) => rb_int2big(*i as c_int),
+                    DataType::Bool(ref b) => if *b { TRUE } else { FALSE },
+                    DataType::String(ref s) => {
+                        let st = s.trim();
+                        if st.is_empty() {
+                            NIL
+                        } else {
+                            rb_utf8_str_new_cstr(cstr(st).as_ptr())
+                        }
+                    }
+                }
+            );
+        }
+
+        rb_ary_push(rows, new_row);
+    }
+
+
+    // Set instance variables
+    rb_iv_set(
+        this,
+        cstr("@width").as_ptr(),
+        rb_int2big(sheet.width() as i32)
+    );
+
+    rb_iv_set(
+        this,
+        cstr("@height").as_ptr(),
+        rb_int2big(sheet.height() as i32)
+    );
+
+    rb_iv_set(
+        this,
+        cstr("@rows").as_ptr(),
+        rows
+    );
+
+    this
+}
+
+// Init_libfastsheet symbol is an entrypoint for the lib
+//
+// This function will be executed when we require the lib.
+//
+#[no_mangle]
+#[allow(non_snake_case)]
+pub unsafe extern fn Init_libfastsheet() {
+    let Fastsheet =
+        rb_define_module(cstr("Fastsheet").as_ptr());
+
+    let Sheet =
+        rb_define_class_under(Fastsheet, cstr("Sheet").as_ptr(), rb_cObject);
+
+    rb_define_method(
+        Sheet,
+        cstr("read!").as_ptr(),
+        // Rust function as pointer to C function
+        read as *const c_void,
+        1 as c_int
+    );
+}

data/extconf.rb

@@ -0,0 +1,28 @@
+require 'mkmf'
+require 'rake'
+
+abort unless have_library 'ruby'
+abort unless have_header  'ruby.h'
+
+abort unless find_executable 'rustc'
+abort unless cargo = find_executable(ENV.fetch('CARGO', 'cargo'))
+
+target_file = 'libfastsheet.so'
+
+target =   File.join(__dir__, 'ext/fastsheet/target/release', target_file)
+lib_dest = File.join(__dir__, 'lib/fastsheet', target_file)
+
+# HACK: rubygems requires Makefile with tasks above
+File.write 'Makefile', <<EOF
+all:
+install:
+clean:
+EOF
+$makefile_created = true
+
+Dir.chdir 'ext/fastsheet' do
+  when_writing 'Building fastsheet...' do
+    sh cargo, 'build', '--release'
+    cp target, lib_dest
+  end
+end

data/fastsheet.gemspec

@@ -20,13 +20,8 @@ Gem::Specification.new do |spec|
   end
   spec.bindir        = 'bin'
   spec.require_paths = ['lib']
-  spec.extensions << 'Rakefile'
+  spec.extensions = %w[extconf.rb]
 
-  spec.add_runtime_dependency 'thermite', '~> 0.12.1'
-
-  spec.add_development_dependency 'pry', '~> 0.10.4'
-
-  # for pretty benchmark
-  spec.add_development_dependency 'tty-spinner', '~> 0.7.0'
-  spec.add_development_dependency 'tty-table', '~> 0.8.0'
+  spec.add_development_dependency 'rake', '~>12.0.0'
+  spec.add_development_dependency 'pry', '~>0.10.4'
 end

data/lib/fastsheet.rb

@@ -1,5 +1,2 @@
-require 'fastsheet/xlsx'
-require 'libfastsheet'
-
-module Fastsheet
-end
+require 'fastsheet/libfastsheet'
+require 'fastsheet/sheet'

data/lib/fastsheet/sheet.rb

@@ -0,0 +1,44 @@
+module Fastsheet
+  class Sheet
+    attr_reader :file_name,
+                :rows, :header,
+                :width, :height
+
+    def initialize(file_name, options = {})
+      # this method sets @rows, @height and @width
+      read!(file_name)
+
+      @header = @rows.shift if options[:header]
+    end
+
+    def row(n)
+      @rows[n]
+    end
+
+    def each_row
+      if block_given?
+        @rows.each { |r| yield r }
+      else
+        @rows.each
+      end
+    end
+
+    def column(n)
+      @rows.map { |r| r[n] }
+    end
+
+    def columns
+      (0...@width).inject([]) do |cols, i|
+        cols.push column(i)
+      end
+    end
+
+    def each_column
+      if block_given?
+        columns.each { |c| yield c }
+      else
+        columns.each
+      end
+    end
+  end
+end

data/lib/fastsheet/version.rb

@@ -1,3 +1,3 @@
 module Fastsheet
-  VERSION = '0.0.7'
+  VERSION = '0.1.0'
 end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: fastsheet
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.1.0
 platform: ruby
 authors:
 - Dmitry Koval
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-12 00:00:00.000000000 Z
+date: 2017-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: thermite
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.12.1
-  type: :runtime
+        version: 12.0.0
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.12.1
+        version: 12.0.0
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -38,56 +38,28 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.10.4
-- !ruby/object:Gem::Dependency
-  name: tty-spinner
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.7.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.7.0
-- !ruby/object:Gem::Dependency
-  name: tty-table
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.8.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.8.0
 description: Fastest ruby gem for reading Excel documents.
 email:
 - dkoval@heliostech.fr
 executables: []
 extensions:
-- Rakefile
+- extconf.rb
 extra_rdoc_files: []
 files:
 - ".gitignore"
-- Cargo.toml
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
-- bin/benchmark
-- bin/console
+- bin/.keep
+- ext/fastsheet/Cargo.toml
+- ext/fastsheet/build.rs
+- ext/fastsheet/src/lib.rs
+- extconf.rb
 - fastsheet.gemspec
 - lib/fastsheet.rb
+- lib/fastsheet/sheet.rb
 - lib/fastsheet/version.rb
-- lib/fastsheet/xlsx.rb
-- src/lib.rs
 homepage: https://github.com/dkkoval/fastsheet
 licenses:
 - MIT
@@ -108,7 +80,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Fast XLSX reader

data/bin/benchmark

@@ -1,59 +0,0 @@
-#!/usr/bin/env ruby
-
-lib = File.expand_path('../../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-
-require 'benchmark'
-require 'tty-spinner'
-require 'tty-table'
-
-require 'fastsheet'
-require 'roo'
-
-FILE = './second_file.xlsx'.freeze
-ROW = rand 9000
-N = 15
-
-options = {
-  hide_cursor: true,
-  format: :dots,
-  interval: 20,
-  clear: true
-}
-
-puts "Benchmark reading row №#{ROW} from `#{FILE}` #{N} times..."
-
-roo_time = Benchmark.measure('Roo') do
-  spinner = TTY::Spinner.new('[:spinner] :progress', options)
-  spinner.auto_spin
-  N.times do |i|
-    spinner.update(progress: "Roo: #{i + 1}/#{N} sheets opened ...")
-    Roo::Excelx.new(FILE).sheet(0).row(ROW)
-  end
-  spinner.stop
-end
-
-fastsheet_time = Benchmark.measure('Fastsheet') do
-  spinner = TTY::Spinner.new('[:spinner] :progress', options)
-  spinner.auto_spin
-  N.times do |i|
-    spinner.update(progress: "Fastsheet: #{i + 1}/#{N} sheets opened ...")
-    Xlsx.new(FILE).rows[ROW]
-  end
-  spinner.stop
-end
-
-table = TTY::Table.new(header: ['Reader', 'Real Time'])
-
-table << ['Roo', roo_time.real.round(4)]
-table << ['Fastsheet', fastsheet_time.real.round(4)]
-
-renderer = TTY::Table::Renderer::Unicode.new(table)
-
-renderer.alignments       = %i[center center]
-renderer.padding          = [0, 1, 0, 1]
-renderer.border.separator = :each_row
-
-puts renderer.render
-
-puts "Fastsheet is #{(roo_time.real / fastsheet_time.real).round} times faster"

data/bin/console

@@ -1,9 +0,0 @@
-#!/usr/bin/env ruby
-
-lib = File.expand_path('../../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-
-require 'fastsheet'
-
-require 'pry'
-Pry.start

data/lib/fastsheet/xlsx.rb

@@ -1,4 +0,0 @@
-module Fastsheet
-  class Xlsx
-  end
-end

data/src/lib.rs

@@ -1,74 +0,0 @@
-#[macro_use] extern crate ruru;
-#[macro_use] extern crate lazy_static;
-
-extern crate calamine;
-
-use ruru::{Array, Class, RString, Float, Fixnum, Boolean, Object, AnyObject, NilClass};
-
-use calamine::{Sheets, DataType};
-
-pub struct Reader {
-    file: String,
-    rows: Array
-}
-
-impl Reader {
-    fn new(file: String) -> Self {
-        let mut this = Reader {
-            file: file,
-            rows: Array::new()
-        };
-
-        let sheet = Sheets::open(&this.file).unwrap().worksheet_range_by_index(0).unwrap();
-
-        for row in sheet.rows() {
-            let mut new_row = Array::with_capacity(sheet.width());
-
-            for (_, c) in row.iter().enumerate() {
-                match *c {
-                    DataType::Error(_)      => new_row.push(NilClass::new()),
-                    DataType::String(ref s) => new_row.push(RString::new(s)),
-                    DataType::Empty         => new_row.push(NilClass::new()),
-                    DataType::Float(ref f)  => new_row.push(Float::new(*f)),
-                    DataType::Int(ref i)    => new_row.push(Fixnum::new(*i)),
-                    DataType::Bool(ref b)   => new_row.push(Boolean::new(*b))
-                };
-            }
-
-            this.rows.push(new_row);
-        }
-        this
-    }
-
-    fn get_rows(&self) -> AnyObject {
-        self.rows.to_any_object()
-    }
-}
-
-wrappable_struct!(Reader, ReaderWrapper, READER_WRAPPER);
-
-class!(Xlsx);
-
-methods!(
-    Xlsx,
-    itself,
-
-    fn ruby_xlsx_new(file: RString) -> AnyObject {
-        let xlsx_reader = Reader::new(file.unwrap().to_string());
-
-        Class::from_existing("Xlsx").wrap_data(xlsx_reader, &*READER_WRAPPER)
-    }
-
-    fn ruby_xlsx_rows() -> AnyObject {
-        itself.get_data(&*READER_WRAPPER).get_rows()
-    }
-);
-
-#[no_mangle]
-#[allow(non_snake_case)]
-pub extern fn Init_libfastsheet() {
-    Class::new("Xlsx", None).define(|itself| {
-        itself.def_self("new", ruby_xlsx_new);
-        itself.def("rows", ruby_xlsx_rows)
-    });
-}