bluemark-smallcage 0.1.3

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/erb_base.rb

@@ -0,0 +1,16 @@
+
+class SmallCage::ErbBase
+  def initialize(loader, renderer, obj)
+    @loader, @renderer, @obj = loader, renderer, obj
+  end
+
+  def method_missing(name)
+    n = name.to_s
+    
+    return @obj[n] unless @obj[n].nil?
+    return @obj["strings"][0] if n == "body" && ! @obj["strings"][0].nil?
+
+    # render if template file exists. or return nil.
+    return @renderer.render(name, @obj)
+  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 => []
+      })
+
+      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

@@ -0,0 +1,278 @@
+module SmallCage
+  class Loader
+    DEFAULT_TEMPLATE = "default"
+    DIR_PROP_FILE = "_dir.smc"
+    MAX_DEPTH = 100
+  
+    attr_reader :root, :target, :erb_base
+  
+    def initialize(target)
+      target = Pathname.new(target.to_s.strip.gsub(%r{(.+)/$}, '\1'))
+      target = real_target(target) 
+
+      @target = target # absolute
+      @root = self.class.find_root(target) # absolute
+      @templates_dir = @root + "_smc/templates"
+      @helpers_dir = @root + "_smc/helpers"
+      @filters_dir = @root + "_smc/filters"
+      @erb_base = load_erb_base
+      @filters = load_filters
+    end
+
+    # return root dir Pathname object.
+    def self.find_root(path, depth = MAX_DEPTH)
+      unless path.exist?
+        raise "Not found: " + path.to_s 
+      end
+      d = path.realpath
+      
+      if d.file?
+        d = d.parent
+      end
+      
+      i = 0
+      loop do
+        if d.join("_smc").directory?
+          return d
+        end
+        break if d.root?
+        d = d.parent
+
+        i += 1
+        break if depth <= i
+      end
+      
+      raise "Root not found: " + path
+    end
+  
+    def load(path)
+      unless path.exist?
+        raise "Not found: " + path.to_s 
+      end
+
+      docpath = SmallCage::DocumentPath.new(@root, path)
+
+      result = {}
+      if path.file?
+        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 # directory
+        path_smc = nil
+        path_out = 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 = SmallCage::DocumentPath.to_uri(@root, source_path)
+        end
+      end
+      
+      add_smc_method(path_out, path_smc)
+      add_smc_method(uri_out, uri_smc)
+
+      result["path"]     = path_out
+      result["uri"]      = uri_out
+      result["arrays"]   = []
+      result["strings"]  = []
+
+      # target is directory and _dir.smc is not exist.
+      return result unless source_path.exist?
+
+      source = source_path.read
+      return result if source.strip.empty?
+
+      begin
+        obj = YAML.load_stream(source)
+        return result if obj.nil?
+      rescue => e
+        raise "Can't load file: #{source_path} / #{e}"
+      end
+      
+      obj.documents.each do |o|
+        if o.is_a? Hash
+          result = result.merge(o)
+        elsif o.is_a? Array
+          result["arrays"]  << o
+        else
+          result["strings"] << o.to_s
+        end
+      end
+
+      return result
+    end
+
+    def load_dirs(path)
+      result = []
+      loop do
+        path = path.parent
+        result.unshift load(path)
+        break if path.join("_smc").directory?
+        raise "Root directory not found!" if path.root?
+      end
+      return result
+    end
+
+    def template_path(name)
+      result = @templates_dir + "#{name}.rhtml"
+      return nil unless result.file?
+      return result
+    end
+    
+    def each_smc_obj
+      each_smc_file do |path|
+        next if path.directory?
+        next if path.basename.to_s == DIR_PROP_FILE
+        obj = load(path)
+        yield obj
+      end
+    end
+    
+    def each_smc_file
+      if @target.directory?
+        p = Pathname.new(@target)
+        Dir.chdir(@target) do
+          Dir.glob("**/*.smc") do |f|
+            yield p + f
+          end
+        end
+      else
+        yield @target
+      end
+    end
+    
+    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?
+      return target.realpath if target.file? and target.to_s =~ /\.smc$/ 
+
+      tmp = Pathname.new(target.to_s + ".smc")
+      return tmp.realpath if tmp.file?
+
+      raise "Target not found: " + target.to_s
+    end
+    private :real_target
+    
+    
+    def load_erb_base
+      result = Class.new(SmallCage::ErbBase)
+      class << result
+        def include_helpers(anon_module, mod_names)
+          smc_module = anon_module.const_get("SmallCage")
+          mod_names.each do |name|
+            helper_module = smc_module.const_get(name)
+            include helper_module
+          end
+        end
+      end
+      
+      helpers = load_anonymous(@helpers_dir, %r{([^/]+_helper)\.rb$})
+      result.include_helpers(helpers[:module], helpers[:names])
+
+      return result
+    end
+    private :load_erb_base
+    
+    def load_anonymous(dir, rex)
+      module_names = []
+      
+      mod = Module.new
+      Dir.entries(dir).sort.each do |h|
+        next unless h =~ rex
+        
+        # create anonymous module.
+        module_name = $1.camelize
+        
+        src = File.read("#{dir}/#{h}")
+        begin
+          mod.module_eval(src, "#{dir}/#{h}")
+        rescue => ex
+          puts ex.to_s # TODO show error
+          load("#{dir}/#{h}", true) # try to know error line number.
+          raise "Can't load #{dir}/#{h} / line# unknown"
+        end
+        module_names << module_name
+      end
+      
+      return { :module => mod, :names => module_names }
+    end
+    private :load_anonymous
+
+    def filters(name)
+      if @filters[name].nil?
+        return []
+      end
+      return @filters[name]
+    end
+    
+    def load_filters
+      result = {}
+      return {} unless @filters_dir.directory?
+      
+      filters = load_anonymous(@filters_dir, %r{([^/]+_filter)\.rb$})
+      
+      config = load_filters_config
+      config.each do |filter_type,filter_list|
+        result[filter_type] = []
+        smc_module = filters[:module].const_get("SmallCage")
+        filter_list.each do |fc|
+          fc = { "name" => fc } if fc.is_a? String
+          filter_class = smc_module.const_get(fc["name"].camelize)
+          result[filter_type] << filter_class.new(fc)
+        end
+      end
+      return result
+    end
+    private :load_filters
+
+    def load_filters_config
+      path = @filters_dir.join("filters.yml")
+      return {} unless path.file?
+      return YAML.load(path.read())
+    end
+    private :load_filters_config
+    
+    def add_smc_method(obj, value)
+      obj.instance_eval do
+        @__smallcage ||= {}
+        @__smallcage[:smc] = value
+      end
+
+      def obj.smc
+        return @__smallcage.nil? ? nil : @__smallcage[:smc]
+      end
+    end
+    private :add_smc_method
+
+  end
+end

data/lib/smallcage/misc.rb

@@ -0,0 +1,13 @@
+
+# From active-support/inflector.rb  
+class String
+  def camelize(first_letter_in_uppercase = true)
+    s = self
+    if first_letter_in_uppercase
+      s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+    else
+      s[0..0] + s.camelize[1..-1]
+    end
+  end
+end
+

data/lib/smallcage/renderer.rb

@@ -0,0 +1,19 @@
+class SmallCage::Renderer
+
+  def initialize(loader)
+    @loader = loader
+  end
+
+  def render(name, obj)
+    path = @loader.template_path(name)
+    return nil if path.nil?
+    return render_string(path.read, obj)
+  end
+    
+  def render_string(str, obj)
+    erb_class = ERB.new(str, nil, '-').def_class(@loader.erb_base, "erb")
+    result = erb_class.new(@loader, self, obj).erb
+    return result
+  end
+
+end

data/lib/smallcage/resources/Manifest.erb

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<title>SmallCage Project Files</title>
+</head>
+<body>
+
+<h1>SmallCage Project Files</h1>
+
+<ul class="files">
+<%- entries.each do |e| -%>
+<li><a href="<%= e %>"><%= e %></a></li>
+<%- end -%>
+</ul>
+
+</body>
+</html>