Checked 1.2.3 → 2.0.0

data/lib/Checked.rb

@@ -1,26 +1,62 @@
 require "Checked/version"
-require 'Uni_Arch'
+require "Checked/DSL"
+require "Checked/Arch"
 
-require "Checked/Base/DSL"
-require "Checked/Base/DSL_Obj"
-require "Checked/Base/Base"
-require "Checked/Base/Arch"
 
+class Checked
+  
+  class Check_Args < Sinatra::Base
+    
+    include Checked::Arch
+    
+    before 
+    def set_target
+      keys! args_hash, 'name', 'value', 'args'
+      a = args_hash['args']
+      t = args_hash['value']
+
+      demand a, array?(a), ':args must be an array.' 
+      
+      request.env['original_target'] = t
+      
+      # === target_name
+      request.env['target_name'] ||= begin
+                                       if t.respond_to?(:english_name)
+                                         t.english_name 
+                                       elsif !args_hash['name'].to_s.strip.empty?
+                                         args_hash['name'].strip
+                                       else
+                                         t.class.name.gsub('_', ' ')
+                                       end
+                                     end
+      
+      return! t
+    end
+    
+  end # === class Check_Args < Sinatra::Base
 
-%w{ Demand Ask Clean }.each { |klass|
+  use Check_Args
+
+  class App
+    include Sin_Arch::App
+  end # === class App
+  
+end # === class Checked
+
+
+
+%w{ Ask Clean Demand }.each { |klass|
+  
   require "Checked/#{klass}/#{klass}"
   
   Dir.glob(File.join File.dirname(__FILE__), "Checked/#{klass}/*.rb").each { |path|
+    next if path["/#{klass}/#{klass}.rb"]
     
-    # Require the file.
     path =~ %r!lib/Checked/(.+)/(.+)\.rb!
-    require( "Checked/#{$1}/#{$2}" ) if $1 && $2
-    
-    # Set up routes.
-    if klass != $2
-      Checked::Arch.use Checked.const_get(:"#{klass}").const_get(:"#{$2}")
-    end
+    require( "Checked/#{$1}/#{$2}" ) 
+    Checked.use eval("Checked::#{klass}::#{$2}")
   }
+  
 }
   
 

data/spec/main.rb

@@ -3,11 +3,15 @@ require File.expand_path('spec/helper')
 require "Bacon_Colored"
 require 'Checked'
 
-class Box
-  include Checked::DSL
+
+shared :ruby_dsl do
+  before { extend Checked::DSL::Ruby }
+end
+
+shared :racked_dsl do
+  before { extend Checked::DSL::Racked }
 end
 
-BOX = Box.new
 
 FOLDER = ("/tmp/Checked_Test")
 %x! mkdir -p #{FOLDER}!

data/spec/tests/Ask.rb

@@ -6,13 +6,15 @@
 
 describe "array! :include?" do
   
+  behaves_like :racked_dsl
+
   it "returns true if array contains element." do
-    BOX.array!([:a]).include?(:a)
+    Array!([:a]).include?(:a)
     .should.be == true
   end
   
   it "returns false if array does not contain element" do
-    BOX.array!([:a]).include?(:b)
+    Array!([:a]).include?(:b)
     .should.be == false
   end
   
@@ -20,13 +22,15 @@ end # === describe Ask :includes
 
 describe "array! :exclude?" do
   
+  behaves_like :racked_dsl
+
   it "returns true if array excludes element." do
-    BOX.array!([:a]).exclude?(:b)
+    Array!([:a]).exclude?(:b)
     .should.be == true
   end
   
   it "returns false if array does contains element" do
-    BOX.array!([:a]).exclude?(:a)
+    Array!([:a]).exclude?(:a)
     .should.be == false
   end
   
@@ -34,8 +38,10 @@ end # === describe Ask :exclude
 
 describe "array! symbols?" do
   
+  behaves_like :racked_dsl
+
   it 'returns true if all elements are symbols' do
-    BOX.array!([:a, :b]).symbols?
+    Array!([:a, :b]).symbols?
     .should.be == true
   end
   
@@ -65,67 +71,52 @@ end # === describe array! symbols?
 # ============================ STRINGS
 # ============================
 
-describe "string! :include?" do
-  
-  it "returns true if string contains regexp." do
-    BOX.string!(": a").include?(/: a/)
-    .should.be == true
-  end
-  
-  it "returns false if string does not element" do
-    BOX.string!(" :a ").include?(/ :b /) 
-    .should.be == false
-  end
-  
-end # === describe Ask :includes
 
-describe "string! :exclude?" do
+# ============================
+# ============================ VARS
+# ============================
+
+describe "Var! :respond_to_all?" do
   
-  it "returns true if string excludes regexp." do
-    BOX.string!(": a").exclude?(/: b/)
-    .should.be == true
-  end
+  behaves_like :racked_dsl
   
-  it "returns false if string does not excludes element" do
-    BOX.string!(" :a ").exclude?(/ :a /) 
-    .should.be == false
+  it 'returns true if it responds to methods' do
+    Var!( [] ).respond_to_all?(:[], :to_s, :pop)
+    .should == true
   end
   
-end # === describe Ask :excludes
-
-
-describe "ask empty?" do
-  
-  it "returns true if string is :empty? after applying :strip" do
-    BOX.string!(" \n ").empty?.should.be === true
+  it 'returns false if it does not to at least one method' do
+    Var!( [] ).respond_to_all?(:[], :to_s, :keys)
+    .should == false
   end
   
-  it "returns false if string is not :empty? after applying :strip" do
-    BOX.string!(" n ").empty?.should.be === false
+  it 'raises Demand::Failed if arg list is empty' do
+    lambda{ Var!( [] ).respond_to_all? }
+    .should.raise(Checked::Demand::Failed)
+    .message.should.match %r!can't be empty!
   end
   
-  
-end # === describe Ask Strings
+end # === describe var! :respond_to?
 
-# ============================
-# ============================ VARS
-# ============================
 
-describe "var! :respond_to?" do
+describe "Var! :respond_to_any?" do
   
-  it 'returns true if it responds to methods' do
-    BOX.var!( [] ).respond_to?(:[], :to_s, :pop)
+  behaves_like :racked_dsl
+  
+  it 'returns true if it responds to any methods' do
+    Var!( [] ).respond_to_any?(:[], :jetsons, :jump_it)
     .should == true
   end
   
-  it 'returns false if it does not to at least one method' do
-    BOX.var!( [] ).respond_to?(:[], :to_s, :keys)
+  it 'returns false if it does not respond to all methods' do
+    Var!( [] ).respond_to_any?(:jetson, :to_flintstones, :thundar)
     .should == false
   end
   
-  it 'returns false if arg list is empty' do
-    BOX.var!( [] ).respond_to?
-    .should == false
+  it 'raises Demand::Failed if arg list is empty' do
+    lambda{ Var!( [] ).respond_to_any? }
+    .should.raise(Checked::Demand::Failed)
+    .message.should.match %r!can't be empty!
   end
   
 end # === describe var! :respond_to?

data/spec/tests/Clean.rb

@@ -6,50 +6,54 @@
 
 describe "Clean :chop_ext" do
   
+  behaves_like :racked_dsl
   
   it "should chop off the extension of a file string: /etc/something.txt" do
-    BOX.string!("/etc/something.txt").chop_ext.should == '/etc/something'
+    String!("/etc/something.txt").chop_ext.should == '/etc/something'
   end
   
   it "should chop off the extension of a file string: /etc/something.rb" do
-    BOX.string!("/etc/something.rb").chop_rb.should == '/etc/something'
+    String!("/etc/something.rb").chop_rb.should == '/etc/something'
   end
   
   it "should not chop off a non-.rb extension for :chop_rb" do
-    BOX.string!("/etc/something.rbs").chop_rb.should == '/etc/something.rbs'
+    String!("/etc/something.rbs").chop_rb.should == '/etc/something.rbs'
   end
   
   it "should not chop off an extension if it has not" do
-    BOX.string!("/etc/something").chop_rb.should == '/etc/something'
+    String!("/etc/something").chop_rb.should == '/etc/something'
   end
   
   it "should not chop off an extension if it includes '.' in a dir: /etc/rc.d/x-something" do
-    BOX.string!("/etc/rc.d/x-something").chop_rb.should == '/etc/rc.d/x-something'
+    String!("/etc/rc.d/x-something").chop_rb.should == '/etc/rc.d/x-something'
   end
   
 end # === describe
 
 describe "Clean :ruby_name" do
   
+  behaves_like :racked_dsl
   
   it 'should return the basename without .rb' do
-    BOX.string!("/dir/some.path/String.rb").ruby_name.should.be == 'String'
+    String!( "/dir/somepath/String.rb" ).ruby_name.should == 'String'
   end
   
   it 'should be the equivalent to :chop_rb if it is just a filename without a dir' do
-    BOX.string!("String.rb").ruby_name.should.be == 'String'
+    String!("String.rb").ruby_name.should.be == 'String'
   end
   
 end # === describe :ruby_name
 
 describe "Clean :chop_slash_r" do
   
+  behaves_like :racked_dsl
+  
   it "should remove all instances of \\r" do
     string = %@ 
       Hi\r\n
       Ok\r\n
     @
-    BOX.string!(string).chop_slash_r.should.be == string.gsub("\r", '')
+    String!(string).chop_slash_r.should.be == string.gsub("\r", '')
   end
   
   
@@ -58,13 +62,14 @@ end # === describe :chop_slash_r
 
 describe "Clean :os_stardard" do
   
+  behaves_like :racked_dsl
   
   it "should remove all \\r and strip" do
     string = %@ 
       Hi\r\n
       Ok\r\n
     @
-    BOX.string!(string).os_stardard.should.be == string.strip.gsub("\r", '')
+    String!(string).os_stardard.should.be == string.strip.gsub("\r", '')
   end
   
 end # === describe

data/spec/tests/DSL.rb

@@ -1,15 +1,123 @@
+# ============================
+# ============================ Ruby
+# ============================
+
+describe "array! " do
+  
+  behaves_like :ruby_dsl
+
+  it 'returns the array' do
+    array!([:a, :b]).should == [:a, :b]
+  end
+  
+  it 'raises Demand::Failed if not an array' do
+    lambda { array!(:a) }
+    .should.raise(Checked::Demand::Failed)
+    .message.should.match %r!Symbol, :a, is not an array.!i
+  end
+  
+end # === describe array! check!
+
+describe "hash! " do
+  
+  behaves_like :ruby_dsl
+
+  it 'returns the hash' do
+    h = {:name=>:a, :val=>:b}
+    hash!(h).should == h
+  end
+  
+  it 'raises Demand::Failed if not a hash' do
+    lambda { hash!(:a) }
+    .should.raise(Checked::Demand::Failed)
+    .message.should == "Symbol, :a, must be a hash."
+  end
+  
+end # === describe array! check!
+
+describe "string! " do
+  
+  behaves_like :ruby_dsl
+
+  it 'returns the string' do
+    s = 'str'
+    string!(s).should == s
+  end
+  
+  it 'raises Demand::Failed if not a string' do
+    lambda { string!(:a) }
+    .should.raise(Checked::Demand::Failed)
+    .message.should == "Symbol, :a, must be a string."
+  end
+  
+end # === describe array! check!
+
+describe "bool! " do
+  
+  behaves_like :ruby_dsl
+
+  it 'returns the boolean' do
+    b = false
+    bool!(b).should == b
+  end
+  
+end # === describe array! check!
+
+describe "true! " do
+  
+  behaves_like :ruby_dsl
+
+  it 'returns true' do
+    true!(true).should == true
+  end
+  
+end # === describe array! check!
+
+describe "false! " do
+  
+  behaves_like :ruby_dsl
+
+  it 'returns false' do
+    false!(false).should == false
+  end
+  
+end # === describe array! check!
+
+
+
+# ============================
+# ============================ Racked
+# ============================
+
+describe "Stripped!" do
+  
+  behaves_like :racked_dsl
+  
+  it "returns true if string is :empty? after applying :strip" do
+    Stripped!(" \n ").empty?.should.be === true
+  end
+  
+  it "returns false if string is not :empty? after applying :strip" do
+    Stripped!(" n ").empty?.should.be === false
+  end
+  
+  
+end # === describe Stripped!
 
 describe "String!" do
   
-  it 'returns a string' do
-    BOX.String!('str').should.be == 'str'
+  behaves_like :racked_dsl
+  
+  it 'returns the string' do
+    s = 'str'
+    String!( s ).object_id.should.be == s.object_id
   end
   
   it 'raises Demand::Failed if not a string' do
     lambda {
-      BOX.String!([])
+      String!([])
     }.should.raise(Checked::Demand::Failed)
-    .message.should.match %r!Array, \[\], must be a String!
+    .message.should.match %r!Array, \[\], must be a String!i
   end
   
 end # === describe String!
@@ -17,15 +125,18 @@ end # === describe String!
 
 describe "Array!" do
   
-  it 'returns an array' do
-    BOX.Array!([:arr]).should.be == [:arr]
+  behaves_like :racked_dsl
+  
+  it 'returns the array' do
+    t = [:arr]
+    Array!( t ).object_id.should.be == t.object_id
   end
   
   it 'raises Demand::Failed if not an Array' do
     lambda {
-      BOX.Array!(:a)
+      Array!(:a)
     }.should.raise(Checked::Demand::Failed)
-    .message.should.match %r!Symbol, :a, is not an Array.!
+    .message.should.match %r!Symbol, :a, is not an array.!i
   end
   
 end # === describe Array!
@@ -33,15 +144,17 @@ end # === describe Array!
 
 describe "File_Path!" do
   
+  behaves_like :racked_dsl
+  
   it 'returns a stripped string' do
-    BOX.File_Path!(" ~/ ").should.be == File.expand_path("~/")
+    File_Path!(" ~/ ").should.be == File.expand_path("~/")
   end
   
   it 'raises Demand::Failed if not a string' do
     lambda {
-      BOX.File_Path!(:something)
+      File_Path!(:something)
     }.should.raise(Checked::Demand::Failed)
-    .message.should.match %r!Symbol, :something, must be a String!
+    .message.should.match %r!Symbol, :something, must be a String!i
   end
   
 end # === describe String!
@@ -49,15 +162,17 @@ end # === describe String!
 
 describe "Bool!" do
   
+  behaves_like :ruby_dsl
+  
   it 'returns original value' do
-    BOX.Bool!(true).should.be === true
-    BOX.Bool!(false).should.be === false
+    bool!(true).should.be === true
+    bool!(false).should.be === false
   end
   
   it 'raises Demand::Failed if not a boolean' do
-    lambda { BOX.Bool!(:true) }
+    lambda { bool!(:true) }
     .should.raise(Checked::Demand::Failed)
-    .message.should.match %r!Symbol, :true, must be either of TrueClass or FalseClass!
+    .message.should == "Symbol, :true, must be either true (TrueClass) or false (FalseClass)."
   end
   
 end # === describe Bool!
@@ -65,12 +180,14 @@ end # === describe Bool!
 
 describe "True!" do
   
+  behaves_like :ruby_dsl
+  
   it 'returns original value' do
-    BOX.True!(true).should.be === true
+    true!(true).should.be === true
   end
   
   it 'raises Demand::Failed if not true' do
-    lambda { BOX.True!(false) }
+    lambda { true!(false) }
     .should.raise(Checked::Demand::Failed)
     .message.should.match %r!FalseClass, false, must be true!
   end
@@ -80,12 +197,14 @@ end # === describe True!
 
 describe "False!" do
   
+  behaves_like :ruby_dsl
+  
   it 'returns original value' do
-    BOX.False!(false).should.be === false
+    false!(false).should.be === false
   end
   
   it 'raises Demand::Failed if not false' do
-    lambda { BOX.False!(true) }
+    lambda { false!(true) }
     .should.raise(Checked::Demand::Failed)
     .message.should.match %r!TrueClass, true, must be false!
   end