usamin-js 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bd8d94c422e7c611281569bb7f6e4925b1c6e399f148ce96303379b18dcd3a2a
+  data.tar.gz: 1a375b7a3b2f58b00f114a93527b9c4913fb6ca72c57fcd80dc2d2f09850f908
+SHA512:
+  metadata.gz: 959f0490d6a235b87bcc72eabfb374f15abbef9b072c060bb7e0d58f050e86b0d8fcde5b88fdcff9cb2bd1e7e9039177ebf6f2f7bfeb1a3e6a4b3b1d649665b1
+  data.tar.gz: a22bd778d426aeab77a1185b6fd7ef0a6540e5e876adf04e5c3066857601d7887502acba084909506c714426afa609e4996fe7ecdf1fc5eb419b8706f45e7d54

data/.gitignore

@@ -0,0 +1,19 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+
+Gemfile.lock
+.DS_Store
+/testdata/
+/vendor/
+/.vscode/

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.5.0
+before_install: gem install bundler -v 1.16.1

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Ishotihadus
+
+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,42 @@
+# UsaminJs
+
+JavaScript generator based on RapidJSON.
+
+## Installation
+
+Install RapidJSON beforehand. Only header files are necessary, and no need to build.
+
+Next, add this line to your application's Gemfile:
+
+```ruby
+gem 'usamin-js'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install usamin-js
+
+The directory of RapidJSON can be explicitly specified with `--with-rapidjson-dir` option.
+
+    $ gem install usamin-js -- --with-rapidjson-dir=/usr/local/opt/rapidjson
+
+## Usage
+
+```ruby
+require 'usamin/js'
+
+puts Usamin::Js.generate({ abe: 'nana', time: Time.now, "3": 5 })
+#=> {"abe":"nana","time":new Date(1655617665882),"3":5}
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Ishotihadus/usamin-js.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT) at the request of RapidJSON.

data/Rakefile

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+require 'rake/extensiontask'
+
+task build: :compile
+
+Rake::ExtensionTask.new('usamin_js') do |ext|
+  ext.lib_dir = 'lib/usamin/js'
+end
+
+task default: %i[clobber compile test]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'usamin'
+
+# 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 'pry'
+Pry.start

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/usamin_js/extconf.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+
+RbConfig::MAKEFILE_CONFIG['CXX'] = ENV['CXX'] if ENV['CXX']
+have_library('stdc++')
+have_library('m')
+dir_config('rapidjson')
+append_cppflags('-O3')
+append_cppflags('-Wall')
+append_cppflags('-Wextra')
+append_cppflags('-Wno-missing-field-initializers')
+append_cppflags('-Wvla')
+
+if checking_for('whether -march=native is accepted as CPPFLAGS') {try_cppflags('-march=native')}
+  if checking_for('whether -msse4.2 is accepted as CPPFLAGS') {try_cppflags('-msse4.2')}
+    $CPPFLAGS << ' -msse4.2 -march=native'
+  elsif checking_for('whether -msse2 is accepted as CPPFLAGS') {try_cppflags('-msse2')}
+    $CPPFLAGS << ' -msse2 -march=native'
+  end
+end
+
+$CPPFLAGS << ' -std=c++11 -fvisibility=hidden'
+
+$CPPFLAGS << ' -DRAPIDJSON_IS_HEAD' if arg_config('--rapidjson-is-head')
+
+create_makefile('usamin/js/usamin_js')

data/ext/usamin_js/generator.cpp

@@ -0,0 +1,279 @@
+#include <sstream>
+#include "rb270_fix.hpp"
+#include <rapidjson/prettywriter.h>
+#include <rapidjson/writer.h>
+#include <ruby.h>
+#include <ruby/version.h>
+#include <iomanip>
+#include "rb_common.hpp"
+#include "generator.hpp"
+
+#define WRITER_CONFIGS rapidjson::UTF8<>, rapidjson::UTF8<>, RubyCrtAllocator, rapidjson::kWriteNanAndInfFlag
+
+void *RubyCrtAllocator::Malloc(size_t size) {
+    if (size)
+        return ruby_xmalloc(size);
+    else
+        return nullptr;
+}
+
+void *RubyCrtAllocator::Realloc(void *originalPtr, size_t, size_t newSize) {
+    if (newSize == 0) {
+        ruby_xfree(originalPtr);
+        return nullptr;
+    }
+    return ruby_xrealloc(originalPtr, newSize);
+}
+
+void RubyCrtAllocator::Free(void *ptr) {
+    ruby_xfree(ptr);
+}
+
+
+template <class Writer>
+static inline void write_hash(Writer &, const VALUE);
+template <class Writer>
+static inline void write_array(Writer &, const VALUE);
+template <class Writer>
+static inline void write_struct(Writer &, const VALUE);
+template <class Writer>
+static inline void write_usamin(Writer &, const VALUE);
+
+template <class Writer>
+static inline void write_str(Writer &writer, const VALUE value) {
+    VALUE v = get_utf8_str(value);
+    writer.String(RSTRING_PTR(v), RSTRING_LENINT(v));
+}
+
+template <class Writer>
+static inline void write_to_s(Writer &writer, const VALUE value) {
+    extern ID id_to_s;
+    write_str(writer, rb_funcall(value, id_to_s, 0));
+}
+
+template <class Writer>
+static inline void write_time(Writer &writer, const VALUE value) {
+    extern ID id_to_f;
+    std::ostringstream stream;
+    stream << "new Date(" << std::fixed << std::setprecision(0) << NUM2DBL(rb_funcall(value, id_to_f, 0)) * 1000 << ")";
+    auto str = stream.str();
+    writer.RawValue(str.c_str(), str.length(), rapidjson::kStringType);
+}
+
+template <class Writer>
+static inline void write_date(Writer &writer, const VALUE value) {
+    extern ID id_to_time;
+    write_time(writer, rb_funcall(value, id_to_time, 0));
+}
+
+template <class Writer>
+static void write(Writer &writer, const VALUE value) {
+    extern VALUE rb_cTime, rb_cDate, rb_cDateTime, rb_cUsaminValue;
+    switch (TYPE(value)) {
+    case RUBY_T_NONE:
+    case RUBY_T_NIL:
+    case RUBY_T_UNDEF:
+        writer.Null();
+        break;
+    case RUBY_T_TRUE:
+        writer.Bool(true);
+        break;
+    case RUBY_T_FALSE:
+        writer.Bool(false);
+        break;
+    case RUBY_T_FIXNUM:
+        writer.Int64(FIX2LONG(value));
+        break;
+    case RUBY_T_FLOAT:
+    case RUBY_T_RATIONAL:
+        writer.Double(NUM2DBL(value));
+        break;
+    case RUBY_T_STRING:
+        write_str(writer, value);
+        break;
+    case RUBY_T_ARRAY:
+        write_array(writer, value);
+        break;
+    case RUBY_T_HASH:
+        write_hash(writer, value);
+        break;
+    case RUBY_T_STRUCT:
+        write_struct(writer, value);
+        break;
+    case RUBY_T_BIGNUM: {
+        VALUE v = rb_big2str(value, 10);
+        writer.RawValue(RSTRING_PTR(v), RSTRING_LEN(v), rapidjson::kNumberType);
+    } break;
+    default:
+        if (rb_cUsaminValue && rb_obj_is_kind_of(value, rb_cUsaminValue))
+            write_usamin(writer, value);
+        else if ((rb_cDate && rb_obj_is_kind_of(value, rb_cDate)) || (rb_cDateTime && rb_obj_is_kind_of(value, rb_cDateTime)))
+            write_date(writer, value);
+        else if (rb_cTime && rb_obj_is_kind_of(value, rb_cTime))
+            write_time(writer, value);
+        else
+            write_to_s(writer, value);
+        break;
+    }
+}
+
+template <class Writer>
+static inline void write_key_str(Writer &writer, const VALUE value) {
+    VALUE v = get_utf8_str(value);
+    writer.Key(RSTRING_PTR(v), RSTRING_LENINT(v));
+}
+
+template <class Writer>
+static inline void write_key_to_s(Writer &writer, const VALUE value) {
+    extern ID id_to_s;
+    write_key_str(writer, rb_funcall(value, id_to_s, 0));
+}
+
+template <class Writer>
+static inline int write_hash_each(const VALUE key, const VALUE value, VALUE writer_v) {
+    Writer *writer = reinterpret_cast<Writer *>(writer_v);
+    if (RB_TYPE_P(key, T_STRING))
+        write_key_str(*writer, key);
+    else if (RB_TYPE_P(key, T_SYMBOL))
+        write_key_str(*writer, rb_sym_to_s(key));
+    else
+        write_key_to_s(*writer, key);
+    write(*writer, value);
+    return ST_CONTINUE;
+}
+
+template <class Writer>
+static inline void write_hash(Writer &writer, const VALUE hash) {
+    writer.StartObject();
+#if RUBY_API_VERSION_CODE < 20700
+    rb_hash_foreach(hash, (int (*)(ANYARGS))write_hash_each<Writer>, reinterpret_cast<VALUE>(&writer));
+#else
+    rb_hash_foreach(hash, write_hash_each<Writer>, reinterpret_cast<VALUE>(&writer));
+#endif
+    writer.EndObject();
+}
+
+template <class Writer>
+static inline void write_array(Writer &writer, const VALUE value) {
+    writer.StartArray();
+    const VALUE *ptr = rb_array_const_ptr(value);
+    for (long i = 0; i < rb_array_len(value); i++, ptr++)
+        write(writer, *ptr);
+    writer.EndArray();
+}
+
+template <class Writer>
+static inline void write_struct(Writer &writer, const VALUE value) {
+    writer.StartObject();
+    VALUE members = rb_struct_members(value);
+    const VALUE *ptr = rb_array_const_ptr(members);
+    for (long i = 0; i < rb_array_len(members); i++, ptr++) {
+        if (RB_TYPE_P(*ptr, T_SYMBOL))
+            write_key_str(writer, rb_sym_to_s(*ptr));
+        else if (RB_TYPE_P(*ptr, T_STRING))
+            write_key_str(writer, *ptr);
+        else
+            write_key_to_s(writer, *ptr);
+        write(writer, rb_struct_aref(value, *ptr));
+    }
+    writer.EndObject();
+}
+
+template <class Writer>
+static inline void write_usamin(Writer &writer, const VALUE self) {
+    extern VALUE rb_mUsamin;
+    extern ID id_generate;
+    VALUE str = rb_funcall(rb_mUsamin, id_generate, 1, self);
+    VALUE v = get_utf8_str(str);
+    writer.RawValue(RSTRING_PTR(v), RSTRING_LENINT(v), rapidjson::kObjectType);
+}
+
+static void prepare_generate() {
+    extern VALUE rb_mUsamin, rb_cTime, rb_cDate, rb_cDateTime, rb_cUsaminValue;
+    extern ID id_Time, id_Date, id_DateTime, id_Value;
+    rb_cTime = rb_const_defined(rb_cObject, id_Time) ? rb_const_get(rb_cObject, id_Time) : 0;
+    rb_cDate = rb_const_defined(rb_cObject, id_Date) ? rb_const_get(rb_cObject, id_Date) : 0;
+    rb_cDateTime = rb_const_defined(rb_cObject, id_DateTime) ? rb_const_get(rb_cObject, id_DateTime) : 0;
+    rb_cUsaminValue = rb_const_defined(rb_mUsamin, id_Value) ? rb_const_get(rb_mUsamin, id_Value) : 0;
+}
+
+/*
+ * Generate the JSON string from Ruby data structures.
+ *
+ * @overload generate(obj)
+ *   @param [Object] obj an object to serialize
+ *   @return [String]
+ */
+VALUE w_generate(const VALUE, const VALUE value) {
+    rapidjson::StringBuffer buf;
+    rapidjson::Writer<rapidjson::StringBuffer, WRITER_CONFIGS> writer(buf);
+    prepare_generate();
+    write(writer, value);
+    return new_utf8_str(buf.GetString(), buf.GetSize());
+}
+
+/*
+ * Generate the prettified JSON string from Ruby data structures.
+ *
+ * @overload pretty_generate(obj, opts = {})
+ *   @param [Object] obj an object to serialize
+ *   @param [::Hash] opts options
+ *   @option opts [String] :indent ('  ') a string used to indent
+ *   @option opts [Boolean] :single_line_array (false)
+ *   @return [String]
+ */
+VALUE w_pretty_generate(const int argc, const VALUE *argv, const VALUE) {
+    extern VALUE rb_eUsaminJsError;
+    extern VALUE sym_indent, sym_single_line_array;
+
+    VALUE value, options;
+    rb_scan_args(argc, argv, "1:", &value, &options);
+    rapidjson::StringBuffer buf;
+#if RAPIDJSON_VERSION_CODE(RAPIDJSON_MAJOR_VERSION, RAPIDJSON_MINOR_VERSION, RAPIDJSON_PATCH_VERSION) > RAPIDJSON_VERSION_CODE(1, 1, 0) || defined(RAPIDJSON_IS_HEAD)
+    rapidjson::PrettyWriter<rapidjson::StringBuffer, WRITER_CONFIGS> writer(buf);
+#else
+    rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buf);
+#endif
+
+    char indent_char = ' ';
+    unsigned int indent_count = 2;
+    if (!NIL_P(options)) {
+        VALUE v_indent = rb_hash_lookup(options, sym_indent);
+        if (RTEST(v_indent)) {
+            if (RB_FIXNUM_P(v_indent)) {
+                int l = FIX2INT(v_indent);
+                indent_count = l > 0 ? l : 0;
+            } else {
+                int vlen = RSTRING_LENINT(v_indent);
+                if (vlen == 0) {
+                    indent_count = 0;
+                } else {
+                    const char *indent_str = RSTRING_PTR(v_indent);
+                    switch (indent_str[0]) {
+                    case ' ':
+                    case '\t':
+                    case '\r':
+                    case '\n':
+                        indent_char = indent_str[0];
+                        break;
+                    default:
+                        rb_raise(rb_eUsaminJsError,
+                                 ":indent must be a repetation of \" \", \"\\t\", \"\\r\" or \"\\n\".");
+                    }
+                    for (long i = 1; i < vlen; i++)
+                        if (indent_str[0] != indent_str[i])
+                            rb_raise(rb_eUsaminJsError,
+                                     ":indent must be a repetation of \" \", \"\\t\", \"\\r\" or \"\\n\".");
+                    indent_count = vlen;
+                }
+            }
+        }
+        if (RTEST(rb_hash_lookup(options, sym_single_line_array)))
+            writer.SetFormatOptions(rapidjson::kFormatSingleLineArray);
+    }
+    writer.SetIndent(indent_char, indent_count);
+
+    prepare_generate();
+    write(writer, value);
+    return new_utf8_str(buf.GetString(), buf.GetSize());
+}

data/ext/usamin_js/generator.hpp

@@ -0,0 +1,17 @@
+#ifndef USAMIN_GENERATOR_HPP
+#define USAMIN_GENERATOR_HPP
+
+#include <ruby.h>
+
+class RubyCrtAllocator {
+public:
+    static const bool kNeedFree = true;
+    void *Malloc(size_t size);
+    void *Realloc(void *originalPtr, size_t, size_t newSize);
+    static void Free(void *ptr);
+};
+
+VALUE w_generate(const VALUE self, const VALUE value);
+VALUE w_pretty_generate(const int argc, const VALUE *argv, const VALUE self);
+
+#endif

data/ext/usamin_js/rb270_fix.hpp

@@ -0,0 +1,17 @@
+#ifndef RB270_FIX_HPP
+#define RB270_FIX_HPP
+
+#include <cstring>
+#include <ruby/version.h>
+
+#if RUBY_API_VERSION_CODE >= 20700
+
+namespace std {
+static inline void *ruby_nonempty_memcpy(void *dest, const void *src, size_t n) {
+    return (n ? ::memcpy(dest, src, n) : dest);
+}
+}  // namespace std
+
+#endif
+
+#endif

data/ext/usamin_js/rb_common.cpp

@@ -0,0 +1,22 @@
+#include <ruby.h>
+#include <ruby/encoding.h>
+
+VALUE get_utf8_str(VALUE str) {
+    extern int utf8index;
+    extern VALUE utf8value;
+    extern rb_encoding *utf8;
+
+    Check_Type(str, T_STRING);
+    int encoding = rb_enc_get_index(str);
+    if (encoding == utf8index || rb_enc_compatible(str, utf8value) == utf8)
+        return str;
+    else
+        return rb_str_conv_enc(str, rb_enc_from_index(encoding), utf8);
+}
+
+VALUE new_utf8_str(const char *cstr, const long len) {
+    extern int utf8index;
+    VALUE ret = rb_str_new(cstr, len);
+    rb_enc_set_index(ret, utf8index);
+    return ret;
+}

data/ext/usamin_js/rb_common.hpp

@@ -0,0 +1,9 @@
+#ifndef USAMIN_RB_COMMON_HPP
+#define USAMIN_RB_COMMON_HPP
+
+#include <ruby.h>
+
+VALUE get_utf8_str(VALUE str);
+VALUE new_utf8_str(const char *cstr, const long len);
+
+#endif

data/ext/usamin_js/usamin_js.cpp

@@ -0,0 +1,40 @@
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include "generator.hpp"
+
+#if SIZEOF_VALUE < SIZEOF_VOIDP
+#error SIZEOF_VOIDP must not be greater than SIZEOF_VALUE.
+#endif
+
+rb_encoding *utf8;
+int utf8index;
+ID id_to_s, id_to_f, id_to_time, id_generate, id_Time, id_Date, id_DateTime, id_Value;
+VALUE rb_mUsamin, rb_mUsaminJs, rb_eUsaminJsError;
+VALUE utf8value, sym_indent, sym_single_line_array, sym_symbolize_names;
+VALUE rb_cUsaminValue, rb_cTime, rb_cDate, rb_cDateTime;
+
+extern "C" {
+void __attribute__((visibility("default"))) Init_usamin_js() {
+    utf8 = rb_utf8_encoding();
+    utf8index = rb_enc_to_index(utf8);
+    utf8value = rb_enc_from_encoding(utf8);
+    sym_indent = rb_id2sym(rb_intern("indent"));
+    sym_single_line_array = rb_id2sym(rb_intern("single_line_array"));
+    sym_symbolize_names = rb_id2sym(rb_intern("symbolize_names"));
+    id_to_s = rb_intern("to_s");
+    id_to_f = rb_intern("to_f");
+    id_to_time = rb_intern("to_time");
+    id_generate = rb_intern("generate");
+    id_Time = rb_intern("Time");
+    id_Date = rb_intern("Date");
+    id_DateTime = rb_intern("DateTime");
+    id_Value = rb_intern("Value");
+
+    rb_mUsamin = rb_define_module("Usamin");
+    rb_mUsaminJs = rb_define_module_under(rb_mUsamin, "Js");
+    rb_define_module_function(rb_mUsaminJs, "generate", RUBY_METHOD_FUNC(w_generate), 1);
+    rb_define_module_function(rb_mUsaminJs, "pretty_generate", RUBY_METHOD_FUNC(w_pretty_generate), -1);
+
+    rb_eUsaminJsError = rb_define_class_under(rb_mUsaminJs, "UsaminJsError", rb_eStandardError);
+}
+}

data/lib/usamin/js/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Usamin
+  module Js
+    VERSION = '1.0.0'
+  end
+end

data/lib/usamin/js.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'usamin/js/version'
+require 'usamin/js/usamin_js'
+
+module Usamin
+  module Js
+  end
+end

data/usamin.gemspec

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$:.unshift(lib) unless $:.include?(lib)
+require 'usamin/js/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'usamin-js'
+  spec.version       = Usamin::Js::VERSION
+  spec.authors       = ['Ishotihadus']
+  spec.email         = ['hanachan.pao@gmail.com']
+
+  spec.summary       = 'A RapidJSON-based JavaScript object generator for Ruby'
+  spec.description   = 'A RapidJSON-based JavaScript object generator for Ruby.'
+  spec.homepage      = 'https://github.com/Ishotihadus/usamin-js'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |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    = ['ext/usamin_js/extconf.rb']
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rake-compiler'
+  spec.add_development_dependency 'usamin'
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: usamin-js
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Ishotihadus
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-06-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: 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: rake
+  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: rake-compiler
+  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: usamin
+  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 RapidJSON-based JavaScript object generator for Ruby.
+email:
+- hanachan.pao@gmail.com
+executables: []
+extensions:
+- ext/usamin_js/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- ext/usamin_js/extconf.rb
+- ext/usamin_js/generator.cpp
+- ext/usamin_js/generator.hpp
+- ext/usamin_js/rb270_fix.hpp
+- ext/usamin_js/rb_common.cpp
+- ext/usamin_js/rb_common.hpp
+- ext/usamin_js/usamin_js.cpp
+- lib/usamin/js.rb
+- lib/usamin/js/version.rb
+- usamin.gemspec
+homepage: https://github.com/Ishotihadus/usamin-js
+licenses:
+- MIT
+metadata: {}
+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.3.3
+signing_key:
+specification_version: 4
+summary: A RapidJSON-based JavaScript object generator for Ruby
+test_files: []