ccp 0.1.2 → 0.1.3

data/README.rdoc

@@ -0,0 +1,111 @@
+= ccp
+
+CCP is a Ruby library for Composite Command Programming
+that helps you to split spaghetti codes into pieces.
+
+=== Websites
+* http://github.com/maiha/ccp
+
+== What is a Composite Command Programming?
+
+There are three principles.
+
+1. SRP (Single responsibility principle)
+2. Typed Variables (especially needed in Ruby)
+3. Explicit Data Dependencies
+
+As you know, Ruby is a handy and powerful programming language.
+We can use variables without definitions and re-assign them even if type mismatch.
+Although it is very comfortable while you are writing, it would be painful for others.
+
+CCP is a framework composed with above principles and a few debugging utils
+that gives you(as writer) a little restrictions and gives you(as reader) a readability.
+
+
+== Example
+=== usual ruby code
+
+  class SomeOperation
+    def execute
+      # fetching data
+      # calculating it
+      # print results
+    end
+  end
+
+Later, it would be a more complex and longer code like this.
+
+  class SomeOperation
+    def execute
+      @data = fetch_data
+      ...
+      @result = calculate(@data)
+      ...
+      print_results(@result)
+    end
+
+    def fetching_data
+      # accessing instance variables, and long code here
+      ...
+
+Let's imagine a situation that you need to replace above "fetch" code after several years.
+It is too hard to see data dependencies especially about instance variables.
+
+=== with CCP
+
+  class SomeOperation
+    include Ccp::Commands::Composite
+
+    command FetchData
+    command Calculate
+    command PrintResult
+  end
+
+  class FetchData                                # 1. SRP 
+    include Ccp::Commands::Core
+
+    # {pre,post} methods can be used like Design By Contract
+    def post
+      data.check(:fetched, {Symbol => [Float]})  # 2. Typed Variables
+    end
+
+    def execute
+      # fetching data...
+      data[:fetched] = ...                       # 3. Data Dependencies
+    end
+  end
+
+  class Calculate
+    ...
+
+
+All sub commands like FetchData,Calculate,PrintResult are executed
+in each scopes, and can share variables only via data object.
+
+So you can easily refactor or replace FetchData unit
+because there are no implicit instance variable dependencies
+and futhermore all depencenies would be explicitly declared in "pre","post" method.
+
+=== execute
+
+Just call a "execute" instance method.
+
+  cmd = SomeOperation.new
+  cmd.execute
+
+=== invokers
+
+Invokers::Base can be used as a top level composite command.
+
+  class SomeOperation < Ccp::Invokers::Base
+    command FetchData
+    ...
+
+
+Its "benchmark" method generates profile information.
+
+  ruby -r some_operation -e 'SomeOperation.new.benchmark'
+  [43.3%] 2.5834830 FetchData#execute
+  [35.9%] 2.0710440 Calculate#execute
+  ...
+

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.0"
+  s.add_dependency "typed", ">= 0.1.2"
   s.add_dependency "dsl_accessor", ">= 0.4.0"
 
   s.add_development_dependency "rspec"

data/lib/ccp.rb

@@ -1,4 +1,5 @@
 require "typed"
+require "dsl_accessor"
 require "active_support/core_ext"
 require "ccp/version"
 require "ccp/data"

data/lib/ccp/commands/composite.rb

@@ -56,12 +56,6 @@ module Ccp
       ######################################################################
       ### Enumerable
 
-      def <<(command)
-        command = command.new if command.is_a?(Class) and command.ancestors.include?(Core)
-        command.must(Core)
-        commands << command
-      end
-
       def commands
         @commands ||= build_commands.must(Array)
       end
@@ -70,19 +64,18 @@ module Ccp
       ### Commands
 
       def execute
-        benchmark
+        commands.each(&:benchmark)
       end
 
-      def benchmark
-        pre if respond_to?(:pre)
-        commands.each(&:benchmark)
-        post if respond_to?(:post)
+      def receiver=(value)
+        super
+        commands.each{|c| c.receiver = value}
       end
 
       private
         def build_commands
           array = self.class.commands.select{|c| c.cond.nil? or instance_eval(&c.cond)}
-          array.map{|c|
+          cmds  = array.map{|c|
             c = c.klass.new(*c.args)
             c.receiver = receiver
             c

data/lib/ccp/commands/executable.rb

@@ -9,8 +9,8 @@ module Ccp
 
       ### Profiling
 
-      def benchmark(method = :execute)
-        receiver.profile(self, method)
+      def benchmark
+        receiver.profile(self, :execute)
       end
     end
   end

data/lib/ccp/commands/receivable.rb

@@ -5,7 +5,7 @@ module Ccp
       ### Receiver Methods
 
       def receiver
-        @receiver ||= Ccp::Receivers::None.new
+        @receiver ||= Ccp::Receivers::Base.new
       end
 
       def receiver=(value)

data/lib/ccp/invokers/base.rb

@@ -12,26 +12,49 @@ module Ccp
       DEFAULT_OPTIONS = {
         :profile => false,
         :comment => true,
+        :logger  => Logger.new($stderr),
       }
 
+      ######################################################################
+      ### Class Methods
+
+      def self.execute(options = {}, &block)
+        cmd = new(options)
+        if block_given?
+          cmd.instance_eval(&block)
+        end
+        cmd.benchmark
+        return cmd
+      end
+
+      def self.benchmark(options = {}, &block)
+        execute({:profile => true}.merge(options), &block)
+      end
+
       ######################################################################
       ### Instance Methods
 
       def initialize(options = nil)
-        self.receiver = self.class.receiver.new
-        self.class.prepend_command Commands::RuntimeArgs, options
+        options ||= {}
+        set_default_receiver(options[:receiver])
         set_default_options
+        set_runtime_options(options)
+      end
+
+      def set_default_receiver(receiver)
+        self.receiver = receiver || self.class.receiver.new
       end
 
       def set_default_options
         self.class::DEFAULT_OPTIONS.each_pair do |key,val|
           data.default[key] = val
         end
-        data.default(:logger) { Logger.new($stderr) }
       end
 
-      def execute
-        benchmark
+      def set_runtime_options(options)
+        options.each_pair do |key,val|
+          data[key] = val
+        end
       end
 
       def benchmark

data/lib/ccp/receivers.rb

@@ -1,7 +1,7 @@
 module Ccp
   module Receivers
     autoload :Base           , 'ccp/receivers/base'
-    autoload :None           , 'ccp/receivers/none'
+    autoload :Global         , 'ccp/receivers/global'
     autoload :Commentable    , 'ccp/receivers/commentable'
     autoload :Profileable    , 'ccp/receivers/profileable'
   end

data/lib/ccp/receivers/global.rb

@@ -0,0 +1,9 @@
+module Ccp
+  module Receivers
+    class Global < Base
+      def self.new
+        @instance ||= super
+      end
+    end
+  end
+end

data/lib/ccp/receivers/none.rb

@@ -1,6 +1,6 @@
 module Ccp
   module Receivers
-    class None < Base
+    class Global < Base
       def self.new
         @instance ||= super
       end

data/lib/ccp/receivers/profileable.rb

@@ -16,12 +16,16 @@ module Ccp
 
       def profile(target, method)
         start = Time.new
-        target.pre if target.must.duck?(:pre)
+        target.__send__(:pre) if target.respond_to?(:pre)
         target.__send__(method)
-        target.post if target.must.duck?(:post)
-        target.must.duck(:no_bench) {
+        target.__send__(:post) if target.respond_to?(:post)
+
+        case target
+        when Ccp::Commands::Composite
+          # no profiles
+        else
           profiles << Profile.new(target, method, (Time.new - start).to_f)
-        }
+        end
       end
 
       def profiles

data/lib/ccp/version.rb

@@ -1,3 +1,3 @@
 module Ccp
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/spec/commands_composite_spec.rb

@@ -0,0 +1,83 @@
+require "spec_helper"
+
+describe Ccp::Commands::Composite do
+  describe "#execute" do
+    it "should call its execute and sub commands's {pre,execute,post} in declared order" do
+      c = Program.new
+      c.data[:breadcrumbs] = []
+      c.execute
+      c.data[:breadcrumbs].should ==
+        ["Cmd1#pre", "Cmd1#execute", "Cmd1#post",
+         "Cmd2#pre", "Cmd2#execute", "Cmd2#post",
+         "Cmd3#pre", "Cmd3#execute", "Cmd3#post"]
+    end
+  end
+
+  describe "#benchmark" do
+    it "should call its and sub commands's {pre,execute,post} in declared order" do
+      c = Program.new
+      c.data[:breadcrumbs] = []
+      c.benchmark
+      c.data[:breadcrumbs].should ==
+        ["Program#pre",
+         "Cmd1#pre", "Cmd1#execute", "Cmd1#post",
+         "Cmd2#pre", "Cmd2#execute", "Cmd2#post",
+         "Cmd3#pre", "Cmd3#execute", "Cmd3#post",
+         "Program#post"]
+    end
+  end
+end
+
+describe "Ccp::Commands::Composite(nested)" do
+  describe "#execute" do
+    it "should call its execute and sub commands's {pre,execute,post} in declared order" do
+      c = CompositeProgram.new
+      c.data[:breadcrumbs] = []
+      c.execute
+      c.data[:breadcrumbs].should ==
+        ["Cmd1#pre", "Cmd1#execute", "Cmd1#post",
+         "Cmd23#pre",
+         "Cmd23#execute:start",
+         "Cmd2#pre", "Cmd2#execute", "Cmd2#post",
+         "Cmd3#pre", "Cmd3#execute", "Cmd3#post",
+         "Cmd23#execute:end",
+         "Cmd23#post",
+         "Cmd4#pre", "Cmd4#execute", "Cmd4#post"]
+    end
+  end
+
+  describe "#benchmark" do
+    it "should call its and sub commands's {pre,execute,post} in declared order" do
+      c = CompositeProgram.new
+      c.data[:breadcrumbs] = []
+      c.benchmark
+      c.data[:breadcrumbs].should ==
+        ["CompositeProgram#pre",
+         "Cmd1#pre", "Cmd1#execute", "Cmd1#post",
+         "Cmd23#pre",
+         "Cmd23#execute:start",
+         "Cmd2#pre", "Cmd2#execute", "Cmd2#post",
+         "Cmd3#pre", "Cmd3#execute", "Cmd3#post",
+         "Cmd23#execute:end",
+         "Cmd23#post",
+         "Cmd4#pre", "Cmd4#execute", "Cmd4#post",
+         "CompositeProgram#post"]
+    end
+  end
+
+  it "should update receiver recursively" do
+    cmd = CompositeProgram.new
+    cmd.commands.each do |c|
+      c.receiver.should == cmd.receiver
+    end
+
+    new_receiver = Ccp::Receivers::Base.new
+    new_receiver.should_not == cmd.receiver
+
+    # update receiver
+    cmd.receiver = new_receiver
+    cmd.commands.each do |c|
+      c.receiver.should == cmd.receiver
+    end
+  end
+end

data/spec/commands_core_spec.rb

@@ -0,0 +1,47 @@
+require "spec_helper"
+
+describe Ccp::Commands::Core do
+  describe "(accessor)" do
+    subject { Object.new.extend Ccp::Commands::Core } 
+
+    # 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) }
+    it { should respond_to(:benchmark) }
+
+    # receivable
+    it { should respond_to(:receiver) }
+    its(:receiver) { should be_kind_of(Ccp::Receivers::Base) }
+  end
+
+  describe "#execute" do
+    it "should call only execute" do
+      cmd1 = Cmd1.new
+      cmd1.data[:breadcrumbs] = []
+      cmd1.execute
+      cmd1.data[:breadcrumbs].should == ["Cmd1#execute"]
+    end
+  end
+
+  describe "#benchmark" do
+    it "should call {pre,execute,post}" do
+      cmd1 = Cmd1.new
+      cmd1.data[:breadcrumbs] = []
+      cmd1.benchmark
+      cmd1.data[:breadcrumbs].should == ["Cmd1#pre", "Cmd1#execute", "Cmd1#post"]
+    end
+
+    it "should call receiver.profile" do
+      (receiver = Ccp::Receivers::Base.new).should_receive(:profile)
+
+      cmd1 = Cmd1.new
+      cmd1.receiver = receiver
+      cmd1.data[:breadcrumbs] = []
+      cmd1.benchmark
+    end
+  end
+end

data/spec/invokers_spec.rb

@@ -0,0 +1,121 @@
+require "spec_helper"
+
+describe Ccp::Invokers::Base do
+  def no_logger; Logger.new('/dev/null'); end
+
+  describe "#execute" do
+    it "should call its execute and sub commands's {pre,execute,post} in declared order" do
+      c = CompositeInvoker.new
+      c.data[:breadcrumbs] = []
+      c.execute
+      c.data[:breadcrumbs].should ==
+        ["Cmd1#pre", "Cmd1#execute", "Cmd1#post",
+         "Cmd23#pre",
+         "Cmd23#execute:start",
+         "Cmd2#pre", "Cmd2#execute", "Cmd2#post",
+         "Cmd3#pre", "Cmd3#execute", "Cmd3#post",
+         "Cmd23#execute:end",
+         "Cmd23#post",
+         "Cmd4#pre", "Cmd4#execute", "Cmd4#post"]
+    end
+  end
+
+  describe "#benchmark" do
+    it "should call its and sub commands's {pre,execute,post} in declared order" do
+      c = CompositeInvoker.new
+      c.data[:breadcrumbs] = []
+      c.benchmark
+      c.data[:breadcrumbs].should ==
+        ["CompositeInvoker#pre",
+         "Cmd1#pre", "Cmd1#execute", "Cmd1#post",
+         "Cmd23#pre",
+         "Cmd23#execute:start",
+         "Cmd2#pre", "Cmd2#execute", "Cmd2#post",
+         "Cmd3#pre", "Cmd3#execute", "Cmd3#post",
+         "Cmd23#execute:end",
+         "Cmd23#post",
+         "Cmd4#pre", "Cmd4#execute", "Cmd4#post",
+         "CompositeInvoker#post"]
+    end
+  end
+
+  describe ".execute" do
+    it "should call its and sub commands's {pre,execute,post} in declared order" do
+      c = CompositeInvoker.execute(:breadcrumbs => [])
+      c.data[:breadcrumbs].should ==
+        ["CompositeInvoker#pre",
+         "Cmd1#pre", "Cmd1#execute", "Cmd1#post",
+         "Cmd23#pre",
+         "Cmd23#execute:start",
+         "Cmd2#pre", "Cmd2#execute", "Cmd2#post",
+         "Cmd3#pre", "Cmd3#execute", "Cmd3#post",
+         "Cmd23#execute:end",
+         "Cmd23#post",
+         "Cmd4#pre", "Cmd4#execute", "Cmd4#post",
+         "CompositeInvoker#post"]
+    end
+
+    it "should call only show_comments in default" do
+      r = Ccp::Receivers::Base.new
+      r.should_receive(:show_comments).once
+      r.should_receive(:show_profiles).never
+      CompositeInvoker.execute(:receiver => r, :breadcrumbs => [])
+    end
+
+    it "should call show_profiles if :profile option is given" do
+      r = Ccp::Receivers::Base.new
+      r.should_receive(:show_profiles).once
+      CompositeInvoker.execute(:receiver => r, :breadcrumbs => [], :profile => true)
+    end
+
+    it "should disable show_comments if :comment option is false" do
+      r = Ccp::Receivers::Base.new
+      r.should_receive(:show_comments).never
+      CompositeInvoker.execute(:receiver => r, :breadcrumbs => [], :comment => false)
+    end
+  end
+
+  describe ".benchmark" do
+    it "should call its and sub commands's {pre,execute,post} in declared order" do
+      r = Ccp::Receivers::Base.new
+      r.stub!(:show_comments)   # disable output
+      r.stub!(:show_profiles)   # disable output
+
+      c = CompositeInvoker.benchmark(:receiver => r, :breadcrumbs => [])
+      c.data[:breadcrumbs].should ==
+        ["CompositeInvoker#pre",
+         "Cmd1#pre", "Cmd1#execute", "Cmd1#post",
+         "Cmd23#pre",
+         "Cmd23#execute:start",
+         "Cmd2#pre", "Cmd2#execute", "Cmd2#post",
+         "Cmd3#pre", "Cmd3#execute", "Cmd3#post",
+         "Cmd23#execute:end",
+         "Cmd23#post",
+         "Cmd4#pre", "Cmd4#execute", "Cmd4#post",
+         "CompositeInvoker#post"]
+    end
+
+    it "should call only show_comments in default" do
+      r = Ccp::Receivers::Base.new
+      r.should_receive(:show_comments).once
+      r.should_receive(:show_profiles).once
+      CompositeInvoker.benchmark(:receiver => r, :breadcrumbs => [])
+    end
+
+    it "should disable show_profiles if :profile option is false" do
+      r = Ccp::Receivers::Base.new
+      r.should_receive(:show_comments).once
+      r.should_receive(:show_profiles).never
+      CompositeInvoker.benchmark(:receiver => r, :breadcrumbs => [], :profile => false)
+    end
+
+    it "should disable show_comments if :comment option is false" do
+      r = Ccp::Receivers::Base.new
+      r.should_receive(:show_comments).never
+      r.should_receive(:show_profiles).once
+      CompositeInvoker.benchmark(:receiver => r, :breadcrumbs => [], :comment => false)
+    end
+  end
+end
+
+

data/spec/models.rb

@@ -0,0 +1,98 @@
+module Breadcrumbing
+  def this
+    "%s#%s" % [self.class.name, caller[0].to_s.scan(/`(.*?)'/).first]
+  end
+end
+
+class Cmd1
+  include Ccp::Commands::Core
+  include Breadcrumbing
+
+  def pre
+    data[:breadcrumbs] << this
+  end
+
+  def execute
+    data[:breadcrumbs] << this
+  end
+
+  def post
+    data[:breadcrumbs] << this
+  end
+end
+
+class Cmd2 < Cmd1; end
+class Cmd3 < Cmd1; end
+class Cmd4 < Cmd1; end
+
+class Program
+  include Ccp::Commands::Composite
+  include Breadcrumbing
+
+  command Cmd1
+  command Cmd2
+  command Cmd3
+
+  def pre
+    data[:breadcrumbs] << this
+  end
+
+  def post
+    data[:breadcrumbs] << this
+  end
+end
+
+class Cmd23
+  include Ccp::Commands::Composite
+  include Breadcrumbing
+
+  command Cmd2
+  command Cmd3
+
+  def pre
+    data[:breadcrumbs] << this
+  end
+
+  def execute
+    data[:breadcrumbs] << this + ":start"
+    super
+    data[:breadcrumbs] << this + ":end"
+  end
+
+  def post
+    data[:breadcrumbs] << this
+  end
+end
+
+class CompositeProgram
+  include Ccp::Commands::Composite
+  include Breadcrumbing
+
+  command Cmd1
+  command Cmd23
+  command Cmd4
+
+  def pre
+    data[:breadcrumbs] << this
+  end
+
+  def post
+    data[:breadcrumbs] << this
+  end
+end
+
+class CompositeInvoker < Ccp::Invokers::Base
+  include Breadcrumbing
+
+  command Cmd1
+  command Cmd23
+  command Cmd4
+
+  def pre
+    data[:breadcrumbs] << this
+  end
+
+  def post
+    data[:breadcrumbs] << this
+  end
+end

data/spec/spec_helper.rb

@@ -3,3 +3,5 @@ $:.unshift File.expand_path('../../lib', __FILE__)
 
 require 'rspec'
 require 'ccp'
+
+require File.join(File.dirname(__FILE__), "models")

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ccp
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 29
   prerelease: false
   segments: 
   - 0
   - 1
-  - 2
-  version: 0.1.2
+  - 3
+  version: 0.1.3
 platform: ruby
 authors: 
 - maiha
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-02-10 00:00:00 +09:00
+date: 2012-02-14 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,12 +26,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 27
+        hash: 31
         segments: 
         - 0
         - 1
-        - 0
-        version: 0.1.0
+        - 2
+        version: 0.1.2
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -76,7 +76,7 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - Gemfile
-- README
+- README.rdoc
 - Rakefile
 - ccp.gemspec
 - lib/ccp.rb
@@ -89,19 +89,21 @@ files:
 - lib/ccp/commands/executable.rb
 - lib/ccp/commands/receivable.rb
 - lib/ccp/commands/resolvable.rb
-- lib/ccp/commands/runtime_args.rb
 - lib/ccp/data.rb
 - lib/ccp/invokers.rb
 - lib/ccp/invokers/base.rb
 - lib/ccp/receivers.rb
 - lib/ccp/receivers/base.rb
 - lib/ccp/receivers/commentable.rb
+- lib/ccp/receivers/global.rb
 - lib/ccp/receivers/none.rb
 - lib/ccp/receivers/profileable.rb
 - lib/ccp/version.rb
-- spec/commands_spec.rb
-- spec/composite_spec.rb
+- spec/commands_composite_spec.rb
+- spec/commands_core_spec.rb
 - spec/data_spec.rb
+- spec/invokers_spec.rb
+- spec/models.rb
 - spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/maiha/ccp

data/lib/ccp/commands/runtime_args.rb

@@ -1,24 +0,0 @@
-# -*- coding: utf-8 -*-
-# map options to data
-
-module Ccp
-  module Commands
-    class RuntimeArgs
-      include Core
-
-      def initialize(options = {})
-        @options = (options || {}).must(Hash)
-      end
-
-      def execute
-        @options.each_pair do |key, val|
-          data[key] = val
-        end
-      end
-
-      def inspect
-        super.sub(/>$/, " #{@options.inspect}>")
-      end
-    end
-  end
-end

data/spec/commands_spec.rb

@@ -1,18 +0,0 @@
-require "spec_helper"
-
-describe Ccp::Commands::Core do
-  subject { Object.new.extend Ccp::Commands::Core } 
-
-  # 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) }
-  it { should respond_to(:benchmark) }
-
-  # receivable
-  it { should respond_to(:receiver) }
-  its(:receiver) { should be_kind_of(Ccp::Receivers::Base) }
-end

data/spec/composite_spec.rb

@@ -1,85 +0,0 @@
-require "spec_helper"
-
-describe Ccp::Commands::Composite do
-  module Breadcrumbing
-    BREADCRUMBS = []
-
-    def this
-      "%s#%s" % [self.class.name, caller[0].to_s.scan(/`(.*?)'/).first]
-    end
-
-    def breadcrumbs
-      BREADCRUMBS
-    end
-  end
-
-  class Cmd1
-    include Ccp::Commands::Core
-    include Breadcrumbing
-
-    def execute
-      breadcrumbs << this
-      data[:foo] = []
-    end
-
-    def post
-      breadcrumbs << this
-    end
-  end
-
-  class Cmd2
-    include Ccp::Commands::Core
-    include Breadcrumbing
-
-    def pre
-      breadcrumbs << this
-    end
-
-    def execute
-      breadcrumbs << this
-      data[:foo] << "cmd2"
-    end
-
-    def post
-      breadcrumbs << this
-    end
-  end
-
-  class Cmd3
-    include Ccp::Commands::Core
-    include Breadcrumbing
-
-    def pre
-      breadcrumbs << this
-    end
-
-    def execute
-      breadcrumbs << this
-      data[:foo] << "cmd3"
-    end
-  end
-
-  class Program
-    include Ccp::Commands::Composite
-
-    command Cmd1
-    command Cmd2
-    command Cmd3
-  end
-
-  subject { Program.new }
-
-  it { should be_kind_of(Ccp::Commands::Core) }
-
-  it "should call sub commands's {pre,execute,post} in declared order" do
-    Breadcrumbing::BREADCRUMBS.clear
-    subject.execute
-    Breadcrumbing::BREADCRUMBS.should ==
-      ["Cmd1#execute", "Cmd1#post", "Cmd2#pre", "Cmd2#execute", "Cmd2#post", "Cmd3#pre", "Cmd3#execute"]
-  end
-
-  it "should share same data storage in each sub commands" do
-    subject.execute
-    subject.data[:foo].should == ["cmd2", "cmd3"]
-  end
-end