jiji 1.2.5

data/lib/jiji/dao/file_system_dao.rb

@@ -0,0 +1,158 @@
+
+require 'fileutils'
+require 'jiji/error'
+
+module JIJI
+  module Dao
+
+    #ファイルシステムにデータを保存するDAO
+    class FileSystemDao
+
+      #コンストラクタ
+      #base:: 保存先の基点となるディレクトリ
+      def initialize( base )
+        @base = base
+      end
+
+      #パスが示すファイルのデータを取得する。
+      def get( path )
+        path = validate_path( path, :exist, :is_file )
+        return FileLock.new(path).readlock {|f|
+          f.read
+        }
+      end
+
+      #パスが示すフォルダ配下の一覧を取得する。
+      def list( path="", recursive=false )
+        path = validate_path( path, :exist, :is_directory )
+        Dir.glob( "#{path}/#{recursive ? '**/*' : '*' }" ).map {|item|
+          next if File.basename(item) =~ /^\..*/
+          { :path  =>item.sub( /^#{@base}\//, "" ),
+            :name  =>File.basename(item),
+            :update=>File.mtime(item).to_i,
+            :type  =>File.directory?(item) ? :directory : :file}
+        }.sort_by {|item| "#{item[:type]}/#{item[:path]}" }
+      end
+
+      #ファイルを追加する。
+      def add( path, body )
+        validate_path( path, :exist_parent, :not_exist )
+        put( path, body )
+        :success
+      end
+
+      #ファイルを追加/更新する。
+      def put( path, body )
+        path = validate_path( path, :exist_parent, :is_file )
+        FileLock.new(path).writelock {|f|
+          f << body
+        }
+        :success
+      end
+
+      #ファイルまたはディレクトリを破棄する
+      def delete( path )
+        path = validate_path( path, :exist )
+        if ( File.file? path )
+          FileLock.new(path).writelock {|f|
+            FileUtils.rm_rf path
+          }
+        else
+          FileUtils.rm_rf path
+        end
+        :success
+      end
+
+
+      #ファイル/フォルダを移動する
+      def move( from, to )
+        from = validate_path( from, :exist )
+        to = validate_path( to, :exist, :is_directory )
+        FileUtils.mv from, to
+        :success
+      end
+
+      #ファイル/フォルダをリネームする
+      def rename( from, to )
+        from = validate_path( from, :exist )
+        to = validate_path( to, :not_exist )
+        FileUtils.mv from, to
+        :success
+      end
+
+      #ファイル/フォルダをコピーする
+      def copy( from, to )
+        from = validate_path( from, :exist )
+        to = validate_path( to )
+        FileUtils.cp_r from, to
+        :success
+      end
+
+      #フォルダを作成する
+      def mkcol(path)
+        path = validate_path( path, :exist_parent, :not_exist )
+        FileUtils.mkdir_p path
+        :success
+      end
+
+      #ディレクトリかどうか評価する。
+      def directory?(path)
+        path = validate_path( path, :exist )
+        File.directory?(path)
+      end
+
+      #データ保存先の基点となるディレクトリ
+      attr_reader :base
+
+    private
+      #パスを正規化する
+      #steps:: パスを示す文字列
+      #return:: 正規化されたパス(baseからの絶対パス)
+      def validate_path( path, *options )
+        # パスの文字列をチェック。
+        steps = path.split( /\/+/ ).map{|str| str.strip }
+        steps.each {|step|
+          if !step || step.length <= 0 || step.strip.length <= 0
+            raise JIJI::UserError.new( JIJI::ERROR_ILLEGAL_NAME, "illegal file or directory name. name=#{step}" )
+          end
+          unless step =~ VALID_FILE_NAME
+            raise JIJI::UserError.new( JIJI::ERROR_ILLEGAL_NAME, "illegal file or directory name. name=#{step}" )
+          end
+          if step =~ /^\.+$/
+            raise JIJI::UserError.new( JIJI::ERROR_ILLEGAL_NAME, "illegal file or directory name. name=#{step}" )
+          end
+          if step =~ /^\..*/
+            raise JIJI::UserError.new( JIJI::ERROR_ILLEGAL_NAME, "illegal file or directory name. name=#{step}" )
+          end
+        }
+        #ファイルパス構築
+        file = "#{@base}#{ steps.empty? ? "" : "/" + steps.join( "/" )}"
+        parent = File.dirname( file )
+
+        #オプションのチェック
+        op = options.inject({}){|h,o| h[o] = true; h }
+        if op.key?(:is_directory) && File.exist?( file )
+          unless File.directory?( file )
+            raise JIJI::UserError.new( JIJI::ERROR_IS_NOT_FOLDER, "target is not a folder. path=#{file}" )
+          end
+        end
+        if op.key?(:is_file) && File.exist?( file )
+          unless File.file?( file )
+            raise JIJI::UserError.new( JIJI::ERROR_IS_NOT_FILE, "target is not a file. path=#{file}" )
+          end
+        end
+        if op.key?(:exist) && !File.exist?( file )
+          raise JIJI::UserError.new( JIJI::ERROR_NOT_FOUND, "file or directory is not found. path=#{file}" )
+        end
+         if op.key?(:not_exist) && File.exist?( file )
+          raise JIJI::UserError.new( JIJI::ERROR_ALREADY_EXIST, "file or directory is already exist. path=#{file}" )
+        end
+        if op.key?(:exist_parent) && !( File.exist?( parent ) && File.directory?( parent ))
+          raise JIJI::UserError.new( JIJI::ERROR_NOT_FOUND, "directory is not found. directory=#{parent}" )
+        end
+        return file
+      end
+      VALID_FILE_NAME = /^[A-Za-z0-9_\+\-\#\'\!\~\(\)\[\]\.\{\}]+$/
+    end
+  end
+end

data/lib/jiji/dao/rate_dao.rb

@@ -0,0 +1,149 @@
+
+require 'thread'
+require 'jiji/util/csv_append_support'
+require 'jiji/util/util'
+require 'jiji/models'
+require 'jiji/dao/timed_data_dao'
+
+module JIJI
+  module Dao
+
+    # レートDAO
+    class RateDao
+
+      def initialize( data_dir, scales=[] )
+        @data_dir = data_dir
+        @scales = scales
+        @daos = {}
+        @mutex = Mutex.new
+      end
+
+      # 所定の期間のレートデータを得る。
+      def each( scale=:raw, pair=:USDJPY, start_date=nil, end_date=nil )
+        dao( pair ).each_data( scale, start_date, end_date ) {|row,time|
+           yield row
+        }
+      end
+
+      # 所定の期間のすべての通貨ペアのレートデータを得る。
+      def each_all_pair_rates( scale=:raw, start_date=nil, end_date=nil, &block )
+        pairs = list_pairs
+        its  = nil
+        begin
+          its = pairs.map {|p|
+            dao(p).each_data( scale,start_date,end_date )
+          }
+          _each_all_pair_rates( pairs, its, &block )
+        ensure
+          its.each {|i| i.close } if its
+        end
+      end
+
+      # 次のレートを追加する。
+      def next_rates( rates )
+        rates.each_pair {|pair,v|
+          dao(pair) << v
+        }
+      end
+
+      # ペアに対応するdaoを取得する
+      def dao(pair)
+        @mutex.synchronize {
+          return @daos[pair] if @daos.key? pair
+
+          dir = "#{@data_dir}/#{pair.to_s}"
+          FileUtils.mkdir_p dir unless File.exists? dir
+
+          aggregators = @scales.map {|s| RatesAggregator.new(s) }
+          aggregators << RawRatesAggregator.new
+
+          @daos[pair] = TimedDataDao.new( dir, aggregators )
+          @daos[pair]
+        }
+      end
+
+      def list_pairs
+        list = []
+        Dir.glob( "#{@data_dir}/*" ) {|d|
+         next unless File.directory? d
+         next unless d =~ /\/([A-Z]+)$/
+         list << $1
+        }
+        list
+      end
+
+    private
+      def _each_all_pair_rates( pairs, its )
+        buff = PairBuffer.new
+        exist_next = true
+        while( exist_next )
+          exist_next = false
+          its.each_index {|index|
+            it = its[index]
+            if ( it.next? )
+              # 末尾のデータはDAOで使うための日時指定で不要なので取り除く
+              item = it.next
+              item.pop
+              buff.add( pairs[index],  item )
+              exist_next = true
+            else
+              exist_next = exist_next || false
+            end
+          }
+          yield buff.next if buff.next?
+        end
+        yield buff.next while buff.next?
+      end
+
+
+      class RatesAggregator < JIJI::Dao::AbstractAggregator
+        def initialize( scale )
+          super
+        end
+        def aggregate( timed_data )
+          unless @rate
+            @rate = PeriodicallyRate.new
+            @rate.start_time = timed_data.time
+          end
+          @rate << timed_data
+        end
+        def aggregated
+          @rate.end_time = @end
+          vs = @rate
+          @rate = PeriodicallyRate.new
+          @rate.start_time = @end
+          return vs
+        end
+      end
+
+      class RawRatesAggregator < JIJI::Dao::Aggregator
+        def initialize
+          super( "raw" )
+        end
+        def next( timed_data )
+          yield timed_data
+        end
+      end
+
+      class PairBuffer
+        def initialize
+          @buff = {}
+        end
+        def add( pair, data )
+          time = data.last.to_i
+          @buff[time] = {} unless @buff[time]
+          @buff[time][pair.to_sym] = data
+        end
+        def next?
+          @buff.length > 0
+        end
+        def next
+          keys = @buff.keys.sort!
+          @buff.delete keys[0]
+        end
+      end
+
+    end
+  end
+
+end

data/lib/jiji/dao/timed_data_dao.rb

@@ -0,0 +1,336 @@
+require 'jiji/error'
+require 'date'
+require 'jiji/util/csv_append_support'
+require 'jiji/util/file_lock'
+require 'jiji/util/iterator'
+
+module JIJI
+  module Dao
+
+    # 時間を持つデータ
+    module TimedData
+      def values
+        []
+      end
+      attr :time, true
+    end
+
+    BasicTimedData = Struct.new( :values, :time )
+
+    # 時間を持つデータをCSVで記録するためのDao
+    # 　データの記録、
+    # 　一定期間のデータの集約結果の記録、
+    # 　一定期間のデータの読み込み、
+    # をサポート。
+    #
+    class TimedDataDao
+
+      DATE_FORMAT = "%Y-%m-%d"
+      MONTHLY_DATE_FORMAT = "%Y-%m"
+
+      def initialize( root_dir, aggregator=[] )
+        @root_dir = root_dir
+        @aggregator = aggregator
+      end
+
+      # 指定期間のデータを読み込む
+      def each_data( scale=:raw, start_time=nil, end_time=nil, &block )
+        sd = start_time || first_day( scale )
+        ed = end_time || last_day( scale )
+
+        it = ( !sd || !ed ) \
+          ? EmptyIterator.new \
+          : TimedDataIterator.new( scale, sd, ed, self )
+        if block_given?
+          it.each {|row|
+            time = row.pop.to_i
+            block.call( row, time )
+          }
+        else
+          return it
+        end
+      end
+
+      # データを強制的に書き込む
+      # バックテストで取引が完了し場合に使用し、結果を表性的に書き出す。
+      def flush( time )
+        @aggregator.each {|ag|
+          ag_dir = ag_dir(ag)
+          ag.flush( time ) {|data|
+            out( ag, ag_dir, data )
+          }
+        }
+      end
+
+      # データを追加する
+      def <<(timed_data)
+        @aggregator.each {|ag|
+          ag_dir = ag_dir(ag)
+          ag.next( timed_data ) {|data|
+            out( ag, ag_dir, data )
+          }
+        }
+      end
+
+      # 利用可能なデータ一覧を得る
+      def list_data_files( scale, pattern="*" )
+        Dir.glob( "#{@root_dir}/#{scale.to_s}/#{pattern}.csv" ).map{|d| File.basename(d) }.sort!
+      end
+      # 利用可能な最後のデータ
+      def last_day( scale )
+        l = list_data_files( scale )
+        return nil if l.empty?
+        if TimedDataDao.dairy?(scale)
+          to_time( l.last[0..-5], true ) + 24*60*60
+        else
+          to_time( l.last[0..-5], false ) + 24*60*60*31
+        end
+      end
+      # 利用可能な最初のデータ
+      def first_day( scale )
+        l = list_data_files( scale )
+        l.empty? ? nil : to_time( l.first[0..-5], TimedDataDao.dairy?(scale) )
+      end
+      # 利用可能な最後のデータ
+      def last_time( scale )
+        l = list_data_files( scale )
+        return nil if l.empty?
+        date = nil
+        it = each_file_data( "#{@root_dir}/#{scale}/#{l.last}" )
+        it.each { |row|
+          date = row.last
+        }
+        date.to_i
+      end
+      # 利用可能な最初のデータ
+      def first_time( scale )
+        l = list_data_files( scale )
+        return nil if l.empty?
+        date = nil
+        it = each_file_data( "#{@root_dir}/#{scale}/#{l.first}" )
+        it.each { |row|
+          date = row.last
+          break
+        }
+        date.to_i
+      end
+      # 文字列を時刻に変換する
+      def to_time( str, dairy=true )
+        d = DateTime.strptime(str, dairy ? DATE_FORMAT : MONTHLY_DATE_FORMAT)
+        Time.local( d.year, d.month, d.day )
+      end
+      # 時刻を日を示す文字列に変換する
+      def to_date_str( time, dairy=true )
+        time.strftime( dairy ? DATE_FORMAT : MONTHLY_DATE_FORMAT)
+      end
+      def self.dairy?(scale)
+        scale.to_s =~ /^(raw|\d+[smh])$/
+      end
+
+      # 特定の日のデータを列挙する
+      def each_dairy_data( scale, date, start_date=nil, end_date=nil)
+        file = "#{@root_dir}/#{scale}/#{to_date_str(date, TimedDataDao.dairy?(scale))}.csv"
+        each_file_data( file, start_date, end_date )
+      end
+
+      attr_reader :aggregator
+
+    private
+
+      # データを保存する
+      def out( ag, ag_dir, data )
+        date = to_date_str( data.time, TimedDataDao.dairy?(ag.scale) )
+        file = "#{ag_dir}/#{date}.csv"
+        CSV.open( file, 'a' ) {|w|
+          w << ( data.values.map{|i|i.to_s} << data.time.to_i )
+        }
+      end
+
+      # アグリゲーターが使用するデータ保存先ディレクトリを作成する。
+      def ag_dir( ag )
+        dir = "#{@root_dir}/#{ag.scale}"
+        FileUtils.mkdir_p dir unless File.exist? dir
+        return dir
+      end
+
+      # ファイルのデータを列挙する
+      def each_file_data( file, start_date=nil, end_date=nil)
+        return EmptyIterator.new  unless File.exist? file
+        it =  CSVIterator.new( CSV.open( file, 'r' ) )
+        return Filter.new( it ) {|row|
+          time = row.last.to_i
+          if start_date && time < start_date.to_i
+            :next
+          elsif end_date && time > end_date.to_i
+            :break
+          else
+            :true
+          end
+        }
+      end
+    end
+
+    # CSVReaderをIteratorにする。
+    class CSVIterator < Iterator
+      def initialize( reader )
+        super()
+        @reader = reader
+        @item = @reader.shift
+      end
+      def next?
+        !@item.empty?
+      end
+      def next
+        begin
+          @item
+        ensure
+          @item = @reader.shift
+        end
+      end
+      def close
+        @reader.close
+      end
+    end
+
+    # 複数のCSVファイルのデータを順番に読み込む。
+    class TimedDataIterator < Iterator
+      def initialize( scale, start_time, end_time, dao )
+        super()
+        @dao = dao
+        @start_time = start_time
+        @end_time = end_time
+        @scale = scale
+        @current = start_time
+        @current_date = Date.new( @current.year, @current.mon, \
+          TimedDataDao.dairy?(@scale)  ? @current.day : 1 )
+        next_iterator
+      end
+      def next?
+        @it && @it.next?
+      end
+      def next
+        begin
+          @it.next
+        ensure
+          next_iterator unless @it.next?
+        end
+      end
+      def close
+        @it.close if @it
+      end
+      def next_iterator
+        @it.close if @it
+        @it = nil
+        while ( @current.to_f <= @end_time.to_f )
+          begin
+            it = @dao.each_dairy_data( @scale, @current, @start_time, @end_time)
+            if it != nil && it.next?
+              @it = it
+              return
+            else
+              it.close
+            end
+          ensure
+            @current_date = TimedDataDao.dairy?(@scale) ? @current_date+1 : @current_date >> 1
+            @current = Time.local(@current_date.year, @current_date.mon, @current_date.day)
+          end
+        end
+      end
+    end
+
+    # 一定期間のデータを集約するクラス
+    class Aggregator
+      def initialize( scale )
+        @scale = scale
+      end
+      # データを受け取り、集約したデータがある場合、それを引数としてブロックを実行する。
+      def next( timed_data )
+      end
+      # 集約したデータがある場合、それを引数としてブロックを実行する。
+      def flush( time )
+      end
+      attr_reader :scale
+    end
+
+    # 集約を行なわないAggregator
+    class RawAggregator < Aggregator
+      def initialize
+        super("raw")
+      end
+      def next( timed_data )
+        yield timed_data
+      end
+    end
+
+    # 一定期間のデータを集約するクラス
+    class AbstractAggregator < Aggregator
+      def initialize( scale )
+        super
+        @period = JIJI::Util.parse_scale(scale)
+        @next = nil
+      end
+      # データを受け取り、集約したデータがある場合、それを引数としてブロックを実行する。
+      def next( timed_data )
+        now = timed_data.time
+        unless @next
+          @next = Time.at(((now.to_i / @period)+1) * @period )
+          @start = Time.at(@next.to_i-@period)
+        end
+        aggregate( timed_data )
+        if now >= @next
+          @end = @next
+          yield aggregated
+          @start = @next
+          @end = nil
+          @next += @period while @next <= now
+        end
+      end
+      def flush( time )
+        return unless @next #一度もnextが呼ばれていない場合、何もしない
+        
+        @end = time
+        yield aggregated
+        @start = @next
+        @end = nil
+        @next += @period while @next <= time
+      end
+      def aggregate( timed_data )
+      end
+      def aggregated
+      end
+      def next_date
+        @next
+      end
+      attr_reader :start
+    end
+
+    # 平均を取るAggregator
+    class AvgAggregator < AbstractAggregator
+      def aggregate( timed_data )
+        @values = [] unless @values
+        timed_data.values.each_index {|i|
+          @values[i] = [] unless @values[i]
+          @values[i] << timed_data.values[i]
+        }
+      end
+      def aggregated
+        avgs = @values.map{|vs|
+          vs.inject(0){|t,v| t+=v }/vs.length
+        }
+        @values = []
+        BasicTimedData.new(avgs + [@start.to_i, @end.to_i], @end)
+      end
+    end
+
+    # 最後の値を返すAggregator
+    class LastAggregator < AbstractAggregator
+      def aggregate( timed_data )
+        @values = timed_data.values
+      end
+      def aggregated
+        BasicTimedData.new( @values + [@start.to_i, @end.to_i], @end)
+      end
+    end
+
+  end
+end