ruby-bsdconv 0.9.0

data/.gitignore

@@ -0,0 +1 @@
+pkg

data/README

@@ -0,0 +1 @@
+see example/* for examples

data/Rakefile

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require "#{dir = File.dirname(__FILE__)}/task/gemgem"
+
+Gemgem.dir = dir
+($LOAD_PATH << File.expand_path("#{Gemgem.dir}/lib")).uniq!
+
+desc 'Generate gemspec'
+task 'gem:spec' do
+  Gemgem.spec = Gemgem.create do |s|
+    s.name    = 'ruby-bsdconv'
+    s.version = '0.9.0'
+    s.extensions  = 'ext/ruby-bsdconv/extconf.rb'
+    s.authors     = ['Buganini Q']
+    s.homepage    = 'https://github.com/buganini/ruby-bsdconv'
+    s.summary     = 'ruby wrapper for bsdconv'
+    s.description =
+      "#{s.summary}. bsdconv is a BSD licensed charset/encoding converter" \
+      " library with more functionalities than libiconv"
+  end
+
+  Gemgem.write
+end

data/example/example.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'bsdconv'
+
+c = Bsdconv.new(ARGV[0])
+
+if c.nil?
+	abort(Bsdconv.error())
+end
+
+c.init
+while $stdin.gets
+	puts c.conv_chunk($_)
+end
+puts c.conv_chunk_last('')
+
+p c.info

data/example/example2.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+require 'bsdconv'
+
+c=Bsdconv.new('utf-8:utf-8')
+
+if c.nil?
+	abort(Bsdconv.error())
+end
+
+c.insert_phase('full',Bsdconv::INTER, 1)
+puts c.conv('test')
+
+p Bsdconv.codec_check(Bsdconv::FROM, "_utf-8")
+p Bsdconv.codec_check(Bsdconv::INTER, "_utf-8")
+puts 'From:'
+p Bsdconv.codecs_list(Bsdconv::FROM)
+puts 'Inter:'
+p Bsdconv.codecs_list(Bsdconv::INTER)
+puts 'To:'
+p Bsdconv.codecs_list(Bsdconv::TO)

data/example/example3.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+require 'bsdconv'
+
+score,path=Bsdconv::mktemp("score.XXXXXX")
+list=open("characters_list.txt","w+")
+
+c=Bsdconv.new('utf-8:score_train:null')
+c.init
+
+c.ctl(Bsdconv::CTL_ATTACH_SCORE, score, 0);
+c.ctl(Bsdconv::CTL_ATTACH_OUTPUT_FILE, list, 0);
+
+open(ARGV[0], "r") { |fp|
+	while !fp.eof?
+		c.conv_chunk(fp.read(1024))
+	end
+	c.conv_chunk_last("")
+}
+
+File.unlink(path)

data/ext/ruby-bsdconv/bsdconv.c

@@ -0,0 +1,317 @@
+#include <ruby.h>
+#ifdef HAVE_RUBY_IO_H		/* Ruby 1.9 and later */
+#include "ruby/io.h"
+#else				/* Ruby 1.8.x */
+#include "rubyio.h"
+#define rb_io_stdio_file(iot)	((iot)->f)
+#endif
+#include <bsdconv.h>
+
+#ifndef WIN32
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#endif
+
+#define IBUFLEN 1024
+
+void Init_bsdconv();
+static VALUE m_new(VALUE, VALUE);
+static VALUE m_insert_phase(VALUE, VALUE, VALUE, VALUE);
+static VALUE m_insert_codec(VALUE, VALUE, VALUE, VALUE);
+static VALUE m_replace_phase(VALUE, VALUE, VALUE, VALUE);
+static VALUE m_replace_codec(VALUE, VALUE, VALUE, VALUE);
+static VALUE m_conv(VALUE, VALUE);
+static VALUE m_init(VALUE);
+static VALUE m_ctl(VALUE, VALUE, VALUE, VALUE);
+static VALUE m_conv_chunk(VALUE, VALUE);
+static VALUE m_conv_chunk_last(VALUE, VALUE);
+static VALUE m_conv_file(VALUE, VALUE, VALUE);
+static VALUE m_info(VALUE);
+static VALUE m_nil(VALUE);
+static VALUE m_inspect(VALUE);
+
+static VALUE f_error(VALUE);
+static VALUE f_codecs_list(VALUE, VALUE);
+static VALUE f_codec_check(VALUE, VALUE, VALUE);
+static VALUE f_mktemp(VALUE, VALUE);
+static VALUE f_fopen(VALUE, VALUE, VALUE);
+
+VALUE Bsdconv_file;
+
+void Init_bsdconv(){
+	VALUE Bsdconv = rb_define_class("Bsdconv", rb_cObject);
+	rb_define_singleton_method(Bsdconv, "new", m_new, 1);
+	rb_define_method(Bsdconv, "insert_phase", m_insert_phase, 3);
+	rb_define_method(Bsdconv, "insert_codec", m_insert_codec, 3);
+	rb_define_method(Bsdconv, "replace_phase", m_replace_phase, 3);
+	rb_define_method(Bsdconv, "replace_codec", m_replace_codec, 3);
+	rb_define_method(Bsdconv, "conv", m_conv, 1);
+	rb_define_method(Bsdconv, "init", m_init, 0);
+	rb_define_method(Bsdconv, "ctl", m_ctl, 3);
+	rb_define_method(Bsdconv, "conv_chunk", m_conv_chunk, 1);
+	rb_define_method(Bsdconv, "conv_chunk_last", m_conv_chunk_last, 1);
+	rb_define_method(Bsdconv, "conv_file", m_conv_file, 2);
+	rb_define_method(Bsdconv, "info", m_info, 0);
+	rb_define_method(Bsdconv, "inspect", m_inspect, 0);
+
+	rb_define_const(Bsdconv, "FROM", INT2NUM(FROM));
+	rb_define_const(Bsdconv, "INTER", INT2NUM(INTER));
+	rb_define_const(Bsdconv, "TO", INT2NUM(TO));
+
+	rb_define_const(Bsdconv, "CTL_ATTACH_SCORE", INT2NUM(BSDCONV_ATTACH_SCORE));
+	rb_define_const(Bsdconv, "CTL_SET_WIDE_AMBI", INT2NUM(BSDCONV_SET_WIDE_AMBI));
+	rb_define_const(Bsdconv, "CTL_SET_TRIM_WIDTH", INT2NUM(BSDCONV_SET_TRIM_WIDTH));
+	rb_define_const(Bsdconv, "CTL_ATTACH_OUTPUT_FILE", INT2NUM(BSDCONV_ATTACH_OUTPUT_FILE));
+
+	rb_define_singleton_method(Bsdconv, "error", f_error, 0);
+	rb_define_singleton_method(Bsdconv, "codecs_list", f_codecs_list, 1);
+	rb_define_singleton_method(Bsdconv, "codec_check", f_codec_check, 2);
+	rb_define_singleton_method(Bsdconv, "mktemp", f_mktemp, 1);
+	rb_define_singleton_method(Bsdconv, "fopen", f_fopen, 2);
+
+	Bsdconv_file = rb_define_class("Bsdconv_file", rb_cObject);
+}
+
+static VALUE m_new(VALUE class, VALUE conversion){
+	struct bsdconv_instance *ins;
+	if(TYPE(conversion)!=T_STRING)
+		ins=bsdconv_create("");
+	else
+		ins=bsdconv_create(RSTRING_PTR(conversion));
+	if(ins==NULL)
+		return Qnil;
+	return Data_Wrap_Struct(class, 0, bsdconv_destroy, ins);
+}
+
+static VALUE m_insert_phase(VALUE self, VALUE conversion, VALUE phase_type, VALUE phasen){
+	struct bsdconv_instance *ins;
+	Data_Get_Struct(self, struct bsdconv_instance, ins);
+	return INT2NUM(bsdconv_insert_phase(ins, RSTRING_PTR(conversion), NUM2INT(phase_type), NUM2INT(phasen)));
+}
+
+static VALUE m_insert_codec(VALUE self, VALUE conversion, VALUE phasen, VALUE codecn){
+	struct bsdconv_instance *ins;
+	Data_Get_Struct(self, struct bsdconv_instance, ins);
+	return INT2NUM(bsdconv_insert_phase(ins, RSTRING_PTR(conversion), NUM2INT(phasen), NUM2INT(codecn)));
+}
+
+static VALUE m_replace_phase(VALUE self, VALUE conversion, VALUE phase_type, VALUE phasen){
+	struct bsdconv_instance *ins;
+	Data_Get_Struct(self, struct bsdconv_instance, ins);
+	return INT2NUM(bsdconv_insert_phase(ins, RSTRING_PTR(conversion), NUM2INT(phase_type), NUM2INT(phasen)));
+}
+
+static VALUE m_replace_codec(VALUE self, VALUE conversion, VALUE phasen, VALUE codecn){
+	struct bsdconv_instance *ins;
+	Data_Get_Struct(self, struct bsdconv_instance, ins);
+	return INT2NUM(bsdconv_insert_phase(ins, RSTRING_PTR(conversion), NUM2INT(phasen), NUM2INT(codecn)));
+}
+
+static VALUE m_conv(VALUE self, VALUE str){
+	VALUE ret;
+	struct bsdconv_instance *ins;
+	Data_Get_Struct(self, struct bsdconv_instance, ins);
+	bsdconv_init(ins);
+	ins->output_mode=BSDCONV_AUTOMALLOC;
+	ins->input.data=RSTRING_PTR(str);
+	ins->input.len=RSTRING_LEN(str);
+	ins->input.flags=0;
+	ins->flush=1;
+	bsdconv(ins);
+	ret=rb_str_new(ins->output.data, ins->output.len);
+	bsdconv_free(ins->output.data);
+	return ret;
+}
+
+static VALUE m_init(VALUE self){
+	struct bsdconv_instance *ins;
+	Data_Get_Struct(self, struct bsdconv_instance, ins);
+	bsdconv_init(ins);
+	return Qtrue;
+}
+
+static VALUE m_ctl(VALUE self, VALUE action, VALUE res, VALUE num){
+	struct bsdconv_instance *ins;
+	rb_io_t *fptr = NULL;
+	void *ptr=NULL;
+	Data_Get_Struct(self, struct bsdconv_instance, ins);
+	if(TYPE(res)==T_FILE){
+		GetOpenFile(res, fptr);
+		ptr=rb_io_stdio_file(fptr);
+	}else{
+		Data_Get_Struct(res, FILE, ptr);
+	}
+	bsdconv_ctl(ins, NUM2INT(action), ptr, NUM2INT(num));
+	return Qtrue;
+}
+
+static VALUE m_conv_chunk(VALUE self, VALUE str){
+	VALUE ret;
+	struct bsdconv_instance *ins;
+	Data_Get_Struct(self, struct bsdconv_instance, ins);
+	ins->output_mode=BSDCONV_AUTOMALLOC;
+	ins->input.data=RSTRING_PTR(str);
+	ins->input.len=RSTRING_LEN(str);
+	ins->input.flags=0;
+	bsdconv(ins);
+	ret=rb_str_new(ins->output.data, ins->output.len);
+	bsdconv_free(ins->output.data);
+	return ret;
+}
+
+static VALUE m_conv_chunk_last(VALUE self, VALUE str){
+	VALUE ret;
+	struct bsdconv_instance *ins;
+	Data_Get_Struct(self, struct bsdconv_instance, ins);
+	ins->output_mode=BSDCONV_AUTOMALLOC;
+	ins->input.data=RSTRING_PTR(str);
+	ins->input.len=RSTRING_LEN(str);
+	ins->input.flags=1;
+	bsdconv(ins);
+	ret=rb_str_new(ins->output.data, ins->output.len);
+	bsdconv_free(ins->output.data);
+	return ret;
+}
+
+static VALUE m_conv_file(VALUE self, VALUE ifile, VALUE ofile){
+	struct bsdconv_instance *ins;
+	FILE *inf, *otf;
+	char *s1=RSTRING_PTR(ifile);
+	char *s2=RSTRING_PTR(ofile);
+	char *in;
+	char *tmp;
+	int fd;
+
+	Data_Get_Struct(self, struct bsdconv_instance, ins);
+	inf=fopen(s1,"r");
+	if(!inf){
+		return Qfalse;
+	}
+	tmp=malloc(strlen(s2)+8);
+	strcpy(tmp, s2);
+	strcat(tmp, ".XXXXXX");
+	if((fd=mkstemp(tmp))==-1){
+		free(tmp);
+		return Qfalse;
+	}
+	otf=fdopen(fd,"w");
+	if(!otf){
+		free(tmp);
+		return Qfalse;
+	}
+
+#ifndef WIN32
+	struct stat stat;
+	fstat(fileno(inf), &stat);
+	fchown(fileno(otf), stat.st_uid, stat.st_gid);
+	fchmod(fileno(otf), stat.st_mode);
+#endif
+
+	bsdconv_init(ins);
+	do{
+		in=bsdconv_malloc(IBUFLEN);
+		ins->input.data=in;
+		ins->input.len=fread(in, 1, IBUFLEN, inf);
+		ins->input.flags|=F_FREE;
+		if(ins->input.len==0){
+			ins->flush=1;
+		}
+		ins->output_mode=BSDCONV_FILE;
+		ins->output.data=otf;
+		bsdconv(ins);
+	}while(ins->flush==0);
+
+	fclose(inf);
+	fclose(otf);
+	unlink(s2);
+	rename(tmp,s2);
+	free(tmp);
+
+	return Qtrue;
+}
+
+static VALUE m_info(VALUE self){
+	VALUE ret;
+	struct bsdconv_instance *ins;
+	Data_Get_Struct(self, struct bsdconv_instance, ins);
+	ret=rb_hash_new();
+	rb_hash_aset(ret, rb_str_new2("ierr"), INT2FIX(ins->ierr));
+	rb_hash_aset(ret, rb_str_new2("oerr"), INT2FIX(ins->oerr));
+	rb_hash_aset(ret, rb_str_new2("score"), rb_float_new(ins->score));
+	rb_hash_aset(ret, rb_str_new2("full"), INT2FIX(ins->full));
+	rb_hash_aset(ret, rb_str_new2("half"), INT2FIX(ins->half));
+	rb_hash_aset(ret, rb_str_new2("ambi"), INT2FIX(ins->ambi));
+	return ret;
+}
+
+static VALUE m_inspect(VALUE self){
+#define TEMPLATE "Bsdconv.new(\"%s\")"
+	VALUE ret;
+	struct bsdconv_instance *ins;
+	char *s;
+	char *s2;
+	int len=sizeof(TEMPLATE);
+	Data_Get_Struct(self, struct bsdconv_instance, ins);
+	s=bsdconv_pack(ins);
+	len+=strlen(s);
+	s2=malloc(len);
+	sprintf(s2, TEMPLATE, s);
+	bsdconv_free(s);
+	ret=rb_str_new2(s2);
+	free(s2);
+	return ret;
+}
+
+static VALUE f_error(VALUE self){
+	VALUE ret;
+	char *s=bsdconv_error();
+	ret=rb_str_new2(s);
+	bsdconv_free(s);
+	return ret;
+}
+
+static VALUE f_codecs_list(VALUE self, VALUE phase_type){
+	char **list, **p;
+	VALUE ret;
+	ret=rb_ary_new();
+	list=bsdconv_codecs_list(NUM2INT(phase_type));
+	p=list;
+	while(*p!=NULL){
+		rb_ary_push(ret, rb_str_new2(*p));
+		bsdconv_free(*p);
+		p+=1;
+	}
+	bsdconv_free(list);
+	return ret;
+}
+
+static VALUE f_codec_check(VALUE self, VALUE phase_type, VALUE codec){
+	if(bsdconv_codec_check(NUM2INT(phase_type), RSTRING_PTR(codec))){
+		return Qtrue;
+	}
+	return Qfalse;
+}
+
+static VALUE f_mktemp(VALUE self, VALUE template){
+	char *fn=strdup(RSTRING_PTR(template));
+	int fd=bsdconv_mkstemp(fn);
+	if(fd==-1)
+		return Qnil;
+	FILE *fp=fdopen(fd, "wb+");
+	VALUE rfp=Data_Wrap_Struct(Bsdconv_file, 0, fclose, fp);
+	VALUE ret;
+	ret=rb_ary_new();
+	rb_ary_push(ret, rfp);
+	rb_ary_push(ret, rb_str_new2(fn));
+	free(fn);
+	return ret;
+}
+
+static VALUE f_fopen(VALUE self, VALUE filename, VALUE mode){
+	FILE *fp=fopen(RSTRING_PTR(filename), RSTRING_PTR(mode));
+	if(!fp)
+		return Qnil;
+	VALUE ret=Data_Wrap_Struct(Bsdconv_file, 0, fclose, fp);
+	return ret;
+}

data/ext/ruby-bsdconv/extconf.rb

@@ -0,0 +1,11 @@
+require 'mkmf'
+
+extension_name = 'bsdconv'
+
+dir_config(extension_name)
+
+have_library('bsdconv', func='bsdconv_create', header='bsdconv.h')
+have_header('bsdconv.h')
+
+create_makefile(extension_name)
+

data/ruby-bsdconv.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "ruby-bsdconv"
+  s.version = "0.9.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Buganini Q"]
+  s.date = "2012-12-03"
+  s.description = "ruby wrapper for bsdconv. bsdconv is a BSD licensed charset/encoding converter library with more functionalities than libiconv"
+  s.extensions = ["ext/ruby-bsdconv/extconf.rb"]
+  s.files = [
+  ".gitignore",
+  "README",
+  "Rakefile",
+  "example/example.rb",
+  "example/example2.rb",
+  "example/example3.rb",
+  "ext/ruby-bsdconv/bsdconv.c",
+  "ext/ruby-bsdconv/extconf.rb",
+  "ruby-bsdconv.gemspec",
+  "task/gemgem.rb"]
+  s.homepage = "https://github.com/buganini/ruby-bsdconv"
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.23"
+  s.summary = "ruby wrapper for bsdconv"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/task/gemgem.rb

@@ -0,0 +1,164 @@
+
+require 'pathname'
+
+module Gemgem
+  class << self
+    attr_accessor :dir, :spec
+  end
+
+  module_function
+  def create
+    yield(spec = Gem::Specification.new{ |s|
+      s.rubygems_version = Gem::VERSION
+      s.date             = Time.now.strftime('%Y-%m-%d')
+      s.files            = gem_files
+      s.test_files       = gem_files.grep(%r{^test/(.+?/)*test_.+?\.rb$})
+      s.executables      = Dir['bin/*'].map{ |f| File.basename(f) }
+      s.require_paths    = %w[lib]
+    })
+    spec
+  end
+
+  def gem_tag
+    "#{spec.name}-#{spec.version}"
+  end
+
+  def write
+    File.open("#{dir}/#{spec.name}.gemspec", 'w'){ |f|
+      f << split_lines(spec.to_ruby) }
+  end
+
+  def split_lines ruby
+    ruby.gsub(/(.+?)\[(.+?)\]/){ |s|
+      if $2.index(',')
+        "#{$1}[\n  #{$2.split(',').map(&:strip).join(",\n  ")}]"
+      else
+        s
+      end
+    }
+  end
+
+  def all_files
+    @all_files ||= find_files(Pathname.new(dir)).map{ |file|
+      if file.to_s =~ %r{\.git/|\.git$}
+        nil
+      else
+        file.to_s
+      end
+    }.compact.sort
+  end
+
+  def gem_files
+    @gem_files ||= all_files - ignored_files
+  end
+
+  def ignored_files
+    @ignored_file ||= all_files.select{ |path| ignore_patterns.find{ |ignore|
+      path =~ ignore && !git_files.include?(path)}}
+  end
+
+  def git_files
+    @git_files ||= if File.exist?("#{dir}/.git")
+                     `git ls-files`.split("\n")
+                   else
+                     []
+                   end
+  end
+
+  # protected
+  def find_files path
+    path.children.select(&:file?).map{|file| file.to_s[(dir.size+1)..-1]} +
+    path.children.select(&:directory?).map{|dir| find_files(dir)}.flatten
+  end
+
+  def ignore_patterns
+    @ignore_files ||= expand_patterns(
+      gitignore.split("\n").reject{ |pattern|
+        pattern.strip == ''
+      }).map{ |pattern| %r{^([^/]+/)*?#{Regexp.escape(pattern)}(/[^/]+)*?$} }
+  end
+
+  def expand_patterns pathes
+    pathes.map{ |path|
+      if path !~ /\*/
+        path
+      else
+        expand_patterns(
+          Dir[path] +
+          Pathname.new(File.dirname(path)).children.select(&:directory?).
+            map{ |prefix| "#{prefix}/#{File.basename(path)}" })
+      end
+    }.flatten
+  end
+
+  def gitignore
+    if File.exist?(path = "#{dir}/.gitignore")
+      File.read(path)
+    else
+      ''
+    end
+  end
+end
+
+namespace :gem do
+
+desc 'Install gem'
+task :install => [:build] do
+  sh("#{Gem.ruby} -S gem install pkg/#{Gemgem.gem_tag}")
+end
+
+desc 'Build gem'
+task :build => [:spec] do
+  sh("#{Gem.ruby} -S gem build #{Gemgem.spec.name}.gemspec")
+  sh("mkdir -p pkg")
+  sh("mv #{Gemgem.gem_tag}.gem pkg/")
+end
+
+desc 'Release gem'
+task :release => [:spec, :check, :build] do
+  sh("git tag #{Gemgem.gem_tag}")
+  sh("git push")
+  sh("git push --tags")
+  sh("#{Gem.ruby} -S gem push pkg/#{Gemgem.gem_tag}.gem")
+end
+
+task :check do
+  ver = Gemgem.spec.version.to_s
+
+  if ENV['VERSION'].nil?
+    puts("\e[35mExpected "                                  \
+         "\e[33mVERSION\e[35m=\e[33m#{ver}\e[0m")
+    exit(1)
+
+  elsif ENV['VERSION'] != ver
+    puts("\e[35mExpected \e[33mVERSION\e[35m=\e[33m#{ver} " \
+         "\e[35mbut got\n         "                         \
+         "\e[33mVERSION\e[35m=\e[33m#{ENV['VERSION']}\e[0m")
+    exit(2)
+  end
+end
+
+end # of gem namespace
+
+desc 'Run tests in memory'
+task :test do
+  require 'bacon'
+  Bacon.extend(Bacon::TestUnitOutput)
+  Bacon.summary_on_exit
+  $LOAD_PATH.unshift('lib')
+  Dir['./test/**/test_*.rb'].each{ |file| require file[0..-4] }
+end
+
+desc 'Run tests with shell'
+task 'test:shell', :RUBY_OPTS do |t, args|
+  files = Dir['test/**/test_*.rb'].join(' ')
+
+  cmd = [Gem.ruby, args[:RUBY_OPTS],
+         '-I', 'lib', '-S', 'bacon', '--quiet', files]
+
+  sh(cmd.compact.join(' '))
+end
+
+task :default do
+  puts `#{Gem.ruby} -S #{$PROGRAM_NAME} -T`
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: ruby-bsdconv
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+  prerelease: 
+platform: ruby
+authors:
+- Buganini Q
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-03 00:00:00.000000000 Z
+dependencies: []
+description: ruby wrapper for bsdconv. bsdconv is a BSD licensed charset/encoding
+  converter library with more functionalities than libiconv
+email: 
+executables: []
+extensions:
+- ext/ruby-bsdconv/extconf.rb
+extra_rdoc_files: []
+files:
+- .gitignore
+- README
+- Rakefile
+- example/example.rb
+- example/example2.rb
+- example/example3.rb
+- ext/ruby-bsdconv/bsdconv.c
+- ext/ruby-bsdconv/extconf.rb
+- ruby-bsdconv.gemspec
+- task/gemgem.rb
+homepage: https://github.com/buganini/ruby-bsdconv
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: ruby wrapper for bsdconv
+test_files: []