ccp 0.1.7 → 0.2.0

data/ccp.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency "typed", ">= 0.1.5"
+  s.add_dependency "typed", ">= 0.2.1"
   s.add_dependency "must", ">= 0.2.7"
   s.add_dependency "dsl_accessor", ">= 0.4.0"
 

data/lib/ccp.rb

@@ -1,13 +1,15 @@
 require "typed"
+require "pathname"
 require "dsl_accessor"
 require "active_support/core_ext"
 require "ccp/version"
-require "ccp/data"
 
 module Ccp
-  autoload :Colorize,          'ccp/colorize'
+  autoload :Utils,             'ccp/utils'
   autoload :Fixtures,          'ccp/fixtures'
   autoload :Commands,          'ccp/commands'
   autoload :Invokers,          'ccp/invokers'
   autoload :Receivers,         'ccp/receivers'
+  autoload :Persistent,        'ccp/persistent'
+  autoload :Serializers,       'ccp/serializers'
 end

data/lib/ccp/invokers/base.rb

@@ -29,8 +29,8 @@ module Ccp
 
       def initialize(options = {})
         self.receiver = options.delete(:receiver) || self.class.receiver.new
-        receiver.data.merge_default(self.class.default_options)
-        receiver.data.merge(options)
+        receiver.data.default.merge!(self.class.default_options)
+        receiver.data.merge!(options)
       end
 
       def after

data/lib/ccp/persistent.rb

@@ -0,0 +1,23 @@
+module Ccp::Persistent
+  NotFound = Class.new(RuntimeError)
+
+  autoload :Base     , 'ccp/persistent/base'
+  autoload :Dir      , 'ccp/persistent/dir'
+  autoload :File     , 'ccp/persistent/file'
+  autoload :Json     , 'ccp/persistent/json'
+  autoload :Tsv      , 'ccp/persistent/tsv'
+  autoload :Versioned, 'ccp/persistent/versioned'
+
+  def self.lookup(name)
+    case name.to_s
+    when "dir"   ; Ccp::Persistent::Dir
+    when "tsv"   ; Ccp::Persistent::Tsv
+    when "file"  ; Ccp::Persistent::File
+    when "json"  ; Ccp::Persistent::Json
+    else
+      name.must(Ccp::Persistent::Base) {
+        raise NotFound, "%s: %s" % [name.class, name]
+      }
+    end
+  end
+end

data/lib/ccp/persistent/base.rb

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+
+class Ccp::Persistent::Base
+  attr_reader :source
+  attr_reader :serializer
+
+  delegate :ext, :encode, :decode, :to => :serializer
+
+  def initialize(source, serializer)
+    @source     = source
+    @serializer = Ccp::Serializers.lookup(serializer)
+  end
+
+  def self.ext
+    raise NotImplementedError, "subclass resposibility"
+  end
+
+  def exist?(key)
+    raise NotImplementedError, "subclass resposibility"
+  end
+
+  def save(hash)
+    hash.keys.each do |key|
+      self[key] = hash[key]
+    end
+  end
+
+  def load!(key)
+    raise NotImplementedError, "subclass resposibility"
+  end
+
+  def load(key)
+    raise NotImplementedError, "subclass resposibility"
+  end
+
+  def [](key)
+    load!(key)
+  end
+
+  def []=(key, val)
+    raise NotImplementedError, "subclass resposibility"
+  end
+
+  def keys
+    raise NotImplementedError, "subclass resposibility"
+  end
+
+  def truncate
+    raise NotImplementedError, "subclass resposibility"
+  end
+end

data/lib/ccp/persistent/dir.rb

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+
+class Ccp::Persistent::Dir < Ccp::Persistent::Base
+  def self.ext
+    ""
+  end
+
+  def exist?(key)
+    path_for(key).exist?
+  end
+
+  def load!(key)
+    path = path_for(key)
+    if path.exist?
+      decode(path.read{})
+    else
+      raise Ccp::Persistent::NotFound, key.to_s
+    end
+  end
+
+  def load(key)
+    load!(key)
+  rescue Ccp::Persistent::NotFound
+    nil
+  end
+
+  def []=(key, val)
+    path_for(key).open("w+"){|f| f.print encode(val)}
+  end
+
+  def keys
+    Dir["#{path}/*.#{ext}"].map{|i| File.basename(i, ".*")}.sort
+  end
+
+  def truncate
+    Dir["#{path}/*.#{ext}"].each{|file| File.unlink(file)}
+  end
+
+  def path
+    @path ||= Pathname(@source)
+  end
+
+  private
+    def path_for(key, mkdir = true)
+      path.mkpath if mkdir
+      path + "#{key}.#{ext}"
+    end
+end

data/lib/ccp/persistent/file.rb

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+
+class Ccp::Persistent::File < Ccp::Persistent::Base
+  def self.ext
+    ""
+  end
+
+  def initialize(source, serializer)
+    @serializer = Ccp::Serializers.lookup(serializer)
+    @source     = File.extname(source) == ".#{ext}" ? source : "#{source}.#{ext}"
+  end
+
+  def exist?(key)
+    read_data.has_key?(key.to_s)
+  end
+
+  def load!(key)
+    hash = read_data
+    if hash.has_key?(key.to_s)
+      read_data[key.to_s]
+    else
+      raise Ccp::Persistent::NotFound, key.to_s
+    end
+  end
+
+  def load(key)
+    load!(key)
+  rescue Ccp::Persistent::NotFound
+    nil
+  end
+
+  def []=(key, val)
+    hash = read_data
+    hash[key.to_s] = val
+    raw_write(encode(hash))
+  end
+
+  def keys
+    read_data.keys.sort
+  end
+
+  def truncate
+    File.unlink(path.to_s)
+  end
+
+  def path
+    @path ||= Pathname(@source)
+  end
+
+  private
+    def read_data
+      path.exist? ? decode(path.read{}).must(Hash) : {}
+    end
+
+    def raw_write(buf)
+      path.parent.mkpath
+      path.open("w+"){|f| f.print buf}
+    end
+end

data/lib/ccp/persistent/tsv.rb

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+
+class Ccp::Persistent::Tsv < Ccp::Persistent::Dir
+  def self.ext
+    "tsv"
+  end
+
+  def load_tsv(path)
+    hash = {}
+    path.readlines.each_with_index do |line, i|
+      no = i+1
+      key, val = line.split(/\t/,2)
+      unless val
+        $stderr.puts "#{self.class}#load_tsv: value not found. key='#{key}' (line: #{no})"
+        next
+      end
+      obj = decode(val)
+      hash[key] = obj
+    end
+
+    return hash
+  end
+
+  def save_tsv(f, hash)
+    keys = hash.keys
+    keys =
+      case keys.first
+      when NilClass ; return
+      when Symbol   ; keys
+      when /\A\d+\Z/; keys.sort_by(&:to_i)
+      when String   ; keys.sort
+      else          ; keys
+      end
+
+    keys.each do |key|
+      f.puts "%s\t%s\n" % [key, encode(hash[key])]
+    end
+  end
+
+  def load!(key)
+    path = path_for(key)
+    if path.exist?
+      super
+    elsif (tsv = tsv_path_for(key)).exist?
+      load_tsv(tsv)
+    else
+      super
+    end
+  end
+
+  def []=(key, val)
+    # Now, tsv can manage only hash
+    case val
+    when Hash
+      tsv_path_for(key).open("w+"){|f| save_tsv(f, val)}
+    else
+      super
+    end
+  end
+
+  def files
+    Dir["#{path}/*.#{ext}"] + Dir["#{path}/*.#{ext}.#{self.class.ext}"]
+  end
+
+  def keys
+    files.map{|i| File.basename(i).split(".").first}.sort
+  end
+
+  def truncate
+    files.each{|file| File.unlink(file)}
+  end
+
+  def tsv_path_for(key)
+    Pathname(path_for(key).to_s + ".tsv")
+  end
+end

data/lib/ccp/persistent/versioned.rb

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+
+class Ccp::Persistent::Versioned
+  attr_reader :path
+
+  Storage = Struct.new(:dir, :name, :ext, :kvs)
+  class Storage
+    def self.complete(file, default_dir, default_kvs, default_ext)
+      s = file.must(Storage) {
+        path, ext, kvs = file.to_s.split(".", 3)
+        new(default_dir, path, ext, kvs)
+      }
+
+      s.name = Pathname(s.name).basename(".*").to_s
+      s.dir  = default_dir if s.dir.blank?
+      s.ext  = default_ext if s.ext.blank?
+      s.kvs  = default_kvs if s.kvs.blank?
+
+      s.ext.must.not.blank
+      s.kvs.must.not.blank
+
+      return s
+    end
+
+    def path
+      kvs = Ccp::Persistent.lookup(self.kvs)
+      ext = Ccp::Serializers.lookup(self.ext)
+      base = [name.to_s, ext.ext, kvs.ext].join(".").sub(/\.$/,'')
+      return Pathname(dir) + base
+    end
+
+    def create
+      kvs = Ccp::Persistent.lookup(self.kvs)
+      ext = Ccp::Serializers.lookup(self.ext)
+      kvs.new(path, ext)
+    end
+  end
+
+  module StorageScanner
+    def scan(dir)
+      files = Dir.chdir(dir){
+        Dir["*"].grep(/^(\d+)\./).sort{|a,b|
+          [a.to_i, File.mtime(a)] <=> [b.to_i, File.mtime(b)]
+        }
+      }
+    end
+
+    extend self
+  end
+
+  def initialize(dir, options = {})
+    @path        = Pathname(dir)
+    @default_kvs = options[:kvs] || :dir
+    @default_ext = options[:ext] || :json
+    @storages    = {}
+
+    @path.mkpath
+  end
+
+  # 最新のストレージを返す。存在しなければnil
+  def latest
+    storage = StorageScanner.scan(path).last
+    storage ? self[storage] : nil
+  end
+
+  # 最新のストレージを返す。存在しなければ例外
+  def latest!
+    latest.must.exist { raise Ccp::Persistent::NotFound, "#{path}/*" }
+  end      
+
+  # 最新のストレージを返す。存在しなければ作成
+  def default
+    latest || now
+  end
+
+  # 現在の時刻で新しいストレージを作成して返す
+  def now
+    self[Time.now.to_i]
+  end
+
+  # 指定したストレージを返す。存在しなければ作成して返す
+  def [](key)
+    storage = Storage.complete(key, path, @default_kvs, @default_ext)
+    @storages[storage.to_s] ||= storage.create
+  end
+
+  def inspect
+    "<Kvs::Versioned dir=#{path} kvs=#{@default_kvs} ext=#{@default_ext}>"
+  end
+end

data/lib/ccp/receivers.rb

@@ -1,11 +1,14 @@
 module Ccp
   module Receivers
+    autoload :Core           , 'ccp/receivers/core'
     autoload :Base           , 'ccp/receivers/base'
     autoload :Global         , 'ccp/receivers/global'
+    autoload :Settings       , 'ccp/receivers/settings'
+    autoload :Variables      , 'ccp/receivers/variables'
     autoload :Executable     , 'ccp/receivers/executable'
     autoload :Aroundable     , 'ccp/receivers/aroundable'
     autoload :Commentable    , 'ccp/receivers/commentable'
     autoload :Profileable    , 'ccp/receivers/profileable'
-    autoload :SaveFixture    , 'ccp/receivers/save_fixture'
+    autoload :Fixtures       , 'ccp/receivers/fixtures'
   end
 end

data/lib/ccp/receivers/base.rb

@@ -1,20 +1,19 @@
 module Ccp
   module Receivers
     class Base
-      include Ccp::Data
+      include Core
+      include Settings
+      include Variables
       include Commentable
 
       # for execute
       include Executable
       include Profileable
       include Aroundable
-      include SaveFixture
+      include Fixtures
 
-      def inspect
-        klass_name = self.class.name.to_s.split(/::/).last
-
-        "#<Receivers::#{klass_name} data:#{data.inspect}>"
-      end
+      # ensure to call '#setup' for module initializations
+      def self.new(*args) r = super; r.setup; r; end
     end
   end
 end

data/lib/ccp/receivers/commentable.rb

@@ -4,7 +4,7 @@ module Ccp
 
       Comment = Struct.new(:text, :level)
       class Comment
-        include Colorize
+        include Utils::Colorize
         def colorized
           case level
           when :warn          ; yellow(text)