bluemark-smallcage 0.1.3

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

@@ -0,0 +1,32 @@
+module SmallCage::Commands
+  class Clean
+    def self.execute(opts)
+      self.new(opts).execute
+    end
+    
+    def initialize(opts)
+      @opts = opts
+    end
+    
+    def execute
+      target = Pathname.new(@opts[:path])
+      unless target.exist?
+        raise "target directory or file does not exist.: " + target.to_s
+      end
+      
+      loader = SmallCage::Loader.new(target)
+      loader.each_smc_obj do |obj|
+        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
+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

@@ -0,0 +1,217 @@
+module SmallCage::Commands
+  class Import
+    def self.execute(opts)
+      self.new(opts).execute
+    end
+    
+    def initialize(opts)
+      @opts = opts
+      if @opts[:from] == "default"
+        @opts[:from] = "base,standard"
+      end
+      @project_dir = Pathname.new(__FILE__) + "../../../../project"
+    end
+    
+    def qp(str = "")
+      print str unless @opts[:quiet]
+    end
+    
+    def qps(str = "")
+      puts str unless @opts[:quiet]
+    end
+    
+    def execute
+      @dest = Pathname.new(@opts[:to])
+      
+      Dir.mkdir(@dest) unless @dest.exist?
+      return unless @dest.directory?
+      
+      from = @opts[:from].split(/,/)
+      from.each do |f|
+        qps
+        qps "Import: #{f}"
+        if f =~ %r{^https?://}
+          import_external(f)
+        elsif f =~ %r{^\w+$}
+          import(f)
+        else
+        end
+      end
+    end
+    
+    def import(from)
+      d = @project_dir + from
+      return unless d.directory?
+      @entries = local_entries(d)
+      unless @opts[:quiet]
+        return unless confirm_entries
+      end
+      import_entries
+    end
+    
+    def import_external
+      @entries = external_entries
+      unless @opts[:quiet]
+        return unless confirm_entries
+      end
+      import_entries
+    end
+
+    def import_entries
+      failed = []
+      @entries.each do |e|
+        if e.overwrite?
+          qps "M /" + e.path
+        elsif ! e.exist?
+          qps "A /" + e.path
+        elsif e.to.directory?
+          # nothing
+        else
+          qps "? /" + e.path
+        end
+        
+        begin
+          e.import
+        rescue
+          failed << e
+          qps "F /" + e.path
+        end
+      end
+      
+      unless failed.empty?
+        qps "FAILED:"
+        failed.each do |e|
+          qps "  " + e.path
+        end
+      end
+    end
+    private :import_entries
+
+    def local_entries(d)
+      result = []
+      Dir.chdir(d) do
+        Dir.glob("**/*") do |f|
+          e = ImportEntry.new
+          e.path = f
+          e.from = d + f
+          e.to = @dest + f
+          result << e
+        end
+      end
+      return result
+    end
+    private :local_entries
+    
+    def external_entries(uri)
+      if uri !~ %r{/$}
+        uri += "/"
+      end
+      mfuri = uri + "Manifest.html"
+      
+      source = open(mfuri) {|io| io.read }
+      result = []
+      
+      files = source.scan(%r{<li><a href="(./[^"]+)">(./[^<]+)</a></li>})
+      files.each do |f|
+        raise "illegal path:#{f[0]},#{f[1]}" if f[0] != f[1]
+        raise "illegal path:#{f[0]}" if f[0] =~ %r{/\.\.}
+        path = f[0]
+        e = ImportEntry.new
+        e.path = path
+        e.from = uri + path
+        e.to = @dest + path
+        result << e
+      end
+      
+      return result
+    end
+    private :external_entries
+    
+    def confirm_entries
+      overwrite = []
+      
+      qps "Create:"
+      @entries.each do |e|
+        if e.overwrite?
+          overwrite << e
+        elsif ! e.exist?
+          qps "  /" + e.path
+        end
+      end
+      qps
+      
+      unless overwrite.empty?
+        qps "Overwrite:"
+        overwrite.each do |e|
+          qps "  /" + e.path
+        end
+        qps
+      end
+      
+      return y_or_n("Import these files?[yN]: ", false)
+    end
+    private :confirm_entries
+    
+    def y_or_n(prompt, default)
+      loop do
+        print prompt
+        yn = STDIN.gets.strip
+        if yn =~ /^(y|yes)$/i
+          return true
+        elsif yn =~ /^(n|no)$/i
+          return false
+        elsif yn == ""
+          return default
+        end
+      end
+    end
+    private :y_or_n
+    
+    
+    class ImportEntry
+      attr_accessor :path, :from, :to
+
+      def import
+        if external?
+          copy_external
+        else
+          copy_local
+        end
+      end
+      
+      def external?
+        from =~ %r{^https?://}
+      end
+      
+      def exist?
+        to.exist?
+      end
+      
+      def overwrite?
+        to.file?
+      end
+      
+      def copy_local
+        if from.directory?
+          FileUtils.makedirs(to)
+        else
+          FileUtils.makedirs(to.parent)
+          FileUtils.copy(from, to)
+        end
+      end
+      private :copy_local
+      
+      def copy_external
+        if from =~ %r{/$}
+          FileUtils.makedirs(to)
+        else
+          FileUtils.makedirs(to.parent)
+          s = open(from) {|io| io.read }
+          open(to, "w") {|io| io << s }
+        end
+      end
+      private :copy_external
+      
+    end
+  end
+end

data/lib/smallcage/commands/manifest.rb

@@ -0,0 +1,39 @@
+module SmallCage::Commands
+  class Manifest
+    def self.execute(opts)
+      self.new(opts).execute
+    end
+    
+    def initialize(opts)
+      @opts = opts
+    end
+    
+    def execute
+      entries = []
+      root = Pathname.new(@opts[:path])
+      Dir.chdir(root) do
+        Dir.glob("**/*") do |f|
+          entries << f
+        end
+      end
+      
+      tmp = []
+      entries.each do |f|
+        path = root + f
+        f = "./" + f
+        if path.directory?
+          f = f + "/"
+        end
+        next if path.basename.to_s == "Manifest.html"
+        tmp << f
+      end
+      entries = tmp
+      
+      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
+      end
+    end
+  end
+end

data/lib/smallcage/commands/server.rb

@@ -0,0 +1,15 @@
+module SmallCage::Commands
+  class Server
+    def self.execute(opts)
+      document_root = opts[:path]
+      port = opts[:port]
+      
+      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

@@ -0,0 +1,121 @@
+module SmallCage::Commands
+  class Update
+    def self.execute(opts)
+      self.new(opts).execute
+    end
+    
+    def initialize(opts)
+      @opts = opts
+    end
+    
+    def execute
+      target = Pathname.new(@opts[:path])
+      unless target.exist?
+        raise "target directory or file does not exist.: " + target.to_s
+      end
+      
+      @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
+      
+      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
+
+      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
+      end
+    end
+    private :output_result
+  end
+end