Checked 0.1.0

data/lib/Checked/Demand/Mods/Bools.rb

@@ -0,0 +1,37 @@
+
+module Checked
+class Demand
+module Mods
+module Bools
+        
+  def self.before_apply d
+  end
+
+  def self.apply? d
+    target = d.target
+    target.is_a?( FalseClass ) ||
+      target.is_a?(TrueClass)
+  end
+  
+  def self.after_apply d
+  end
+
+  def be! meth, *args
+    answer = target.send meth, *args
+    demand answer, :bool!
+    return true if answer
+    fail!("...failed #{meth} with #{args.inspect}")
+  end
+
+  def not_be! meth, *args
+    bool!
+    pass = target.send(meth, *args)
+    demand pass, :bool!
+    return true unless pass
+    fail!("...#{meth} should not be true with #{args.inspect}")
+  end
+        
+end # === module Bools      
+end # === module Mods
+end # === class Demand
+end # === module Checked

data/lib/Checked/Demand/Mods/File_Addresses.rb

@@ -0,0 +1,56 @@
+
+module Checked
+class Demand
+module Mods
+module File_Addresses
+
+  def self.apply? d
+    d.target.is_a?(String)
+  end
+
+  def hostname!
+    string!
+    not_empty!
+    contain_only! %r![\dA-Za-z_-]!
+  end
+
+  def not_dir!
+    string!
+    not_empty!
+    if File.directory?(target)
+      fail! "...can't be a directory."
+    end
+  end
+
+  def not_file!
+    string!
+    not_empty!
+    if File.file?(target)
+      fail! "...can't be a file."
+    end
+  end
+
+  def dir_address!
+    file_address!
+  end
+
+  def file_address!
+    self.target= target.strip
+    string!
+    not_empty!
+  end
+
+  def file_read!
+    self.target= target.gsub("\r\n", "\n")
+  end
+
+  def file_content! 
+    string!
+    not_empty!   
+    file_read!
+  end
+      
+end # === module File_Addresses
+end # === module Mods
+end # === class Demand
+end # === module Checked

data/lib/Checked/Demand/Mods/Strings.rb

@@ -0,0 +1,51 @@
+
+module Checked
+class Demand
+module Mods
+module Strings
+    
+  def self.before_apply d
+  end
+
+  def self.apply? d
+    d.target.is_a?( String ) ||
+      d.target.is_a?(StringIO)
+  end
+  
+  def self.after_apply d
+    if d.target.is_a?(StringIO)
+      d.target.rewind
+      d.target= d.target.readlines
+      d.target.rewind
+    end
+  end
+
+  def include! matcher
+    included = target[matcher]
+    return true if included
+    fail!("...must contain: #{matcher.inspect}")
+  end
+
+  def exclude! matcher
+    raise_e = val[matcher]
+    return true unless raise_e
+    fail!("...can't contain #{matcher.inspect}")
+  end
+
+  def matches_only! matcher
+      str = target.gsub(matcher, '')
+      if !str.empty?
+        fail!( "...invalid characters: #{str.inspect}" ) 
+      end
+  end
+
+  def not_empty!
+    if target.strip.empty? 
+      fail!("...can't be empty.") 
+    end
+  end
+  
+end # === module Strings
+end # === module DSL
+end # === class Demand
+end # === module Checked

data/lib/Checked/Demand/Mods/Symbols.rb

@@ -0,0 +1,20 @@
+
+module Checked
+class Demand
+module Mods
+module Symbols
+
+  def self.before_apply d
+  end
+
+  def self.apply? d
+    d.target.is_a? Symbol
+  end
+  
+  def self.after_apply d
+  end
+
+end # === module Symbols
+end # === class DEMANDS
+end # === class Demand
+end # === module Checked

data/lib/Checked/Demand/Mods/Vars.rb

@@ -0,0 +1,91 @@
+
+module Checked
+class Demand
+module Mods
+module Vars
+
+  def array!
+    a! Array
+  end
+
+  def bool!
+    return true if [true, false].include?(target)
+    fail!("...has to be a boolean.")
+  end
+
+  def string!
+    a! String
+  end
+
+  def symbol!
+    a! Symbol
+  end
+        
+  def no_block_given!
+    one_of! NilClass, FalseClass
+    if target
+      fail! "No block allowed."
+    end
+  end
+  
+  def no_block!
+    no_block_given!
+  end
+
+  def either! *meths
+    meths.flatten.detect { |m|
+      begin
+        send m
+        true
+      rescue Failed
+        false
+      end
+    }
+  end
+
+  def one_of! *klasses
+    return true if klasses.flatten.any? { |k| target.is_a?(k) }  
+    fail! "...can only be of class/module: #{klasses.map(&:to_s).join(', ')}"
+  end
+
+  def a! klass
+    one_of! klass
+  end
+
+  def nil!
+    return true if target == nil
+    fail!("...must be nil.")
+  end
+  
+  def not_nil!
+    fail!("...can't be nil.") if target.nil?
+    true
+  end
+
+  def respond_to! meth
+    return true if target.respond_to?(meth)
+    fail!("...must respond to #{meth.inspect}")
+  end
+
+  def not_empty!
+    respond_to! :empty?
+    is_empty = target.empty?
+    fail!("...can't be empty.") if is_empty
+  end
+
+  def exists!
+    respond_to! :exists?
+    return true if target.exists?
+    fail!("...must exist.")
+  end
+
+  def not_exists!
+    respond_to! :exists?
+    return true unless target.exists?
+    fail!("...must not exist.")
+  end
+        
+end # === module Var      
+end # === module Mods
+end # === class Demand
+end # === module Checked

data/lib/Checked/Demand.rb

@@ -0,0 +1,46 @@
+require "Checked/Base"
+require "Checked/Demand/DSL"
+
+
+module Checked
+
+  class Demand
+
+    Failed = Class.new(RuntimeError)
+
+    module Base
+      
+      include DSL
+      include ::Checked::Base
+
+
+      def err_msg msg = "...is invalid."
+        message = if msg.strip[ %r!^\.\.\.! ]
+                    msg.sub('...', '').strip
+                  else
+                    msg
+                  end
+      
+        @err_msg || "#{target_name} #{message}"
+      end
+
+      def err_msg= msg
+        demand! msg, :string!, :not_empty!
+        @err_msg = msg
+      end
+      
+      private # ==========================================
+
+      def fail! msg
+        raise Failed, err_msg(msg)
+      end
+
+    end # === module Base
+    
+    include Base
+    
+  end # === class Demand
+  
+end # === module Checked
+
+

data/lib/Checked/version.rb

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

data/lib/Checked.rb

@@ -0,0 +1,14 @@
+require "Checked/version"
+
+%w{ Args Base Ask Clean Demand }.each { |klass|
+  require "Checked/#{klass}"
+}
+  
+
+module Checked
+  module DSL
+    include ::Checked::Ask::DSL
+    include ::Checked::Clean::DSL
+    include ::Checked::Demand::DSL
+  end # === module DSL
+end

data/spec/helper.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'bacon'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+Bacon.summary_on_exit

data/spec/main.rb

@@ -0,0 +1,32 @@
+
+require File.expand_path('spec/helper')
+require "Bacon_Colored"
+require 'Checked'
+
+
+FOLDER = ("/tmp/Checked_Test")
+%x! mkdir -p #{FOLDER}!
+at_exit {
+  %x! rm -rf #{FOLDER} !
+}
+
+def ruby_e cmd
+  file = "#{FOLDER}/delete_me_perf_#{rand(100000)}.rb"
+  begin
+    loader = File.expand_path( File.dirname(__FILE__) + '/../lib' )
+    File.open(file, 'w') { |io|
+      io.write %~
+      $LOAD_PATH.unshift('#{loader}')
+      #{cmd}
+    ~
+    }
+  %x[ bundle exec ruby #{file} 2>&1].strip
+  ensure
+    File.delete file
+  end
+end
+
+
+Dir.glob('spec/tests/*.rb').each { |file|
+  require File.expand_path(file.sub('.rb', '')) if File.file?(file)
+}

data/spec/tests/Ask.rb

@@ -0,0 +1,13 @@
+
+
+describe "require 'Checked/Ask'" do
+  
+  it 'must include DSL' do
+    ruby_e(%! 
+       require 'Checked/Ask'
+       puts Checked::Ask::DSL.to_s
+    !)
+    .should.be == 'Checked::Ask::DSL'
+  end
+  
+end # === describe require 'Checked/Ask'

data/spec/tests/Ask_Strings.rb

@@ -0,0 +1,57 @@
+
+shared 'Ask' do
+  before {
+    extend Checked::Ask::DSL
+  }
+end
+
+describe "ask empty?" do
+  
+  behaves_like 'Ask'
+
+  it "returns true if string is :empty? after applying :strip" do
+    ask?(" \n ", :empty?).should.be === true
+  end
+  
+  it "returns false if string is not :empty? after applying :strip" do
+    ask?(" n ", :empty?).should.be === false
+  end
+  
+  
+end # === describe Ask Strings
+
+describe "Ask :includes" do
+  
+  behaves_like 'Ask'
+  
+  it "returns true if string contains a Regexp matcher" do
+    Checked::Ask.new(" :a ") { |a|
+      a.< :includes?, / :a /
+    }.true?.should.be == true
+  end
+  
+  it "returns false if string excludes a Regexp matcher" do
+    Checked::Ask.new(" :a ") { |a|
+      a.< :includes?, / :b /
+    }.true?.should.be == false
+  end
+  
+end # === describe Ask :includes
+
+describe "Ask :excludes" do
+  
+  behaves_like 'Ask'
+  
+  it "returns true if string excludes a Regexp matcher" do
+    Checked::Ask.new(" :a ") { |a|
+      a.< :excludes?, / :b /
+    }.true?.should.be == true
+  end
+  
+  it 'returns false if string includes a Regexp matcher' do
+    Checked::Ask.new(" :a ") { |a|
+      a.< :excludes?, / :a /
+    }.true?.should.be == false
+  end
+  
+end # === describe Ask :excludes

data/spec/tests/Checked.rb

@@ -0,0 +1,43 @@
+
+describe "Checked::DSL" do
+  
+  %w{ Ask Demand Clean }.each { |name|
+    klass = Checked.const_get(name)
+    
+    it "includes #{name}::DSL" do
+      Checked::DSL.included_modules.should.include klass::DSL
+    end
+    
+  }
+  
+end # === describe
+
+
+describe "Checked.demand!" do
+  
+  before {
+    @perf = Class.new { include Checked::DSL }.new
+  }
+  
+  it 'must be equivalent to: Demand.new(target)' do
+    should.raise(Checked::Demand::Failed) {
+      @perf.demand! [], :not_empty!
+    }.message.should == "Array, [], can't be empty."
+    
+  end
+  
+end # === describe Checked.demand!
+
+describe "Checked.named_demand!" do
+  
+  before {
+    @perf = Class.new { include Checked::DSL }.new
+  }
+  
+  it 'must be equivalent to: Demand.new(target) { |d| d.* name; d << args}' do
+    should.raise(Checked::Demand::Failed) {
+      @perf.named_demand! "Test Val", [:a, 'c'], :symbols!
+    }.message.should == "Test Val, [:a, \"c\"], contains a non-symbol."
+  end
+  
+end # === describe Checked.named_demand!

data/spec/tests/Clean.rb

@@ -0,0 +1,13 @@
+
+
+describe "require 'Checked/Clean'" do
+  
+  it 'must include DSL' do
+    ruby_e(%! 
+           require 'Checked/Clean'
+           puts Checked::Clean::DSL.to_s
+           !)
+    .should.be == 'Checked::Clean::DSL'
+  end
+  
+end # === describe require 'Checked/Clean'

data/spec/tests/Clean_Strings.rb

@@ -0,0 +1,76 @@
+
+shared "Clean" do
+  
+  extend Checked::Clean::DSL
+
+end # === shared 
+
+describe "Clean :chop_ext" do
+  
+  behaves_like 'Clean'
+  
+  it "should chop off the extension of a file string: /etc/something.txt" do
+    clean("/etc/something.txt", :chop_ext).should == '/etc/something'
+  end
+  
+  it "should chop off the extension of a file string: /etc/something.rb" do
+    clean("/etc/something.rb", :chop_rb).should == '/etc/something'
+  end
+  
+  it "should not chop off a non-.rb extension for :chop_rb" do
+    clean("/etc/something.rbs", :chop_rb).should == '/etc/something.rbs'
+  end
+  
+  it "should not chop off an extension if it has not" do
+    clean("/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
+    clean("/etc/rc.d/x-something", :chop_rb).should == '/etc/rc.d/x-something'
+  end
+  
+end # === describe
+
+describe "Clean :ruby_name" do
+  
+  behaves_like 'Clean'
+  
+  it 'should return the basename without .rb' do
+    clean("/dir/some.path/String.rb", :ruby_name).should.be == 'String'
+  end
+  
+  it 'should be the equivalent to :chop_rb if it is just a filename without a dir' do
+    clean("String.rb", :ruby_name).should.be == 'String'
+  end
+  
+end # === describe :ruby_name
+
+describe "Clean :chop_slash_r" do
+  
+  behaves_like 'Clean'
+  
+  it "should remove all instances of \\r" do
+    string = %@ 
+      Hi\r\n
+      Ok\r\n
+    @
+    clean(string, :chop_slash_r).should.be == string.gsub("\r", '')
+  end
+  
+  
+end # === describe :chop_slash_r
+
+
+describe "Clean :os_stardard" do
+  
+  behaves_like 'Clean'
+  
+  it "should remove all \\r and strip" do
+    string = %@ 
+      Hi\r\n
+      Ok\r\n
+    @
+    clean(string, :os_stardard).should.be == string.strip.gsub("\r", '')
+  end
+  
+end # === describe

data/spec/tests/Demand.rb

@@ -0,0 +1,39 @@
+
+describe "require 'Checked/Demand'" do
+  
+  it 'must include DSL' do
+    ruby_e(%! 
+        require 'Checked/Demand'
+        puts Checked::Demand::DSL.to_s
+    !)
+    .should.be == 'Checked::Demand::DSL'
+  end
+  
+end # === describe require 'Checked/Demand'
+
+describe "Demand errors" do
+  
+  it 'must recommend method if not found in current modules' do
+    lambda {
+      d = Checked::Demand.new('') 
+      d.<< :symbols!
+    }.should.raise(NoMethodError)
+    .message.should.be === "String, \"\", can not demand symbols!, which is found in: Arrays"
+  end
+  
+  it 'must raise a NoMethodError when a missing method is used within a valid demand! method.' do
+    Missing_Meth = Module.new do
+      def file_content!
+        something()
+      end
+    end
+    
+    d = Checked::Demand.new('')
+    d.extend Missing_Meth
+    lambda { d.<< :file_content! }
+    .should.raise(NoMethodError)
+    .message.should.match %r!undefined method `something' for!
+    
+  end
+  
+end # === describe Demand errors

data/spec/tests/Demand_Arrays.rb

@@ -0,0 +1,31 @@
+
+describe "demand :symbols!" do
+  
+  before {
+    @fail = Checked::Demand::Failed
+    @d = lambda { |val|
+      d=Checked::Demand.new(val)
+      d << :symbols!
+      d.target
+    }
+  }
+
+  it 'must require Array' do
+    m = should.raise(NoMethodError) {
+      @d.call :sym
+    }.message
+    m.should.include "Symbol, :sym, can not demand symbols!, which is found in"
+    m.should.include "in: Arrays"
+  end
+
+  it 'must require Array be non-empty.' do
+    should.raise(@fail) {
+      @d.call( [] )
+    }.message.should.be == "Array, [], can't be empty."
+  end
+  
+  it 'must pass for Array of single Symbol instance' do
+    @d.call([:sym]).should.be == [:sym]
+  end
+  
+end # === describe Demand for Arrays

data/spec/tests/Demand_File_Addresses.rb

@@ -0,0 +1,37 @@
+
+describe "Demand not_dir!" do
+  
+  it 'must fail for an existing dir' do
+    lambda { 
+      d = Checked::Demand.new(File.expand_path "~/")
+      d.<< :not_dir!
+    }.should.raise(Checked::Demand::Failed)
+  end
+  
+end # === describe Demand not_dir!
+
+
+
+describe "Demand not_file!" do
+  
+  it 'must fail for an existing file' do
+    lambda { 
+      d = Checked::Demand.new(File.expand_path "~/.bashrc")
+      d.<< :not_file!
+    }.should.raise(Checked::Demand::Failed)
+  end
+  
+end # === describe Demand not_file!
+
+
+describe "Demand :file_content!" do
+  
+  it 'must fail for an empty string' do
+    lambda { 
+      d = Checked::Demand.new('')
+      d.<< :file_content!
+    }.should.raise(Checked::Demand::Failed)
+    .message.should.be == "String, \"\", can't be empty."
+  end
+  
+end # === describe Demand :file_content!