data_hut 0.0.4

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.db

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.9.3@data_hut --create

data/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+## 0.0.4
+
+* added the capability to mark records in the datahut as processed so that transform passes can ignore previously processed data and only process new data... good for cycles where you pull regular updates and then process them.
+
+* added capability to force the transform to write in spite of processed; good for situations where you are playing with the structure of the transform and want to regenerate the data.
+
+
+## 0.0.3
+
+* fixed an update issue found in transforms where data was written successfully, but Sequel::Model couldn't read it immediately after.
+
+
+## 0.0.2
+
+* fixed problem with multiple instances of the datahut returning only a single dataset instance.
+
+* added more interesting example to motivate edge cases.
+
+
+## 0.0.1
+
+* initial checkin. basic functionality

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Larry Kyrala
+
+MIT License
+
+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,244 @@
+# DataHut
+
+A small, portable data warehouse for Ruby for analytics on anything!
+
+DataHut has basic features for small one-off analytics like parsing error logs and such.  Like its bigger cousin (the Data Warehouse) it has support for *extract*, *transform* and *load* processes (ETL).  Unlike its bigger cousin it is simple to setup and use for simple projects.
+
+*Extract* your data from anywhere, *transform* it however you like and *analyze* it for insights!
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+*NOTE* I haven't released this gem yet, so you'll need to ref git:
+
+    gem 'data_hut', :git => "git://github.com/coldnebo/data_hut.git"
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install data_hut
+
+## Usage
+
+Setting up a datahut is easy...
+
+    require 'data_hut'
+    require 'pry'
+
+    dh = DataHut.connect("scratch")
+
+    data = [{name: "barney", age: 27},
+            {name: "phil", age: 31},
+            {name: "fred", age: 44}]
+
+    # extract your data by iterating over your data format (from whatever source) and map it to a record model...
+    dh.extract(data) do |r, d|
+      r.name = d[:name]
+      r.age = d[:age]
+    end
+
+    # transform your data by adding fields to it
+    dh.transform do |r|
+      r.eligible = r.age < 30
+    end
+
+    # operate on your dataset by using chained queries
+    ds = dh.dataset
+
+    binding.pry
+
+The datahut *dataset* is a Sequel::Model backed by the data warehouse you just created. 
+
+And here's the kinds of powerful things you can do:
+
+    [2] pry(main)> ds.where(eligible: false).count
+    => 2
+    [3] pry(main)> ds.avg(:age)
+    => 34.0
+    [4] pry(main)> ds.max(:age)
+    => 44
+    [5] pry(main)> ds.min(:age)
+    => 27
+
+But wait, you can name these collections:
+
+    [6] pry(main)> ineligible = ds.where(eligible: false)
+    => #<Sequel::SQLite::Dataset: "SELECT * FROM `data_warehouse` WHERE (`eligible` = 'f')">
+
+    [26] pry(main)> ineligible.avg(:age)
+    => 37.5
+    [24] pry(main)> ineligible.order(Sequel.desc(:age)).all
+    => [#< @values={:dw_id=>3, :name=>"fred", :age=>44, :eligible=>false}>,
+     #< @values={:dw_id=>2, :name=>"phil", :age=>31, :eligible=>false}>]
+
+The results are Sequel::Model objects, so you can treat them as such:
+
+    [32] pry(main)> record = ineligible.order(Sequel.desc(:age)).first
+    => #< @values={:dw_id=>3, :name=>"fred", :age=>44, :eligible=>false}>
+    [33] pry(main)> record.name
+    => "fred"
+    [34] pry(main)> record.age
+    => 44
+
+
+Read more about the [Sequel gem](http://sequel.rubyforge.org/rdoc/files/README_rdoc.html) to determine what operations you can perform on a datahut dataset.
+
+## A More Ambitious Example...
+
+Taking a popular game like League of Legends and hand-rolling some simple analysis of the champions...
+
+    require 'nokogiri'
+    require 'open-uri'
+    require 'pry'
+
+    root = 'http://na.leagueoflegends.com'
+
+    # load the data once... (manually delete it to refresh)
+    unless File.exists?("lolstats.db")
+      dh = DataHut.connect("lolstats")
+
+      champions_page = Nokogiri::HTML(open("#{root}/champions"))
+
+      urls = champions_page.css('table.champion_item td.description span a').collect{|e| e.attribute('href').value}
+
+      # keep the powers for later since they are on different pages.
+      powers = {}
+      champions_page.css('table.champion_item').each do |c|
+        name        = c.css('td.description span.highlight a').text
+        attack      = c.css('td.graphing td.filled_attack').count
+        health      = c.css('td.graphing td.filled_health').count
+        spells      = c.css('td.graphing td.filled_spells').count
+        difficulty  = c.css('td.graphing td.filled_difficulty').count
+        powers.store(name, {attack_power: attack, defense_power: health, ability_power: spells, difficulty: difficulty})
+      end
+
+      puts "loading champion data"
+      dh.extract(urls) do |r, url|
+        champion_page = Nokogiri::HTML(open("#{root}#{url}"))
+        r.name = champion_page.css('div.page_header_text').text
+
+        st = champion_page.css('table.stats_table')
+        names = st.css('td.stats_name').collect{|e| e.text.strip}
+        values = st.css('td.stats_value').collect{|e| e.text.strip}
+        modifiers = st.css('td.stats_modifier').collect{|e| e.text.strip}
+
+        (0..names.count-1).collect do |i| 
+          stat = (names[i].downcase.gsub(/ /,'_') << "=").to_sym
+          r.send(stat, values[i].to_f)
+          stat_per_level = (names[i].downcase.gsub(/ /,'_') << "_per_level=").to_sym
+          per_level_value = modifiers[i].match(/\+([\d\.]+)/)[1].to_f rescue 0
+          r.send(stat_per_level, per_level_value)
+        end
+
+        # add the powers for this champion...
+        power = powers[r.name]
+        r.attack_power = power[:attack_power]
+        r.defense_power = power[:defense_power]
+        r.ability_power = power[:ability_power]
+        r.difficulty = power[:difficulty]
+
+        print "."
+      end
+      puts "done."
+    end
+
+    dh = DataHut.connect("lolstats")
+
+    puts "first transform"
+    dh.transform do |r|
+      r.total_damage = r.damage + (r.damage_per_level * 18.0)
+      r.total_health = r.health + (r.health_per_level * 18.0)
+      r.total_mana = r.mana + (r.mana_per_level * 18.0)
+      r.total_move_speed = r.move_speed + (r.move_speed_per_level * 18.0)
+      r.total_armor = r.armor + (r.armor_per_level * 18.0)
+      r.total_spell_block = r.spell_block + (r.spell_block_per_level * 18.0)
+      r.total_health_regen = r.health_regen + (r.health_regen_per_level * 18.0)
+      r.total_mana_regen = r.mana_regen + (r.mana_regen_per_level * 18.0)
+      print '.'
+    end
+
+    puts "second transform"
+    # there's no need to do transforms all in one batch either... you can layer them...
+    dh.transform(true) do |r|
+      # this index combines the tank dimensions above for best combination (simple Euclidean metric)
+      r.nuke_index = r.total_damage * r.total_move_speed * r.total_mana * (r.ability_power)
+      r.easy_nuke_index = r.total_damage * r.total_move_speed * r.total_mana * (r.ability_power) * (1.0/r.difficulty)
+      r.tenacious_index = r.total_armor * r.total_health * r.total_spell_block * r.total_health_regen * (r.defense_power)
+      r.support_index = r.total_mana * r.total_armor * r.total_spell_block * r.total_health * r.total_health_regen * r.total_mana_regen * (r.ability_power * r.defense_power)
+      print '.'
+    end
+
+    # use once at the end to mark records processed.
+    dh.transform_complete
+    puts "transforms complete"
+
+    ds = dh.dataset
+
+    binding.pry
+
+
+Now that we have some data, lets play...
+
+* who has the most base damage?
+
+        [14] pry(main)> ds.order(Sequel.desc(:damage)).limit(5).collect{|c| {c.name => c.damage}}
+        => [{"Taric"=>58.0},
+         {"Maokai"=>58.0},
+         {"Warwick"=>56.76},
+         {"Singed"=>56.65},
+         {"Poppy"=>56.3}]
+
+* but wait a minute... what about at level 18?  Fortunately, we've transformed our data to add some extra fields for this...
+
+        [3] pry(main)> ds.order(Sequel.desc(:total_damage)).limit(5).collect{|c| {c.name => c.total_damage}}
+        => [{"Skarner"=>129.70000000000002},
+         {"Cho'Gath"=>129.70000000000002},
+         {"Kassadin"=>122.5},
+         {"Taric"=>121.0},
+         {"Alistar"=>120.19}]
+
+* how about using some of the indexes we defined above... like the 'nuke_index' (notice that the assumptions on what make a good
+nuke are subjective, but that's the fun of it; we can model our assumptions and see how the data changes in response.)
+
+        [5] pry(main)> ds.order(Sequel.desc(:nuke_index)).limit(5).collect{|c| {c.name => [c.total_damage, c.total_move_speed, c.total_mana, c.ability_power]}}
+        => [{"Karthus"=>[100.7, 335.0, 1368.0, 10]},
+         {"Morgana"=>[114.58, 335.0, 1320.0, 9]},
+         {"Ryze"=>[106.0, 335.0, 1240.0, 10]},
+         {"Karma"=>[109.4, 335.0, 1320.0, 9]},
+         {"Lux"=>[109.4, 340.0, 1150.0, 10]}]
+
+I must have hit close to the mark, because personally I hate each of these champions when I go up against them!  ;)
+
+* and (now I risk becoming addicted to datahut myself), here's some further guesses with an easy_nuke index:
+
+        [2] pry(main)> ds.order(Sequel.desc(:easy_nuke_index)).limit(5).collect{|c| c.name}
+        => ["Sona", "Ryze", "Nasus", "Soraka", "Heimerdinger"]
+
+* makes sense, but is still fascinating... what about my crack at a support_index?
+
+        [3] pry(main)> ds.order(Sequel.desc(:support_index)).limit(5).collect{|c| c.name}
+        => ["Sion", "Diana", "Nunu", "Nautilus", "Amumu"]
+
+You get the idea now!  *Extract* your data from anywhere, *transform* it however you like and *analyze* it for insights!
+
+Have fun!
+
+
+## TODOS
+
+* fill out tests
+* further optimizations
+* time-based series and binning helpers (by week/day/hour/5-min/etc).
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,15 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+task :default => :test
+
+desc "clean up"
+task :clean do
+  FileUtils.rm(FileList["*.db"], force: true, verbose: true)
+end

data/data_hut.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/data_hut/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Larry Kyrala"]
+  gem.email         = ["larry.kyrala@gmail.com"]
+  gem.description   = %q{A small, portable data warehouse for Ruby for analytics on anything!}
+  gem.summary       = %q{Like a data warehouse, but smaller.}
+  gem.homepage      = "https://github.com/coldnebo/data_hut"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "data_hut"
+  gem.require_paths = ["lib"]
+  gem.version       = DataHut::VERSION
+
+  gem.add_dependency 'sequel'
+  gem.add_dependency 'sqlite3'
+
+  gem.add_development_dependency 'mocha'
+  gem.add_development_dependency 'pry'
+end

data/lib/data_hut.rb

@@ -0,0 +1,12 @@
+require "data_hut/version"
+require "data_hut/data_warehouse"
+
+
+module DataHut
+  # Your code goes here...
+
+  def self.connect(name)
+    DataWarehouse.connect(name)
+  end
+
+end

data/lib/data_hut/data_warehouse.rb

@@ -0,0 +1,94 @@
+require 'sequel'
+require 'ostruct'
+require 'logger'
+
+module DataHut
+  class DataWarehouse
+    private_class_method :new
+
+    def self.connect(name)
+      new(name)
+    end
+
+    def initialize(name)
+      @db_file = "#{name}.db"
+      @db = Sequel.sqlite(@db_file)
+      #@db.logger = ::Logger.new(STDOUT)
+      unless @db.table_exists?(:data_warehouse)
+        @db.create_table(:data_warehouse) do
+          primary_key :dw_id
+          column :dw_processed, TrueClass, :null => false, :default => false
+        end
+      end
+    end
+
+    def dataset
+      Class.new(Sequel::Model(@db[:data_warehouse]))
+    end
+
+    def extract(data)
+      raise(ArgumentError, "a block is required for extract.", caller) unless block_given?
+
+      data.each do |d|
+        r = OpenStruct.new
+        yield r, d
+        store(r)
+      end
+    end
+
+    # transform all (could also be limited to not processed)
+    def transform(forced=false)
+      raise(ArgumentError, "a block is required for transform.", caller) unless block_given?
+
+      # now process all the records with the updated schema...
+      @db[:data_warehouse].each do |h|
+        # check for processed if not forced
+        unless forced
+          next if h[:dw_processed] == true
+        end
+        # then get rid of the internal id and processed flags
+        dw_id = h.delete(:dw_id)
+        h.delete(:dw_processed)
+        # copy record fields to an openstruct
+        r = OpenStruct.new(h)
+        # and let the transformer modify it...
+        yield r
+        # now add any new transformation fields to the schema...
+        adapt_schema(r)
+        # get the update hash from the openstruct
+        h = r.marshal_dump
+        # and use it to update the record
+        @db[:data_warehouse].where(dw_id: dw_id).update(h)
+      end
+    end
+
+    def transform_complete
+      @db[:data_warehouse].update(:dw_processed => true)
+    end
+
+    private 
+
+    def store(r)
+      adapt_schema(r)
+      h = r.marshal_dump
+      # don't insert dups
+      unless @db[:data_warehouse].where(h).count > 0
+        @db[:data_warehouse].insert(h)
+      end
+    end
+
+    def adapt_schema(r)
+      h = r.marshal_dump
+      h.keys.each do |key|
+        type = h[key].class
+        unless @db[:data_warehouse].columns.include?(key)
+          @db.alter_table(:data_warehouse) do 
+            add_column key, type
+            add_index key
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/data_hut/version.rb

@@ -0,0 +1,3 @@
+module DataHut
+  VERSION = "0.0.4"
+end

data/scratch

@@ -0,0 +1,164 @@
+#!/usr/bin/env ruby
+# allows this script to behave as if the gem were installed.
+lp = File.expand_path(File.join(*%w[lib]), File.dirname(__FILE__))
+unless $LOAD_PATH.include?(lp)
+  $LOAD_PATH.unshift(lp)
+end
+
+# ------------------ manual example of client usage for docs, etc. -----------
+
+    require 'data_hut'
+    require 'pry'
+
+    dh = DataHut.connect("scratch")
+
+    data = [{name: "barney", age: 27, login: DateTime.parse('2008-05-03') },
+            {name: "phil", age: 31},
+            {name: "fred", age: 44, login: DateTime.parse('2013-02-07')}]
+
+    # extract your data by iterating over your data format (from whatever source) and map it to a record model...
+    dh.extract(data) do |r, d|
+      r.name = d[:name]
+      r.age = d[:age]
+      # data quality step:
+      d[:login] = DateTime.new unless d.has_key?(:login)
+      r.last_active = d[:login]
+      print 'v'
+    end
+
+    # transform your data by adding fields to it
+    dh.transform do |r|
+      r.eligible = r.age < 30
+      print '*'
+    end
+
+    dh.transform_complete
+
+    # later... you have more data...
+    data = [{name: "sarah", age: 24, login: DateTime.parse('2011-04-01') },
+            {name: "robin", age: 45},
+            {name: "jane", age: 19, login: DateTime.parse('2012-10-14')}]
+
+    # add it too...
+    dh.extract(data) do |r, d|
+      r.name = d[:name]
+      r.age = d[:age]
+      # data quality step:
+      d[:login] = DateTime.new unless d.has_key?(:login)
+      r.last_active = d[:login]
+      print 'v'
+    end
+
+    # and only transform the new records automatically
+    dh.transform do |r|
+      r.eligible = r.age < 30
+      print '*'
+    end
+
+    dh.transform_complete
+
+
+    # operate on your dataset by using chained queries
+    ds = dh.dataset
+
+    #binding.pry
+
+
+    # clean up scratch demo
+    FileUtils.rm("scratch.db")
+    puts "done."
+
+#exit
+
+# ------------------------------ a more ambitious example -------------------------
+
+    require 'nokogiri'
+    require 'open-uri'
+    require 'pry'
+
+    root = 'http://na.leagueoflegends.com'
+
+    # load the data once... (manually delete it to refresh)
+    unless File.exists?("lolstats.db")
+      dh = DataHut.connect("lolstats")
+
+      champions_page = Nokogiri::HTML(open("#{root}/champions"))
+
+      urls = champions_page.css('table.champion_item td.description span a').collect{|e| e.attribute('href').value}
+
+      # keep the powers for later since they are on different pages.
+      powers = {}
+      champions_page.css('table.champion_item').each do |c|
+        name        = c.css('td.description span.highlight a').text
+        attack      = c.css('td.graphing td.filled_attack').count
+        health      = c.css('td.graphing td.filled_health').count
+        spells      = c.css('td.graphing td.filled_spells').count
+        difficulty  = c.css('td.graphing td.filled_difficulty').count
+        powers.store(name, {attack_power: attack, defense_power: health, ability_power: spells, difficulty: difficulty})
+      end
+
+      puts "loading champion data"
+      dh.extract(urls) do |r, url|
+        champion_page = Nokogiri::HTML(open("#{root}#{url}"))
+        r.name = champion_page.css('div.page_header_text').text
+
+        st = champion_page.css('table.stats_table')
+        names = st.css('td.stats_name').collect{|e| e.text.strip}
+        values = st.css('td.stats_value').collect{|e| e.text.strip}
+        modifiers = st.css('td.stats_modifier').collect{|e| e.text.strip}
+
+        (0..names.count-1).collect do |i| 
+          stat = (names[i].downcase.gsub(/ /,'_') << "=").to_sym
+          r.send(stat, values[i].to_f)
+          stat_per_level = (names[i].downcase.gsub(/ /,'_') << "_per_level=").to_sym
+          per_level_value = modifiers[i].match(/\+([\d\.]+)/)[1].to_f rescue 0
+          r.send(stat_per_level, per_level_value)
+        end
+
+        # add the powers for this champion...
+        power = powers[r.name]
+        r.attack_power = power[:attack_power]
+        r.defense_power = power[:defense_power]
+        r.ability_power = power[:ability_power]
+        r.difficulty = power[:difficulty]
+
+        print "."
+      end
+      puts "done."
+    end
+
+    dh = DataHut.connect("lolstats")
+
+    puts "first transform"
+    dh.transform do |r|
+      r.total_damage = r.damage + (r.damage_per_level * 18.0)
+      r.total_health = r.health + (r.health_per_level * 18.0)
+      r.total_mana = r.mana + (r.mana_per_level * 18.0)
+      r.total_move_speed = r.move_speed + (r.move_speed_per_level * 18.0)
+      r.total_armor = r.armor + (r.armor_per_level * 18.0)
+      r.total_spell_block = r.spell_block + (r.spell_block_per_level * 18.0)
+      r.total_health_regen = r.health_regen + (r.health_regen_per_level * 18.0)
+      r.total_mana_regen = r.mana_regen + (r.mana_regen_per_level * 18.0)
+      print '.'
+    end
+
+    puts "second transform"
+    # there's no need to do transforms all in one batch either... you can layer them...
+    dh.transform(true) do |r|
+      # this index combines the tank dimensions above for best combination (simple Euclidean metric)
+      r.nuke_index = r.total_damage * r.total_move_speed * r.total_mana * (r.ability_power)
+      r.easy_nuke_index = r.total_damage * r.total_move_speed * r.total_mana * (r.ability_power) * (1.0/r.difficulty)
+      r.tenacious_index = r.total_armor * r.total_health * r.total_spell_block * r.total_health_regen * (r.defense_power)
+      r.support_index = r.total_mana * r.total_armor * r.total_spell_block * r.total_health * r.total_health_regen * r.total_mana_regen * (r.ability_power * r.defense_power)
+      print '.'
+    end
+
+    # use once at the end to mark records processed.
+    dh.transform_complete
+    puts "transforms complete"
+
+    ds = dh.dataset
+
+    binding.pry
+
+puts "done."

data/test/spec/basic_test.rb

@@ -0,0 +1,53 @@
+require_relative File.join(*%w[.. test_helper])
+
+
+describe DataHut do
+  def teardown
+    FileUtils.rm("foo.db", force: true, verbose: true)
+  end
+
+  describe "gem loading" do
+    it "must be defined" do
+      DataHut::VERSION.wont_be_nil
+    end
+  end
+
+  describe "connect" do 
+    it "should create a database if none exists" do
+      FileUtils.rm("foo.db", force: true, verbose: true)
+      dh = DataHut.connect("foo")
+      assert File.exists?("foo.db")
+    end
+  end
+
+  describe "extract" do
+    it "should support extracting data" do
+      dh = DataHut.connect("foo")
+
+      data = [{name: "barney", age: 27},
+              {name: "phil", age: 31},
+              {name: "fred", age: 44}]
+
+      # ignore dups!!
+      data2 = [{name: "barney", age: 27},
+              {name: "phil", age: 31},{name: "phil", age: 31},
+              {name: "fred", age: 44}]
+              
+      # the idea of the extract phase is that you control exactly how an element of your data 'd' is 
+      # extracted into a transactional record 'r' in the data warehouse.
+      dh.extract(data2) do |r, d|
+        r.name = d[:name]
+        r.age = d[:age]
+      end
+
+      dh.dataset.each_with_index do |r,i|
+        assert r.name == data[i][:name]
+        assert_kind_of(data[i][:name].class, r.name)
+        assert r.age == data[i][:age]
+        assert_kind_of(data[i][:age].class, r.age)
+      end
+    end
+  end
+
+end
+

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require 'minitest/autorun'
+require 'mocha/setup'
+
+require File.expand_path(File.join(*%w[.. lib data_hut]), File.dirname(__FILE__))
+
+require 'pry'

data/test/unit/data_warehouse_test.rb

@@ -0,0 +1,16 @@
+require_relative File.join(*%w[.. test_helper])
+
+
+class DataWarehouseTest < MiniTest::Unit::TestCase
+  def setup
+  end
+
+  def test_cannot_instaniate
+    assert_raises(NoMethodError) do
+      dw = DataHut::DataWarehouse.new  
+    end
+    
+  #  assert_equal "OHAI!", @meme.i_can_has_cheezburger?
+  end
+
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: data_hut
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+  prerelease: 
+platform: ruby
+authors:
+- Larry Kyrala
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A small, portable data warehouse for Ruby for analytics on anything!
+email:
+- larry.kyrala@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- data_hut.gemspec
+- lib/data_hut.rb
+- lib/data_hut/data_warehouse.rb
+- lib/data_hut/version.rb
+- scratch
+- test/spec/basic_test.rb
+- test/test_helper.rb
+- test/unit/data_warehouse_test.rb
+homepage: https://github.com/coldnebo/data_hut
+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.24
+signing_key: 
+specification_version: 3
+summary: Like a data warehouse, but smaller.
+test_files:
+- test/spec/basic_test.rb
+- test/test_helper.rb
+- test/unit/data_warehouse_test.rb