Checked 0.1.4 → 1.0.0

data/Checked.gemspec

@@ -21,9 +21,8 @@ Gem::Specification.new do |s|
   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_runtime_dependency "Uni_Arch"
+  
   s.add_development_dependency 'rake'
   s.add_development_dependency 'bacon'
   s.add_development_dependency 'Bacon_Colored'

data/lib/Checked.rb

@@ -1,14 +1,26 @@
 require "Checked/version"
+require 'Uni_Arch'
 
-%w{ Args Base Ask Clean Demand }.each { |klass|
-  require "Checked/#{klass}"
+require "Checked/Base/DSL"
+require "Checked/Base/DSL_Obj"
+require "Checked/Base/Base"
+require "Checked/Base/Arch"
+
+
+%w{ Demand Ask Clean }.each { |klass|
+  require "Checked/#{klass}/#{klass}"
+  
+  Dir.glob(File.join File.dirname(__FILE__), "Checked/#{klass}/*.rb").each { |path|
+    
+    # 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
+  }
 }
   
 
-module Checked
-  module DSL
-    include ::Checked::Ask::DSL
-    include ::Checked::Clean::DSL
-    include ::Checked::Demand::DSL
-  end # === module DSL
-end

data/lib/Checked/Ask/Arrays.rb

@@ -0,0 +1,31 @@
+
+
+module Checked
+  class Ask
+    class Arrays
+
+      include Ask::Base
+
+      namespace '/array!'
+
+      route
+      def symbols?
+        return false if target.empty?
+        target.all? { |val| val.is_a? Symbol }
+      end 
+      
+      route
+      def include? 
+        target.include?(*args)
+      end
+
+      route
+      def exclude? 
+        !target.include?(*args)
+      end
+      
+    end # === class Arrays
+
+
+  end # === class Ask
+end # === class Checked

data/lib/Checked/Ask/Ask.rb

@@ -0,0 +1,21 @@
+
+module Checked
+  class Ask
+    module Base
+      
+      include ::Checked::Base
+      
+      def records
+        @records ||= []
+      end
+      
+      private # ==============================
+      
+    end # === module Base
+    
+    def initialize *args
+      raise "Not allowed to use this Class directly."
+    end
+
+  end # === class Ask
+end # === module Checked

data/lib/Checked/Ask/Strings.rb

@@ -0,0 +1,27 @@
+
+module Checked
+  class Ask
+      class Strings
+
+        include Ask::Base
+        
+        namespace '/string!'
+
+        route
+        def empty?
+          target.strip.empty?
+        end
+
+        route
+        def include? 
+          !!target[*args]
+        end
+
+        route
+        def exclude? 
+          !target[*args]
+        end
+
+      end # === class Strings
+  end # === class Ask
+end # === module Checked

data/lib/Checked/Ask/Vars.rb

@@ -0,0 +1,21 @@
+
+module Checked
+  class Ask
+    class Vars
+      
+      include Ask::Base
+
+      namespace '/var!'
+
+      route
+      def respond_to?
+        answ = args.map { |a|
+          target.respond_to? a
+        }.uniq == [true]
+        
+        answ
+      end
+
+    end # === class Vars
+  end # === class Ask
+end # === module Checked

data/lib/Checked/Base/Arch.rb

@@ -0,0 +1,20 @@
+
+module Checked 
+  class Arch
+    include ::Checked::Base
+
+    before
+    def save_key
+      request.response.body= request.headers.check_target
+    end
+    
+    after_method
+    def save_last_response
+      unless request.path[%r@!/\Z@]
+        request.response.body= request.response.last
+      end
+    end
+
+  end # === class Arch
+  
+end # === module Checked

data/lib/Checked/Base/Base.rb

@@ -0,0 +1,110 @@
+module Checked
+
+  module Base
+
+    include Uni_Arch::Base
+
+    CHECK = begin
+              o = Object.new
+              o.extend Checked::DSL
+              o
+            end
+
+    def target_klass
+      klass = self.class.name.split('::').last.sub(%r!s/Z!, '')
+      if klass == 'Var'
+        klass
+      else
+        eval klass
+      end
+    end
+
+    def target
+      request.response.body
+    end
+    
+    def original_target
+      request.headers.check_target
+    end
+    
+    def target_name
+      if target.respond_to?(:english_name)
+        return target.english_name 
+      end
+      
+      if request.headers.has_key?(:check_name) && request.headers.check_name
+        return request.headers.check_name
+      end
+      
+      target.class.name.gsub('_', ' ')
+    end
+    
+    def args
+      request.headers.args
+    end
+
+    #
+    # ::Checked::Demand::Arrays => demand
+    # ::Checked::Clean::Arrays  => clean
+    # ::Checked::Ask::Arrays    => ask
+    #
+    def purpose
+      @purpose ||= begin
+                     temp = self.class.name.split('::')[-2]
+                     if temp
+                       temp.downcase.sub(/er$/, '')
+                     else
+                       raise "Unknown purpose"
+                     end
+                   end
+    end
+    
+    def fail! msg
+      raise Checked::Demand::Failed, "#{request.env.target.inspect} #{msg}"
+    end
+    
+    def not_empty!
+      fail!('...can\'t be empty.') if target.empty?
+    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
+
+    def array? val
+      respond_to_all?( val, :[], :pop )
+    end
+
+    def hash? val
+      respond_to_all?( val, :[], :keys, :values )
+    end
+    
+    def respond_to_all? val, *meths
+      meths.map { |m|
+        val.respond_to? m
+      }.uniq == [true]
+    end
+
+    def matcher
+      request.headers.matcher
+    end
+
+    def strip_target
+      request.response.body= target.strip
+    end
+
+  end # === module Base
+  
+end # === module Checked
+

data/lib/Checked/Base/DSL.rb

@@ -0,0 +1,73 @@
+
+module Checked
+  module DSL
+    
+    # ============ Demand ==============
+    
+    %w{ String Array Hash }.each { |name|
+      eval %~
+        def #{name}!( *args )
+          #{name.downcase}!(*args).check!
+        end
+      ~
+    }
+    
+    %w{ var array bool file_path string symbol hash }.each { |klass|
+      eval %~
+        def #{klass}! *args
+          raise "No block allowed here." if block_given?
+          check_it( '#{klass}!', *args )
+        end
+      
+        def #{klass}? *args
+          raise "No block allowed here." if block_given?
+          check_it( 'ask', *args )
+        end
+      
+        def #{klass} *args
+          raise "No block allowed here." if block_given?
+          check_it( 'clean',  *args )
+        end
+      ~
+    }
+    
+    alias_method :demand!, :var!
+    alias_method :ask?, :var?
+
+    # ============= Ask ================
+
+    def check_it namespace, *args
+      args.unshift(nil) if args.size == 1
+      ::Checked::DSL::Obj.new( namespace, *args )
+    end
+
+    def _main_class_ unk
+      case unk
+      when String
+        'string'
+      when Hash
+        'hash'
+      when Array
+        'array'
+      when Symbol
+        'symbol'
+      when TrueClass, FalseClass
+        'bool'
+      else
+        raise ArgumentError, "Unknown class: #{unk.inspect}"
+      end
+    end
+
+    def any? target, *args
+      raise "No block allowed." if block_given?
+      
+      args.map { |a|
+        send "#{klass}?", target, a
+        check_it( 'ask', _main_class_(target), nil, target).send( a ).request.response.body
+      }.compact == [true]
+    end
+
+    # ============ Clean ===============
+    
+  end # === module DSL
+end

data/lib/Checked/Base/DSL_Obj.rb

@@ -0,0 +1,35 @@
+
+module Checked
+  
+  module DSL
+    
+    class Obj < BasicObject
+      
+      attr_reader :prefix, :headers
+      def initialize prefix, name, val
+        @prefix      = prefix
+        @headers     = { 'check_name' => name, 'check_target' => val }
+        @max_missing = 4
+        @miss_count  = 0
+      end
+      
+      def method_missing name, *args, &blok
+        if @miss_count >= @max_missing
+          ::Kernel.raise "Infinite loop: #{name}, #{args}"
+        end
+        
+        @miss_count = @miss_count + 1
+        ::Kernel.raise "No block allowed." if blok
+        headers['args'] = args
+        
+        path = '/' + [ @prefix, name ].map(&:to_s).join('/') + '/'
+        app = ::Checked::Arch.new( path, headers ) 
+        app.fulfill_request
+        app.request.response.body
+      end # === def method_missing
+      
+    end # === class Obj < BasicObject
+    
+  end # === module DSL
+  
+end # === module Checked

data/lib/Checked/{Clean.rb → Clean/Clean.rb}

@@ -1,13 +1,10 @@
-require "Checked/Base"
-require "Checked/Clean/DSL"
-require "Checked/Demand/DSL"
 
 module Checked
   class Clean
     module Base
       
       private # =============================
-      include ::Checked::Demand::DSL
+      include ::Checked::DSL
 
       public # ==============================
       include ::Checked::Base

data/lib/Checked/Clean/Strings.rb

@@ -0,0 +1,94 @@
+
+module Checked
+  class Clean
+    class Strings
+
+      include Clean::Base
+
+      namespace '/string!'
+
+      before_these_methods
+      def strip_string
+         target.strip
+      end
+
+      route
+      def untar
+        target
+        .sub(/\.tar\.gz$/, '')
+        .sub(/\.tar/, '')
+      end
+
+      route
+      def file_names 
+        ( target.strip.split.select { |word| word[*args] } )
+      end 
+
+      route
+      def file_names_by_ext  
+        names = CHECK.string!(target).file_names(*args)
+        bases = names.map { |s|
+          s.sub(%r!#{ext}$!, '')
+        }
+
+        names.zip bases
+      end
+
+      route
+      def shell 
+         target
+        .strip
+        .split("\n")
+        .map(&:strip)
+        .reject { |line| line.empty? }
+        .join(' && ')
+      end
+
+      route
+      def chop_ext
+         target.sub /\.[^\.]+$/, ''
+      end
+
+      route
+      def ruby_name
+         CHECK.string!( File.basename( target ) ).chop_rb
+      end
+
+      route
+      def chop_rb
+         target.sub %r!\.rb$!, '' 
+      end
+
+      route
+      def chop_slash_r
+        target.gsub "\r", ''
+      end
+
+      route
+      def os_stardard
+        CHECK.string!(target).chop_slash_r.strip
+      end
+
+      route
+      def to_single
+        target.gsub( /s\Z/, '' )
+      end
+
+      route
+      def to_plural
+        target.to_single + 's'
+      end
+
+      route
+      def to_class_name
+        target.split('_').map(&:capitalize).join('_')
+      end
+
+      route
+      def to_camel_case
+        target.split('_').map(&:capitalize).join
+      end
+
+    end # === class Strings
+  end # === class Clean
+end # === module Checked