plato 0.2.3 → 0.2.4

data/VERSION

@@ -1 +1 @@
-0.2.3
+0.2.4

data/lib/plato/headers_codec.rb

@@ -0,0 +1,78 @@
+module Plato
+  module HeadersCodec
+    extend self
+
+    def deflate(hash)
+      hash = stringify_keys(hash)
+      body = hash.delete('body')
+
+      [].tap do |buffer|
+        buffer << hash.map do |key, value|
+          "#{header_for(key)}: #{Sanitize.header(value)}"
+        end.join("\n")
+
+        buffer << "\n\n" << Sanitize.body(body) if body
+        buffer << "\n" unless buffer.last =~ /\n\Z/
+      end
+    end
+
+    def inflate(string)
+      {}.tap do |result|
+        headers, body = string.split(/\n\n/, 2)
+
+        headers.split("\n").each do |line|
+          header, val = line.split(/:\s*/, 2)
+
+          result.update hash_key_for(header) => deserialize_value(val)
+        end
+
+        result['body'] = body.chomp if body
+      end
+    end
+
+    private
+
+    def stringify_keys(hash)
+      hash.inject({}) {|h, (k, v)| h.update k.to_s => v }
+    end
+
+    def header_for(attr)
+      attr.to_s.gsub('_', ' ').gsub(/\b([a-z])/) {|m| m.capitalize }
+    end
+
+    def hash_key_for(header)
+      header.gsub(/\s+/, '_').downcase.to_s
+    end
+
+    def deserialize_value(val)
+      YAML.load(val) rescue val
+    end
+
+    module Sanitize
+      extend self
+
+      def header(header_val)
+        header_val.gsub(/(\r|\n)/) {|m| {"\r" => '\r', "\n" => '\n'}[m] }
+      end
+
+      def path_elem(elem)
+        elem.to_s.gsub(/\s+/, '_').gsub(/[^a-zA-Z0-9_-]/,'')
+      end
+
+      def body(body)
+        body # do we really need to do anything here?
+      end
+
+      def method_missing(method, value)
+        warn "Warning: not sanitizing #{method}."
+        value.to_s
+      end
+
+      private
+
+      def warn(warning)
+        $stderr.puts warning
+      end
+    end
+  end
+end

data/lib/plato/manifest.rb

@@ -2,27 +2,23 @@ module Plato
   class Manifest
     include Enumerable
 
-    attr_reader :contents, :codec
-
-    def initialize(contents = nil, opts = {})
-      opts = { :codec => opts } unless opts.is_a? Hash
-      @codec = opts[:codec]
+    attr_reader :contents
+    alias to_h    contents
+    alias to_hash contents
 
+    def initialize(contents = nil)
       @contents =
         if contents.nil?
           {}
-        elsif contents.is_a? Hash
-          contents
-        elsif contents.is_a? String
-          Repo.new(contents, @codec).all &opts[:filter]
+        elsif contents.respond_to? :to_hash
+          contents.to_hash
         else
           raise ArgumentError, "invalid contents"
         end
     end
 
-    def save_to(path, codec = nil)
-      repo = Repo.new(path, codec || self.codec)
-      @contents.map {|path, hash| repo.save(path, hash); path }
+    def save_to(path)
+      Repo.new(path).set_all(contents)
     end
 
     def [](key)
@@ -36,18 +32,14 @@ module Plato
 
     # if given a block, block should return a hash of the new path and
     # new data, or nil if the file should be skipped
-    def map(new_codec = nil)
+    def map
       new_contents =
-        if block_given?
-          @contents.inject({}) do |hash, (path, data)|
-            new_path_data = yield(path, data)
-            new_path_data ? hash.update(new_path_data) : hash
-          end
-        else
-          @contents.dup
+        @contents.inject({}) do |hash, (path, data)|
+          new_path_data = yield(path, data)
+          new_path_data ? hash.update(new_path_data) : hash
         end
 
-      self.class.new(new_contents, new_codec || self.codec)
+      self.class.new(new_contents)
     end
 
     def each(&block)

data/lib/plato/rendering.rb

@@ -74,14 +74,4 @@ module Plato
       %{<script #{attribute_pairs(opts)}></script>}
     end
   end
-
-  class RubyTiltTemplate < Tilt::Template
-    def prepare; end
-
-    def precompiled_template(locals)
-      data
-    end
-  end
-
-  ::Tilt.register('rb', RubyTiltTemplate)
 end

data/lib/plato/repo.rb

@@ -2,33 +2,76 @@ require 'yaml'
 require 'fileutils'
 
 module Plato
+  class FileObject
+    attr_reader :path, :data
+
+    def initialize(opts = {})
+      @path = opts[:path]
+      @data = opts[:data]
+    end
+
+    def data
+      @data ||= (File.read(@path) if @path)
+    end
+    alias read data
+
+    def write_to(to_path)
+      if @data
+        FileUtils.mkdir_p(File.dirname(to_path))
+        File.open(to_path, 'w') {|f| f.write(@data) }
+      elsif @path
+        FileUtils.mkdir_p(File.dirname(to_path))
+        FileUtils.cp(@path, to_path)
+      else
+        raise "cannot write out empty file object"
+      end
+    end
+  end
+  
   class Repo
-    attr_reader :root, :codec
+    class NotFound < StandardError; end
 
-    CODEC_MAP = {}
+    attr_reader :root
 
-    def initialize(root, codec = nil)
+    def initialize(root)
       unless root == File.expand_path(root)
         raise ArgumentError, "root is not an absolute path"
       end
 
-      @codec = CODEC_MAP[codec] || StringCodec
       @root = root.sub(/\/+\Z/, '') #remove trailing slash(es)
     end
 
-    def load(path)
+    def get(path)
       path = expanded_path(path)
-      if File.exist? path
-        @codec.read(path)
-      else
-        raise Filestore::NotFound
+      raise NotFound unless File.exist? path
+
+      FileObject.new(:path => path)
+    end
+
+    def set(path, data)
+      fo = data.respond_to?(:write_to) ?
+        data : FileObject.new(:data => data)
+
+      fo.write_to(expanded_path(path))
+    end
+
+    def all
+      paths = Dir[File.join(root, '**/*')].select {|e| File.file? e }
+
+      paths.inject({}) do |hash, path|
+        relative = relative_path(path)
+        hash.update relative => get(relative)
       end
     end
+    alias to_h    all
+    alias to_hash all
 
-    def save(path, data)
-      path = expanded_path(path)
-      FileUtils.mkdir_p(File.dirname(path))
-      @codec.write(path, data)
+    def each(&block)
+      all.each(&block)
+    end
+
+    def set_all(hash)
+      hash.each {|path, data| set(path, data) }
     end
 
     def destroy(path)
@@ -45,18 +88,6 @@ module Plato
       end
     end
 
-    def all
-      paths = Dir[File.join(root, '**/*')].select {|e| File.file? e }
-
-      if block_given?
-        paths = paths.select {|p| yield relative_path(p) }
-      end
-
-      paths.inject({}) do |hash, path|
-        hash.update relative_path(path) => load(path)
-      end
-    end
-
     private
 
     def expanded_path(path)
@@ -68,131 +99,5 @@ module Plato
         raise ArgumentError, "path must subpath of root" if relative == path
       end
     end
-
-    module RefCodec
-      extend self
-
-      def write(path, ref)
-        FileUtils.cp(ref, path)
-      end
-
-      def read(ref)
-        ref
-      end
-    end
-    CODEC_MAP[:refs] = RefCodec
-
-    module StringCodec
-      extend self
-
-      def write(path, data)
-        File.open(path, 'w') {|f| f.write data }
-      end
-
-      def read(path)
-        File.read(path)
-      end
-    end
-    CODEC_MAP[:string] = StringCodec
-
-    module TemplateCodec
-      extend self
-
-      def read(path)
-        if template_class = Tilt[path]
-          template_class.new(path)
-        else
-          path
-        end
-      end
-
-      def write(path, data)
-        raise "Templates cannot be directly written"
-      end
-    end
-    CODEC_MAP[:template] = TemplateCodec
-
-    module HashCodec
-      extend StringCodec
-      extend self
-
-      def write(path, hash)
-        hash = stringify_keys(hash)
-        body = hash.delete('body')
-
-        data = [].tap do |buffer|
-          buffer << hash.map do |key, value|
-            "#{header_for(key)}: #{Sanitize.header(value)}"
-          end.join("\n")
-
-          buffer << "\n\n" << Sanitize.body(body) if body
-          buffer << "\n" unless buffer.last =~ /\n\Z/
-        end.join
-
-        super(path, data)
-      end
-
-      def read(path)
-        string = super
-
-        {}.tap do |result|
-          headers, body = string.split(/\n\n/, 2)
-
-          headers.split("\n").each do |line|
-            header, val = line.split(/:\s*/, 2)
-
-            result.update hash_key_for(header) => deserialize_value(val)
-          end
-
-          result['body'] = body.chomp if body
-        end
-      end
-
-      private
-
-      def stringify_keys(hash)
-        hash.inject({}) {|h, (k, v)| h.update k.to_s => v }
-      end
-
-      def header_for(attr)
-        attr.to_s.gsub('_', ' ').gsub(/\b([a-z])/) {|m| m.capitalize }
-      end
-
-      def hash_key_for(header)
-        header.gsub(/\s+/, '_').downcase.to_s
-      end
-
-      def deserialize_value(val)
-        YAML.load(val) rescue val
-      end
-    end
-    CODEC_MAP[:hash] = HashCodec
-
-    module Sanitize
-      extend self
-
-      def header(header_val)
-        header_val.gsub(/(\r|\n)/) {|m| {"\r" => '\r', "\n" => '\n'}[m] }
-      end
-
-      def path_elem(elem)
-        elem.to_s.gsub(/\s+/, '_').gsub(/[^a-zA-Z0-9_-]/,'')
-      end
-
-      def body(body)
-        body # do we really need to do anything here?
-      end
-
-      def method_missing(method, value)
-        warn "Warning: not sanitizing #{method}."
-        value.to_s
-      end
-
-      private
-
-      def warn(warning)
-        $stderr.puts warning
-      end
-    end
   end
 end

data/lib/plato/site.rb

@@ -14,29 +14,21 @@ module Plato
       @config_path    = File.join(@template_path, 'config.rb')
       @content_path   = File.join(@root)
       @resources_path = File.join(@root, "resources")
-    end
 
-    def generate!
-      RenderContext.load_view_helpers(File.join(template_path, 'view_helpers.rb'))
-      [ resources.save_to(cache_path),
-        template_resources.save_to(cache_path),
-        rendered_templates.save_to(cache_path),
-        rendered_content.save_to(cache_path)
-      ].each do |ps|
-        puts ps.map{|s| " » #{File.join(cache_path,s)}" }
-      end
+      RenderContext.load_view_helpers(File.join(@template_path, 'view_helpers.rb'))
     end
 
-    DETECT_EXT = /(?:(.*)\/)?([^\/]+)\.([^.]+)\Z/
-    def detect_zip_path(path)
-      path = "#{path}.zip" if !File.exist? path and File.exist? "#{path}.zip"
-
-      if File.exist? path and !File.directory? path and path.match(DETECT_EXT)
-        dir, base, ext = path.match(DETECT_EXT).values_at(1,2,3)
-
-        [dir, "#{base}.#{ext}!", base].compact.join("/")
-      else
-        path
+    def generate!
+      [ ["resources",          resources],
+        ["template resources", template_resources],
+        ["rendered templates", rendered_templates],
+        ["rendered content",   rendered_content]
+      ].each do |(name, manifest)|
+        puts "## #{name}:"
+        manifest.save_to(cache_path)
+        manifest.to_h.keys.map{|p| File.join cache_path, p }.each do |path|
+          puts "    #{path}"
+        end
       end
     end
 
@@ -45,46 +37,30 @@ module Plato
     end
 
     def templates
-      return @templates if @templates
-
-      manifest = Manifest.new template_path, {
-        :codec => :template,
-        :filter => lambda {|p| p !~ /\A(config\.rb|view_helpers\.rb)/ }
-      }
-
-      path_parser = PathTemplate.new(":name*.:format.:engine")
-      sass_parser = PathTemplate.new(":name*.sass")
-
-      @template_resources = Manifest.new({}, :refs)
-      @templates = manifest.map do |path, template|
-        if template.is_a? String
-          # could not find a template engine, assume we're a raw resource
-          @template_resources[path] = template
-          nil
-        else
-          if match = path_parser.parse(path)
-            name, format = match.values_at("name", "format")
-            { "#{name}.#{format}" => Template.new(template, format) }
-          else name = sass_parser.parse(path).values_at("name")
-            { "#{name}.css" => Template.new(template, 'css') }
-          end
-        end
-      end
+      initialize_templates! unless @templates
+      @templates
     end
 
+    def template_resources
+      initialize_templates! unless @templates
+      @template_resources
+    end    
+
     def content
       return @content if @content
 
       @content = config["content_categories"]
       categories = @content.values
-      content_manifests = @content.keys.map do |c|
-        Manifest.new(File.join(content_path, c), :hash)
+      content_repos = @content.keys.map do |c|
+        Repo.new(File.join(content_path, c))
       end
 
-      content_manifests.each do |manifest|
-        manifest.each do |path, content_data|
+      content_repos.each do |repo|
+        repo.each do |path, file|
           if category = categories.find {|c| c.match path }
-            data = category.match(path).merge(content_data)
+            data = category.match(path).merge(
+              HeadersCodec.inflate(file.read)
+            )
 
             category.documents << Document.new(category, data)
           end
@@ -94,16 +70,51 @@ module Plato
       @content
     end
 
-    def template_resources
-      templates unless @templates
-      @template_resources
+    def resources
+      @resources ||= Manifest.new(Repo.new(resources_path))
     end
 
-    def resources
-      @resources ||= Manifest.new(resources_path, :refs)
+    DETECT_EXT = /(?:(.*)\/)?([^\/]+)\.([^.]+)\Z/
+    def detect_zip_path(path)
+      path = "#{path}.zip" if !File.exist? path and File.exist? "#{path}.zip"
+
+      if File.exist? path and !File.directory? path and path.match(DETECT_EXT)
+        dir, base, ext = path.match(DETECT_EXT).values_at(1,2,3)
+
+        [dir, "#{base}.#{ext}!", base].compact.join("/")
+      else
+        path
+      end
     end
 
+    def initialize_templates!
+      path_parser = PathTemplate.new(":name*.:format.:engine")
+      sass_parser = PathTemplate.new(":name*.sass")
+
+      @template_resources = Manifest.new
+      @templates = {}
+
+      Repo.new(template_path).each do |path, file|
+        next if path =~ /\A(config\.rb|view_helpers\.rb)/
+
+        if tilt_class = Tilt[path]
+          tilt = tilt_class.new(File.join(template_path, path))
 
+          if match = path_parser.parse(path)
+            name, format = match.values_at("name", "format")
+            @templates["#{name}.#{format}"] = Template.new(tilt, format)
+
+          else name = sass_parser.parse(path).values_at("name")
+            @templates["#{name}.css"] = Template.new(tilt, 'css')
+          end
+        else
+          # could not find a template engine, assume we're a raw resource
+          @template_resources[path] = file
+          nil
+        end
+      end
+    end
+    
     # helpers
 
     Template = Struct.new(:renderer, :format)
@@ -117,7 +128,7 @@ module Plato
     end
 
     def rendered_templates
-      templates.map(:string) do |path, template|
+      Manifest.new(templates).map do |path, template|
         if path !~ /\A_/
           { path => render(template, template.format, nil) }
         end

data/lib/plato.rb

@@ -4,9 +4,10 @@ require 'ruby_archive'
 module Plato
   require 'plato/config'
   require 'plato/document'
+  require 'plato/headers_codec'
   require 'plato/manifest'
   require 'plato/path_template'
-  require 'plato/repo'
   require 'plato/rendering'
+  require 'plato/repo'
   require 'plato/site'
 end

data/plato.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{plato}
-  s.version = "0.2.3"
+  s.version = "0.2.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Matt Freels"]
@@ -23,6 +23,7 @@ Gem::Specification.new do |s|
      "lib/plato.rb",
      "lib/plato/config.rb",
      "lib/plato/document.rb",
+     "lib/plato/headers_codec.rb",
      "lib/plato/manifest.rb",
      "lib/plato/path_template.rb",
      "lib/plato/rendering.rb",

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: plato
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 31
   prerelease: false
   segments: 
   - 0
   - 2
-  - 3
-  version: 0.2.3
+  - 4
+  version: 0.2.4
 platform: ruby
 authors: 
 - Matt Freels
@@ -97,6 +97,7 @@ files:
 - lib/plato.rb
 - lib/plato/config.rb
 - lib/plato/document.rb
+- lib/plato/headers_codec.rb
 - lib/plato/manifest.rb
 - lib/plato/path_template.rb
 - lib/plato/rendering.rb