ccp 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+gem 'must', '>= 0.2.5'
+gem 'dsl_accessor', '>= 0.4.0'

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/ccp.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ccp/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ccp"
+  s.version     = Ccp::VERSION
+  s.authors     = ["maiha"]
+  s.email       = ["maiha@wota.jp"]
+  s.homepage    = "http://github.com/maiha/ccp"
+  s.summary     = %q{A Ruby library for Composite Command Programming}
+  s.description = %q{CCP}
+
+  s.rubyforge_project = "ccp"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "activesupport"
+  s.add_dependency "must", ">= 0.2.5"
+  s.add_dependency "dsl_accessor", ">= 0.4.0"
+
+  s.add_development_dependency "rspec"
+end

data/lib/ccp.rb

@@ -0,0 +1,11 @@
+require "must"
+require "active_support/core_ext"
+require "ccp/version"
+require "ccp/data"
+
+module Ccp
+  autoload :Colorize,          'ccp/colorize'
+  autoload :Commands,          'ccp/commands'
+  autoload :Invokers,          'ccp/invokers'
+  autoload :Receivers,         'ccp/receivers'
+end

data/lib/ccp/colorize.rb

@@ -0,0 +1,13 @@
+module Ccp
+  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

data/lib/ccp/commands.rb

@@ -0,0 +1,12 @@
+module Ccp
+  module Commands
+    autoload :CommandNotFound, 'ccp/commands/command_not_found'
+    autoload :Composite      , 'ccp/commands/composite'
+    autoload :Executable     , 'ccp/commands/executable'
+    autoload :Receivable     , 'ccp/commands/receivable'
+    autoload :RuntimeArgs    , 'ccp/commands/runtime_args'
+    autoload :Commentable    , 'ccp/commands/commentable'
+    autoload :Core           , 'ccp/commands/core'
+    autoload :Resolvable     , 'ccp/commands/resolvable'
+  end
+end

data/lib/ccp/commands/command_not_found.rb

@@ -0,0 +1,6 @@
+module Ccp
+  module Commands
+    CommandNotFound = Class.new(RuntimeError)
+  end
+end
+

data/lib/ccp/commands/commentable.rb

@@ -0,0 +1,21 @@
+module Ccp
+  module Commands
+    module Commentable
+      def MEMO(*messages)
+        from = caller.is_a?(Array) ? caller.first : self.class
+        receiver.comment("MEMO: #{_build_comment(*messages)}\n  #{from}")
+      end
+
+      def TODO(*messages)
+        from = caller.is_a?(Array) ? caller.first : self.class
+        receiver.comment("TODO: #{_build_comment(*messages)}\n  #{from}", :warn)
+      end
+
+      private
+        def _build_comment(*objs)
+          objs = objs.first if objs.size == 1
+          objs.is_a?(String) ? objs : objs.inspect
+        end
+    end
+  end
+end

data/lib/ccp/commands/composite.rb

@@ -0,0 +1,93 @@
+module Ccp
+  module Commands
+    module Composite
+      def self.included(base)
+        base.class_eval do
+          extend ClassMethods
+        end
+      end
+
+      CommandClass = Struct.new(:klass, :args, :cond) unless defined?(CommandClass)
+      class CommandClass
+        def inspect
+          name = klass.name.split(/Commands::/,2).last
+          "<%s args=%s cond=%s>" % [name, args.inspect, cond.inspect]
+        end
+
+        def to_s
+          inspect
+        end
+      end
+
+      ######################################################################
+      ### Class Methods
+
+      module ClassMethods
+        include Resolvable
+
+        def prepend_command(klass, *args, &block)
+          commands.unshift CommandClass.new(resolve(klass), args, block)
+        end
+
+        def append_command(klass, *args, &block)
+          klass = resolve(klass)
+          if commands.find{|cc| cc.klass == klass}
+            # ignore: already added
+          else
+            commands << CommandClass.new(klass, args, block)
+          end
+        end
+
+        def command(*args)
+          append_command(*args)
+        end
+
+        def commands
+          @commands ||= []
+        end
+      end
+
+      ######################################################################
+      ### Instance Methods
+
+      include Core
+      include Enumerable
+
+      ######################################################################
+      ### 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
+
+      ######################################################################
+      ### Commands
+
+      def execute
+        benchmark
+      end
+
+      def benchmark
+        pre if respond_to?(:pre)
+        commands.each(&:benchmark)
+        post if respond_to?(:post)
+      end
+
+      private
+        def build_commands
+          array = self.class.commands.select{|c| c.cond.nil? or instance_eval(&c.cond)}
+          array.map{|c|
+            c = c.klass.new(*c.args)
+            c.receiver = receiver
+            c
+          }
+        end
+    end
+  end
+end

data/lib/ccp/commands/core.rb

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

data/lib/ccp/commands/executable.rb

@@ -0,0 +1,17 @@
+module Ccp
+  module Commands
+    module Executable
+
+      ### Command
+
+      def execute
+      end
+
+      ### Profiling
+
+      def benchmark(method = :execute)
+        receiver.profile(self, method)
+      end
+    end
+  end
+end

data/lib/ccp/commands/receivable.rb

@@ -0,0 +1,21 @@
+module Ccp
+  module Commands
+    module Receivable
+      ######################################################################
+      ### Receiver Methods
+
+      def receiver
+        @receiver ||= Ccp::Receivers::None.new
+      end
+
+      def receiver=(value)
+        @receiver = value.must(Ccp::Receivers::Base)
+      end
+
+      ######################################################################
+      ### Delegate Methods
+
+      delegate :data, :data?, :to=>"receiver"
+    end
+  end
+end

data/lib/ccp/commands/resolvable.rb

@@ -0,0 +1,23 @@
+module Ccp
+  module Commands
+    module Resolvable
+      def resolve(klass)
+        klass.must.coerced(Class, Module) {
+          raise CommandNotFound, "expected Class or Module, but got #{klass.class}"
+        }
+
+        if klass.ancestors.include?(Commands::Core)
+          return klass # ok
+        end
+
+        if klass.must.duck?("#execute")
+          # dynamically assign core
+          klass.class_eval{ include Commands::Core }
+          return klass
+        end
+
+        raise CommandNotFound, "#{klass} found but it misses 'execute' method"
+      end
+    end
+  end
+end

data/lib/ccp/commands/runtime_args.rb

@@ -0,0 +1,24 @@
+# -*- 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/lib/ccp/data.rb

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+
+require 'pathname'
+
+module Ccp
+  module Data
+    NotDefined = Class.new(RuntimeError)
+
+    class KVS
+      delegate :[]=, :to=>"@hash"
+
+      LazyValue = Struct.new(:block)
+
+      class Default
+        def initialize(kvs)
+          @kvs = kvs
+        end
+
+        def []=(key, val)
+          return if @kvs.exist?(key)
+          @kvs[key] = val
+        end
+
+        def regsiter_lazy(key, block)
+          return if @kvs.exist?(key)
+          raise ArgumentError, "Lazy default value needs block: #{key}" unless block
+          @kvs[key] = LazyValue.new(block)
+        end
+      end
+
+      def initialize
+        @hash    = {}
+        @default = Default.new(self)
+      end
+
+      ######################################################################
+      ### Default values
+
+      def default(key = nil, &block)
+        if key
+          @default.regsiter_lazy(key, block)
+        else
+          @default
+        end
+      end
+
+      ######################################################################
+      ### Accessor
+
+      def [](key)
+        if exist?(key)
+          return load(key)
+        else
+          from = caller.is_a?(Array) ? caller.first : self.class
+          raise NotDefined, "'#{key}' is not initialized\n#{from}"
+        end
+      end
+
+      ######################################################################
+      ### Testing
+
+      def exist?(key)
+        @hash.has_key?(key)
+      end
+
+      def set?(key)
+        !! (exist?(key) && self[key])
+      end
+
+      def check(key, type)
+        self[key].must.struct(type) {
+          summary = self[key].inspect
+          summary = summary[0,200] + "..." if summary.size > 200
+          raise TypeError, "'#{key}' expects '#{type.inspect}', but got #{summary}"
+        }
+      end
+
+      ######################################################################
+      ### Utils
+
+      def path(key)
+        self[key].must.coerced(Pathname, String=>proc{|i| Pathname(i)})
+      end
+
+      def inspect
+        keys = @hash.keys.map(&:to_s).sort.join(',')
+        "{#{keys}}"
+      end
+
+      private
+        def load(key)
+          # LazyValue should be evaluated at runtime
+          value = @hash[key]
+          value = value.block.call if value.is_a?(LazyValue)
+          return value
+        end
+    end
+
+    def data
+      @data ||= KVS.new
+    end
+
+    def data?(key)
+      data.set?(key)
+    end
+  end
+end

data/lib/ccp/invokers.rb

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

data/lib/ccp/invokers/base.rb

@@ -0,0 +1,62 @@
+require 'logger'
+
+module Ccp
+  module Invokers
+    class Base
+      include Commands::Composite
+
+      dsl_accessor :receiver, Receivers::Base
+      delegate :show_profiles, :profiles, :to=>"receiver"
+      delegate :show_comments, :comments, :to=>"receiver"
+
+      DEFAULT_OPTIONS = {
+        :profile => false,
+        :comment => true,
+      }
+
+      ######################################################################
+      ### Instance Methods
+
+      def initialize(options = nil)
+        self.receiver = self.class.receiver.new
+        self.class.prepend_command Commands::RuntimeArgs, options
+        set_default_options
+      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
+      end
+
+      def benchmark
+        before
+        super
+        after
+        return true
+      end
+
+      def receiver
+        @receiver.must(Receivers::Base)
+      end
+
+      def receiver=(value)
+        @receiver = value.must(Receivers::Base)
+      end
+
+      private
+        def before
+        end
+
+        def after
+          show_profiles if data?(:profile)
+          show_comments if data?(:comment)
+        end
+    end
+  end
+end

data/lib/ccp/receivers.rb

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

data/lib/ccp/receivers/base.rb

@@ -0,0 +1,15 @@
+module Ccp
+  module Receivers
+    class Base
+      include Ccp::Data
+      include Profileable
+      include Commentable
+
+      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/commentable.rb

@@ -0,0 +1,35 @@
+module Ccp
+  module Receivers
+    module Commentable
+
+      Comment = Struct.new(:text, :level)
+      class Comment
+        include Colorize
+        def colorized
+          case level
+          when :warn          ; yellow(text)
+          when :error, :fatal ; red(text)
+          when :info          ; green(text)
+          else                ; text
+          end
+        end
+      end
+
+      def comment(text, level = nil)
+        comments[text] ||= Comment.new(text, level)
+      end
+
+      def comments
+        @comments ||= ActiveSupport::OrderedHash.new
+      end
+
+      def show_comments(*args)
+        opts   = Optionize.new(args, :output)
+        output = opts[:output] || $stderr
+        comments.each_value do |comment|
+          output.puts comment.colorized
+        end
+      end
+    end
+  end
+end

data/lib/ccp/receivers/none.rb

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

data/lib/ccp/receivers/profileable.rb

@@ -0,0 +1,57 @@
+module Ccp
+  module Receivers
+    module Profileable
+      include Colorize
+
+      Profile = Struct.new(:target, :method, :time)
+      class Profile
+        def name
+          target.is_a?(Class) ? "#{target.name}.#{method}" : "#{target.class}##{method}"
+        end
+
+        def profile(total)
+          "[%4.1f%%] %.7f %s" % [(time*100/total), time, name]
+        end
+      end
+
+      def profile(target, method)
+        start = Time.new
+        target.pre if target.must.duck?(:pre)
+        target.__send__(method)
+        target.post if target.must.duck?(:post)
+        target.must.duck(:no_bench) {
+          profiles << Profile.new(target, method, (Time.new - start).to_f)
+        }
+      end
+
+      def profiles
+        @profiles ||= []
+      end
+
+      def show_profiles(*args, &block)
+        opts   = Optionize.new(args, :benchs, :output)
+        benchs = opts[:benchs] || profiles
+        output = opts[:output] || $stderr
+
+        # search worst item
+        total = 0
+        worst = nil
+        benchs.each do |bench|
+          total += bench.time
+          worst = bench if !worst or bench.time > worst.time
+        end
+
+        benchs.each do |bench|
+          colorize = (bench == worst) ? :pink : :aqua
+          profiled = __send__(colorize, bench.profile(total))
+          if block
+            block.call(profiled)
+          else
+            output.puts profiled
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/ccp/version.rb

@@ -0,0 +1,3 @@
+module Ccp
+  VERSION = "0.1.0"
+end

data/spec/commands_spec.rb

@@ -0,0 +1,18 @@
+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(Ccp::Data::KVS) }
+
+  # 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

@@ -0,0 +1,85 @@
+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

data/spec/data_spec.rb

@@ -0,0 +1,129 @@
+require "spec_helper"
+
+describe Ccp::Data::KVS do
+  ######################################################################
+  ### Accessor
+
+  it "should behave like hash" do
+    subject[:foo] = 1
+    subject[:foo].should == 1
+  end
+
+  describe "#[]" do
+    it "should raise NotDefined if no data exist for the key" do
+      lambda {
+        subject[:foo]
+      }.should raise_error(Ccp::Data::NotDefined)
+    end
+  end
+
+  describe "#[]=" do
+    it "can override values" do
+      subject[:foo] = 1
+      subject[:foo] = 2
+      subject[:foo].should == 2
+    end
+  end
+
+  ######################################################################
+  ### Testing
+
+  describe "#exist?" do
+    it "should return true if the value is set" do
+      subject[:foo] = 1
+      subject.exist?(:foo).should == true
+    end
+
+    it "should return false if the value is not set" do
+      subject.exist?(:foo).should == false
+    end
+  end
+
+  describe "#set?" do
+    it "should return true if the value is set and not (nil|false)" do
+      subject[:foo] = 0
+      subject.set?(:foo).should == true
+
+      subject.default[:bar] = 0
+      subject.set?(:bar).should == true
+
+      subject.default(:baz) { 0 }
+      subject.set?(:baz).should == true
+    end
+
+    it "should return false if the value is set but (nil|false)" do
+      subject[:foo] = nil
+      subject.set?(:foo).should == false
+
+      subject[:foo] = false
+      subject.set?(:foo).should == false
+    end
+  end
+
+  describe "#check" do
+    it "should satisfy its type" do
+      subject[:foo] = 1
+      lambda {
+        subject.check(:foo, Integer)
+      }.should_not raise_error
+    end
+
+    it "should satisfy its struct" do
+      subject[:foo] = {:a => "text"}
+      lambda {
+        subject.check(:foo, {Symbol => String})
+      }.should_not raise_error
+    end
+
+    it "should raise TypeError if not satisfied" do
+      subject[:foo] = {:a => "text"}
+      lambda {
+        subject.check(:foo, Integer)
+      }.should raise_error(TypeError)
+    end
+  end
+
+  ######################################################################
+  ### Default values
+
+  describe "#default" do
+    it "should set default value" do
+      subject.default[:foo] = 1
+      subject.exist?(:foo).should == true
+      subject[:foo].should == 1
+    end
+
+    it "should be overriden by []=" do
+      subject.default[:foo] = 1
+      subject[:foo] = 2
+      subject[:foo].should == 2
+    end
+
+    it "should not affect data when already set" do
+      subject[:foo] = 1
+      subject.default[:foo] = 2
+      subject[:foo].should == 1
+    end
+  end
+
+  describe "#default(&block)" do
+    it "should set lazy default value" do
+      @a = 1
+      subject.default(:foo) { @a }
+      @a = 2
+      subject[:foo].should == 2
+    end
+  end
+
+  ######################################################################
+  ### Utils
+
+  describe "#path" do
+    it "should return pathname" do
+      subject[:foo] = __FILE__
+      subject.path(:foo).should be_kind_of(Pathname)
+      subject.path(:foo).basename.should == Pathname("data_spec.rb")
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+# $:.unshift File.expand_path('..', __FILE__)
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rspec'
+require 'ccp'

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification 
+name: ccp
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- maiha
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-02-09 00:00:00 +09:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: must
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 29
+        segments: 
+        - 0
+        - 2
+        - 5
+        version: 0.2.5
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: dsl_accessor
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 0
+        - 4
+        - 0
+        version: 0.4.0
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: CCP
+email: 
+- maiha@wota.jp
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README
+- Rakefile
+- ccp.gemspec
+- lib/ccp.rb
+- lib/ccp/colorize.rb
+- lib/ccp/commands.rb
+- lib/ccp/commands/command_not_found.rb
+- lib/ccp/commands/commentable.rb
+- lib/ccp/commands/composite.rb
+- lib/ccp/commands/core.rb
+- 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/none.rb
+- lib/ccp/receivers/profileable.rb
+- lib/ccp/version.rb
+- spec/commands_spec.rb
+- spec/composite_spec.rb
+- spec/data_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/maiha/ccp
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: ccp
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A Ruby library for Composite Command Programming
+test_files: []
+