ccp 0.2.1 → 0.2.3

data/README.rdoc

@@ -157,23 +157,25 @@ This will create following files.
   % tree tmp/fixtures
   tmp/fixtures
   +- tsfc
-      +- read.json
-      +- write.json
+      +- stub.json
+      +- mock.json
 
   1 directory, 2 files    
-  % cat tmp/fixtures/tsfc/read.json
+  % cat tmp/fixtures/tsfc/stub.json
   {"a":1}
-  % cat tmp/fixtures/tsfc/write.json
+  % cat tmp/fixtures/tsfc/mock.json
   {"x":10}
 
+Where, reading means stub and writing means mock.
+
 === Writing tests
 
 Use them as stubs and expected data as you like.
 
   describe TSFC do
     it "should work" do
-      data     = JSON.load(Pathname("tmp/fixtures/tsfc/read.json").read{})
-      expected = JSON.load(Pathname("tmp/fixtures/tsfc/write.json").read{})
+      data     = JSON.load(Pathname("tmp/fixtures/tsfc/stub.json").read{})
+      expected = JSON.load(Pathname("tmp/fixtures/tsfc/mock.json").read{})
 
       cmd = TSFC.execute(data)
 
@@ -238,8 +240,28 @@ In this case, we want to filter save data. Try fixtures_keys!
 
     Cmd.execute(:fixture_save => true, :fixture_keys => ['x'])
 
-This will generate "read.json" that contains only 'x'.
+This will generate "stub.json" that contains only 'x'.
 And, "!" can be used for negations as same as "Filter commands".
 
     Cmd.execute(:fixture_save => true, :fixture_keys => ['!logger'])
 
+=== Static options
+
+Static options(hard code) are also available.
+
+    class Cmd
+      include Ccp::Commands::Core
+      stub "tmp/stub.json"
+      mock "tmp/mock.json"
+      # keys ["x"]
+      save true
+
+      def execute
+        data[:a]
+        data[:x] = 10
+      end
+    end
+
+    Cmd.execute(:a=>1)
+
+This generates "tmp/stub.json", "tmp/mock.json".

data/ccp.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency "typed", ">= 0.2.2"
   s.add_dependency "must", ">= 0.2.7"
-  s.add_dependency "dsl_accessor", ">= 0.4.0"
+  s.add_dependency "dsl_accessor", ">= 0.4.1"
 
   s.add_development_dependency "rspec"
 end

data/lib/ccp/commands.rb

@@ -4,6 +4,7 @@ module Ccp
     autoload :Composite      , 'ccp/commands/composite'
     autoload :Executable     , 'ccp/commands/executable'
     autoload :Receivable     , 'ccp/commands/receivable'
+    autoload :Fixturable     , 'ccp/commands/fixturable'
     autoload :RuntimeArgs    , 'ccp/commands/runtime_args'
     autoload :Commentable    , 'ccp/commands/commentable'
     autoload :Core           , 'ccp/commands/core'

data/lib/ccp/commands/composite.rb

@@ -6,6 +6,7 @@ module Ccp
         base.class_eval do
           extend ClassMethods
           extend Executable::ClassMethods
+          include Fixturable
         end
       end
 

data/lib/ccp/commands/core.rb

@@ -6,8 +6,10 @@ module Ccp
       include Executable
 
       def self.included(base)
+        super
         base.class_eval do
           extend ClassMethods
+          include Fixturable
         end
       end
 

data/lib/ccp/commands/fixturable.rb

@@ -0,0 +1,12 @@
+module Ccp
+  module Commands
+    module Fixturable
+      def self.included(base)
+        base.class_eval do
+          include Ccp::Utils::Options
+          dsl_accessor :fixture, options(:stub, :mock, :fail, :save, :keys, :dir, :kvs, :ext)
+        end
+      end
+    end
+  end
+end

data/lib/ccp/invokers.rb

@@ -1,5 +1,6 @@
 module Ccp
   module Invokers
     autoload :Base           , 'ccp/invokers/base'
+    autoload :Spec           , 'ccp/invokers/spec'
   end
 end

data/lib/ccp/invokers/base.rb

@@ -4,15 +4,19 @@ module Ccp
   module Invokers
     class Base
       include Commands::Composite
+      include Utils::Options
 
       dsl_accessor :receiver, Receivers::Base
-      dsl_accessor :profile , false
-      dsl_accessor :comment , true
-      dsl_accessor :logger  , proc{ Logger.new($stderr) }
 
-      dsl_accessor :builtin_options, :default => {:profile => profile, :comment => comment, :logger => logger}
       dsl_accessor :default_options, :default => {}
 
+      dsl_accessor :builtins, options(:profile, :comment, :logger)
+      dsl_accessor :fixtures, options(:fixture_save, :fixture_keys, :fixture_dir, :fixture_kvs, :fixture_ext)
+
+      profile false
+      comment true
+      logger  Logger.new($stderr)
+
       ######################################################################
       ### Class Methods
 
@@ -23,14 +27,20 @@ module Ccp
         return cmd
       end
 
+      def self.receiver_options
+        opts = fixtures.options
+        opts[:fixture_keys] ||= builtins.options.keys.map{|i| "!#{i}"}
+        return opts
+      end
+
       ######################################################################
       ### Instance Methods
 
       def initialize(options = {})
         self.receiver = options.delete(:receiver) || self.class.receiver.new
-        receiver.parse!(:fixture_keys => self.class.builtin_options.keys.map{|i| "!#{i}"})
+        receiver.parse!(self.class.receiver_options)
         receiver.parse!(options)
-        receiver.data.default.merge!(self.class.builtin_options)
+        receiver.data.default.merge!(self.class.builtins.options)
         receiver.data.default.merge!(self.class.default_options)
       end
 

data/lib/ccp/invokers/spec.rb

@@ -0,0 +1,8 @@
+module Ccp
+  module Invokers
+    class Spec < Base
+      def self.spec
+      end
+    end
+  end
+end

data/lib/ccp/persistent.rb

@@ -7,6 +7,9 @@ module Ccp::Persistent
   autoload :Json     , 'ccp/persistent/json'
   autoload :Tsv      , 'ccp/persistent/tsv'
   autoload :Versioned, 'ccp/persistent/versioned'
+  autoload :Loadable , 'ccp/persistent/loadable'
+
+  extend Ccp::Persistent::Loadable
 
   def self.lookup(name)
     case name.to_s

data/lib/ccp/persistent/base.rb

@@ -41,6 +41,16 @@ class Ccp::Persistent::Base
     raise NotImplementedError, "subclass resposibility"
   end
 
+  def read
+    read!
+  rescue Ccp::Persistent::NotFound
+    {}
+  end
+
+  def read!
+    keys.inject({}) {|h,k| h[k] = v; h}
+  end
+
   def keys
     raise NotImplementedError, "subclass resposibility"
   end

data/lib/ccp/persistent/file.rb

@@ -11,13 +11,13 @@ class Ccp::Persistent::File < Ccp::Persistent::Base
   end
 
   def exist?(key)
-    read_data.has_key?(key.to_s)
+    read.has_key?(key.to_s)
   end
 
   def load!(key)
-    hash = read_data
+    hash = read
     if hash.has_key?(key.to_s)
-      read_data[key.to_s]
+      hash[key.to_s]
     else
       raise Ccp::Persistent::NotFound, key.to_s
     end
@@ -30,13 +30,13 @@ class Ccp::Persistent::File < Ccp::Persistent::Base
   end
 
   def []=(key, val)
-    hash = read_data
+    hash = read
     hash[key.to_s] = val
     raw_write(encode(hash))
   end
 
   def keys
-    read_data.keys.sort
+    read.keys.sort
   end
 
   def truncate
@@ -47,11 +47,18 @@ class Ccp::Persistent::File < Ccp::Persistent::Base
     @path ||= Pathname(@source)
   end
 
-  private
-    def read_data
-      path.exist? ? decode(path.read{}).must(Hash) : {}
-    end
+  def read
+    read!
+  rescue Ccp::Persistent::NotFound
+    {}
+  end
 
+  def read!
+    path.exist? or raise Ccp::Persistent::NotFound, path.to_s
+    decode(path.read{}).must(Hash)
+  end
+
+  private
     def raw_write(buf)
       path.parent.mkpath
       path.open("w+"){|f| f.print buf}

data/lib/ccp/persistent/loadable.rb

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+
+module Ccp::Persistent::Loadable
+  def load(file)
+    ext = Ccp::Serializers.lookup(Pathname(file).extname.to_s.delete("."))
+    kvs = load_kvs_lookup_by_filename(file)
+    kvs.new(file.sub(%r{/$},''), ext)
+  end
+
+  private
+    def load_kvs_lookup_by_filename(file)
+      case file.to_s
+      when %r{/$}    ; Ccp::Persistent::Dir
+      when %r{\.tsv$}; Ccp::Persistent::Tsv
+      else           ; Ccp::Persistent::File
+      end
+    end
+end

data/lib/ccp/receivers/fixtures.rb

@@ -1,31 +1,18 @@
 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 fixture_save?(cmd)
-
-        observer = Ccp::Fixtures::Observer.new(data)
-        observer.start
-        super
-        observer.stop
-
-        fixture_save(cmd, observer.read, observer.write)
+        if fixture_save?(cmd)
+          observer = Ccp::Fixtures::Observer.new(data)
+          observer.start
+          super
+          observer.stop
+          fixture_save(cmd, observer.read, observer.write)
+        else
+          fixture_stub(cmd)
+          super
+          fixture_mock(cmd)
+        end
       end
 
       def setup
@@ -52,7 +39,49 @@ module Ccp
         super
       end
 
+      def fixture_stub(cmd)
+        path = cmd.class.stub or return
+        hash = Ccp::Persistent.load(path).read!
+        data.merge!(hash)
+      end
+
+      def fixture_mock(cmd)
+        path = cmd.class.mock or return
+        hash = Ccp::Persistent.load(path).read!
+
+        hash.keys.each do |key|
+          fixture_validate(cmd, key, data, hash)
+        end
+      end
+
+      def fixture_validate(cmd, key, data, hash)
+        data.exist?(key)       or fixture_fail(cmd, key)
+        data[key] == hash[key] or fixture_fail(cmd, key, hash[key], data[key])
+        # or, success
+      end
+
+      def fixture_fail(cmd, key, expected = nil, got = nil)
+        block = fixture_fail_for(cmd)
+        instance_exec(cmd, key, expected, got, &block)
+      end
+
+      def fixture_fail_for(cmd)
+        cmd.class.fail || method(:default_fixture_fail)
+      end
+
+      def default_fixture_fail(cmd, key, exp, got)
+        if exp == nil and got == nil
+          raise "#{cmd.class} should write #{key} but not found"
+        end
+
+        exp_info = "%s(%s)" % [exp.inspect.truncate(200), Must::StructInfo.new(exp).compact.inspect]
+        got_info = "%s(%s)" % [got.inspect.truncate(200), Must::StructInfo.new(got).compact.inspect]
+        raise "%s should create %s for %s, but got %s" % [cmd.class, exp_info, key, got_info]
+      end
+
       def fixture_save?(cmd)
+        return true if cmd.class.save # highest priority
+
         case (obj = self[:fixture_save])
         when true  ; true
         when false ; false
@@ -68,19 +97,31 @@ module Ccp
         end
       end
 
-      def fixture_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 , fixture_keys_filter(read.keys))
-        versioned["write"].save(write, fixture_keys_filter(write.keys))
+      def fixture_save(cmd, stub, mock)
+        path = self[:fixture_path_for].call(cmd)
+        path = Pathname(cmd.class.dir) + cmd.class.name.underscore if cmd.class.dir
+
+        keys = cmd.class.keys || self[:fixture_keys]
+        kvs  = cmd.class.kvs  || self[:fixture_kvs]
+        ext  = cmd.class.ext  || self[:fixture_ext]
+
+        versioned = Ccp::Persistent::Versioned.new(path, :kvs=>kvs, :ext=>ext)
+
+        # stub
+        storage = cmd.class.stub ? Ccp::Persistent.lookup(kvs).new(cmd.class.stub, ext) : versioned["stub"]
+        storage.save(stub, fixture_keys_filter(keys, stub.keys))
+
+        # mock
+        storage = cmd.class.mock ? Ccp::Persistent.lookup(kvs).new(cmd.class.mock, ext) : versioned["mock"]
+        storage.save(mock, fixture_keys_filter(keys, mock.keys))
       end
 
-      def fixture_keys_filter(keys)
-        case (obj = self[:fixture_keys])
+      def fixture_keys_filter(acl, keys)
+        case acl
         when true ; keys
         when false; []
         when Array
-          ary = obj.map(&:to_s)
+          ary = acl.map(&:to_s)
           return keys if ary == []
           if ary.size == ary.grep(/^!/).size
             return keys.dup.reject{|v| ary.include?("!#{v}")}
@@ -88,17 +129,10 @@ module Ccp
             ary & keys
           end
         else
-          raise ":fixture_keys is invalid: #{obj.class}"
+          raise ":fixture_keys is invalid: #{acl.class}"
         end
       end
 
-      def fixture_for(cmd, key)
-        kvs  = Ccp::Persistent.lookup(self[:fixture_kvs])
-        code = Ccp::Serializers.lookup(self[:fixture_ext])
-        path = instance_exec(cmd, &self[:fixture_path_for]) + "#{key}.#{code.ext}.#{kvs.ext}"
-        return Storage.new(kvs.new(path, code))
-      end
-
       def default_fixture_path_for
         proc{|cmd| settings.path(:fixture_dir) + cmd.class.name.underscore}
       end

data/lib/ccp/utils.rb

@@ -2,5 +2,6 @@ module Ccp
   module Utils
     autoload :Data           , 'ccp/utils/data'
     autoload :Colorize       , 'ccp/utils/colorize'
+    autoload :Options        , 'ccp/utils/options'
   end
 end

data/lib/ccp/utils/fixture_options.rb

@@ -0,0 +1,6 @@
+module Ccp
+  module Utils
+    class FixtureOptions < Options::Proxy
+    end
+  end
+end

data/lib/ccp/utils/options.rb

@@ -0,0 +1,50 @@
+module Ccp
+  module Utils
+    module Options
+      def self.included(base)
+        super
+
+        class << base
+          def options(*keys)
+            Proxy.new(self, *keys)
+          end
+        end
+      end
+
+      class Proxy
+        include Enumerable
+
+        attr_reader :keys
+
+        def initialize(base, *keys)
+          @base = base
+          @keys = keys.map(&:to_sym)
+
+          @keys.each do |key|
+            @base.dsl_accessor key
+#            instance_eval "def self.#{key}; :#{key}; end"
+          end
+        end
+
+        def [](key)
+          @base.__send__(key)
+        end
+
+        def each(&block)
+          keys.each do |key|
+            yield(self[key])
+          end
+        end
+
+        def options
+          opts = {}
+          keys.each do |key|
+            val = self[key]
+            opts[key] = val unless val.nil?
+          end
+          return opts
+        end
+      end
+    end
+  end
+end

data/lib/ccp/version.rb

@@ -1,3 +1,3 @@
 module Ccp
-  VERSION = "0.2.1"
+  VERSION = "0.2.3"
 end

data/spec/commands/composite_spec.rb

@@ -1,5 +1,23 @@
 require "spec_helper"
 
+describe Ccp::Commands::Composite do
+  describe "(instance)" do
+    subject { Object.new.extend Ccp::Commands::Composite } 
+
+    # data container
+    it { should respond_to(:data?) }
+    it { should respond_to(:data) }
+    its(:data) { should be_kind_of(Typed::Hash) }
+
+    # executable
+    it { should respond_to(:execute) }
+
+    # receivable
+    it { should respond_to(:receiver) }
+    its(:receiver) { should be_kind_of(Ccp::Receivers::Base) }
+  end
+end
+
 describe Ccp::Commands::Composite do
   describe "#execute" do
     it "should call its execute and sub commands's {before,execute,after} in declared order" do

data/spec/commands/fixturable_spec.rb

@@ -0,0 +1,66 @@
+require "spec_helper"
+
+describe Ccp::Commands::Core do
+  subject { Class.new{include Ccp::Commands::Core} } 
+
+  it { should include(Ccp::Commands::Fixturable) }
+end
+
+describe Ccp::Commands::Fixturable do
+  context "Ccp::Commands::Core" do
+    subject { Cmd1 }
+    it { should respond_to("stub") }
+    it { should respond_to("mock") }
+    it { should respond_to("fail") }
+    it { should respond_to("save") }
+    it { should respond_to("keys") }
+    it { should respond_to("dir") }
+    it { should respond_to("kvs") }
+    it { should respond_to("ext") }
+    it { should respond_to("fixture") }
+    its(:fixture) { should respond_to("options") }
+  end
+
+  context "Ccp::Commands::Composite" do
+    subject { Program }
+    it { should respond_to("stub") }
+    it { should respond_to("mock") }
+    it { should respond_to("fail") }
+    it { should respond_to("save") }
+    it { should respond_to("keys") }
+    it { should respond_to("dir") }
+    it { should respond_to("kvs") }
+    it { should respond_to("ext") }
+    it { should respond_to("fixture") }
+    its(:fixture) { should respond_to("options") }
+  end
+
+  context "Ccp::Invokers::Base" do
+    subject { CompositeInvoker }
+    it { should respond_to("stub") }
+    it { should respond_to("mock") }
+    it { should respond_to("fail") }
+    it { should respond_to("save") }
+    it { should respond_to("keys") }
+    it { should respond_to("dir") }
+    it { should respond_to("kvs") }
+    it { should respond_to("ext") }
+    it { should respond_to("fixture") }
+    its(:fixture) { should respond_to("options") }
+  end
+
+  context "included class" do
+    subject { Class.new{include Ccp::Commands::Fixturable} } 
+    it { should respond_to("stub") }
+    it { should respond_to("mock") }
+    it { should respond_to("fail") }
+    it { should respond_to("save") }
+    it { should respond_to("keys") }
+    it { should respond_to("dir") }
+    it { should respond_to("kvs") }
+    it { should respond_to("ext") }
+    it { should respond_to("fixture") }
+    its(:fixture) { should respond_to("options") }
+  end
+end
+

data/spec/fixtures/cmd1stub_mock/mock.json

@@ -0,0 +1 @@
+{"breadcrumbs":["Cmd1StubMock#before", "Cmd1StubMock#execute", "Cmd1StubMock#after"]}

data/spec/fixtures/stub/breadcrumbs.json

@@ -0,0 +1 @@
+{"breadcrumbs":[]}

data/spec/invokers/fixture_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+require 'fileutils'
+
+describe Ccp::Invokers::Base do
+  describe "(class)" do
+    subject {Class.new(Ccp::Invokers::Base)}
+    it { should respond_to(:fixture_save) }
+    it { should respond_to(:fixture_keys) }
+    it { should respond_to(:fixture_dir) }
+    it { should respond_to(:fixture_kvs) }
+    it { should respond_to(:fixture_ext) }
+  end
+end

data/spec/invokers/save_fixture_spec.rb

@@ -2,29 +2,21 @@ require "spec_helper"
 require 'fileutils'
 
 describe Ccp::Invokers::Base do
-  def load(path)
-    case path.extname
-    when ".json"; JSON.load(Pathname(path).read{})
-    when ".yaml"; YAML.load(Pathname(path).read{})
-    else; raise "load doesn't support #{path.extname}"
-    end
-  end
-
   describe ".execute" do
     before do
       FileUtils.rm_rf("tmp")
     end
 
     context "(:fixture_save=>true)" do
-      it "should generate read/write fixtures in tmp/fixtures as json files" do
+      it "should generate stub/mock fixtures in tmp/fixtures as json files" do
         path = Pathname("tmp/fixtures")
         data = {:breadcrumbs => []}
         opts = {:fixture_save=>true}
 
         CompositeInvoker.execute(data.merge(opts))
 
-        (read = path + "composite_invoker/read.json" ).should exist
-        load(read)["breadcrumbs"].should == 
+        (stub = path + "composite_invoker/stub.json" ).should exist
+        load_fixture(stub)["breadcrumbs"].should == 
           ["CompositeInvoker#before",
            "Cmd1#before", "Cmd1#execute", "Cmd1#after",
            "Cmd23#before",

data/spec/invokers/spec_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+require 'fileutils'
+
+describe Ccp::Invokers::Spec do
+  it "should inherit Ccp::Invokers::Base" do
+    subject.should be_kind_of(Ccp::Invokers::Base)
+  end
+
+  describe "(class)" do
+    subject { Ccp::Invokers::Spec }
+    it { should respond_to("spec") }
+  end
+end
+
+
+__END__
+
+  class Cmd1Spec < Ccp::Invokers::Spec
+    fixture_dir "spec/fixtures/invokers/spec/stub"
+    command Cmd1
+  end
+
+  it "should stub data" do
+    path = truncate_pathname("tmp/fixtures/spec/invokers/spec/stub")
+    save_fixture(path + "stub.json", "breadcrumbs"=>[])
+
+    lambda {
+      Cmd1Spec.execute
+    }.should raise_error(Typed::NotDefined)
+
+    lambda {
+      Cmd1Spec.spec
+    }.should_not raise_error
+  end
+end
+

data/spec/persistent/base_spec.rb

@@ -11,39 +11,15 @@ describe Ccp::Persistent::Base do
     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
+  it { should respond_to("ext") }
+  it { should respond_to("exist?") }
+  it { should respond_to("save") }
+  it { should respond_to("load!") }
+  it { should respond_to("load") }
+  it { should respond_to("[]") }
+  it { should respond_to("[]=") }
+  it { should respond_to("read") }
+  it { should respond_to("read!") }
+  it { should respond_to("keys") }
+  it { should respond_to("truncate") }
 end

data/spec/persistent/loadable_spec.rb

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require 'fileutils'
+
+describe Ccp::Persistent do
+  it { should respond_to("load") }
+
+  describe ".load" do
+    context "('tmp/foo.json')" do
+      subject { Ccp::Persistent.load('tmp/foo.json') }
+      its(:class)  { should == Ccp::Persistent::File }
+      its(:ext)    { should == "json" }
+      its(:source) { should == 'tmp/foo.json' }
+    end
+
+    context "('tmp/foo.yaml')" do
+      subject { Ccp::Persistent.load('tmp/foo.yaml') }
+      its(:class)  { should == Ccp::Persistent::File }
+      its(:ext)    { should == "yaml" }
+      its(:source) { should == 'tmp/foo.yaml' }
+    end
+
+    context "('tmp/foo.json/')" do
+      subject { Ccp::Persistent.load('tmp/foo.json/') }
+      its(:class)  { should == Ccp::Persistent::Dir }
+      its(:ext)    { should == "json" }
+      its(:source) { should == 'tmp/foo.json' }
+    end
+
+    context "('tmp/foo')" do
+      it "should raise Ccp::Serializers::NotFound" do
+        lambda {
+          Ccp::Persistent.load('tmp/foo')
+        }.should raise_error(Ccp::Serializers::NotFound)
+      end
+    end
+
+    context "('tmp/foo/')" do
+      it "should raise Ccp::Serializers::NotFound" do
+        lambda {
+          Ccp::Persistent.load('tmp/foo/')
+        }.should raise_error(Ccp::Serializers::NotFound)
+      end
+    end
+  end
+end

data/spec/receivers/fixture_save_how_spec.rb

@@ -8,41 +8,41 @@ describe "Ccp::Commands::Core" do
     end
 
     context "(:fixture_save=>true)" do
-      it "should generate read/write fixtures in tmp/fixtures as json files" do
+      it "should generate stub/mock fixtures in tmp/fixtures as json files" do
         path = Pathname("tmp/fixtures")
         data = {:a=>"a", :b=>"b", :x=>1, :y=>2}
         opts = {:fixture_save=>true}
 
         TSFC.execute(data.merge(opts))
 
-        load_fixture(path + "tsfc/read.json" ).should == {"a" => "a"}
-        load_fixture(path + "tsfc/write.json").should == {"x" => 10}
+        load_fixture(path + "tsfc/stub.json").should == {"a" => "a"}
+        load_fixture(path + "tsfc/mock.json").should == {"x" => 10}
       end
     end
 
     context "(:fixture_save=>true, :fixture_ext=>:yaml)" do
-      it "should generate read/write fixtures in tmp/fixtures as yaml files" do
+      it "should generate stub/mock fixtures in tmp/fixtures as yaml files" do
         path = Pathname("tmp/fixtures")
         data = {:a=>"a", :b=>"b", :x=>1, :y=>2}
         opts = {:fixture_save=>true, :fixture_ext=>:yaml}
 
         TSFC.execute(data.merge(opts))
 
-        load_fixture(path + "tsfc/read.yaml" ).should == {"a" => "a"}
-        load_fixture(path + "tsfc/write.yaml").should == {"x" => 10}
+        load_fixture(path + "tsfc/stub.yaml" ).should == {"a" => "a"}
+        load_fixture(path + "tsfc/mock.yaml").should == {"x" => 10}
       end
     end
 
     context "(:fixture_save=>true, :fixture_kvs=>:dir)" do
-      it "should generate json files in read/write dir" do
+      it "should generate json files in stub/mock dir" do
         path = Pathname("tmp/fixtures")
         data = {:a=>"a", :b=>"b", :x=>1, :y=>2}
         opts = {:fixture_save=>true, :fixture_kvs=>:dir}
 
         TSFC.execute(data.merge(opts))
 
-        load_fixture(path + "tsfc/read.json/a.json" ).should == "a"
-        load_fixture(path + "tsfc/write.json/x.json").should == 10
+        load_fixture(path + "tsfc/stub.json/a.json" ).should == "a"
+        load_fixture(path + "tsfc/mock.json/x.json").should == 10
       end
     end
   end

data/spec/receivers/fixture_save_ignore_logger_spec.rb

@@ -21,8 +21,8 @@ describe Ccp::Invokers::Base do
       it "should ignore :logger in default" do
         ULI.execute(:a=>"a", :fixture_save=>true)
 
-        load_fixture("tmp/fixtures/uli/read.json" ).should == {"a" => "a"}
-        load_fixture("tmp/fixtures/uli/write.json" ).should == {"x" => 10}
+        load_fixture("tmp/fixtures/uli/stub.json").should == {"a" => "a"}
+        load_fixture("tmp/fixtures/uli/mock.json").should == {"x" => 10}
       end
     end
   end

data/spec/receivers/fixture_save_what_spec.rb

@@ -13,7 +13,7 @@ describe Cmd1 do
     end
 
     def created_keys
-      load_fixture(FIXTURE_PATH + "read.json").keys.sort
+      load_fixture(FIXTURE_PATH + "stub.json").keys.sort
     rescue Errno::ENOENT
       []
     end

data/spec/receivers/fixture_save_where_spec.rb

@@ -8,15 +8,51 @@ describe "Ccp::Commands::Core" do
     end
 
     context "(:fixture_save=>true, :fixture_dir=>...)" do
-      it "should generate read/write fixtures in <save_fixture_dir> as json files" do
+      it "should generate stub/mock fixtures in <save_fixture_dir> as json files" do
         path = Pathname("tmp/test/fixtures")
         data = {:a=>"a", :b=>"b", :x=>1, :y=>2}
         opts = {:fixture_save=>true, :fixture_dir=>path.to_s}
 
         TSFC.execute(data.merge(opts))
 
-        load_fixture(path + "tsfc/read.json" ).should == {"a" => "a"}
-        load_fixture(path + "tsfc/write.json").should == {"x" => 10}
+        load_fixture(path + "tsfc/stub.json").should == {"a" => "a"}
+        load_fixture(path + "tsfc/mock.json").should == {"x" => 10}
+      end
+    end
+
+    context "(:fixture_save=>true) with hard coded" do
+      it "should generate fixtures in given path" do
+        data = {:a=>"a", :b=>"b", :x=>1, :y=>2}
+        opts = {:fixture_save=>true}
+
+        begin
+          TSFC.stub "tmp/tsfc/in.json"
+          TSFC.mock "tmp/tsfc/out.json"
+
+          TSFC.execute(data.merge(opts))
+        ensure
+          TSFC.stub nil
+          TSFC.mock nil
+        end
+
+        load_fixture("tmp/tsfc/in.json").should == {"a" => "a"}
+        load_fixture("tmp/tsfc/out.json").should == {"x" => 10}
+      end
+
+      it "should generate stub/mock fixtures in <dir> as json files" do
+        data = {:a=>"a", :b=>"b", :x=>1, :y=>2}
+        opts = {:fixture_save=>true}
+
+        begin
+          TSFC.dir "tmp/foo"
+
+          TSFC.execute(data.merge(opts))
+        ensure
+          TSFC.dir nil
+        end
+
+        load_fixture("tmp/foo/tsfc/stub.json").should == {"a" => "a"}
+        load_fixture("tmp/foo/tsfc/mock.json").should == {"x" => 10}
       end
     end
   end

data/spec/receivers/fixture_save_why_spec.rb

@@ -13,7 +13,7 @@ describe Ccp::Commands::Composite do
     end
 
     def created_fixtures
-      Dir.chdir(FIXTURE_ROOT){Dir["*/read.json"].map{|i| File.dirname(i)}.sort}
+      Dir.chdir(FIXTURE_ROOT){Dir["*/stub.json"].map{|i| File.dirname(i)}.sort}
     rescue Errno::ENOENT
       []
     end
@@ -88,5 +88,27 @@ describe Ccp::Commands::Composite do
     execute(:fixture_save => ['Cmd1','!Cmd1']) do
       ['cmd1']
     end
+
+    ######################################################################
+    ### hard coded
+    context "(hard coded)" do
+      before { Cmd2.save true }
+      after  { Cmd2.save false }
+
+      # will save if hard coded is enabled
+      execute do
+        ['cmd2']
+      end
+
+      # respect hard coded even if runtime args are given
+      execute(:fixture_save => ['Cmd1']) do
+        ['cmd1', 'cmd2']
+      end
+
+      # respect it even if it is rejected by runtime args
+      execute(:fixture_save => ['!Cmd1', '!Cmd2']) do
+        ["cmd2", "cmd3", "program"]
+      end
+    end
   end
 end

data/spec/receivers/fixture_stub_spec.rb

@@ -0,0 +1,64 @@
+require "spec_helper"
+
+describe Ccp::Receivers::Fixtures do
+  context "(stub)" do
+    class Cmd1Stub < Cmd1
+      stub "spec/fixtures/stub/breadcrumbs.json"
+    end
+
+    it "should merge given data file into data variable" do
+      lambda {
+        Cmd1.execute
+      }.should raise_error(Typed::NotDefined)
+
+      lambda {
+        Cmd1Stub.execute
+      }.should_not raise_error
+    end
+  end
+
+  context "(stub and mock)" do
+    class Cmd1StubMock < Cmd1
+      stub "spec/fixtures/stub/breadcrumbs.json"
+      mock "spec/fixtures/cmd1stub_mock/mock.json"
+    end
+
+    it "should raise when current data doesn't match the given data" do
+      lambda {
+        Cmd1StubMock.execute
+      }.should_not raise_error
+    end
+  end
+
+  context "(stub and invalid mock)" do
+    class Cmd1StubInvalidMock < Cmd1
+      stub "spec/fixtures/stub/breadcrumbs.json"
+      mock "spec/fixtures/stub/breadcrumbs.json"
+    end
+
+    it "should raise when current data doesn't match the given data" do
+      lambda {
+        Cmd1StubInvalidMock.execute
+      }.should raise_error(/should create/)
+    end
+  end
+
+  context "(stub and mock and fail)" do
+    class Cmd1StubInvalidMockWithFail < Cmd1
+      dsl_accessor :failed, false
+
+      stub "spec/fixtures/stub/breadcrumbs.json"
+      mock "spec/fixtures/stub/breadcrumbs.json"
+
+      fail do |cmd, key, expected, got|
+        Cmd1StubInvalidMockWithFail.failed true
+      end
+    end
+
+    it "should raise when current data doesn't match the given data" do
+      Cmd1StubInvalidMockWithFail.failed.should == false
+      Cmd1StubInvalidMockWithFail.execute
+      Cmd1StubInvalidMockWithFail.failed.should == true
+    end
+  end
+end

data/spec/serializers/core_spec.rb

@@ -5,15 +5,7 @@ require 'fileutils'
 describe Ccp::Serializers::Core do
   subject { Object.new.extend Ccp::Serializers::Core }
 
-  it "should provide ext" do
-    subject.methods.include?("ext").should == true
-  end
-
-  it "should provide encode" do
-    subject.methods.include?("encode").should == true
-  end
-
-  it "should provide decode" do
-    subject.methods.include?("decode").should == true
-  end
+  it { should respond_to("ext") }
+  it { should respond_to("encode") }
+  it { should respond_to("decode") }
 end

data/spec/spec_helper.rb

@@ -12,11 +12,24 @@ def breadcrumbs_receiver
   return r
 end
 
+def lookup_serializer(extname)
+  {".json"=>JSON, ".yaml"=>YAML}[extname] or raise "no serializers for #{extname}"
+end
+
 def load_fixture(path)
   path = Pathname(path)
-  case path.extname
-  when ".json"; JSON.load(Pathname(path).read{})
-  when ".yaml"; YAML.load(Pathname(path).read{})
-  else; raise "load doesn't support #{path.extname}"
-  end
+  lookup_serializer(path.extname).load(path.read{})
+end
+
+def save_fixture(path, obj)
+  path = Pathname(path)
+  buf  = lookup_serializer(path.extname).dump(obj)
+  path.open("w+"){|f| f.print buf}
+end
+
+def truncate_pathname(dir)
+  path = Pathname(dir)
+  FileUtils.rm_rf(path.to_s)
+  path.mkpath
+  return path
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ccp
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 17
   prerelease: false
   segments: 
   - 0
   - 2
-  - 1
-  version: 0.2.1
+  - 3
+  version: 0.2.3
 platform: ruby
 authors: 
 - maiha
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-05-07 00:00:00 +09:00
+date: 2012-05-10 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -58,12 +58,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 15
+        hash: 13
         segments: 
         - 0
         - 4
-        - 0
-        version: 0.4.0
+        - 1
+        version: 0.4.1
   type: :runtime
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
@@ -103,6 +103,7 @@ files:
 - lib/ccp/commands/composite.rb
 - lib/ccp/commands/core.rb
 - lib/ccp/commands/executable.rb
+- lib/ccp/commands/fixturable.rb
 - lib/ccp/commands/receivable.rb
 - lib/ccp/commands/resolvable.rb
 - lib/ccp/fixtures.rb
@@ -110,10 +111,12 @@ files:
 - lib/ccp/fixtures/writers.rb
 - lib/ccp/invokers.rb
 - lib/ccp/invokers/base.rb
+- lib/ccp/invokers/spec.rb
 - lib/ccp/persistent.rb
 - lib/ccp/persistent/base.rb
 - lib/ccp/persistent/dir.rb
 - lib/ccp/persistent/file.rb
+- lib/ccp/persistent/loadable.rb
 - lib/ccp/persistent/tsv.rb
 - lib/ccp/persistent/versioned.rb
 - lib/ccp/receivers.rb
@@ -134,17 +137,25 @@ files:
 - lib/ccp/serializers/yaml.rb
 - lib/ccp/utils.rb
 - lib/ccp/utils/colorize.rb
+- lib/ccp/utils/fixture_options.rb
+- lib/ccp/utils/options.rb
 - lib/ccp/version.rb
 - spec/commands/base_spec.rb
 - spec/commands/composite_spec.rb
 - spec/commands/core_spec.rb
 - spec/commands/executable_spec.rb
+- spec/commands/fixturable_spec.rb
+- spec/fixtures/cmd1stub_mock/mock.json
+- spec/fixtures/stub/breadcrumbs.json
 - spec/invokers/base_spec.rb
+- spec/invokers/fixture_spec.rb
 - spec/invokers/save_fixture_spec.rb
+- spec/invokers/spec_spec.rb
 - spec/models.rb
 - spec/persistent/base_spec.rb
 - spec/persistent/dir_spec.rb
 - spec/persistent/file_spec.rb
+- spec/persistent/loadable_spec.rb
 - spec/persistent/tsv_spec.rb
 - spec/persistent/versioned_spec.rb
 - spec/receivers/fixture_save_how_spec.rb
@@ -152,6 +163,7 @@ files:
 - spec/receivers/fixture_save_what_spec.rb
 - spec/receivers/fixture_save_where_spec.rb
 - spec/receivers/fixture_save_why_spec.rb
+- spec/receivers/fixture_stub_spec.rb
 - spec/serializers/core_spec.rb
 - spec/serializers/json_spec.rb
 - spec/serializers/spec.rb