smallcage 0.0.8 → 0.0.9

data/lib/smallcage/commands/base.rb

@@ -0,0 +1,19 @@
+module SmallCage::Commands
+  class Base
+    def self.execute(opts)
+      self.new(opts).execute
+    end
+    
+    def initialize(opts)
+      @opts = opts
+    end
+    
+    def execute
+    end
+    
+    def quiet?
+      return @opts[:quiet]
+    end
+    
+  end
+end

data/lib/smallcage/commands/clean.rb

@@ -16,8 +16,16 @@ module SmallCage::Commands
       
       loader = SmallCage::Loader.new(target)
       loader.each_smc_obj do |obj|
-        obj["path"].delete
-        puts "remove: " + obj["uri"]
+        if obj["path"].exist?
+          obj["path"].delete 
+          puts "D " + obj["uri"] unless @opts[:quiet]
+        end
+      end
+      
+      tmpdir = loader.root + "./_smc/tmp"
+      if tmpdir.exist?
+        FileUtils.rm_r(tmpdir)
+        puts "D /_smc/tmp" unless @opts[:quiet]
       end
     end
   end

data/lib/smallcage/commands/export.rb

@@ -0,0 +1,41 @@
+module SmallCage::Commands
+  class Export < SmallCage::Commands::Base
+    def execute
+      target = Pathname.new(@opts[:path])
+      unless target.exist?
+        raise target.to_s + " does not exist."
+      end
+      
+      loader = SmallCage::Loader.new(target)
+      root = loader.root
+      
+      if @opts[:out].nil?
+        out = root + ("./_smc/tmp/export/" + Time.now.strftime("%Y%m%d%H%M%S"))
+      else
+        out = Pathname.new(@opts[:out])
+      end
+      if out.exist?
+        raise out.to_s + " already exist."
+      end
+      FileUtils.makedirs(out)
+      out = out.realpath
+      
+      # TODO create empty directories
+      loader.each_not_smc_file do |docpath|
+        dir = Pathname.new(docpath.uri).parent
+        outdir = out + ("." + dir.to_s)
+        FileUtils.makedirs(outdir)
+        FileUtils.cp(docpath.path, outdir)
+        puts "A " + docpath.uri unless quiet?
+      end
+
+      unless quiet?
+        puts "" 
+        puts "All contents exported to:"
+        puts " #{out.to_s}"
+      end
+
+    end
+
+  end
+end

data/lib/smallcage/commands/import.rb

@@ -6,6 +6,9 @@ module SmallCage::Commands
     
     def initialize(opts)
       @opts = opts
+      if @opts[:from] == "default"
+        @opts[:from] = "base,standard"
+      end
       @project_dir = Pathname.new(__FILE__) + "../../../../project"
     end
     
@@ -58,18 +61,20 @@ module SmallCage::Commands
       failed = []
       @entries.each do |e|
         if e.overwrite?
-          qp "*"
+          qps "M /" + e.path
         elsif ! e.exist?
-          qp "+"
+          qps "A /" + e.path
+        elsif e.to.directory?
+          # nothing
         else
-          qp " "
+          qps "? /" + e.path
         end
-        qps " " + e.path
+        
         begin
           e.import
         rescue
           failed << e
-          qps "F " + e.path
+          qps "F /" + e.path
         end
       end
       
@@ -130,7 +135,7 @@ module SmallCage::Commands
         if e.overwrite?
           overwrite << e
         elsif ! e.exist?
-          qps "  " + e.path
+          qps "  /" + e.path
         end
       end
       qps
@@ -138,7 +143,7 @@ module SmallCage::Commands
       unless overwrite.empty?
         qps "Overwrite:"
         overwrite.each do |e|
-          qps "  " + e.path
+          qps "  /" + e.path
         end
         qps
       end

data/lib/smallcage/commands/manifest.rb

@@ -29,7 +29,7 @@ module SmallCage::Commands
       end
       entries = tmp
       
-      template = File.dirname(__FILE__) + "/Manifest.erb"
+      template = File.dirname(__FILE__) + "/../resources/Manifest.erb"
       source = ERB.new(File.read(template), nil, "-").result(binding)
       open(root + "Manifest.html", "w") do |io|
         io << source

data/lib/smallcage/commands/server.rb

@@ -1,24 +1,15 @@
-require 'webrick'
-
 module SmallCage::Commands
   class Server
     def self.execute(opts)
       document_root = opts[:path]
       port = opts[:port]
-
-      server = WEBrick::HTTPServer.new({
-        :DocumentRoot => document_root,
-        :Port => port
-      })
-
-      WEBrick::HTTPServlet::FileHandler.remove_handler("cgi")
-      WEBrick::HTTPServlet::FileHandler.remove_handler("rhtml")
       
-      ['INT', 'TERM'].each do |signal|
-        Signal.trap(signal){ server.shutdown }
-      end
-      server.start    
+      server = SmallCage::HTTPServer.new(document_root, port)
+      
+      sighandler = Proc.new {|signal| server.shutdown}
+      SmallCage::Application.add_signal_handler(["INT", "TERM"], sighandler)
 
+      server.start    
     end
   end
 end

data/lib/smallcage/commands/update.rb

@@ -14,22 +14,103 @@ module SmallCage::Commands
         raise "target directory or file does not exist.: " + target.to_s
       end
       
-      loader = SmallCage::Loader.new(target)
-      renderer = SmallCage::Renderer.new(loader)
+      @loader = SmallCage::Loader.new(target)
+      @renderer = SmallCage::Renderer.new(@loader)
+
+      urilist = render_smc_files
+      if list_file.exist?
+        urilist = delete_expired_files(urilist)
+      end
+      save_list(urilist)
+    end
+
+    def render_smc_files
+      urilist = []
+      @loader.each_smc_obj do |obj|
+        urilist << obj["uri"].smc
+        mark = obj["path"].exist? ? "U " : "A "
+        render_smc_obj(obj)
+        puts mark + obj["uri"] unless @opts[:quiet]
+      end
+      return urilist
+    end
+    private :render_smc_files
+
+    def render_smc_obj(obj)
+      result = @renderer.render(obj["template"], obj)
+      result = after_rendering_filters(obj, result)
+      output_result(obj, result)
+    end
+    private :render_smc_obj
+
+    def delete_expired_files(urilist)
+      old_urilist = load_list
+      root = @loader.root
+      target_uri = SmallCage::DocumentPath.new(root, @loader.target).uri
+
+      if @loader.target.file?
+        old_urilist << target_uri unless old_urilist.include?(target_uri)
+        return old_urilist
+      end
       
-      loader.each_smc_obj do |obj|
-        result = renderer.render(obj["template"], obj)
-              
-        filters = loader.filters("after_rendering_filters")
-        filters.each do |f|
-          result = f.after_rendering_filter(obj, result)
+      target_uris = []
+      not_target_uris = []
+      old_urilist.each do |uri|
+        if uri.index(target_uri) == 0
+          target_uris << uri
+        else
+          not_target_uris << uri
         end
+      end
+      
+      deletelist = target_uris - urilist
 
-        output_result(obj, result)
-        puts obj["uri"] if @opts[:quiet].nil?
+      deletelist.each do |uri|
+        delfile = SmallCage::DocumentPath.new(root, root + ("." + uri)).outfile
+        next unless delfile.path.file?
+        
+        File.delete(delfile.path)
+        puts "D #{delfile.uri}" unless @opts[:quiet]
+      end
+      
+      return (not_target_uris + urilist).sort
+    end
+    private :delete_expired_files
+    
+    def after_rendering_filters(obj, result)
+      filters = @loader.filters("after_rendering_filters")
+      filters.each do |f|
+        result = f.after_rendering_filter(obj, result)
+      end
+      return result
+    end
+    private :after_rendering_filters
+
+    def save_list(urilist)
+      f = list_file
+      FileUtils.makedirs(f.parent)
+      open(f, "w") do |io|
+        io << "version: " + SmallCage::VERSION::STRING + "\n"
+        urilist.each do |u|
+          io << u + "\n"
+        end
       end
     end
+    private :save_list
     
+    def load_list
+      txt = File.read(list_file)
+      result = txt.split(/\n/)
+      result.shift
+      return result
+    end
+    private :load_list
+
+    def list_file
+      @loader.root + "./_smc/tmp/list.txt"
+    end
+    private :list_file
+
     def output_result(obj, str)
       open(obj["path"], "w") do |io|
         io << str
@@ -37,4 +118,4 @@ module SmallCage::Commands
     end
     private :output_result
   end
-end
+end

data/lib/smallcage/document_path.rb

@@ -0,0 +1,46 @@
+module SmallCage
+  class DocumentPath
+    
+    attr_reader :root, :uri, :path
+    
+    def initialize(root, path)
+      @root = Pathname.new(root).realpath;
+
+      @path = Pathname.new(path)
+      if @path.exist?
+        @path = @path.realpath
+      else
+        @path = @path.cleanpath
+      end
+      
+      if @path.to_s[0...@root.to_s.length] != @root.to_s
+        raise "Illegal path: #{path.to_s}"
+      end
+      
+      if @path == @root
+        @uri = "/"
+      else
+        @uri = @path.to_s[@root.to_s.length .. -1]
+      end
+    end
+    
+    def smc?
+      return @path.extname == ".smc"
+    end
+    
+    def outfile
+      return nil unless smc?
+      return self.class.new(@root, @path.to_s[0 .. -5])
+    end
+    
+    def outuri
+      return nil unless smc?
+      return uri[0 .. -5]
+    end
+
+    def self.to_uri(root, path)
+      return self.new(root,path).uri
+    end
+
+  end
+end

data/lib/smallcage/http_server.rb

@@ -0,0 +1,66 @@
+require 'webrick'
+
+module SmallCage
+  class HTTPServer
+  
+    def initialize(document_root, port)
+      # logger = WEBrick::Log.new(nil, 1)
+      @server = WEBrick::HTTPServer.new({
+        :DocumentRoot => document_root,
+        :Port => port,
+        :AccessLog => [[File.open("/dev/null", "w+"), ""]]
+      })
+
+      WEBrick::HTTPServlet::FileHandler.remove_handler("cgi")
+      WEBrick::HTTPServlet::FileHandler.remove_handler("rhtml")
+
+      @server.mount("/_smc/update_uri", UpdateUriServlet)
+      @server.mount("/_smc/auto", AutoServlet)
+    end
+    
+    def start
+      @server.start
+    end
+    
+    def shutdown
+      @server.shutdown
+    end
+    
+    def updated_uri=(uri)
+      UpdateUriServlet.uri = uri
+    end
+    
+    def reload
+      UpdateUriServlet.uri = ":reload"
+    end
+  end
+
+
+  class UpdateUriServlet < WEBrick::HTTPServlet::AbstractServlet
+    @@uri = "/index.html"
+    @@update_time = ""
+  
+    def do_GET(req, res)
+      res['content-type'] = "text/plain"
+      res.body = @@uri + "\n" + @@update_time
+    end
+    
+    def self.uri=(uri)
+      @@uri = uri
+      update_time
+    end
+    
+    def self.update_time
+      @@update_time = Time.now.to_s
+    end
+    
+  end
+
+  class AutoServlet < WEBrick::HTTPServlet::AbstractServlet
+    def do_GET(req, res)
+      res['content-type'] = "text/html"
+      html = File.dirname(__FILE__) + "/resources/auto.html"
+      res.body = File.read(html)
+    end
+  end
+end

data/lib/smallcage/loader.rb

@@ -11,7 +11,7 @@ module SmallCage
       target = real_target(target) 
 
       @target = target # absolute
-      @root = SmallCage::Loader.find_root(target) # absolute
+      @root = self.class.find_root(target) # absolute
       @templates_dir = @root + "_smc/templates"
       @helpers_dir = @root + "_smc/helpers"
       @filters_dir = @root + "_smc/filters"
@@ -49,32 +49,34 @@ module SmallCage
       unless path.exist?
         raise "Not found: " + path.to_s 
       end
-      path = path.realpath
-      unless path.to_s[0...@root.to_s.length] == @root.to_s
-        raise "Illegal path: " + path.to_s + " , " + @root.to_s
-      end
+
+      docpath = SmallCage::DocumentPath.new(@root, path)
 
       result = {}
       if path.file?
-        path_smc = path
-        path_out = Pathname.new(strip_ext(path))
-        uri_smc = to_uri(path)
-        uri_out = strip_ext(uri_smc)
-        source_path = path
+        unless docpath.smc?
+          raise "Path is not smc file: " + docpath.to_s
+        end
+
+        path_smc = docpath.path
+        path_out = docpath.outfile.path
+        uri_smc  = docpath.uri
+        uri_out  = docpath.outuri
+        source_path = path_smc
 
         result["dirs"]     = load_dirs(path)
         result["template"] = DEFAULT_TEMPLATE
-      else
+      else # directory
         path_smc = nil
         path_out = path
-        uri_smc = nil
-        uri_out = to_uri(path)
+        uri_smc  = nil
+        uri_out  = docpath.uri
         uri_out += "/" unless uri_out =~ %r{/$}
         source_path = path + DIR_PROP_FILE
-
+        
         if source_path.file?
           path_smc = source_path
-          uri_smc = to_uri(source_path)
+          uri_smc = SmallCage::DocumentPath.to_uri(@root, source_path)
         end
       end
       
@@ -86,6 +88,7 @@ module SmallCage
       result["arrays"]   = []
       result["strings"]  = []
 
+      # target is directory and _dir.smc is not exist.
       return result unless source_path.exist?
 
       source = source_path.read
@@ -145,7 +148,25 @@ module SmallCage
         yield @target
       end
     end
-    private :each_smc_file
+    
+    def each_not_smc_file
+      if @target.directory?
+        p = Pathname.new(@target)
+        Dir.chdir(@target) do
+          Dir.glob("**/*") do |f|
+            f = p + f
+            next if f.directory?
+            next if f.to_s =~ %r{/_smc/}
+            next if f.to_s =~ %r{\.smc$}
+            yield SmallCage::DocumentPath.new(@root, p + f)
+          end
+        end
+      else
+        return if @target.to_s =~ %r{/_smc/}
+        return if @target.to_s =~ %r{\.smc$}
+        yield SmallCage::DocumentPath.new(@root, @target)
+      end
+    end
     
     def real_target(target)
       return target.realpath if target.directory?
@@ -213,16 +234,6 @@ module SmallCage
     end
     private :load_filters_config
     
-    def strip_ext(path)
-      path.to_s[0..-5]
-    end
-    private :strip_ext
-    
-    def to_uri(path)
-      path.realpath.to_s[@root.to_s.length .. -1]
-    end
-    private :to_uri
-
     def add_smc_method(obj, value)
       obj.instance_eval do
         @__smallcage ||= {}