ruby-daj 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 186bd3f05c510fd6fea8356fa573ba7959a9053e
+  data.tar.gz: 79b222a670ff3339a0a0e17dfc8174869c4454d2
+SHA512:
+  metadata.gz: c01ec5b40de9c1cb87a3aebe3d7b2da4d97e66c3cef43d1a221747f7a1f1e271e6365c7a92c88e63675be0da5ba7395d4b8b9199ccc18d858a12289a49e3a185
+  data.tar.gz: f05ff4b49a21ccd277cfffb01e2b173f56ce99f49ff3c176e602fae81901d147f74c5ba5dbace1a11fd230e1d9607dfe26cd92da0fc580f0b6211337d959199f

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/README.md

@@ -0,0 +1,113 @@
+# daj
+
+Are you terminally annoyed by the number of unaesthetic lines you have to write when the only thing you need is just reading and parsing some fracking data?
+
+Well if this is the case, **daj** is made for you!
+
+**daj**'s philosophy is to enable you to read and write popular data formats in one simplistic line.
+
+No more of the following nonsense:
+
+```ruby
+import codecs
+import json
+
+with codecs.open('path/to/your-fracking-data.json', 'r', encoding='utf-8') as jf:
+    data = json.load(jf)
+```
+
+Now, you just write:
+
+```ruby
+from daj import daj
+
+data = daj < 'path/to/your-fracking-data.json'
+```
+
+**daj** is your quick & dirty scripting companion. No more annoying boilerplate code: you start coding things that matter right now!
+
+## Installation
+
+With pip
+
+```ruby
+gem 'ruby-daj'
+```
+or 
+
+```ruby
+gem install ruby-daj
+```
+
+
+To install the latest dev version
+
+```ruby
+gem 'ruby-daj', git: "git://github.com/gtroppee/ruby-daj.git"
+```
+or 
+
+```ruby
+gem specific_install -l git://github.com/gtroppee/ruby-daj.git
+```
+
+## Formats supported
+
+* plain text
+* json
+* yaml
+* csv
+* tsv
+
+## Reading
+Note that if you do not provide a method to **daj**, this one will try to guess your format by analyzing the file's extension.
+
+So if you have a twisted mind and like to name csv files `table.json`, well first of all you are a sneaky bastard, second, just use the proper **daj** method.
+
+```ruby
+# Guessing the format
+data = daj < 'file.json'
+
+# Will also work with raw text
+data = daj < 'file.txt'
+
+# Using daj methods
+data = daj.json < 'file.json'
+data = daj.yml < 'file.yml'
+data = daj.csv < 'file.csv'
+data = daj.tsv < 'file.tsv'
+
+# Needing headers for your neat CSV files?
+data = daj.csvh < 'file.csv'
+data = daj.tsvh < 'file.tsv'
+```
+
+## Writing
+As for reading, **daj** will try to guess the correct format for your data based on the extension of the file.
+
+```ruby
+# Writing some data
+daj(data) > 'file.json'
+
+# Will also work with raw text
+daj(data) > 'file.txt'
+
+# Using daj methods
+daj.json(data) > 'file.json'
+daj.yml(data) > 'file.yml'
+
+# If you want to ouput a pretty printed json
+daj.pjson(data) > 'prettyfile.json'
+
+# For csv, you can give an array of arrays or an array of objects
+# If an array of objects is given, daj will output a csv with headers.
+daj.csv(data) > 'file.csv'
+daj.tsv(data) > 'file.tsv'
+```
+
+## Disclaimers
+**daj** is clearly orientated toward quick & dirty data processing. This is probably a bad idea to use it in a production context and I would not vouch for that.
+**ruby-daj** is directly inspired by [python-daj](https://github.com/Yomguithereal/python-daj)
+
+## Contribution
+Contribution are more than welcome, be sure to add relevant unit tests and pass them all before subitting any code.

data/lib/ruby-daj.rb

@@ -0,0 +1,14 @@
+module RubyDaj
+  FORMATS = %w(json yml csv csvh tsv tsvh)
+  def self.root
+    File.dirname __dir__
+  end
+end
+
+require 'json'
+require 'yaml'
+require 'csv'
+require_relative 'ruby-daj/helpers'
+require_relative 'ruby-daj/reader'
+require_relative 'ruby-daj/writer'
+require_relative 'ruby-daj/daj'

data/lib/ruby-daj/daj.rb

@@ -0,0 +1,29 @@
+# Main class
+#===========
+class Daj
+  attr_accessor :kind
+
+  # Constructor
+  def initialize(data = nil)
+    @data = data
+  end
+
+  # Less than operator as read file
+  def <(filename)
+    ext = kind || extension(filename)
+    Reader.new.read(ext, filename)
+  end
+
+  def >(filename)
+    ext = kind || extension(filename)
+    Writer.new(@data).write(ext, filename)
+  end
+
+  # Methods
+  #--------
+  RubyDaj::FORMATS.each do |format|
+    define_method(format) do |data = nil|
+      daj = Daj.new(data); daj.kind = format; daj
+    end
+  end
+end

data/lib/ruby-daj/helpers.rb

@@ -0,0 +1,7 @@
+def extension(filename)
+  File.extname(filename).gsub('.', '')
+end
+
+def daj(data = nil)
+  Daj.new(data)
+end

data/lib/ruby-daj/reader.rb

@@ -0,0 +1,45 @@
+class Reader
+
+	# Reading
+	#--------
+
+	# Reader abstract
+	def read(ext, filename)
+		RubyDaj::FORMATS.include?(ext) ? send(:"read_#{ext}", filename) : read_plain_text(filename)
+	end
+
+	def read_plain_text(filename)
+		File.read(filename).chomp
+	end
+
+	def read_json(filename)
+		json = JSON.parse(File.read(filename))
+		json.kind_of?(Array) ? json[0] : json
+	end
+
+	def read_yml(filename)
+		YAML.load_file(filename)
+	end
+
+	def read_csv(filename)
+		CSV.read(filename)
+	end
+
+	def read_csvh(filename)
+		CSV.read(filename, headers: true).map{|row| Hash[row.map{|col, row| [col, row]}]}
+	end
+
+	def read_tsv(filename)
+		# TODO Refactor this ugliness
+		CSV.read(filename, col_sep: "\t").map{|x| x.map{|x| x.split(" ")}}.map(&:flatten)
+	end
+
+	def read_tsvh(filename)
+		CSV.read(filename, col_sep: "\t", headers: true).map do |row| 
+			headers = row.headers[0].split(' ')
+			fields  = row.fields[0].split(' ')
+			Hash[headers.each_with_index.map{|_, index| [headers[index], fields[index]]}]
+		end
+	end
+
+end

data/lib/ruby-daj/writer.rb

@@ -0,0 +1,57 @@
+class Writer
+
+  def initialize(data)
+    if data.nil?
+      raise ArgumentError, 'Data is required in order to perform this operation. Please use the following form "daj(your_data) > your_file" and everything should be fine.'
+    else
+      @data = data
+    end
+  end
+
+  # Writing
+  #--------
+
+  # Call operator as writer
+  def write(ext, filename)
+    ext = @kind || ext
+    RubyDaj::FORMATS.include?(ext) ? send(:"write_#{ext}", filename) : write_plain_text(filename)
+  end
+
+  def write_plain_text(filename, encoding = 'utf-8')
+    File.open(filename, "w:#{encoding}") {|f| f.puts @data }
+  end
+
+  def write_json(filename)
+    File.open(filename, "w") {|f| f.puts @data.to_json }
+  end
+
+  def write_yml(filename)
+    File.open(filename, "w") {|f| f.puts @data.to_yaml }
+  end
+
+  def write_csv(filename)
+    CSV.open(filename, "w") do |csv|
+      @data.each {|data| csv << data}
+    end
+  end
+
+  def write_csvh(filename)
+    CSV.open(filename, "w") do |csv|
+      csv << @data.first.keys # adds the attributes name on the first line
+      @data.each {|hash| csv << hash.values}
+    end
+  end
+
+  def write_tsv(filename)
+    CSV.open(filename, "w", col_sep: "\t") do |tsv|
+      @data.each {|data| tsv << data}
+    end
+  end
+
+  def write_tsvh(filename)
+    CSV.open(filename, "w", col_sep: "\t") do |tsv|
+      tsv << @data.first.keys # adds the attributes name on the first line
+      @data.each {|hash| tsv << hash.values}
+    end
+  end
+end

data/spec/reader_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+describe Reader do  
+
+  it '#read_plain_text' do
+    data = "Hello World !"
+    expect(data).to eq daj < resources_path('hello.txt')
+  end
+
+  it '#read_json' do
+    data = {"hello"=>"world", "colors"=>["yellow", "blue"]}
+    expect(data).to eq daj      < resources_path('hello.json')
+    expect(data).to eq daj.json < resources_path('hello.json')
+  end
+
+  it '#read_yml' do
+    data = {"hello"=>"world", "colors"=>["yellow", "blue"]}
+    expect(data).to eq daj     < resources_path('hello.yml')
+    expect(data).to eq daj.yml < resources_path('hello.yml')
+  end
+
+  it '#read_csv' do
+    names = [['Joe', 'Dagger'], ['Elena', 'Ashcroft']]
+    hnames = [{'Firstname'=>'Joe', 'Lastname'=>'Dagger'}, {'Firstname'=>'Elena', 'Lastname'=>'Ashcroft'}]
+    expect(names).to  eq daj      < resources_path('names.csv')
+    expect(names).to  eq daj.csv  < resources_path('names.csv')
+    expect(hnames).to eq daj.csvh < resources_path('hnames.csv')
+  end
+
+  it '#read_tsv' do
+    names = [['Joe', 'Dagger'], ['Elena', 'Ashcroft']]
+    hnames = [{'Firstname'=>'Joe', 'Lastname'=>'Dagger'}, {'Firstname'=>'Elena', 'Lastname'=>'Ashcroft'}]
+    expect(names).to eq daj     < resources_path('names.tsv')
+    expect(names).to eq daj.tsv < resources_path('names.tsv')
+    expect(hnames).to eq daj.tsvh < resources_path('hnames.tsv')
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'bundler/setup'
+require 'utilities'
+require 'pry'
+Bundler.setup
+
+require 'ruby-daj' # and any other gems you need
+
+RSpec.configure do |config|
+  # some (optional) config here
+end

data/spec/utilities.rb

@@ -0,0 +1,7 @@
+def resources_path(file)
+  "#{RubyDaj.root}/spec/resources/#{file}"
+end
+
+def delete_resources(*filenames)
+  filenames.each{|filename| FileUtils.remove_file(resources_path(filename))}
+end

data/spec/writer_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+describe Writer do  
+
+  it '#write_plain_data' do
+    data = "Hello, world!"
+    daj(data) > resources_path('test_hello.txt')
+    expect(data).to eq daj < resources_path('test_hello.txt')
+
+    delete_resources('test_hello.txt')
+  end
+
+  it '#write_json' do
+    data1 = {'hello' => 'world'}
+    data2 = {hello: 'world'}
+
+    daj(data1) > resources_path('test_hello1.json')
+    daj(data2) > resources_path('test_hello2.json')
+
+    expect(data1).to eq daj      < resources_path('test_hello1.json')
+    expect(data1).to eq daj.json < resources_path('test_hello2.json')
+
+    delete_resources('test_hello1.json', 'test_hello2.json')
+  end
+
+  it '#write_yaml' do
+    data = {"hello"=>"world", "colors"=>["yellow", "blue"]}
+    daj(data) > resources_path('test_hello.yml')
+    expect(data).to eq daj < resources_path('test_hello.yml')
+
+    delete_resources('test_hello.yml')
+  end
+
+  it '#write_csv' do
+    data = [['Joe', 'Dagger'], ['Elena', 'Ashcroft']]
+    daj(data) > resources_path('test_names.csv')
+    expect(data).to eq daj < resources_path('test_names.csv')
+
+    delete_resources('test_names.csv')
+  end
+
+  it '#write_csvh' do
+    data = [{'Firstname'=>'Joe', 'Lastname'=>'Dagger'}, {'Firstname'=>'Elena', 'Lastname'=>'Ashcroft'}]
+    daj.csvh(data) > resources_path('test_hnames.csv')
+    expect(data).to eq daj.csvh < resources_path('test_hnames.csv')
+
+    delete_resources('test_hnames.csv')
+  end
+
+  it '#write_tsv' do
+    data = [['Joe', 'Dagger'], ['Elena', 'Ashcroft']]
+    daj(data) > resources_path('test_names.tsv')
+    expect(data).to eq daj < resources_path('test_names.tsv')
+
+    delete_resources('test_names.tsv')
+  end
+
+  # it '#write_tsvh' do
+  #   data = [{'Firstname'=>'Joe', 'Lastname'=>'Dagger'}, {'Firstname'=>'Elena', 'Lastname'=>'Ashcroft'}]
+  #   daj.tsvh(data) > resources_path('test_hnames.tsv')
+  #   expect(data).to eq daj.tsvh < resources_path('test_hnames.tsv')
+
+  #   delete_resources('test_hnames.tsv')
+  # end
+
+  it 'should raise an exception if no data is provided' do
+    expect { daj.csvh > resources_path('test_hnames.csv') }.to raise_error
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: ruby-daj
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Guillaume Troppée
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: 
+email: gtroppee@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Gemfile
+- spec/reader_spec.rb
+- spec/spec_helper.rb
+- spec/utilities.rb
+- spec/writer_spec.rb
+- lib/ruby-daj/daj.rb
+- lib/ruby-daj/helpers.rb
+- lib/ruby-daj/reader.rb
+- lib/ruby-daj/writer.rb
+- lib/ruby-daj.rb
+homepage: http://rubygems.org/gems/ruby-daj
+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: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: Read and write data in ruby without further ado
+test_files: []
+has_rdoc: