altsv 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6dabb0913e3f6ee313714b955983a1b52a6ca3dfd3a567287cb08397184a8ffa
+  data.tar.gz: '090396592332217d2c087c8e8944b1b5cad271a08f5f2231de01b41002fc1422'
+SHA512:
+  metadata.gz: a799aae3dd58843d7b7e70ebfdc5f48099e850fbff88d92e003e9615a1d9e86597ea9da95703ccc1377264bea9a3a5790bfb521761640e0b5d40775318d89175
+  data.tar.gz: 0516ea9c4d4b019309c7dca87a3016856bfe6e760d937a67b17b3382c61f34aae0d1e9aacd7a7d960ea14db63029cad4e1ec2e7d9dcc01d8b62471cacbaf2e65

data/.gitignore

@@ -0,0 +1,57 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+/.idea/
+
+# Avoid the merging of the build intermediates
+/target/
+
+/lib/altsv/native.bundle

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.0
+before_install: gem install bundler -v 1.17.2

data/Cargo.lock

@@ -0,0 +1,41 @@
+[[package]]
+name = "altsv"
+version = "0.0.1"
+dependencies = [
+ "helix 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libcruby-sys 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "cstr-macro"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "helix"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "cstr-macro 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libcruby-sys 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.48"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
+name = "libcruby-sys"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[metadata]
+"checksum cstr-macro 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "db53fddba18cdd35477a7213a3ef6acfbfa333c31b42ce019e544c4a1420a06f"
+"checksum helix 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)" = "49a017e3e798ad9386e0a0584e66fd6c04a80ccc1242eb8f689c62ce6f408240"
+"checksum libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)" = "e962c7641008ac010fa60a7dfdc1712449f29c44ef2d4702394aea943ee75047"
+"checksum libcruby-sys 0.7.5 (registry+https://github.com/rust-lang/crates.io-index)" = "fef6028cdce0c8d55676fd1d66bb810facef8cade0dd71d28511d375e84da4c0"

data/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "altsv"
+version = "0.0.1"
+edition = "2018"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+helix = "0.7.5"
+libcruby-sys = "0.7.5"

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in altsv.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 condor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,78 @@
+# altsv
+
+An ALTernative LTSV Parser / Dumper gem partially written in Rust.
+
+## Prerequisites
+
+* rustc (tested with 1.32.0)
+* cargo (The de-fact standard package manager for Rust)
+
+You can install both with [rustup.rs](https://rustup.rs/)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'altsv'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install altsv
+
+## Usage
+
+At first, you should require altsv:
+
+    require 'altsv'
+
+In addition, if you manage gems with bundler, you should add the statement below into your Gemfile:
+
+    gem 'altsv'
+
+
+### parsing LTSV
+
+    # parse string
+    string = "label1:value1\tlabel2:value2"
+    values = Altsv.parse(string) # => [{:label1 => "value1", :label2 => "value2"}]
+
+    # parse via stream
+    # content: as below
+    # label1_1:value1_1\tlabel1_2:value1_2
+    # label2_1:value2_1\tlabel2_2:value2_2
+    stream = File.open("some_file.ltsv", "r")
+    values = Altsv.parse(stream)
+    # => [{:label1_1 => "value1_2", :label1_2 => "value1_2"},
+    #     {:label2_1 => "value2_2", :label2_2 => "value2_2"}]
+
+### loading LTSV file
+
+    # load via path
+    values = Altsv.load("some_path.ltsv")
+
+    # load via stream
+    stream = File.open("some_file.ltsv", "r")
+    values = Altsv.load(stream) # => same as LTSV.parse(stream)
+
+### dumping into LTSV
+
+    value = {label1: "value1", label2: "value2"}
+    dumped = Altsv.dump(value) # => "label1:value1\tlabel2:value2"
+
+Dumped objects should respond to :to_hash.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+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).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/condor/altsv.

data/Rakefile

@@ -0,0 +1,5 @@
+require 'helix_runtime/build_task'
+
+HelixRuntime::BuildTask.new
+
+require "bundler/gem_tasks"

data/altsv.gemspec

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "altsv/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "altsv"
+  spec.version       = Altsv::VERSION
+  spec.authors       = ["condor"]
+  spec.email         = ["condor1226@gmail.com"]
+
+  spec.summary       = %q{an ALTernative ltSV parser / dumper library}
+  spec.description   = %q{A more lightweight LTSV handler library partially written in Rust.}
+  spec.homepage      = "https://github.com/condor/altsv"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://github.com/condor/altsv"
+    spec.metadata["changelog_uri"] = "https://github.com/condor/altsv/blob/master/CHANGELOG.md"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.extensions    = %w(ext/altsv/extconf.rb)
+
+  spec.add_dependency 'helix_runtime', '~> 0.7.5'
+
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.8", '< 4.0'
+  spec.add_development_dependency 'ltsv'
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "altsv"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ext/altsv/extconf.rb

@@ -0,0 +1,25 @@
+RAKEFILE = 'native.rake'
+
+def command_exists(command, *extra_test_arguments)
+  raise "Command #{command} not found. exitting..." unless system(command, *extra_test_arguments)
+end
+
+command_exists('cargo', '--version')
+command_exists('rustc', '--version')
+
+File.open('Makefile', 'w') do |makefile|
+  makefile.puts <<~MAKEFILE
+    clean:
+    \trake -f #{RAKEFILE} clobber
+    install:
+    \trake -f #{RAKEFILE} build
+  MAKEFILE
+end
+
+File.open(RAKEFILE, 'w') do |rakefile|
+  rakefile.puts <<~RUBY
+    require 'helix_runtime/build_task'
+
+    HelixRuntime::BuildTask.new
+  RUBY
+end

data/lib/altsv.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+require 'helix_runtime'
+require 'altsv/native'
+
+require "altsv/version"
+
+class Altsv
+  class Error < StandardError; end
+  # Your code goes here...
+
+  class << self
+    def parse(input)
+      case input
+      when String
+        parse_native input
+      when StringIO
+        parse_native input.string
+      when IO
+        input.each_line.map{|line| parse_line_native line}
+      end
+    end
+
+    def load(path_or_io)
+      case path_or_io
+      when String
+        File.open(path_or_io){|f| parse f}
+      when IO
+        parse(path_or_io)
+      else
+        raise ArgumentError, "#{name}.#{__method__} only accepts IO or path."
+      end
+    end
+
+    def dump(value)
+      dump_native value
+    end
+  end
+end

data/lib/altsv/version.rb

@@ -0,0 +1,3 @@
+class Altsv
+  VERSION = "0.0.2"
+end

data/src/lib.rs

@@ -0,0 +1,356 @@
+use std::collections::HashMap;
+use std::ffi::CString;
+
+use libcruby_sys::*;
+
+use helix::*;
+
+const BUFFER_SIZE_KEY: usize = 64usize;
+const BUFFER_SIZE_VALUE: usize = 128usize;
+
+struct HashMapWrapper {
+    map: HashMap<Symbol, Option<CString>>,
+}
+
+impl HashMapWrapper {
+    fn with_capacity(capacity: usize) -> Self {
+        HashMapWrapper {
+            map: HashMap::with_capacity(capacity)
+        }
+    }
+
+    fn insert(&mut self, key: &String, value: &str) {
+        let value_to_insert: Option<CString>;
+        if value.is_empty() {
+            value_to_insert = None;
+        } else {
+            value_to_insert = Some(CString::new(value).expect("This must success since it is from String"))
+        }
+        let key_to_insert = Symbol::from_string(key.clone());
+
+        self.map.insert(key_to_insert, value_to_insert);
+    }
+
+    fn inner(self) -> HashMap<Symbol, Option<CString>> {
+        self.map
+    }
+}
+
+impl ToRuby for HashMapWrapper {
+    fn to_ruby(self) -> ToRubyResult {
+        let hash: VALUE;
+        unsafe {
+            hash = rb_hash_new();
+
+            for (key, value) in self.inner().into_iter() {
+                let key_ruby = key.to_ruby().expect("This must success since it is from String");
+                let value_ruby = match value {
+                    None => Qnil,
+                    Some(v) => rb_utf8_str_new(v.as_ptr(), v.as_bytes().len() as i64),
+                };
+                rb_hash_aset(hash, key_ruby, value_ruby);
+            }
+        }
+
+        return Ok(hash);
+    }
+}
+
+fn parse_line(input: &str) -> HashMapWrapper {
+    let mut key = String::with_capacity(BUFFER_SIZE_KEY);
+    let mut value = String::with_capacity(BUFFER_SIZE_VALUE);
+    let mut in_value = false;
+    let mut escaping = false;
+
+    // First: count the key-value pairs.
+    let mut count = 0usize;
+    let mut chars = input.chars();
+    loop {
+        match chars.next() {
+            None => break,
+            Some(c) => {
+                match c {
+                    '\t' => count += 1,
+                    _ => {}
+                }
+            }
+        }
+    }
+
+    let mut line=  HashMapWrapper::with_capacity(count);
+
+    // start actual parsing
+    let mut chars = input.chars();
+    loop {
+        match chars.next() {
+            None => {
+                if !key.is_empty() {
+                    line.insert(&key, &value);
+                }
+                break;
+            }
+            Some(c) => {
+                if c == '\r' || c == '\n' {
+                    if !key.is_empty() {
+                        line.insert(&key, &value);
+                    }
+                    break;
+                }
+
+                let current_char: char;
+                if escaping {
+                    match c {
+                        'n' => current_char = '\n',
+                        'r' => current_char = '\r',
+                        't' => current_char = '\t',
+                        '\\' => current_char = '\\',
+                        _ => {
+                            current_char = c;
+                            if in_value {
+                                value.push('\\')
+                            }else {
+                                key.push('\\')
+                            }
+                        },
+                    }
+                    escaping = false;
+                } else {
+                    match c {
+                        '\\' => {
+                            escaping = true;
+                            continue;
+                        },
+                        ':' => {
+                            // key-value separator(only when not separated)
+                            if !in_value {
+                                in_value = true;
+                                continue;
+                            }
+                        }
+                        '\t' => {
+                            // field separator
+                            if !key.is_empty() {
+                                // TODO: Whether OR NOT the empty label should cause error?
+                                line.insert(&key, &value);
+                            }
+                            key.clear();
+                            value.clear();
+                            in_value = false;
+                            continue;
+                        }
+                        _ => {}
+                    }
+                    current_char = c;
+                }
+
+                if in_value {
+                    value.push(current_char)
+                } else {
+                    key.push(current_char)
+                }
+            }
+        }
+    }
+
+    line
+}
+
+const METHOD_NAME_RESPOND_TO: &[u8] = b"respond_to?\0`";
+const METHOD_NAME_TO_H: &[u8] = b"to_h\0";
+const METHOD_NAME_TO_HASH: &[u8] = b"to_hash\0";
+const METHOD_NAME_TO_S: &[u8] = b"to_s\0";
+
+const CLASS_NAME_ARGUMENT_ERROR: &str = "ArgumentError";
+
+const MESSAGE_DUMP_ERROR: &'static str = "Argument does not respond to neither :to_h nor :to_hash";
+
+unsafe fn rb_intern_u8(method_name: &[u8]) -> ID {
+    use std::mem;
+    rb_intern(mem::transmute::<&u8, c_string>(&method_name[0]))
+}
+
+unsafe fn respond_to(object: VALUE, name: ID) -> bool {
+    let respond_to = rb_intern_u8(METHOD_NAME_RESPOND_TO);
+    let method = rb_id2sym(name);
+
+    rb_funcall(object, respond_to, 1, method) == Qtrue
+}
+
+extern "C" fn join_hash(key: VALUE, value: VALUE, farg: *mut void) -> st_retval {
+    use std::mem;
+
+    let s = unsafe {mem::transmute::<*mut void, *mut DumpResult>(farg) };
+
+    match unsafe{ (*s).push_value(key, true) } {
+        None => {}
+        Some(error) => {
+            unsafe{ (*s).set_error(error) };
+            return st_retval::ST_STOP;
+        }
+    }
+
+    unsafe { (*s).push_char(':') };
+
+    match unsafe{ (*s).push_value(value, false) } {
+        None => {}
+        Some(error) => {
+            unsafe{ (*s).set_error(error) };
+            return st_retval::ST_STOP;
+        }
+    }
+    unsafe { (*s).push_char('\t') };
+
+    st_retval::ST_CONTINUE
+}
+
+struct DumpResult {
+    error: Option<Error>,
+    buffer: String,
+}
+
+impl DumpResult {
+    fn new(item_count: usize) -> Self{
+        DumpResult {
+            buffer: String::with_capacity(item_count * (BUFFER_SIZE_KEY + BUFFER_SIZE_VALUE)),
+            error: None,
+        }
+    }
+    fn push_value(&mut self, v: VALUE, for_key: bool) -> Option<Error>{
+        match unsafe {
+            if RB_TYPE_P(v, T_SYMBOL) {
+                String::from_ruby(rb_id2str(rb_sym2id(v)))
+            } else if RB_TYPE_P(v, T_STRING) {
+                String::from_ruby(v)
+            } else {
+                let to_s = rb_intern_u8(&METHOD_NAME_TO_S);
+                String::from_ruby(rb_funcall(v, to_s, 0))
+            }
+        } {
+            Ok(checked) => {
+                use helix::Error;
+
+                for c in String::from_checked(checked).chars() {
+                    match c {
+                        '\r' => self.buffer.push_str("\\r"),
+                        '\n' => self.buffer.push_str("\\n"),
+                        '\t' => self.buffer.push_str("\\t"),
+                        ':' => {
+                            if for_key {
+                                return Some(Error::with_c_string(CString::new("Key should not include ':'").unwrap().as_ptr()));
+                            }
+                            self.buffer.push(c)
+                        },
+                        _ => self.buffer.push(c),
+                    }
+                }
+                None
+            },
+            Err(e) => Some(e),
+        }
+    }
+
+    fn push_char(&mut self, c: char) {
+        self.buffer.push(c);
+    }
+
+    fn set_error(&mut self, e: Error) {
+        self.error = Some(e);
+    }
+
+    fn extract(self) -> Result<String, Error> {
+        match self.error {
+            Some(e) => Err(e),
+            None => Ok(String::from(self.buffer.trim_end())),
+        }
+    }
+}
+
+struct DumpArgument {
+    inner: VALUE,
+    count: usize,
+}
+
+impl DumpArgument {
+    pub unsafe fn from_hash(inner: VALUE) -> Self{
+        let count = RHASH_SIZE(inner) as usize;
+
+        DumpArgument{
+            inner,
+            count,
+        }
+    }
+    pub fn dump(&self) -> Result<String, Error> {
+        use std::mem;
+
+        let mut dump_result = DumpResult::new(self.count);
+        unsafe{
+            rb_hash_foreach(
+                self.inner,
+                join_hash,
+                mem::transmute::<&mut DumpResult, *mut void>(&mut dump_result)
+            )
+        };
+
+        dump_result.extract()
+    }
+}
+
+impl FromRuby for DumpArgument {
+    type Checked = CheckedValue<DumpArgument>;
+
+    fn from_ruby(value: VALUE) -> CheckResult<CheckedValue<DumpArgument>> {
+        unsafe {
+            if RB_TYPE_P(value, T_HASH) {
+                return Ok(CheckedValue::new(value));
+            }
+
+            let hashed_value: VALUE;
+            let to_h = rb_intern_u8(METHOD_NAME_TO_H);
+            if respond_to(value, to_h) {
+                hashed_value = rb_funcall(value, to_h, 0);
+                return Ok(CheckedValue::new(hashed_value));
+            }
+
+            let hashed_value: VALUE;
+            let to_h = rb_intern_u8(METHOD_NAME_TO_HASH);
+            if respond_to(value, to_h) {
+                hashed_value = rb_funcall(value, to_h, 0);
+                return Ok(CheckedValue::new(hashed_value));
+            }
+        }
+
+        let argument_error = unsafe {
+            let id_argument_error = rb_intern(CString::new(CLASS_NAME_ARGUMENT_ERROR).unwrap().as_ptr());
+            rb_const_get(rb_cObject, id_argument_error)
+        };
+        let argument_error_class = unsafe{ Class::from_value(argument_error) };
+        raise!(argument_error_class, MESSAGE_DUMP_ERROR);
+    }
+
+    fn from_checked(checked: CheckedValue<DumpArgument>) -> DumpArgument {
+        unsafe{ DumpArgument::from_hash(checked.to_value())}
+    }
+}
+
+ruby! {
+    class Altsv {
+        def parse_native(input: String) -> Vec<HashMapWrapper> {
+            let mut hashes: Vec<HashMapWrapper> = Vec::new();
+            let mut lines = input.lines();
+            loop {
+                match lines.next() {
+                    Some(line) => hashes.push(parse_line(line)),
+                    None => break,
+                }
+            }
+            hashes
+        }
+        def parse_line_native(input: String) -> HashMapWrapper {
+            parse_line(&input)
+        }
+
+        def dump_native(value: DumpArgument) -> Result<String, Error> {
+            value.dump()
+        }
+    }
+}

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: altsv
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- condor
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-03-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: helix_runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.5
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: ltsv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A more lightweight LTSV handler library partially written in Rust.
+email:
+- condor1226@gmail.com
+executables: []
+extensions:
+- ext/altsv/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Cargo.lock
+- Cargo.toml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- altsv.gemspec
+- bin/console
+- bin/setup
+- ext/altsv/extconf.rb
+- lib/altsv.rb
+- lib/altsv/version.rb
+- src/lib.rs
+homepage: https://github.com/condor/altsv
+licenses: []
+metadata:
+  homepage_uri: https://github.com/condor/altsv
+  source_code_uri: https://github.com/condor/altsv
+  changelog_uri: https://github.com/condor/altsv/blob/master/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: an ALTernative ltSV parser / dumper library
+test_files: []