sequel_plus 0.0.6 → 0.1.0

data/README.md

@@ -1,9 +1,13 @@
 # sequel_plus
 
-This library starts the collection of plugins and possibly extension I assemble for the Ruby Sequel 
-ORM.  
+This library starts the collection of plugins and extensions I have assembled for the Ruby Sequel library.  
+The library is in very early infancy stage, so there's not much presently, but what's here is fully covered
+in specs and tested and used in production-level deployments already.
+  
 
-Currently, it only contains a plugin for Trees to mimic the Rails acts_as_tree plugin.
+Currently, sequel_plus contains:
+  * plugin for Trees to mimic the Rails acts_as_tree plugin.
+  * extension for exporting data using Dataset#export. 
 
 NOTE:  Authors of other plugins and extensions for Sequel are welcome to contact me for inclusion
 of your plugin and extension to this project.
@@ -12,21 +16,39 @@ Released under MIT license.
 
 # For the Impatient
 
+## Install 
+
 This gem is released to gemcutter.  Rubyforge is not utilized. 
 
 	gem install sequel_plus
 
-And then, in your project:
+## Use Tree Plugin 
 
 	require 'sequel'
 
 	class Node < Sequel::Model
 		plugin :tree
 	end
+
+## Use Exporter
+
+    require 'sequel'
+    require 'sequel_plus'
+
+    DB = Sequel.sqlite
+
+    # Every row, every column, tab delimited, unquoted...
+    File.open("nodes.txt", "w"){|file| DB[:nodes].export(file)}
+
+    # Every row, every column, comma delimited double-quotes
+    File.open("nodes.txt", "w"){|file| DB[:nodes].export(file, :delimiter => ',', :quote_char => '"')}
   
+    # Specific rows and columns
+    File.open("nodes.txt", "w"){|file| DB[:nodes].filter(:id < 5).select(:id, :name).export(file)}
+
 # Note on Patches/Pull Requests
  
-* First release!
+* This release adds an export facility to the Sequel::Dataset
 
 # Copyright
 

data/Rakefile

@@ -15,6 +15,7 @@ begin
        "README.md",
        "Rakefile",
        "lib/*",
+       "lib/**/*",
        "test/*"
     ]
     

data/lib/extensions/export.rb

@@ -0,0 +1,61 @@
+# The export extension adds Sequel::Dataset#export and the
+# Sequel::Export class for creating plain-text data exports
+
+module Sequel
+  class Dataset
+    # outputs the records in the dataset as plain-text table.
+    def export(fd = $stdout, options = {})
+      opts[:delimiter] = options[:delimiter] || "\t"
+      opts[:quote_char] = options[:quote_char] || '"'
+      opts[:headers] = options[:headers] != false
+      Sequel::Export::Writer.new(fd, self, opts).output
+    end
+  end
+
+  module Export
+
+    class Writer
+      def initialize(fd, dataset, options)
+        @file = fd
+        @dataset = dataset
+        @options = options
+      end
+    
+      class ::Date; def to_export(q); ; end; end
+      class ::DateTime; def to_export(q); "#{q}#{iso8601}#{q}"; end; end
+      class ::Time; def to_export(q); "#{q}#{iso8601}#{q}"; end; end
+      class ::Float; def to_export(q); to_f.to_s; end; end
+      class ::BigDecimal; def to_export(q); to_f.to_s; end; end
+      class ::Bignum; def to_export(q); to_i.to_s; end; end
+      class ::Fixnum; def to_export(q); to_i.to_s; end; end
+      class ::Object; def to_export(q); "#{q}#{to_s}#{q}"; end; end
+
+      def output 
+        quot = @options[:quote_char]
+        @columns ||= @dataset.first.keys.sort_by{|x|x.to_s}
+
+        if @options[:headers] == true
+          @file.puts @columns.map{|col| "#{quot}#{col}#{quot}"}.join(@options[:delimiter])
+        end
+        
+        @dataset.each do |row| 
+          data = @columns.map do |col|
+            case row[col]
+            when Date, DateTime, Time then "#{quot}#{row[col].iso8601}#{quot}"
+            when Float, BigDecimal then row[col].to_f
+            when BigDecimal, Bignum, Fixnum then row[col].to_i
+            else "#{quot}#{row[col].to_s}#{quot}"
+            end
+          end
+          @file.puts data.join(@options[:delimiter])
+        end
+      end
+
+      def build_row(row) 
+        quot = @options[:quote_char] 
+        @columns.map{|col| row[col].to_export(quot)}.join(@options[:delimiter])
+      end
+    end  # Writer
+  end  # Export 
+end  # Sequel 
+

data/lib/sequel_plus.rb

@@ -1,2 +1,2 @@
 require 'sequel_tree'
-require 'extensions/export'
+require File.join(File.dirname(__FILE__), 'extensions', 'export')

data/lib/sequel_tree.rb

@@ -61,7 +61,7 @@ module Sequel
         #   subchild1.ancestors # => [child1, root]
         def descendants
           nodes = self.children
-          self.children.each{|c| nodes + c.descendants}
+          nodes.each{|child| nodes + child.descendants}
           nodes 
         end
 

data/test/test_export.rb

@@ -1,58 +1,164 @@
 require 'helper'
 require 'sequel_plus'
 
-DB = Sequel.sqlite
-
-DB.create_table :nodes do
-  primary_key :id
-  String :name
-  Integer :parent_id
-  Integer :position 
-end
-
-NODES = [
-  {:id => 1, :name => 'one', :parent_id => nil, :position => 1}, 
-  {:id => 2, :name => 'two', :parent_id => nil, :position => 2}, 
-  {:id => 3, :name => 'three', :parent_id => nil, :position => 3}, 
-  {:id => 4, :name => "two.one", :parent_id => 2, :position => 1},
-  {:id => 5, :name => "two.two", :parent_id => 2, :position => 2},
-  {:id => 6, :name => "two.two.one", :parent_id => 5, :position => 1},
-  {:id => 7, :name => "one.two", :parent_id => 1, :position => 2},
-  {:id => 8, :name => "one.one", :parent_id => 1, :position => 1},
-  {:id => 9, :name => "five", :parent_id => nil, :position => 5},
-  {:id => 10, :name => "four", :parent_id => nil, :position => 4},
-  {:id => 11, :name => "five.one", :parent_id => 9, :position => 1},
-  {:id => 12, :name => "two.three", :parent_id => 2, :position => 3},
-]
-
-DB.create_table :lorems do
-  primary_key :id
-  String :name
-  Integer :ipsum_id
-  Integer :neque
-end
-
-LOREMS = [
-  {:id => 1, :name => 'Lorem', :ipsum_id => nil, :neque => 4}, 
-  {:id => 2, :name => 'Ipsum', :ipsum_id => nil, :neque => 3}, 
-  {:id => 4, :name => "Neque", :ipsum_id => 2, :neque => 2},
-  {:id => 5, :name => "Porro", :ipsum_id => 2, :neque => 1},
-]  
-
-NODES.each{|node| DB[:nodes].insert(node)}
-LOREMS.each{|lorem| DB[:lorems].insert(lorem)}
-
-describe Sequel::Export do
+module ExportTest
   
-  it "should instantiate" do
-    DB[:nodes].all.size.should == 12
+  DB = Sequel.sqlite
+
+  DB.create_table :nodes do
+    primary_key :id
+    String :name
+    Integer :parent_id
+    Integer :position 
   end
 
-  it "should export everything" do 
-    DB[:nodes].export.should == "id\tname\tparent_id\tposition\n1\tone\t\t1\n2\ttwo\t\t2\n3\tthree\t\t3\n4\ttwo.one\t2\t1\n5\ttwo.two\t2\t2\n6\ttwo.two.one\t5\t1\n7\tone.two\t1\t2\n8\tone.one\t1\t1\n9\tfive\t\t5\n10\tfour\t\t4\n11\tfive.one\t9\t1\n12\ttwo.three\t2\t3"
+  NODES = [
+    {:id => 1, :name => 'one', :parent_id => nil, :position => 1}, 
+    {:id => 2, :name => 'two', :parent_id => nil, :position => 2}, 
+    {:id => 3, :name => 'three', :parent_id => nil, :position => 3}, 
+    {:id => 4, :name => "two.one", :parent_id => 2, :position => 1},
+    {:id => 5, :name => "two.two", :parent_id => 2, :position => 2},
+    {:id => 6, :name => "two.two.one", :parent_id => 5, :position => 1},
+    {:id => 7, :name => "one.two", :parent_id => 1, :position => 2},
+    {:id => 8, :name => "one.one", :parent_id => 1, :position => 1},
+    {:id => 9, :name => "five", :parent_id => nil, :position => 5},
+    {:id => 10, :name => "four", :parent_id => nil, :position => 4},
+    {:id => 11, :name => "five.one", :parent_id => 9, :position => 1},
+    {:id => 12, :name => "two.three", :parent_id => 2, :position => 3},
+  ]
+
+  DB.create_table :lorems do
+    primary_key :id
+    String :name
+    Integer :ipsum_id
+    Integer :neque
   end
+
+  LOREMS = [
+    {:id => 1, :name => 'Lorem', :ipsum_id => nil, :neque => 4}, 
+    {:id => 2, :name => 'Ipsum', :ipsum_id => nil, :neque => 3}, 
+    {:id => 4, :name => "Neque", :ipsum_id => 2, :neque => 2},
+    {:id => 5, :name => "Porro", :ipsum_id => 2, :neque => 1},
+  ]  
+
+  NODES.each{|node| DB[:nodes].insert(node)}
+  LOREMS.each{|lorem| DB[:lorems].insert(lorem)}
+
+  describe Sequel::Export do
   
-  it "should export selected" do 
-    DB[:nodes].filter(:id < 3).select(:id, :name).export.should == "id\tname\n1\tone\n2\ttwo"
+    it "should instantiate" do
+      DB[:nodes].all.size.should == 12
+    end
+
+    it "should export everything" do 
+      mem_stream = StringIO.new("", "w+")
+      DB[:nodes].export(mem_stream)
+      mem_stream.pos = 0
+      mem_stream.read.should == <<-TEXT
+"id"	"name"	"parent_id"	"position"
+1	"one"	""	1
+2	"two"	""	2
+3	"three"	""	3
+4	"two.one"	2	1
+5	"two.two"	2	2
+6	"two.two.one"	5	1
+7	"one.two"	1	2
+8	"one.one"	1	1
+9	"five"	""	5
+10	"four"	""	4
+11	"five.one"	9	1
+12	"two.three"	2	3
+      TEXT
+    end
+
+    it "should export everything with comma delimiter" do 
+      mem_stream = StringIO.new("", "w+")
+      DB[:nodes].export(mem_stream, :delimiter => ',')
+      mem_stream.pos = 0
+      mem_stream.read.should == <<-TEXT
+"id","name","parent_id","position"
+1,"one","",1
+2,"two","",2
+3,"three","",3
+4,"two.one",2,1
+5,"two.two",2,2
+6,"two.two.one",5,1
+7,"one.two",1,2
+8,"one.one",1,1
+9,"five","",5
+10,"four","",4
+11,"five.one",9,1
+12,"two.three",2,3
+      TEXT
+    end
+      
+    it "should export everything with comma delimiter and no quote characters" do 
+      mem_stream = StringIO.new("", "w+")
+      DB[:nodes].export(mem_stream, :delimiter => ',', :quote_char => '')
+      mem_stream.pos = 0
+      mem_stream.read.should == <<-TEXT
+id,name,parent_id,position
+1,one,,1
+2,two,,2
+3,three,,3
+4,two.one,2,1
+5,two.two,2,2
+6,two.two.one,5,1
+7,one.two,1,2
+8,one.one,1,1
+9,five,,5
+10,four,,4
+11,five.one,9,1
+12,two.three,2,3
+      TEXT
+    end
+    
+    it "should export selected" do 
+      mem_stream = StringIO.new("", "w+")
+      DB[:nodes].filter(:id < 3).select(:id, :name).export(mem_stream)
+      mem_stream.pos = 0
+      mem_stream.read.should == "\"id\"\t\"name\"\n1\t\"one\"\n2\t\"two\"\n"
+    end
+
+    it "should not export headers" do 
+      mem_stream = StringIO.new("", "w+")
+      DB[:nodes].export(mem_stream, :headers => false)
+      mem_stream.pos = 0
+      mem_stream.read.should == <<-TEXT
+1	"one"	""	1
+2	"two"	""	2
+3	"three"	""	3
+4	"two.one"	2	1
+5	"two.two"	2	2
+6	"two.two.one"	5	1
+7	"one.two"	1	2
+8	"one.one"	1	1
+9	"five"	""	5
+10	"four"	""	4
+11	"five.one"	9	1
+12	"two.three"	2	3
+      TEXT
+    end
+    
+    it "should explicitly export headers" do 
+      mem_stream = StringIO.new("", "w+")
+      DB[:nodes].export(mem_stream, :headers => true)
+      mem_stream.pos = 0
+      mem_stream.read.should == <<-TEXT
+"id"	"name"	"parent_id"	"position"
+1	"one"	""	1
+2	"two"	""	2
+3	"three"	""	3
+4	"two.one"	2	1
+5	"two.two"	2	2
+6	"two.two.one"	5	1
+7	"one.two"	1	2
+8	"one.one"	1	1
+9	"five"	""	5
+10	"four"	""	4
+11	"five.one"	9	1
+12	"two.three"	2	3
+      TEXT
+    end
   end
-end
+end

data/test/test_sequel_tree.rb

@@ -1,157 +1,159 @@
 require 'helper'
 
-DB = Sequel.sqlite
+module SequelTreeTest
+  DB = Sequel.sqlite
 
-DB.create_table :nodes do
-  primary_key :id
-  String :name
-  Integer :parent_id
-  Integer :position 
-end
+  DB.create_table :nodes do
+    primary_key :id
+    String :name
+    Integer :parent_id
+    Integer :position 
+  end
 
-NODES = [
-  {:id => 1, :name => 'one', :parent_id => nil, :position => 1}, 
-  {:id => 2, :name => 'two', :parent_id => nil, :position => 2}, 
-  {:id => 3, :name => 'three', :parent_id => nil, :position => 3}, 
-  {:id => 4, :name => "two.one", :parent_id => 2, :position => 1},
-  {:id => 5, :name => "two.two", :parent_id => 2, :position => 2},
-  {:id => 6, :name => "two.two.one", :parent_id => 5, :position => 1},
-  {:id => 7, :name => "one.two", :parent_id => 1, :position => 2},
-  {:id => 8, :name => "one.one", :parent_id => 1, :position => 1},
-  {:id => 9, :name => "five", :parent_id => nil, :position => 5},
-  {:id => 10, :name => "four", :parent_id => nil, :position => 4},
-  {:id => 11, :name => "five.one", :parent_id => 9, :position => 1},
-  {:id => 12, :name => "two.three", :parent_id => 2, :position => 3},
-]
+  NODES = [
+    {:id => 1, :name => 'one', :parent_id => nil, :position => 1}, 
+    {:id => 2, :name => 'two', :parent_id => nil, :position => 2}, 
+    {:id => 3, :name => 'three', :parent_id => nil, :position => 3}, 
+    {:id => 4, :name => "two.one", :parent_id => 2, :position => 1},
+    {:id => 5, :name => "two.two", :parent_id => 2, :position => 2},
+    {:id => 6, :name => "two.two.one", :parent_id => 5, :position => 1},
+    {:id => 7, :name => "one.two", :parent_id => 1, :position => 2},
+    {:id => 8, :name => "one.one", :parent_id => 1, :position => 1},
+    {:id => 9, :name => "five", :parent_id => nil, :position => 5},
+    {:id => 10, :name => "four", :parent_id => nil, :position => 4},
+    {:id => 11, :name => "five.one", :parent_id => 9, :position => 1},
+    {:id => 12, :name => "two.three", :parent_id => 2, :position => 3},
+  ]
 
-DB.create_table :lorems do
-  primary_key :id
-  String :name
-  Integer :ipsum_id
-  Integer :neque
-end
+  DB.create_table :lorems do
+    primary_key :id
+    String :name
+    Integer :ipsum_id
+    Integer :neque
+  end
 
-LOREMS = [
-  {:id => 1, :name => 'Lorem', :ipsum_id => nil, :neque => 4}, 
-  {:id => 2, :name => 'Ipsum', :ipsum_id => nil, :neque => 3}, 
-  {:id => 4, :name => "Neque", :ipsum_id => 2, :neque => 2},
-  {:id => 5, :name => "Porro", :ipsum_id => 2, :neque => 1},
-]  
+  LOREMS = [
+    {:id => 1, :name => 'Lorem', :ipsum_id => nil, :neque => 4}, 
+    {:id => 2, :name => 'Ipsum', :ipsum_id => nil, :neque => 3}, 
+    {:id => 4, :name => "Neque", :ipsum_id => 2, :neque => 2},
+    {:id => 5, :name => "Porro", :ipsum_id => 2, :neque => 1},
+  ]  
 
-NODES.each{|node| DB[:nodes].insert(node)}
-LOREMS.each{|lorem| DB[:lorems].insert(lorem)}
+  NODES.each{|node| DB[:nodes].insert(node)}
+  LOREMS.each{|lorem| DB[:lorems].insert(lorem)}
 
-class Node < Sequel::Model
-  plugin :tree
-end
+  class Node < Sequel::Model
+    plugin :tree
+  end
 
-class NaturalNode < Sequel::Model(:nodes)
-  plugin :tree
-end
+  class NaturalNode < Sequel::Model(:nodes)
+    plugin :tree
+  end
 
-class OrderedNode < Sequel::Model(:nodes)
-  plugin :tree, :order => :position
-end
+  class OrderedNode < Sequel::Model(:nodes)
+    plugin :tree, :order => :position
+  end
 
-class Lorem < Sequel::Model
-  plugin :tree, :key => :ipsum_id, :order => :neque
-end
+  class Lorem < Sequel::Model
+    plugin :tree, :key => :ipsum_id, :order => :neque
+  end
 
-describe Sequel::Plugins::Tree do
+  describe Sequel::Plugins::Tree do
   
-  it "should instantiate" do
-    Node.all.size.should == 12
-  end
+    it "should instantiate" do
+      Node.all.size.should == 12
+    end
   
-  it "should find top level nodes" do
-    Node.roots.count.should == 5
-  end
+    it "should find top level nodes" do
+      Node.roots.count.should == 5
+    end
   
-  it "should find all descendants of a node" do 
-    two = Node.find(:id => 2)
-    two.name.should == "two"
-    two.descendants.map{|m| m[:id]}.should == [4, 5, 12]
-  end
+    it "should find all descendants of a node" do 
+      two = Node.find(:id => 2)
+      two.name.should == "two"
+      two.descendants.map{|m| m[:id]}.should == [4, 5, 12]
+    end
   
-  it "should find all ancestors of a node" do 
-    twotwoone = Node.find(:id => 6)
-    twotwoone.name.should == "two.two.one"
-    twotwoone.ancestors.map{|m| m[:id]}.should == [5, 2]
-  end
+    it "should find all ancestors of a node" do 
+      twotwoone = Node.find(:id => 6)
+      twotwoone.name.should == "two.two.one"
+      twotwoone.ancestors.map{|m| m[:id]}.should == [5, 2]
+    end
     
-  it "should find all siblings of a node, excepting self" do 
-    twoone = Node.find(:id => 4)
-    twoone.name.should == "two.one"
-    twoone.siblings.map{|m| m[:id]}.should == [5, 12]
-  end
+    it "should find all siblings of a node, excepting self" do 
+      twoone = Node.find(:id => 4)
+      twoone.name.should == "two.one"
+      twoone.siblings.map{|m| m[:id]}.should == [5, 12]
+    end
   
-  it "should find all siblings of a node, including self" do 
-    twoone = Node.find(:id => 4)
-    twoone.name.should == "two.one"
-    twoone.self_and_siblings.map{|m| m[:id]}.should == [4, 5, 12]
-  end
+    it "should find all siblings of a node, including self" do 
+      twoone = Node.find(:id => 4)
+      twoone.name.should == "two.one"
+      twoone.self_and_siblings.map{|m| m[:id]}.should == [4, 5, 12]
+    end
   
-  it "should find siblings for root nodes" do 
-    three = Node.find(:id => 3)
-    three.name.should == "three"
-    three.self_and_siblings.map{|m| m[:id]}.should == [1, 2, 3, 9, 10]
-  end
+    it "should find siblings for root nodes" do 
+      three = Node.find(:id => 3)
+      three.name.should == "three"
+      three.self_and_siblings.map{|m| m[:id]}.should == [1, 2, 3, 9, 10]
+    end
   
-  it "should find correct root for a node" do
-    twotwoone = Node.find(:id => 6)
-    twotwoone.name.should == "two.two.one"
-    twotwoone.root[:id].should == 2
+    it "should find correct root for a node" do
+      twotwoone = Node.find(:id => 6)
+      twotwoone.name.should == "two.two.one"
+      twotwoone.root[:id].should == 2
     
-    three = Node.find(:id => 3)
-    three.name.should == "three"
-    three.root[:id].should == 3
+      three = Node.find(:id => 3)
+      three.name.should == "three"
+      three.root[:id].should == 3
     
-    fiveone = Node.find(:id => 11)
-    fiveone.name.should == "five.one"
-    fiveone.root[:id].should == 9
-  end
-  
-  describe "Nodes in natural database order" do
-    it "iterate top-level nodes in natural database order" do
-      NaturalNode.roots.count.should == 5
-      NaturalNode.roots.inject([]){|ids, p| ids << p.position}.should == [1, 2, 3, 5, 4]
+      fiveone = Node.find(:id => 11)
+      fiveone.name.should == "five.one"
+      fiveone.root[:id].should == 9
     end
+  
+    describe "Nodes in natural database order" do
+      it "iterate top-level nodes in natural database order" do
+        NaturalNode.roots.count.should == 5
+        NaturalNode.roots.inject([]){|ids, p| ids << p.position}.should == [1, 2, 3, 5, 4]
+      end
     
-    it "should have children" do
-      one = NaturalNode.find(:id => 1)
-      one.name.should == "one"
-      one.children.count.should == 2
-    end
+      it "should have children" do
+        one = NaturalNode.find(:id => 1)
+        one.name.should == "one"
+        one.children.count.should == 2
+      end
     
-    it "children should be natural database order" do 
-      one = NaturalNode.find(:id => 1)
-      one.name.should == "one"
-      one.children.map{|m| m[:position]}.should == [2, 1]
+      it "children should be natural database order" do 
+        one = NaturalNode.find(:id => 1)
+        one.name.should == "one"
+        one.children.map{|m| m[:position]}.should == [2, 1]
+      end
     end
-  end
 
-  describe "Nodes in specified order" do
-    it "iterate top-level nodes in order by position" do
-      OrderedNode.roots.count.should == 5
-      OrderedNode.roots.inject([]){|ids, p| ids << p.position}.should == [1, 2, 3, 4, 5]
-    end
+    describe "Nodes in specified order" do
+      it "iterate top-level nodes in order by position" do
+        OrderedNode.roots.count.should == 5
+        OrderedNode.roots.inject([]){|ids, p| ids << p.position}.should == [1, 2, 3, 4, 5]
+      end
 
-    it "children should be in specified order" do 
-      one = OrderedNode.find(:id => 1)
-      one.name.should == "one"
-      one.children.map{|m| m[:position]}.should == [1, 2]
+      it "children should be in specified order" do 
+        one = OrderedNode.find(:id => 1)
+        one.name.should == "one"
+        one.children.map{|m| m[:position]}.should == [1, 2]
+      end
     end
-  end
   
-  describe "Lorems in specified order" do
-    it "iterate top-level nodes in order by position" do
-      Lorem.roots.count.should == 2
-      Lorem.roots.inject([]){|ids, p| ids << p.neque}.should == [3, 4]
-    end
+    describe "Lorems in specified order" do
+      it "iterate top-level nodes in order by position" do
+        Lorem.roots.count.should == 2
+        Lorem.roots.inject([]){|ids, p| ids << p.neque}.should == [3, 4]
+      end
 
-    it "children should be specified order" do 
-      one = Lorem.find(:id => 2)
-      one.children.map{|m| m[:neque]}.should == [1, 2]
+      it "children should be specified order" do 
+        one = Lorem.find(:id => 2)
+        one.children.map{|m| m[:neque]}.should == [1, 2]
+      end
     end
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sequel_plus
 version: !ruby/object:Gem::Version 
-  version: 0.0.6
+  version: 0.1.0
 platform: ruby
 authors: 
 - Michael Lang
@@ -45,6 +45,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- lib/extensions/export.rb
 - lib/sequel_plus.rb
 - lib/sequel_tree.rb
 - test/helper.rb