Checked 1.2.3 → 2.0.0

data/Checked.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency "Uni_Arch"
+  s.add_runtime_dependency "Sin_Arch"
   
   s.add_development_dependency 'rake'
   s.add_development_dependency 'bacon'

data/lib/Checked/Arch.rb

@@ -0,0 +1,63 @@
+class Checked
+
+  module Arch
+    include DSL::Ruby
+
+    def self.included klass
+      klass.send :include, Sin_Arch::Arch
+    end
+    
+    def target_name
+      request.env['target_name']
+    end
+
+    def original_target
+      request.env['original_target']
+    end
+
+    def matcher
+      @matcher ||= begin
+                    m = args_hash['args'].first
+                    if !m
+                      raise Sin_Arch::Missing_Argument, "Missing argument for matcher."
+                    end
+                    m
+                   end
+    end
+    
+    #
+    # ::Checked::Demand::Arrays => demand
+    # ::Checked::Clean::Arrays  => clean
+    # ::Checked::Ask::Arrays    => ask
+    #
+    def purpose
+      @purpose ||= begin
+                     temp = self.class.name.split('::')[-2]
+                     (temp && temp.downcase) || raise("Unknown purpose")
+                   end
+    end
+
+    private
+
+    def strip_target
+      return! return!.strip
+    end
+
+    def not_empty_args!
+      not_empty! args_hash['args']
+    end
+      
+    def fail! raw_msg
+      msg = if raw_msg['...'] == 0
+              raw_msg.sub '...', target_name
+            else
+              raw_msg
+            end
+
+      super(msg)
+    end
+    
+  end # === module Arch
+  
+end # === module Checked
+

data/lib/Checked/Ask/Arrays.rb

@@ -1,28 +1,27 @@
 
 
-module Checked
+class Checked
   class Ask
-    class Arrays
+    class Arrays < Sinatra::Base
 
-      include Uni_Arch::Base
-      include Ask::Base
+      include Checked::Arch
 
-      namespace '/array!'
+      map '/array!'
 
-      route
+      get
       def symbols?
-        return false if target.empty?
-        target.all? { |val| val.is_a? Symbol }
+        return false if return!.empty?
+        return!.all? { |val| val.is_a? Symbol }
       end 
       
-      route
+      get
       def include? 
-        target.include?(*args)
+        return!.include?(*args_hash['args'])
       end
 
-      route
+      get
       def exclude? 
-        !target.include?(*args)
+        !return!.include?(*args_hash['args'])
       end
       
     end # === class Arrays

data/lib/Checked/Ask/Ask.rb

@@ -1,21 +1,10 @@
 
-module Checked
+class 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
+end # === class Checked

data/lib/Checked/Ask/Strings.rb

@@ -1,28 +1,12 @@
 
-module Checked
+class Checked
   class Ask
-    class Strings
+    class Strings < Sinatra::Base
 
-      include Uni_Arch::Base
-      include Ask::Base
+      include Checked::Arch
 
-      namespace '/string!'
-
-      route
-      def empty?
-        target.strip.empty?
-      end
-
-      route
-      def include? 
-        !!target[*args]
-      end
-
-      route
-      def exclude? 
-        !target[*args]
-      end
+      map '/string!'
 
     end # === class Strings
   end # === class Ask
-end # === module Checked
+end # === class Checked

data/lib/Checked/Ask/Vars.rb

@@ -1,22 +1,30 @@
 
-module Checked
+class Checked
   class Ask
-    class Vars
+    class Vars < Sinatra::Base
       
-      include Uni_Arch::Base
-      include Ask::Base
+      include Checked::Arch
 
-      namespace '/var!'
+      map '/var!'
 
-      route
-      def respond_to?
-        answ = args.map { |a|
-          target.respond_to? a
-        }.uniq == [true]
-        
-        answ
+      get
+      def respond_to_all?
+        a = not_empty_args!
+
+        a.all? { |a|
+          return!.respond_to? a
+        }
       end
 
+      get
+      def respond_to_any?
+        a = not_empty_args!
+        
+        a.any? { |a|
+          return!.respond_to? a
+        }
+      end
+      
     end # === class Vars
   end # === class Ask
-end # === module Checked
+end # === class Checked

data/lib/Checked/Clean/Clean.rb

@@ -1,38 +1,10 @@
 
-module Checked
+class Checked
   class Clean
-    module Base
-      
-      private # =============================
-      include ::Checked::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
     
+    def initialize *args
+      raise "Not allowed to use this Class directly."
+    end
+
   end # === class Clean
 end # === class Checked

data/lib/Checked/Clean/Strings.rb

@@ -1,33 +1,36 @@
 
-module Checked
+class Checked
   class Clean
-    class Strings
+    class Strings < Sinatra::Base
 
-      include Uni_Arch::Base
-      include Clean::Base
+      include Checked::Arch
 
-      namespace '/string!'
+      map '/string!'
 
-      before_these_methods
-      def strip_string
-         target.strip
+      before '/:name' 
+      def strip_val 
+        return!( return!.strip ) if strippable_route?
+      end
+      
+      def strippable_route?
+        params['name'][%r![^\?\!]\Z!] && !%w{chop_slash_r}.include?(params['name'])
       end
 
-      route
+      get
       def untar
-        target
+        return!
         .sub(/\.tar\.gz$/, '')
         .sub(/\.tar/, '')
       end
 
-      route
+      get
       def file_names 
-        ( target.strip.split.select { |word| word[*args] } )
+        ( return!.split.select { |word| word[*args] } )
       end 
 
-      route
+      get
       def file_names_by_ext  
-        names = CHECK.string!(target).file_names(*args)
+        names = CHECK.string!(return!).file_names(*args)
         bases = names.map { |s|
           s.sub(%r!#{ext}$!, '')
         }
@@ -35,61 +38,60 @@ module Checked
         names.zip bases
       end
 
-      route
+      get
       def shell 
-         target
-        .strip
+         return!
         .split("\n")
         .map(&:strip)
         .reject { |line| line.empty? }
         .join(' && ')
       end
 
-      route
+      get
       def chop_ext
-         target.sub /\.[^\.]+$/, ''
+         return!.sub /\.[^\.]+$/, ''
       end
 
-      route
+      get
       def ruby_name
-         CHECK.string!( File.basename( target ) ).chop_rb
+        File.basename chop_rb
       end
 
-      route
+      get
       def chop_rb
-         target.sub %r!\.rb$!, '' 
+         return!.sub %r!\.rb$!, '' 
       end
 
-      route
+      get
       def chop_slash_r
-        target.gsub "\r", ''
+        return!.gsub "\r", ''
       end
 
-      route
+      get
       def os_stardard
-        CHECK.string!(target).chop_slash_r.strip
+        chop_slash_r
       end
 
-      route
+      get
       def to_single
-        target.gsub( /s\Z/, '' )
+        return!.gsub( /s\Z/, '' )
       end
 
-      route
+      get
       def to_plural
-        target.to_single + 's'
+        return!.to_single + 's'
       end
 
-      route
+      get
       def to_class_name
-        target.split('_').map(&:capitalize).join('_')
+        return!.split('_').map(&:capitalize).join('_')
       end
 
-      route
+      get
       def to_camel_case
-        target.split('_').map(&:capitalize).join
+        return!.split('_').map(&:capitalize).join
       end
 
     end # === class Strings
   end # === class Clean
-end # === module Checked
+end # === class Checked

data/lib/Checked/DSL.rb

@@ -0,0 +1,238 @@
+class Object
+  
+  def Checked
+    @sin_arch ||= begin
+                    o = ::Checked::Obj.new
+                    o.value = self
+                    o
+                  end
+  end
+
+  def Checked_applys?
+    (instance_variable_defined?(:@sin_arch) && Checked().on?)
+  end
+
+  def method_missing meth_name, *args
+    return(super) if !Checked_applys?
+    
+    # Keep count after :Checked_applys? call
+    #   because sometimes value is frozen.
+    @count ||= 1
+    @count += 1
+    return(super) if @count > 6 
+    
+    raise "Unknown block." if block_given?
+    begin
+      result = Checked().get!(meth_name, *args)
+    rescue Sin_Arch::Not_Found
+      return super
+    end
+    @count = 1
+    
+    result.Checked.<< Checked()
+    result
+  end
+
+end # === class Object
+
+class Checked
+
+  class Obj
+
+    module Base
+      
+      attr_accessor :map, :name, :value, :app
+      
+      def initialize
+        off!
+        self.map  = nil
+        self.name = nil
+      end
+      
+      def << checked
+        on! checked.map
+        self.name = checked.name
+      end
+
+      def on?
+        @on
+      end
+      
+      def on! new_map
+        raise ArgumentError, "Map value unacceptable: #{new_map.inspect}" unless new_map
+        self.map = new_map
+        @on = true
+      end
+      
+      def off?
+        !@on
+      end
+
+      def off!
+        @on = false
+      end
+      
+      def get! meth_name, *args
+        self.app = Checked::App.new
+        app.get!("/#{map}/#{meth_name}", 'name'=>name, 'value'=>value, 'args'=>args)
+      end
+      
+    end # === module Base
+    
+    include Base
+    
+  end # === class Obj
+  
+end # === class Checked
+
+class Checked
+  module DSL
+  
+    module Ruby
+
+      def demand *args
+        case args.size
+        when 2
+          bool, raw_msg = args
+          msg = raw_msg.sub(%r!\A\.\.\.!, "#{target_name || return!.class}, #{return!.inspect}, ")
+          fail!(msg) unless bool
+          return!
+        when 3
+          val, bool, raw_msg = args
+          if respond_to?(:return!) && return! == val
+            return demand( bool, raw_msg )
+          end
+          msg = raw_msg.sub(%r!\A\.\.\.!, "#{val.class}, #{val.inspect}, ")
+          fail!(msg) unless bool
+          val
+        else
+          raise ArgumentError, "Too many arguments: #{args.inspect}"
+        end
+      end
+
+      def fail! msg
+        raise Checked::Demand::Failed, msg
+      end
+
+      def respond_to_all? val, *meths
+        meths.map { |m|
+          val.respond_to? m
+        }.uniq == [true]
+      end
+
+      def array? val
+        respond_to_all?( val, :[], :pop )
+      end
+
+      def hash? val
+        respond_to_all?( val, :[], :keys, :values )
+      end
+      
+      def array! val
+        demand val, array?(val), '...is not an array.'
+        val
+      end
+      
+      def hash! val
+        demand val, hash?(val), '...must be a hash.'
+        val
+      end
+      
+      def string? val
+        val.is_a?(String)
+      end
+
+      def string! val
+        demand val, val.is_a?(String), '...must be a string.'
+        val
+      end
+      
+      def bool! val
+        demand val, val.is_a?(TrueClass) || val.is_a?(FalseClass), '...must be either true (TrueClass) or false (FalseClass).'
+        val
+      end
+      
+      def true! val
+        demand val, val === true, '...must be true (TrueClass).'
+        val
+      end
+      
+      def false! val
+        demand val, val === false, '...must be false (FalseClass).'
+        val
+      end
+      
+      def not_empty! val
+        demand val, !val.empty?, "...can't be empty."
+        val
+      end
+
+      def keys! h, *args
+        missing = args.select { |k| !h.has_key?(k) }
+        unless missing.empty?
+          raise Checked::Demand::Fail, "Missing keys: #{missing.inspect} in #{h}"
+        end
+        true
+      end
+
+    end # === module Ruby
+
+    module Racked
+
+      include Ruby
+
+      def self.eval! m
+        caller(1).first =~ %r!([^\:]+):(\d+):in `.!
+        if $1 && $2
+          eval m, nil, $1, $2.to_i - m.split("\n").size + 1
+        else
+          eval m, nil
+        end
+      end
+
+      %w{ Array Bool File_Path Hash String Symbol Var }.each { |name|
+        eval! %~
+          def #{name}!( *args )
+            Check!( '#{name.downcase}!', *args ).check!
+          end
+        ~
+      }
+
+      def Stripped! *args
+        v = String!(*args)
+        String!(v.strip)
+      end
+
+      def Check! ns, *name_and_or_val
+        name, val = case name_and_or_val.size
+                    when 1
+                      [ nil, name_and_or_val.first ]
+                    when 2
+                      name_and_or_val
+                    else
+                      raise ArgumentError, "Unknown values for name/value: #{name_and_or_val.inspect}"
+                    end
+
+        val.Checked.on! ns
+        val.Checked.name = name
+        val.Checked.get! 'check!'
+        val
+      end
+
+      # ============= Ask ================
+
+      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
+
+
+      end # === module Rack_Arch
+    
+  end # === module DSL
+  
+end # === class Checked