ccp 0.1.0 → 0.1.2

data/Gemfile

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

data/ccp.gemspec

@@ -18,8 +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 "activesupport"
-  s.add_dependency "must", ">= 0.2.5"
+  s.add_dependency "typed", ">= 0.1.0"
   s.add_dependency "dsl_accessor", ">= 0.4.0"
 
   s.add_development_dependency "rspec"

data/lib/ccp.rb

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

data/lib/ccp/data.rb

@@ -4,100 +4,14 @@ 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
-
+    module Pathable
       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
+      @data ||= Typed::Hash.new.extend Pathable
     end
 
     def data?(key)

data/lib/ccp/version.rb

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

data/spec/commands_spec.rb

@@ -6,7 +6,7 @@ describe Ccp::Commands::Core do
   # data container
   it { should respond_to(:data?) }
   it { should respond_to(:data) }
-  its(:data) { should be_kind_of(Ccp::Data::KVS) }
+  its(:data) { should be_kind_of(Typed::Hash) }
 
   # executable
   it { should respond_to(:execute) }

data/spec/data_spec.rb

@@ -1,128 +1,17 @@
 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
+describe Ccp::Data do
+  subject { Object.new.extend Ccp::Data }
+  def data; subject.data; 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")
+      data[:foo] = __FILE__
+      data.path(:foo).should be_kind_of(Pathname)
+      data.path(:foo).basename.should == Pathname("data_spec.rb")
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ccp
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 31
   prerelease: false
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 2
+  version: 0.1.2
 platform: ruby
 authors: 
 - maiha
@@ -15,43 +15,29 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-02-09 00:00:00 +09:00
+date: 2012-02-10 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: activesupport
+  name: typed
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 27
         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: 
+        - 1
         - 0
-        - 2
-        - 5
-        version: 0.2.5
+        version: 0.1.0
   type: :runtime
-  version_requirements: *id002
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: dsl_accessor
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -63,11 +49,11 @@ dependencies:
         - 0
         version: 0.4.0
   type: :runtime
-  version_requirements: *id003
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: rspec
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -77,7 +63,7 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id004
+  version_requirements: *id003
 description: CCP
 email: 
 - maiha@wota.jp