Checked 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.gitignore

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

data/Checked.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "Checked/version"
+
+Gem::Specification.new do |s|
+  s.name        = "Checked"
+  s.version     = Checked::VERSION
+  s.authors     = ["da99"]
+  s.email       = ["i-hate-spam-45671204@mailinator.com"]
+  s.homepage    = ""
+  s.summary     = %q{Check your types and more.}
+  s.description = %q{
+    Various DSLs to clean, question (Ask), and validate (Demand) your objects,
+  their classes (data types), and their properties.
+  }
+
+  s.rubyforge_project = "Checked"
+
+  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"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'bacon'
+  s.add_development_dependency 'Bacon_Colored'
+end

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in Checked.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 da99
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,19 @@
+= Checked
+
+Check types and more in your code.
+
+== Contributing to Checked
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 da99. See LICENSE.txt for
+further details.
+

data/Rakefile

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

data/lib/Checked/Args.rb

@@ -0,0 +1,55 @@
+
+module Checked
+
+  class Args
+    
+    Unknown_Class = Class.new(RuntimeError)
+
+    module Base
+
+      def initialize *arr
+        arr.flatten.each { |var|
+          case var
+          when Array
+            var.each { |k|
+              define k
+            }
+          when Hash
+            var.each { |k,v|
+              define k
+              send("#{k}=", v)
+            }
+          else
+            raise Unknown_Class, var.inspect
+          end
+        }
+      end
+
+      def define *raw
+        raw.flatten.each { |k|
+          eval %~
+
+        def #{k}
+          @#{k}
+        end
+
+        def #{k}= v
+          @#{k} = v
+        end
+
+        ~
+        }
+      end
+
+      def defined? key
+        respond_to?( key ) && 
+          respond_to?( :"#{key}=" )
+      end
+
+    end # === module Base
+    
+    include Base
+    
+  end # === module Args
+  
+end # === module Checked

data/lib/Checked/Ask/DSL.rb

@@ -0,0 +1,31 @@
+require 'Checked/Demand/DSL'
+
+module Checked
+  class Ask
+    module DSL
+
+      include Demand::DSL
+
+      def ask? target, *args
+        Checked::Ask.new(target) { |a|
+          a.<< args
+        }.true?
+      end
+
+      def true? target, *args
+        demand! block_given?, :no_block!
+        q = Ask.new(target)
+        q << args
+        q.true?
+      end
+
+      def any? target, *args
+        demand! block_given?, :no_block!
+        q = Ask.new(target)
+        q << args
+        q.any?
+      end
+      
+    end # === module DSL
+  end # === class Ask
+end # === module Checked

data/lib/Checked/Ask/Mods/Arrays.rb

@@ -0,0 +1,25 @@
+
+
+module Checked
+class Ask
+module Mods
+module Arrays
+  
+  def self.apply?(d)
+    d.target.is_a?(Array)
+  end
+
+  def symbols?
+    valid! target, :array!
+    return false if target.empty?
+    target.all? { |val| val.is_a? Symbol }
+  end 
+  
+  def excludes? matcher
+    !target.includes?(matcher)
+  end
+  
+end # === module Arrays
+end # === module Mods
+end # === class Ask
+end # === class Checked

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

@@ -0,0 +1,26 @@
+
+module Checked
+class Ask
+module Mods
+module Strings
+
+  def self.apply? d
+    d.target.is_a?(String)
+  end
+  
+  def empty?
+    target.strip.empty?
+  end
+  
+  def includes? matcher
+    !!target[matcher]
+  end
+  
+  def excludes? matcher
+    !includes?(matcher)
+  end
+
+end # === module Strings
+end # === module Mods
+end # === class Ask
+end # === module Checked

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

@@ -0,0 +1,12 @@
+
+module Checked
+class Ask
+module Mods
+module Vars
+  
+  
+  
+end # === module Vars
+end # === module Mods
+end # === class Ask
+end # === module Checked

data/lib/Checked/Ask.rb

@@ -0,0 +1,69 @@
+require 'Checked/Base'
+require 'Checked/Ask/DSL'
+
+module Checked
+  class Ask
+    module Base
+      
+      private # ==============================
+      
+      include ::Checked::Base
+      
+      #  
+      # Demand::DSL is not used here 
+      # because it uses the Questioner.
+      # It would cause an stack level/infinite loop 
+      # error.
+      #
+      def valid! target, *args
+        v = Demand.new(target) 
+        if args.empty?
+          yield v
+        else
+          raise "No block allowed with arguments: #{args.inspect}" if block_given?
+          v << args
+        end
+        
+        v.target
+      end
+
+      public # ==============================
+      
+      attr_reader :records
+      
+      def before_init 
+        @records = []
+      end
+
+      def < name, *args, &blok
+        a = super
+        valid!(a, :bool!)
+        records << a
+        a
+      end
+      
+      def << *methods
+        valid! block_given?, :no_block!
+        super(*methods) { |name|
+          self.< name
+        }
+      end
+
+      def true?
+        return false if records.empty?
+        records.all?
+      end
+      
+      def any?
+        return false if records.empty?
+        records.any?
+      end
+      
+      private # ==============================
+      
+      
+    end # === module Base
+    
+    include Base
+  end # === class Ask
+end # === module Checked

data/lib/Checked/Base.rb

@@ -0,0 +1,119 @@
+
+module Checked
+module Base
+  
+  def self.included var
+    klass_name = var.to_s.gsub(/::Base$/, '').split('::').last
+    klass = Checked.const_get(klass_name)
+    
+    files = Dir.glob(File.join File.dirname(__FILE__), "#{klass_name}/Mods/*.rb")
+    raise "No Mods found for #{klass}" if files.empty?
+    
+    files.each { |path|
+      name = File.basename(path).sub('.rb', '')
+      require "Checked/#{klass_name}/Mods/#{name}"
+      if name == 'Vars'
+        klass.class_eval {
+          include klass::Mods::Vars
+        }
+      else
+        klass.const_set(:Mod_List, []) unless klass.const_defined?(:Mod_List)
+        klass::Mod_List << klass::Mods.const_get(name)
+      end
+    }
+  end
+
+  attr_accessor :target
+  attr_reader :target_name
+  
+  def initialize target, &blok
+    
+    if respond_to? :before_init
+      if method(:before_init).parameters === []
+        before_init
+      else
+        before_init target, &blok
+      end
+    end
+    
+    @target = target
+    @target_name = target.respond_to?(:english_name) ?
+      target.english_name : 
+      "#{target.class.name.gsub('_', ' ')}, #{target.inspect},"
+    
+    self.class.const_get(:Mod_List).each { |mod|
+      if mod.apply?(self)
+        extend mod
+      end
+    }
+    
+    if respond_to? :after_init
+      if method(:after_init).parameters === []
+        after_init
+      else
+        after_init target, &blok
+      end
+    end
+
+    yield(self) if block_given?
+  end
+
+  # 
+  # Sets the name.
+  #   
+  def * name
+    @target_name = "#{name}, #{target.inspect},"
+    self
+  end
+  
+  #
+  # ::Checked::Demand => demand
+  # ::Checked::Clean  => clean
+  # ::Checked::Ask    => ask
+  #
+  def purpose
+    @purpose ||= self.class.name.split('::').last.downcase.sub(/er$/, '')
+  end
+
+  def < name, *args, &blok
+    send(name, *args, &blok)
+  end
+
+  def << *methods
+    meths = begin
+              ::Checked::Demand.new(methods.flatten) { |d|
+                d.* "(Originally: #{target_name})"
+                d.instance_eval { not_empty!; symbols! }
+              }.target
+            end
+
+
+    meths.each { |name|
+      
+      begin
+        if block_given?
+          yield name
+        else
+          send name
+        end
+      rescue NoMethodError => e
+        raise e if !e.message[/undefined method `#{name.to_s}' for/]
+        to_name = lambda { |m| m.to_s.split('::').last }
+        mods = self.class::Mod_List.select { |m| m.instance_methods.include?(name.to_sym) }
+        all  = self.class::Mod_List
+        
+        if mods.empty?
+          e_msg = e.message
+          raise NoMethodError, "#{e_msg} using mods: #{all.map(&to_name).join(', ')}"
+        else
+          raise NoMethodError, err_msg(
+              "...can not #{purpose} #{name}, which is found in: #{mods.map(&to_name).join(', ')}"
+          )
+        end
+      end
+    }
+    self
+  end 
+  
+end # === module Base
+end # === module Checked

data/lib/Checked/Clean/DSL.rb

@@ -0,0 +1,16 @@
+
+module Checked
+  class Clean
+    module DSL
+
+      def clean target, *args
+        raise "No block allowed here." if block_given?
+
+        c = Clean.new(target)
+        c.<(*args)
+        c.target
+      end
+
+    end # === module DSL
+  end # === class Clean
+end # === module Checked

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

@@ -0,0 +1,98 @@
+
+module Checked
+class Clean
+module Mods
+module Strings
+  
+  def self.apply? d
+    d.target.is_a?(String) ||
+      d.target.is_a?(StringIO)
+  end
+
+  def self.on_apply d
+    case d.target
+    when StringIO
+      d.target.rewind
+      d.target= d.target.readlines
+    else
+      # Do nothing.
+    end
+  end
+
+  def file_names matcher
+    strip.split.select { |word| word[matcher] }
+  end 
+
+  def file_names_by_ext ext
+    names = file_names(ext)
+    bases = names.map { |s|
+      s.sub(%r!#{ext}$!, '')
+    }
+
+    names.zip bases 
+  end
+
+  def shell 
+    target
+    .strip
+    .split("\n")
+    .map(&:strip)
+    .reject { |line| line.empty? }
+    .join(' && ')
+  end
+  
+  def chop_ext
+    target.sub /\.[^\.]+$/, ''
+  end
+  
+  def ruby_name
+    c = ::Checked::Clean.new( File.basename( target ) ) 
+    c.< :chop_rb
+    c.target
+  end
+  
+  def chop_rb
+    target.sub %r!\.rb$!, ''
+  end
+  
+  def chop_slash_r
+    target.gsub "\r", ''
+  end
+  
+  def os_stardard
+    chop_slash_r.strip
+  end
+  
+  def file_names matcher
+    strip.split.select { |word| word[matcher] }
+  end
+  
+  def file_names_by_ext  ext
+    names = file_names(ext)
+    bases = names.map { |s|
+      s.sub(%r!#{ext}$!, '')
+    }
+    
+    names.zip bases
+  end
+  
+  def to_single
+    target.gsub( /s\Z/, '' )
+  end
+
+  def to_plural
+    target.to_single + 's'
+  end
+
+  def to_class_name
+    target.split('_').map(&:capitalize).join('_')
+  end
+
+  def to_camel_case
+    target.split('_').map(&:capitalize).join
+  end
+
+end # === module Strings
+end # === module Mods
+end # === class Clean
+end # === module Checked

data/lib/Checked/Clean.rb

@@ -0,0 +1,41 @@
+require "Checked/Base"
+require "Checked/Clean/DSL"
+require "Checked/Demand/DSL"
+
+module Checked
+  class Clean
+    module Base
+      
+      private # =============================
+      include ::Checked::Demand::DSL
+
+      public # ==============================
+      include ::Checked::Base
+
+      def < meth, *args
+        val = super
+        named_demand!("Cleaned val", val, :not_nil!)
+          
+        self.target= super
+      end
+      
+      def << *args
+        args.flatten.each { |name|
+          self.< name
+        }
+      end
+
+      private # ===========================================
+      
+      def target= val
+        named_demand! "Clean target", val, :not_nil!
+          
+        @target = val
+      end
+
+    end # === module Base
+    
+    include Base
+    
+  end # === class Clean
+end # === class Checked

data/lib/Checked/Demand/DSL.rb

@@ -0,0 +1,29 @@
+
+module Checked
+  class Demand
+    module DSL
+      
+      def demand! target, *args
+        if block_given?
+          raise "No block allowed here."
+        end
+        
+        Demand.new(target) { |d|
+          d.<< args
+        }.target
+      end
+      
+      def named_demand! name, target, *args
+        if block_given?
+          raise "No block allowed here."
+        end
+        
+        Demand.new(target) { |d|
+          d.* name
+          d.<< args
+        }.target
+      end
+      
+    end # === module Dsl
+  end # === class Demand
+end # === module Checked

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

@@ -0,0 +1,72 @@
+
+module Checked
+class Demand
+module Mods
+module Arrays
+
+  def self.before_apply d
+  end
+
+  def self.apply? d
+    d.target.is_a?(Array)
+  end
+  
+  def self.after_apply d
+  end
+
+  def no_nils!
+    array!
+    if target.include?(nil)
+      fail!("...can't contain nils.")
+    end
+  end
+
+  def no_empty_strings!
+    array!
+    target.each { |s| 
+
+      if s.respond_to?(:rewind) 
+        s.rewind
+      end
+
+      final = if s.respond_to?(:readlines)
+                s.readlines
+              else
+                s
+              end
+
+      if final.is_a?(String) && final.strip.empty?
+        fail!("...can't contain empty strings.")
+      end
+    }
+  end
+
+  def symbols!
+    array!
+    not_empty!
+    if !target.all? { |v| v.is_a?(Symbol) }
+      fail! "...contains a non-symbol."
+    end
+  end
+  
+  def include! matcher
+    included = target.include?(matcher)
+    return true if included
+    fail!("...must contain: #{matcher.inspect}")
+  end
+
+  def exclude! matcher
+    raise_e = val.include?(matcher)
+    return true unless raise_e
+    fail!("...can't contain #{matcher.inspect}")
+  end
+
+  def matches_only! matcher
+    arr = target.reject { |val| val == matcher }
+    fail!( "...invalid elements: #{arr.inspect}" ) if !arr.empty?
+  end
+        
+end # === module Arrays
+end # === module Mods
+end # === class Demand
+end # === module Checked