active_tsv 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fa1189fb2be4c0a87c3e95522ea91a23cf35f956
-  data.tar.gz: 18aa344f90494fe0a3d42ae74688a2771598eed9
+  metadata.gz: 7aace3a8490ac510480e630683114815b46ce0a8
+  data.tar.gz: 5e3c803aa0ce4e2df7b7cadc95e4bb9d07b57270
 SHA512:
-  metadata.gz: c905b4740b81faf9f7068c5da07f4b1f5805cee13fa1667ce2f05d6bbf190481e71bdfd0819af2402202d79b77da6f37b371c5b4d2541be1d4c6b994b6bd00f4
-  data.tar.gz: 14d82e1931e8aaee4643d5a2caa6ec443d269d7bee6c5b130a0b34f68ef254ec131fa6482c3db7d2ed1a5d521ad5cfea5792a4f6fe8967a4f17d8b3f2ac96419
+  metadata.gz: 5ed85bc2c763103d1f036910a1fe8c6a7effc47838b8666d0ce06c1d8b93b931cebd918b735627206714a0cdcf7294f54e24ab93953f615ab1cfa600b2399185
+  data.tar.gz: e6b13eff65621c3ce3f995e80c94ca00ad0c5280667f82daaa0285821d06d564a7aa180b822fed07e2107bcf42fcaa321202442981c61edadf1f59c7a38c753c

data/README.md

@@ -17,25 +17,45 @@ id	name	age
 
 ```ruby
 require 'active_tsv'
+
 class User < ActiveTsv::Base
   self.table_path = "data/users.tsv"
 end
 
+User.all
+=> #<ActiveTsv::Relation [#<User id: "1", name: "ksss", age: "30">, #<User id: "2", name: "foo", age: "29">, #<User id: "3", name: "bar", age: "30">]>
+User.all.to_a
+=> [#<User id: "1", name: "ksss", age: "30">, #<User id: "2", name: "foo", age: "29">, #<User id: "3", name: "bar", age: "30">]
+
 User.first
-#=> #<User {:id=>"1", :name=>"ksss", :age=>"30"}>
+#=> #<User id: "1", name: "ksss", age: "30">
 User.last
-#=> #<User {:id=>"3", :name=>"bar", :age=>"30"}>
+#=> #<User id: "3", name: "bar", age: "30">
+
 User.where(age: 30).each do |user|
   user.name #=> "ksss", "bar"
 end
+
 User.where(age: 30).to_a
-#=> [#<User {:id=>"1", :name=>"ksss", :age=>"30"}>, #<User {:id=>"3", :name=>"bar", :age=>"30"}>]
+#=> [#<User id: "1", name: "ksss", age: "30">, #<User id: "3", name: "bar", age: "30">]
+
 User.where(age: 30).last
-#=> #<User {:id=>"3", :name=>"bar", :age=>"30"}>
+#=> #<User id: "3", name: "bar", age: "30">
+
 User.where(age: 30).where(name: "ksss").first
-#=> #<User {:id=>"1", :name=>"ksss", :age=>"30"}>
+#=> #<User id: "1", name: "ksss", age: "30">
+
 User.where.not(name: "ksss").first
-#=> #<User {:id=>"2", :name=>"foo", :age=>"29"}>
+#=> #<User id: "2", name: "foo", age: "29">
+
+User.group(:age).count
+#=> {"30"=>2, "29"=>1}
+
+User.order(:name).to_a
+#=> [#<User id: "3", name: "bar", age: "30">, #<User id: "2", name: "foo", age: "29">, #<User id: "1", name: "ksss", age: "30">]
+
+User.order(name: :desc).to_a
+=> [#<User id: "1", name: "ksss", age: "30">, #<User id: "2", name: "foo", age: "29">, #<User id: "3", name: "bar", age: "30">]
 ```
 
 Also Supported **CSV**.
@@ -49,7 +69,7 @@ end
 
 ## Goal
 
-Support all methods that like ActiveRecord
+Support all methods of ActiveRecord
 
 ## Installation
 

data/data/benchmark.rb

@@ -0,0 +1,104 @@
+#! /usr/bin/env ruby
+
+require 'active_tsv'
+require 'tempfile'
+require 'active_hash'
+require 'csv'
+require 'objspace'
+require 'stringio'
+
+module ActiveHashTsv
+  class Base < ActiveFile::Base
+    SEPARATER = "\t"
+    extend ActiveFile::HashAndArrayFiles
+    class << self
+      def load_file
+        raw_data
+      end
+
+      def extension
+        "tsv"
+      end
+
+      private
+
+      def load_path(path)
+        data = []
+        CSV.open(path, col_sep: self::SEPARATER) do |csv|
+          keys = csv.gets.map(&:to_sym)
+          while line = csv.gets
+            data << keys.zip(line).to_h
+          end
+        end
+        data
+      end
+    end
+  end
+end
+
+def open_csv_with_temp_table(n)
+  headers = [*'a'..'j']
+  Tempfile.create(["", ".tsv"]) do |f|
+    f.puts headers.join("\t")
+    n.times do |i|
+      f.puts [*1..(headers.length)].map{ |j| i * j }.join("\t")
+    end
+    f.close
+    yield f.path
+  end
+end
+io = StringIO.new
+$stdout = io
+def b
+  GC.start
+  before = ObjectSpace.memsize_of_all
+  realtime = Benchmark.realtime {
+    yield
+  }
+  GC.start
+  mem = (ObjectSpace.memsize_of_all - before).to_f
+  [realtime, mem]
+end
+puts "title\tActiveHash\tActiveTsv\ttActiveHash\ttActiveTsv"
+ns = [100, 200, 300, 400, 500]
+ns.each do |n|
+  open_csv_with_temp_table(n) do |path|
+    hr, hm = b {
+      h = Class.new(ActiveHashTsv::Base) do
+        set_root_path File.dirname(path)
+        set_filename File.basename(path).sub(/\..*/, '')
+      end
+      h.all.each {}
+    }
+    tr, tm = b {
+      t = Class.new(ActiveTsv::Base) do
+        self.table_path = path
+      end
+      t.all.each {}
+    }
+    puts sprintf("%d\t%0.5f\t%0.5f\t%d\t%d", n, hr, tr, hm, tm)
+
+    hr, hm = b {
+      h = Class.new(ActiveHashTsv::Base) do
+        set_root_path File.dirname(path)
+        set_filename File.basename(path).sub(/\..*/, '')
+      end
+      h.where(a: '10').first
+    }
+
+    tr, tm = b {
+      t = Class.new(ActiveTsv::Base) do
+        self.table_path = path
+      end
+      t.where(a: '10').first
+    }
+    puts sprintf("%d\t%0.5f\t%0.5f\t%d\t%d", n, hr, tr, hm, tm)
+  end
+end
+$stdout = STDOUT
+io.rewind
+puts io.gets
+lines = io.each_line.to_a
+2.times do |i|
+  puts lines.values_at(i, i+2, i+4, i+6, i+8)
+end

data/data/users.tsv

@@ -1,4 +1,4 @@
 id	name	age
-1	ksss	30
+1	"ksss"	30
 2	foo	29
 3	bar	30

data/lib/active_tsv/base.rb

@@ -7,9 +7,10 @@ module ActiveTsv
   #   end
   class Base
     SEPARATER = "\t"
-    BUF_SIZE = 1024
 
     class << self
+      include Querying
+
       attr_reader :table_path
 
       def table_path=(path)
@@ -33,31 +34,11 @@ module ActiveTsv
       end
 
       def all
-        Relation.new(self, [])
+        Relation.new(self)
       end
 
-      def first
-        first_value = open { |csv| csv.gets; csv.gets }
-        new(keys.zip(first_value).to_h)
-      end
-
-      def last
-        last_value = File.open(table_path) do |f|
-          f.seek(0, IO::SEEK_END)
-          size = f.size
-          buf_size = [size, self::BUF_SIZE].min
-          while true
-            f.seek(-buf_size, IO::SEEK_CUR)
-            buf = f.read(buf_size)
-            if index = buf.rindex($INPUT_RECORD_SEPARATOR, -2)
-              f.seek(-buf_size + index + 1, IO::SEEK_CUR)
-              break f.read.chomp
-            else
-              f.seek(-buf_size, IO::SEEK_CUR)
-            end
-          end
-        end
-        new(keys.zip(CSV.new(last_value, col_sep: self::SEPARATER).shift).to_h)
+      def scope(name, proc)
+        define_singleton_method(name, &proc)
       end
 
       def open(&block)
@@ -67,30 +48,21 @@ module ActiveTsv
       def keys
         @keys ||= open { |csv| csv.gets }.map(&:to_sym)
       end
-
-      def where(condition = nil)
-        all.where(condition)
-      end
-
-      def count
-        all.count
-      end
-
-      def order(*columns)
-        all.order(*columns)
-      end
     end
 
     def initialize(attrs = {})
-      unless attrs.kind_of?(Hash)
+      case attrs
+      when Hash
+        @attrs = attrs
+      when Array
+        @attrs = self.class.keys.zip(attrs).to_h
+      else
         raise ArgumentError, "#{attrs.class} is not supported value"
       end
-
-      @attrs = attrs
     end
 
     def inspect
-      "#<#{self.class} #{to_h}>"
+      "#<#{self.class} #{@attrs.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')}>"
     end
 
     def [](key)
@@ -104,5 +76,10 @@ module ActiveTsv
     def to_h
       @attrs.dup
     end
+
+    def ==(other)
+      super || other.instance_of?(self.class) && to_h == other.to_h
+    end
+    alias eql? ==
   end
 end

data/lib/active_tsv/ordering.rb

@@ -0,0 +1,15 @@
+module ActiveTsv
+  Ordering = Struct.new(:column)
+
+  class Ascending < Ordering
+    def to_i
+      1
+    end
+  end
+
+  class Descending < Ordering
+    def to_i
+      -1
+    end
+  end
+end

data/lib/active_tsv/querying.rb

@@ -0,0 +1,12 @@
+module ActiveTsv
+  module Querying
+    METHODS = %i(first last take where count order group pluck)
+    METHODS.each do |m|
+      module_eval <<-DEFINE_METHOD, __FILE__, __LINE__
+        def #{m}(*args, &block)
+          all.#{m}(*args, &block)
+        end
+      DEFINE_METHOD
+    end
+  end
+end

data/lib/active_tsv/relation.rb

@@ -4,12 +4,31 @@ module ActiveTsv
   class Relation
     include Enumerable
 
+    BUF_SIZE = 1024
+    VALID_DIRECTIONS = [:asc, :desc, :ASC, :DESC, "asc", "desc", "ASC", "DESC"]
+
     attr_reader :model
-    attr_reader :where_values
-    def initialize(model, where_values, order_values = [])
+    attr_accessor :where_values
+    attr_accessor :order_values
+    attr_accessor :group_values
+
+    def initialize(model)
       @model = model
-      @where_values = where_values
-      @order_values = order_values
+      @where_values = []
+      @order_values = []
+      @group_values = []
+    end
+
+    def initialize_copy(copy)
+      copy.where_values = where_values.dup
+      copy.order_values = order_values.dup
+      copy.group_values = group_values.dup
+    end
+
+    def ==(other)
+      where_values == other.where_values &&
+        order_values == other.order_values &&
+        group_values == other.group_values
     end
 
     def where(where_value = nil)
@@ -22,16 +41,89 @@ module ActiveTsv
       end
     end
 
+    def pluck(*fields)
+      key_to_value_index = @model.keys.each_with_index.to_h
+      if fields.empty?
+        to_value_a
+      elsif fields.one?
+        field = fields.first
+        to_value_a.map { |v| v[key_to_value_index[field]] }
+      else
+        to_value_a.map { |v| fields.map { |field| v[key_to_value_index[field]] } }
+      end
+    end
+
     def exists?
       !first.nil?
     end
 
+    def first
+      if @order_values.empty?
+        each_model.first
+      else
+        to_a.first
+      end
+    end
+
     def last
-      to_a.last
+      if @where_values.empty? && @order_values.empty?
+        last_value = File.open(@model.table_path) do |f|
+          f.seek(0, IO::SEEK_END)
+          buf_size = [f.size, self.class::BUF_SIZE].min
+          while true
+            f.seek(-buf_size, IO::SEEK_CUR)
+            buf = f.read(buf_size)
+            if index = buf.rindex($INPUT_RECORD_SEPARATOR, -2)
+              f.seek(-buf_size + index + 1, IO::SEEK_CUR)
+              break f.read.chomp
+            else
+              f.seek(-buf_size, IO::SEEK_CUR)
+            end
+          end
+        end
+        @model.new(CSV.new(last_value, col_sep: @model::SEPARATER).shift)
+      else
+        to_a.last
+      end
+    end
+
+    def take(n = nil)
+      if n
+        if @order_values.empty?
+          each_model.take(n)
+        else
+          to_a.take(n)
+        end
+      else
+        first
+      end
+    end
+
+    def count
+      if @group_values.empty?
+        super
+      else
+        h = if @group_values.one?
+          group_by { |i| i[@group_values.first] }
+        else
+          group_by { |i| @group_values.map { |c| i[c] } }
+        end
+        h.each do |k, v|
+          h[k] = v.count
+        end
+        h
+      end
     end
 
     def order(*columns)
-      @order_values += columns
+      @order_values += order_conditions(columns)
+      @order_values.uniq!
+      self
+    end
+
+    def group(*columns)
+      @group_values += columns
+      @group_values.uniq!
       self
     end
 
@@ -40,26 +132,74 @@ module ActiveTsv
     end
 
     def to_a
-      ret = []
-      keys = @model.keys
-      key_to_value_index = keys.each_with_index.map { |k, index| [k, index] }.to_h
+      to_value_a.map { |v| @model.new(v) }
+    end
+
+    def inspect
+      a = to_a.take(11).map(&:inspect)
+      a[10] = '...' if a.length == 11
+
+      "#<#{self.class.name} [#{a.join(', ')}]>"
+    end
+
+    private
+
+    def to_value_a
+      ret = each_value.to_a
+      key_to_value_index = @model.keys.each_with_index.to_h
+      if @order_values.empty?.!
+        ret.sort! do |a, b|
+          @order_values.each.with_index(1) do |order_condition, index|
+            comp = a[key_to_value_index[order_condition.column]] <=> b[key_to_value_index[order_condition.column]]
+            break 0 if comp == 0 && index == @order_values.length
+            break comp * order_condition.to_i if comp != 0
+          end
+        end
+      end
+      ret
+    end
+
+    def each_value
+      return to_enum(__method__) unless block_given?
+
+      key_to_value_index = @model.keys.each_with_index.to_h
       @model.open do |csv|
         csv.gets
         csv.each do |value|
-          ret << @model.new(keys.zip(value).to_h) if @where_values.all? { |cond|
+          yield value if @where_values.all? { |cond|
             cond.values.all? do |k, v|
               value[key_to_value_index[k]].__send__(cond.method_name, v.to_s)
             end
           }
         end
       end
-      if @order_values.empty?
-        ret
-      else
-        ret.sort_by do |i|
-          @order_values.map { |m| i[m] }.join('-')
+    end
+
+    def each_model
+      return to_enum(__method__) unless block_given?
+
+      each_value { |v| yield @model.new(v) }
+    end
+
+    def order_conditions(columns)
+      columns.map { |column|
+        case column
+        when Symbol
+          Ascending.new(column)
+        when Hash
+          column.map do |col, direction|
+            unless VALID_DIRECTIONS.include?(direction)
+              raise ArgumentError, %(Direction "#{direction}" is invalid. Valid directions are: #{VALID_DIRECTIONS})
+            end
+            case direction.downcase.to_sym
+            when :asc
+              Ascending.new(col)
+            when :desc
+              Descending.new(col)
+            end
+          end
         end
-      end
+      }.flatten
     end
   end
 end

data/lib/active_tsv/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveTsv
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/active_tsv.rb

@@ -2,8 +2,10 @@
 
 require 'csv'
 
-require "active_tsv/base"
+require "active_tsv/querying"
 require "active_tsv/relation"
 require "active_tsv/where_chain"
 require "active_tsv/condition"
+require "active_tsv/ordering"
+require "active_tsv/base"
 require "active_tsv/version"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_tsv
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - ksss
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-06 00:00:00.000000000 Z
+date: 2016-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -68,6 +68,8 @@ files:
 - active_tsv.gemspec
 - bin/console
 - bin/setup
+- data/benchmark.png
+- data/benchmark.rb
 - data/names.tsv
 - data/users.csv
 - data/users.tsv
@@ -75,6 +77,8 @@ files:
 - lib/active_tsv.rb
 - lib/active_tsv/base.rb
 - lib/active_tsv/condition.rb
+- lib/active_tsv/ordering.rb
+- lib/active_tsv/querying.rb
 - lib/active_tsv/relation.rb
 - lib/active_tsv/version.rb
 - lib/active_tsv/where_chain.rb
@@ -98,7 +102,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.3
+rubygems_version: 2.6.4
 signing_key: 
 specification_version: 4
 summary: A Class of Active record pattern for TSV/CSV