ccp 0.1.7 → 0.2.0

data/lib/ccp/receivers/core.rb

@@ -0,0 +1,14 @@
+module Ccp
+  module Receivers
+    module Core
+      def setup
+      end
+
+      def inspect
+        klass_name = self.class.name.to_s.split(/::/).last
+
+        "#<Receivers::#{klass_name} data:#{data.inspect}>"
+      end
+    end
+  end
+end

data/lib/ccp/receivers/fixtures.rb

@@ -0,0 +1,75 @@
+module Ccp
+  module Receivers
+    module Fixtures
+      class Storage
+        def initialize(kvs)
+          @kvs = kvs
+        end
+
+        def save(data)
+          data.keys.each do |key|
+            @kvs[key.to_s] = data[key]
+          end
+        end
+
+        def load
+          raise NotImplementedError
+        end
+      end
+
+      def execute(cmd)
+        return super unless fixtures_save?(cmd)
+
+        observer = Ccp::Fixtures::Observer.new(data)
+        observer.start
+        super
+        observer.stop
+
+        fixtures_save(cmd, observer.read, observer.write)
+      end
+
+      def setup
+        super
+
+        self[:fixture_save]     = Object # Schema
+
+        self[:fixture_dir]      = "tmp/fixtures"
+        self[:fixture_kvs]      = :file
+        self[:fixture_ext]      = :json
+        self[:fixture_save]     = proc{|cmd| false }
+        self[:fixture_path_for] = proc{|cmd| settings.path(:fixture_dir) + cmd.class.name.underscore}
+      end
+
+      def parse!(options)
+        settings.keys.grep(/^fixture_/).each do |key|
+          self[key] = options.delete(key.to_sym) if options.has_key?(key.to_sym)
+          self[key] = options.delete(key) if options.has_key?(key)
+        end
+        super
+      end
+
+      def fixtures_save?(cmd)
+        case (obj = self[:fixture_save])
+        when true ; obj
+        when false; obj
+        when Proc; obj.call(cmd)
+        else; raise ":fixture_save is invalid: #{obj.class}"
+        end
+      end
+
+      def fixtures_save(cmd, read, write)
+        path      = self[:fixture_path_for].call(cmd)
+        versioned = Ccp::Persistent::Versioned.new(path, :kvs=>self[:fixture_kvs], :ext=>self[:fixture_ext])
+        versioned["read" ].save(read)
+        versioned["write"].save(write)
+      end
+
+      def fixtures_for(cmd, key)
+        kvs  = Ccp::Persistent.lookup(self[:fixture_kvs])
+        code = Ccp::Serializers.lookup(self[:fixture_ext])
+        path = self[:fixture_path_for].call(cmd) + "#{key}.#{code.ext}.#{kvs.ext}"
+        return Storage.new(kvs.new(path, code))
+      end
+    end
+  end
+end

data/lib/ccp/receivers/profileable.rb

@@ -1,7 +1,7 @@
 module Ccp
   module Receivers
     module Profileable
-      include Colorize
+      include Utils::Colorize
 
       Profile = Struct.new(:target, :method, :time)
       class Profile

data/lib/ccp/receivers/settings.rb

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+# provide variables used in receiver itself
+
+module Ccp
+  module Receivers
+    module Settings
+      def settings
+        @settings ||= Typed::Hash.new
+      end
+
+      def [](key)
+        settings[key]
+      end
+
+      def []=(key, val)
+        settings[key] = val
+      end
+    end
+  end
+end

data/lib/ccp/receivers/variables.rb

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+# provide variables shared by commands
+
+module Ccp
+  module Receivers
+    module Variables
+      def data
+        @data ||= Typed::Hash.new
+      end
+
+      def data?(key)
+        data.set?(key)
+      end
+
+      def parse!(options)
+        data.merge!(options)
+      end
+    end
+  end
+end

data/lib/ccp/serializers.rb

@@ -0,0 +1,19 @@
+module Ccp::Serializers
+  NotFound = Class.new(RuntimeError)
+
+  autoload :Core , 'ccp/serializers/core'
+  autoload :Json , 'ccp/serializers/json'
+  autoload :Yaml , 'ccp/serializers/yaml'
+
+  def self.lookup(name)
+    case name
+    when :json, 'json'; Ccp::Serializers::Json
+    when :yaml, 'yaml'; Ccp::Serializers::Yaml
+    else
+      Ccp::Serializers::Core.instance_methods.each do |key|
+        name.must.duck(key) { raise NotFound, "%s: %s" % [name.class, name] }
+      end
+      return name
+    end
+  end
+end

data/lib/ccp/serializers/core.rb

@@ -0,0 +1,13 @@
+module Ccp::Serializers::Core
+  def ext
+    raise NotImplementedError, "subclass resposibility"
+  end
+
+  def encode(val)
+    raise NotImplementedError, "subclass resposibility"
+  end
+
+  def decode(val)
+    raise NotImplementedError, "subclass resposibility"
+  end
+end

data/lib/ccp/serializers/json.rb

@@ -0,0 +1,15 @@
+module Ccp::Serializers::Json
+  include Ccp::Serializers::Core
+
+  def self.ext
+    "json"
+  end
+
+  def self.encode(val)
+    JSON.dump(val)
+  end
+
+  def self.decode(val)
+    JSON.load(val)
+  end
+end

data/lib/ccp/serializers/yaml.rb

@@ -0,0 +1,15 @@
+module Ccp::Serializers::Yaml
+  include Ccp::Serializers::Core
+
+  def self.ext
+    "yaml"
+  end
+
+  def self.encode(val)
+    val.to_yaml
+  end
+
+  def self.decode(val)
+    YAML.load(val)
+  end
+end

data/lib/ccp/utils.rb

@@ -0,0 +1,6 @@
+module Ccp
+  module Utils
+    autoload :Data           , 'ccp/utils/data'
+    autoload :Colorize       , 'ccp/utils/colorize'
+  end
+end

data/lib/ccp/utils/colorize.rb

@@ -0,0 +1,15 @@
+module Ccp
+  module Utils
+    module Colorize
+      def colorize(text, ansi); "#{ansi}#{text}\e[0m"; end
+      def red   (text); colorize(text, "\e[31m"); end
+      def green (text); colorize(text, "\e[32m"); end
+      def yellow(text); colorize(text, "\e[33m"); end
+      def blue  (text); colorize(text, "\e[34m"); end
+      def pink  (text); colorize(text, "\e[35m"); end
+      def aqua  (text); colorize(text, "\e[36m"); end
+
+      extend self
+    end
+  end
+end

data/lib/ccp/version.rb

@@ -1,3 +1,3 @@
 module Ccp
-  VERSION = "0.1.7"
+  VERSION = "0.2.0"
 end

data/spec/persistent/base_spec.rb

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require 'fileutils'
+
+describe Ccp::Persistent::Base do
+  subject { Ccp::Persistent::Base.new(:source, Ccp::Serializers::Json) }
+
+  describe "#source" do
+    it "should return source" do
+      subject.source.should == :source
+    end
+  end
+
+  it "should provide ext" do
+    subject.methods.include?("ext").should == true
+  end
+
+  it "should provide exist?" do
+    subject.methods.include?("exist?").should == true
+  end
+
+  it "should provide #save" do
+    subject.methods.include?("save").should == true
+  end
+
+  it "should provide #load!" do
+    subject.methods.include?("load!").should == true
+  end
+
+  it "should provide #load" do
+    subject.methods.include?("load").should == true
+  end
+
+  it "should provide #[]" do
+    subject.methods.include?("[]").should == true
+  end
+
+  it "should provide #[]=" do
+    subject.methods.include?("[]=").should == true
+  end
+
+  it "should provide #keys" do
+    subject.methods.include?("keys").should == true
+  end
+
+  it "should provide #truncate" do
+    subject.methods.include?("truncate").should == true
+  end
+end

data/spec/persistent/dir_spec.rb

@@ -0,0 +1,111 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require 'fileutils'
+
+describe Ccp::Persistent::Dir do
+  def root; Pathname("tmp/spec/ccp/persistent/dir"); end
+  def db1 ; root + "db1"; end
+  def db2 ; root + "db2"; end
+
+  before do
+    FileUtils.rm_rf(root)
+    root.mkpath
+  end
+
+  describe ".ext" do
+    it "should return ''" do
+      Ccp::Persistent::Dir.ext.should == ''
+    end
+  end
+
+  describe "#path" do
+    it "should return the given source" do
+      kvs = Ccp::Persistent::Dir.new(root, :json)
+      kvs.path.to_s.should == root.to_s
+    end
+  end
+
+  describe "#[]=" do
+    it "should create data.file into <dir>/<key>.<ext>" do
+      kvs = Ccp::Persistent::Dir.new(root, :json)
+      kvs[:foo] = "[1,2,3]"
+      (root + "foo.json").should exist
+    end
+  end
+
+  describe "#load!" do
+    it "should fetch data if exists" do
+      (root + "foo.json").open("w+"){|f| f.print "1"}
+      kvs = Ccp::Persistent::Dir.new(root, :json)
+      kvs.load!(:foo).should == 1
+    end
+
+    it "should raise NotFound if not exists" do
+      kvs = Ccp::Persistent::Dir.new(root, :json)
+      lambda {
+        kvs.load!(:foo)
+      }.should raise_error(Ccp::Persistent::NotFound)
+    end
+  end
+
+  describe "#load" do
+    it "should fetch data if exists" do
+      (root + "foo.json").open("w+"){|f| f.print "1"}
+      kvs = Ccp::Persistent::Dir.new(root, :json)
+      kvs.load(:foo).should == 1
+    end
+
+    it "should return nil if not exists" do
+      kvs = Ccp::Persistent::Dir.new(root, :json)
+      kvs.load(:foo).should == nil
+    end
+  end
+
+  describe "#[]" do
+    it "should fetch data if exists" do
+      (root + "foo.json").open("w+"){|f| f.print "1"}
+      kvs = Ccp::Persistent::Dir.new(root, :json)
+      kvs.load!(:foo).should == 1
+    end
+
+    it "should raise NotFound if not exists" do
+      kvs = Ccp::Persistent::Dir.new(root, :json)
+      lambda {
+        kvs.load!(:foo)
+      }.should raise_error(Ccp::Persistent::NotFound)
+    end
+  end
+
+  describe "#keys" do
+    it "should return a sorted array of key names filtered by given ext" do
+      ["1.json", "2.yaml", "3.json"].each do |i|
+        (root + i).open("w+"){}
+      end
+
+      kvs = Ccp::Persistent::Dir.new(root, :json)
+      kvs.keys.should == ["1","3"]
+    end
+  end
+
+  describe "#truncate" do
+    it "should delete all *.<ext>" do
+      ["1.json", "2.yaml", "3.json"].each do |i|
+        (root + i).open("w+"){}
+      end
+      root.children.map{|i| i.basename.to_s}.sort.should == ["1.json", "2.yaml", "3.json"]
+
+      kvs = Ccp::Persistent::Dir.new(root, :json)
+      kvs.truncate
+      root.children.map{|i| i.basename.to_s}.sort.should == ["2.yaml"]
+    end
+  end
+
+  it "should save data into storage and load it" do
+    kvs = Ccp::Persistent::Dir.new(db1, :json)
+    kvs[:foo] = "[1,2,3]"
+
+    FileUtils.mv(db1, db2)
+    kvs = Ccp::Persistent::Dir.new(db2, :json)
+    kvs[:foo].should == "[1,2,3]"
+  end
+end

data/spec/persistent/file_spec.rb

@@ -0,0 +1,124 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require 'fileutils'
+
+describe Ccp::Persistent::File do
+  def db; Pathname("tmp/spec/ccp/persistent/json/db.json"); end
+
+  before do
+    FileUtils.rm_rf(db)
+  end
+
+  describe ".ext" do
+    it "should return ''" do
+      Ccp::Persistent::File.ext.should == ''
+    end
+  end
+
+  describe "#path" do
+    it "should return the given source if its ext is json" do
+      kvs = Ccp::Persistent::File.new("tmp/foo.json", :json)
+      kvs.path.to_s.should == "tmp/foo.json"
+    end
+
+    it "should return <given source>.json if its ext is not json" do
+      kvs = Ccp::Persistent::File.new("tmp/foo", :json)
+      kvs.path.to_s.should == "tmp/foo.json"
+    end
+  end
+
+  describe "#[]=" do
+    it "should create a json file" do
+      db.should_not exist
+      kvs = Ccp::Persistent::File.new(db, :json)
+      kvs["foo"] = "[1,2,3]"
+      db.should exist
+    end
+
+    it "should write json data as hash" do
+      kvs = Ccp::Persistent::File.new(db, :json)
+      kvs["foo"] = "[1,2,3]"
+      db.read{}.should == '{"foo":"[1,2,3]"}'
+    end
+
+    it "should convert key to string" do
+      kvs = Ccp::Persistent::File.new(db, :json)
+      kvs[:foo] = "[1,2,3]"
+      db.read{}.should == '{"foo":"[1,2,3]"}'
+    end
+  end
+
+  describe "#load!" do
+    it "should raise NotFound if not exists" do
+      kvs = Ccp::Persistent::File.new(db, :json)
+      lambda {
+        kvs.load!("foo")
+      }.should raise_error(Ccp::Persistent::NotFound)
+    end
+
+    it "should fetch data if exists" do
+      db.open("w+"){|f| f.print(JSON.dump({"foo" => 1}))}
+      kvs = Ccp::Persistent::File.new(db, :json)
+      kvs.load!("foo").should == 1
+    end
+
+    it "should convert key to string" do
+      db.open("w+"){|f| f.print(JSON.dump({"foo" => 1}))}
+      kvs = Ccp::Persistent::File.new(db, :json)
+      kvs.load!(:foo).should == 1
+    end
+  end
+
+  describe "#load" do
+    it "should return nil if not exists" do
+      kvs = Ccp::Persistent::File.new(db, :json)
+      kvs.load("foo2").should == nil
+    end
+
+    it "should fetch data if exists" do
+      db.open("w+"){|f| f.print(JSON.dump({"foo" => 1}))}
+      kvs = Ccp::Persistent::File.new(db, :json)
+      kvs.load("foo").should == 1
+    end
+
+    it "should convert key to string" do
+      db.open("w+"){|f| f.print(JSON.dump({"foo" => 1}))}
+      kvs = Ccp::Persistent::File.new(db, :json)
+      kvs.load(:foo).should == 1
+    end
+  end
+
+  describe "#[]" do
+    it "should fetch data if exists" do
+      db.open("w+"){|f| f.print(JSON.dump({"foo" => 1}))}
+      kvs = Ccp::Persistent::File.new(db, :json)
+      kvs.load!(:foo).should == 1
+    end
+
+    it "should raise NotFound if not exists" do
+      kvs = Ccp::Persistent::File.new(db, :json)
+      lambda {
+        kvs.load!(:foo)
+      }.should raise_error(Ccp::Persistent::NotFound)
+    end
+  end
+
+  describe "#keys" do
+    it "should return a sorted array of key names filtered by given ext" do
+      db.open("w+"){|f| f.print(JSON.dump({"foo" => 1, "bar" => "xxx"}))}
+      kvs = Ccp::Persistent::File.new(db, :json)
+      kvs.keys.should == ["bar", "foo"]
+    end
+  end
+
+  describe "#truncate" do
+    it "should delete its db file" do
+      db.open("w+"){|f| f.print(JSON.dump({"foo" => 1}))}
+      db.should exist
+
+      kvs = Ccp::Persistent::File.new(db, :json)
+      kvs.truncate
+      db.should_not exist      
+    end
+  end
+end