Checked 0.1.4 → 1.0.0

data/lib/Checked/Args.rb

@@ -1,55 +0,0 @@
-
-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.rb

@@ -1,69 +0,0 @@
-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/Ask/DSL.rb

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

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

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

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

data/lib/Checked/Base.rb

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

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

@@ -1,104 +0,0 @@
-
-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 untar
-          target
-          .sub(/\.tar\.gz$/, '')
-          .sub(/\.tar/, '')
-        end
-
-        def file_names matcher
-          target.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