gooddata_datawarehouse 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6a3ba4f26ae8e33a6118a1f0a892315968f92857
+  data.tar.gz: 2be9b35b829f8910116a65252a3651ab6dfd5be6
+SHA512:
+  metadata.gz: c2b74588cb194e9c0928dcd3c6c3250bf64907d1fe4fc93d137506a2f2f8e86c02350cbdbbc7341c5854a30d75ac7ad36b2269e8f3c5f393959f6b4ee1b26b59
+  data.tar.gz: e7e8b1cb11d8926b47d516e9a636b79096d055bb7ca35331bb6edcf5d67926fde3a57ebb32c719741f83cf0caa2e6da66f2f0688535be91e13158e55af446113

data/.gitignore

@@ -0,0 +1,36 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.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
+
+env_setup.sh

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in gooddata_datawarehouse.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+BSD License
+Copyright (c) 2013, GoodData Corporation
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+* Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+* Neither the name of GoodData Corporation nor the names of its contributors
+may be used to endorse or promote products derived from this software
+without specific prior written permission.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL GOODDATA CORPORATION BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,61 @@
+# GooddataDatawarehouse
+
+A little library to help you work with GoodData's Datawarehouse
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'gooddata_datawarehouse'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install gooddata_datawarehouse
+
+## Usage
+
+```ruby
+require 'gooddata_datawarehouse'
+
+# connect
+dwh = GoodData::Datawarehouse.new('you@gooddata.com', 'yourpass', 'your ADS instance id'
+
+# import a csv
+dwh.csv_to_new_table('my_table', 'path/to/my.csv')
+
+dwh.table_exists?('my_table') # true
+dwh.get_columns('my_table') # [{column_name: 'col1', data_type: 'varchar(88)'}, {column_name: 'col2', data_type: 'int'}]
+
+# run an aribrary sql
+dwh.execute('ALTER TABLE my_table ADD COLUMN col3 INTEGER')
+
+# run a select and process results 
+dwh.execute_select('SELECT * FROM my_table ORDER BY col1') do |row| 
+  puts row[:col1] 
+end
+
+
+# rename a table
+dwh.rename_table('my_table', 'my_new_table')
+
+# export to csv
+dwh.export_table('my_new_table', 'path/to/my_new.csv')
+
+# drop table
+dwh.drop_table('my_new_table')
+```
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/gooddata_datawarehouse/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/env_setup-example.sh

@@ -0,0 +1,5 @@
+#!/bin/sh
+
+export USERNAME=""
+export PASSWORD=""
+export INSTANCE_ID=""

data/gooddata_datawarehouse.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gooddata_datawarehouse/version'
+
+if RUBY_PLATFORM != 'java'
+  fail "Only java platform supported! Use jRuby, e.g. rvm use jruby"
+end
+
+Gem::Specification.new do |spec|
+  spec.name          = "gooddata_datawarehouse"
+  spec.version       = GoodData::Datawarehouse::VERSION
+  spec.authors       = ["Petr Cvengros"]
+  spec.email         = ["petr.cvengros@gooddata.com"]
+  spec.summary       = %q{Convenient work with GoodData's Datawarehouse (ADS) }
+  spec.description   = ""
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency 'rspec', '~>2.14'
+  spec.add_development_dependency 'pry', '~> 0.9'
+
+  spec.add_dependency "sequel", "~> 4.17"
+  spec.add_dependency "gooddata-dss-jdbc", "~> 0.1"
+end

data/lib/gooddata_datawarehouse/datawarehouse.rb

@@ -0,0 +1,144 @@
+require 'jdbc/dss'
+require 'sequel'
+require 'logger'
+require 'csv'
+
+require_relative 'sql_generator'
+
+module GoodData
+  class Datawarehouse
+    def initialize(username, password, instance_id, options={})
+      @logger = Logger.new(STDOUT)
+      @username = username
+      @password = password
+      @jdbc_url = "jdbc:dss://secure.gooddata.com/gdc/dss/instances/#{instance_id}"
+      Jdbc::DSS.load_driver
+      Java.com.gooddata.dss.jdbc.driver.DssDriver
+    end
+
+    def export_table(table_name, csv_path)
+      CSV.open(csv_path, 'wb', :force_quotes => true) do |csv|
+        # get the names of cols
+        cols = get_columns(table_name).map {|c| c[:column_name]}
+        col_names =
+
+        # write header
+        csv << cols
+
+        # get the keys for columns, stupid sequel
+        col_keys = nil
+        rows = execute_select(GoodData::SQLGenerator.select_all(table_name, limit: 1))
+
+        col_keys = rows[0].keys
+
+        execute_select(GoodData::SQLGenerator.select_all(table_name)) do |row|
+          # go through the table write to csv
+          csv << row.values_at(*col_keys)
+        end
+      end
+    end
+
+    def rename_table(old_name, new_name)
+      execute(GoodData::SQLGenerator.rename_table(old_name, new_name))
+    end
+
+    def drop_table(table_name, opts={})
+      execute(GoodData::SQLGenerator.drop_table(table_name,opts))
+    end
+
+    def csv_to_new_table(table_name, csv_path, opts={})
+      cols = create_table_from_csv_header(table_name, csv_path, opts)
+      load_data_from_csv(table_name, csv_path, columns: cols)
+    end
+
+    def load_data_from_csv(table_name, csv_path, opts={})
+      columns = opts[:columns] || get_csv_headers(csv_path)
+      execute(GoodData::SQLGenerator.load_data(table_name, csv_path, columns))
+    end
+
+    # returns a list of columns created
+    # does nothing if file empty, returns []
+    def create_table_from_csv_header(table_name, csv_path, opts={})
+      # take the header as a list of columns
+      columns = get_csv_headers(csv_path)
+      create_table(table_name, columns, opts) unless columns.empty?
+      columns
+    end
+
+    def create_table(name, columns, options={})
+      execute(GoodData::SQLGenerator.create_table(name, columns, options))
+    end
+
+    def table_exists?(name)
+      count = execute_select(GoodData::SQLGenerator.get_table_count(name), :count => true)
+      count > 0
+    end
+
+    def get_columns(table_name)
+      res = execute_select(GoodData::SQLGenerator.get_columns(table_name))
+    end
+
+    # execute sql, return nothing
+    def execute(sql_strings)
+      if ! sql_strings.kind_of?(Array)
+        sql_strings = [sql_strings]
+      end
+      connect do |connection|
+        sql_strings.each do |sql|
+          @logger.info("Executing sql: #{sql}") if @logger
+          connection.run(sql)
+        end
+      end
+    end
+
+    # executes sql (select), for each row, passes execution to block
+    def execute_select(sql, options={})
+      fetch_handler = options[:fetch_handler]
+      count = options[:count]
+
+      connect do |connection|
+        # do the query
+        f = connection.fetch(sql)
+
+        @logger.info("Executing sql: #{sql}") if @logger
+        # if handler was passed call it
+        if fetch_handler
+          fetch_handler.call(f)
+        end
+
+        if count
+          return f.first[:count]
+        end
+
+        # if block given yield to process line by line
+        if block_given?
+          # go through the rows returned and call the block
+          return f.each do |row|
+            yield(row)
+          end
+        end
+
+        # return it all at once
+        f.map{|h| h}
+      end
+    end
+
+    def connect
+      Sequel.connect @jdbc_url,
+        :username => @username,
+        :password => @password do |connection|
+          yield(connection)
+      end
+    end
+
+    private
+
+    def get_csv_headers(csv_path)
+      header_str = File.open(csv_path, &:gets)
+      if header_str.nil? || header_str.empty?
+        return []
+      end
+      header_str.split(',').map{ |s| s.gsub(/[\s"-]/,'') }
+    end
+  end
+end

data/lib/gooddata_datawarehouse/sql_generator.rb

@@ -0,0 +1,49 @@
+module GoodData
+  class SQLGenerator
+    DEFAULT_TYPE = 'varchar(1023)'
+    class << self
+
+      def rename_table(old_name, new_name)
+        "ALTER TABLE #{old_name} RENAME TO #{new_name}"
+      end
+
+      def drop_table(table_name, opts={})
+        "DROP TABLE #{opts[:skip_if_exists] ? 'IF EXISTS' : ''} #{table_name}"
+      end
+
+      def create_table(table_name, columns, opts={})
+        not_exists = opts[:skip_if_exists] ? 'IF NOT EXISTS' : ''
+        columns_string = columns.map { |c|
+          c.is_a?(String) ? "#{c} #{DEFAULT_TYPE}" : "#{c[:column_name]} #{c[:data_type] || DEFAULT_TYPE}"
+        }.join(', ')
+        "CREATE TABLE #{not_exists} #{table_name} (#{columns_string})"
+      end
+
+      def load_data(table, csv, columns)
+        col_list = columns.join(', ')
+
+        # TODO: exceptions, rejections
+        #       EXCEPTIONS '#{except_filename(filename)}'
+        # REJECTED DATA '#{reject_filename(filename)}' }
+
+        %Q{COPY #{table} (#{col_list})
+        FROM LOCAL '#{csv}' WITH PARSER GdcCsvParser()
+        ESCAPE AS '"'
+         SKIP 1}
+      end
+
+      def get_table_count(table_name)
+        "SELECT COUNT(*) FROM tables WHERE table_name = '#{table_name}'"
+      end
+
+      def get_columns(table_name)
+        "SELECT column_name, data_type FROM columns WHERE table_name = '#{table_name}'"
+      end
+
+      def select_all(table_name, options={})
+        limit = options[:limit] ? "LIMIT #{options[:limit]}" : ''
+        "SELECT * FROM #{table_name} #{limit}"
+      end
+    end
+  end
+end

data/lib/gooddata_datawarehouse/version.rb

@@ -0,0 +1,5 @@
+module GoodData
+  class Datawarehouse
+    VERSION = "0.0.1"
+  end
+end

data/lib/gooddata_datawarehouse.rb

@@ -0,0 +1,2 @@
+require_relative "gooddata_datawarehouse/version"
+require_relative "gooddata_datawarehouse/datawarehouse"

data/spec/data/bike.csv

@@ -0,0 +1,5 @@
+wheel_size,manufacturer
+"29","Specialized"
+"27.5","Scott"
+"29","Scott"
+"989","989"

data/spec/datawarehouse_spec.rb

@@ -0,0 +1,175 @@
+require 'tempfile'
+require 'gooddata_datawarehouse/datawarehouse'
+require_relative 'spec_helper'
+
+describe GoodData::Datawarehouse do
+  before(:each) do
+    @dwh = SpecHelper::create_default_connection
+    @random = rand(10000000).to_s
+    @random_table_name = "temp_#{@random}"
+    @created_tables = nil
+  end
+
+  after(:each) do
+    @created_tables.each{|t| @dwh.drop_table(t)} if @created_tables
+  end
+
+  describe '#create_table' do
+    it 'creates a table with default type' do
+      cols = ['col1', 'col2', 'col3']
+      @dwh.create_table(@random_table_name, cols)
+      @created_tables = [@random_table_name]
+
+      # table exists
+      expect(@dwh.table_exists?(@random_table_name)).to eq true
+
+      # cols are the same
+      expect(Set.new(@dwh.get_columns(@random_table_name))).to eq Set.new(cols.map {|c| {:column_name => c, :data_type => GoodData::SQLGenerator::DEFAULT_TYPE}})
+    end
+
+    it "doesn't create a table when it already exists" do
+      cols = ['col1', 'col2', 'col3']
+      cols2 = ['col1', 'col2']
+      @dwh.create_table(@random_table_name, cols)
+      @created_tables = [@random_table_name]
+
+      expect(@dwh.table_exists?(@random_table_name)).to eq true
+
+      # try to create a table with di
+      @dwh.create_table(@random_table_name, cols2, skip_if_exists: true)
+
+      # table still exists
+      expect(@dwh.table_exists?(@random_table_name)).to eq true
+      # cols are the same
+      expect(Set.new(@dwh.get_columns(@random_table_name))).to eq Set.new(cols.map {|c| {:column_name => c, :data_type => GoodData::SQLGenerator::DEFAULT_TYPE}})
+    end
+
+    it 'creates a table with given types' do
+      cols = [
+        {
+          column_name: 'col1',
+          data_type: 'varchar(88)'
+        }, {
+          column_name: 'col2',
+          data_type: 'int'
+        }, {
+          column_name: 'col3',
+          data_type: 'boolean'
+        }
+      ]
+      @dwh.create_table(@random_table_name, cols)
+      @created_tables = [@random_table_name]
+
+      # table exists
+      expect(@dwh.table_exists?(@random_table_name)).to eq true
+
+      # cols are the same
+      expect(Set.new(@dwh.get_columns(@random_table_name))).to eq Set.new(cols)
+    end
+  end
+
+  describe '#drop_table' do
+    it 'drops a table' do
+      cols = ['col1', 'col2', 'col3']
+
+      @dwh.create_table(@random_table_name, cols)
+      expect(@dwh.table_exists?(@random_table_name)).to eq true
+
+      # it shouldn't exist after being dropped
+      @dwh.drop_table(@random_table_name)
+      expect(@dwh.table_exists?(@random_table_name)).to eq false
+    end
+  end
+
+  describe '#rename_table' do
+    it 'renames a table' do
+      cols = ['col1', 'col2', 'col3']
+
+      @dwh.create_table(@random_table_name, cols)
+      expect(@dwh.table_exists?(@random_table_name)).to eq true
+
+      # the renamed table should exist, not the old name
+      changed_name = "#{@random_table_name}_something"
+      @dwh.rename_table(@random_table_name, changed_name)
+      expect(@dwh.table_exists?(@random_table_name)).to eq false
+      expect(@dwh.table_exists?(changed_name)).to eq true
+
+      @created_tables = [changed_name]
+    end
+  end
+
+  describe '#csv_to_new_table' do
+    it 'creates a new table from csv' do
+      path = 'spec/data/bike.csv'
+      @dwh.csv_to_new_table(@random_table_name, path)
+
+      # table exists
+      expect(@dwh.table_exists?(@random_table_name)).to eq true
+
+      # cols are the same as in the csv
+      expected_cols = File.open(path, &:gets).strip.split(',')
+      expect(Set.new(@dwh.get_columns(@random_table_name))).to eq Set.new(expected_cols.map {|c| {:column_name => c, :data_type => GoodData::SQLGenerator::DEFAULT_TYPE}})
+      @created_tables = [@random_table_name]
+    end
+  end
+
+  describe '#export_table' do
+    it 'exports a created table' do
+      path = 'spec/data/bike.csv'
+      @dwh.csv_to_new_table(@random_table_name, path)
+
+      # table exists
+      expect(@dwh.table_exists?(@random_table_name)).to eq true
+
+      # export it
+      f = Tempfile.new('bike.csv')
+      @dwh.export_table(@random_table_name, f)
+
+      # should be the same except for order of the lines
+      imported = Set.new(CSV.read(path))
+      exported = Set.new(CSV.read(f))
+
+      expect(exported).to eq imported
+      @created_tables = [@random_table_name]
+    end
+  end
+
+  describe '#load_data_from_csv' do
+    it 'loads data from csv to existing table' do
+      path = 'spec/data/bike.csv'
+
+      # create the table
+      @dwh.create_table_from_csv_header(@random_table_name, path)
+      expect(@dwh.table_exists?(@random_table_name)).to eq true
+
+      expected_cols = File.open(path, &:gets).strip.split(',')
+      expect(Set.new(@dwh.get_columns(@random_table_name))).to eq Set.new(expected_cols.map {|c| {:column_name => c, :data_type => GoodData::SQLGenerator::DEFAULT_TYPE}})
+
+      # load the data there
+      @dwh.load_data_from_csv(@random_table_name, path)
+
+      # export it
+      f = Tempfile.new('bike.csv')
+      @dwh.export_table(@random_table_name, f)
+
+      # should be the same except for order of the lines
+      imported = Set.new(CSV.read(path))
+      exported = Set.new(CSV.read(f))
+
+      expect(exported).to eq imported
+      @created_tables = [@random_table_name]
+    end
+
+    it 'fails for a wrong csv' do
+      path_wrong = 'spec/data/bike-wrong.csv'
+
+      # create the table
+      @dwh.create_table_from_csv_header(@random_table_name, path_wrong)
+      expect(@dwh.table_exists?(@random_table_name)).to eq true
+
+      # load the data there
+      @dwh.load_data_from_csv(@random_table_name, path_wrong)
+
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'gooddata_datawarehouse'
+
+RSpec.configure do |c|
+  c.filter_run :focus => true
+  c.run_all_when_everything_filtered = true
+end
+
+class SpecHelper
+  def self.create_default_connection
+    GoodData::Datawarehouse.new(ENV['USERNAME'], ENV['PASSWORD'], ENV['INSTANCE_ID'])
+  end
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: gooddata_datawarehouse
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Petr Cvengros
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2014-12-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  name: bundler
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  name: rake
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  name: rspec
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  name: pry
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.17'
+  name: sequel
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.17'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  name: gooddata-dss-jdbc
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+description: ''
+email:
+- petr.cvengros@gooddata.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- env_setup-example.sh
+- gooddata_datawarehouse.gemspec
+- lib/gooddata_datawarehouse.rb
+- lib/gooddata_datawarehouse/datawarehouse.rb
+- lib/gooddata_datawarehouse/sql_generator.rb
+- lib/gooddata_datawarehouse/version.rb
+- spec/data/bike.csv
+- spec/datawarehouse_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+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.9
+signing_key:
+specification_version: 4
+summary: Convenient work with GoodData's Datawarehouse (ADS)
+test_files:
+- spec/data/bike.csv
+- spec/datawarehouse_spec.rb
+- spec/spec_helper.rb