zwite 1.0.0

data/lib/zwite/core/site.rb

@@ -0,0 +1,134 @@
+module Zwite
+  
+  class Site
+
+    ##
+    # Properties
+    ##
+  
+    attr_accessor :path
+    attr_accessor :config_path
+    attr_accessor :apps_path
+    attr_accessor :output_path
+    attr_accessor :cache_path
+    
+    attr_accessor :config
+    attr_accessor :plugins
+    attr_accessor :apps
+    
+    attr_accessor :liquid_context
+    
+    def files_changed?
+      @timestamps ||= {}
+      old_timestamps = @timestamps.dup
+      
+      # save timestamps
+      @timestamps = {}
+      Dir[self.apps_path + "**/*"].each do |p|
+        path = Pathname.new(p)
+        @timestamps[path.to_s] = path.mtime
+      end
+      
+      # if we have no old_timestamps probably a first generation
+      unless old_timestamps.any?
+        return true
+      end
+      
+      # if we have no timestamps probably a bug
+      unless @timestamps.any?
+        return true
+      end
+      
+      # check if we deleted any files
+      old_timestamps.each do |path, timestamp|
+        if @timestamps.fetch(path, nil).nil?
+          return true
+        end
+      end
+      
+      # check if we added any files or modified any
+      @timestamps.each do |path, timestamp|
+        old_timestamp = old_timestamps.fetch(path, nil)
+        if old_timestamp.nil? || old_timestamp != timestamp
+          return true
+        end
+      end
+      
+      return false
+    end
+    
+    ##
+    # Initialization
+    ##
+
+    def initialize(path)
+      self.path = path
+      self.config_path = self.path + "config.yml"
+      self.apps_path = self.path + "apps"
+      self.output_path = self.path + "public"
+      self.cache_path = self.path + ".cache"
+      self.load
+    end
+    
+    ##
+    # Actions
+    ##
+
+    def load
+      self.config = YAML.load_file(self.config_path)
+      
+      self.plugins = Zwite::Plugin.subclasses
+      
+      self.apps = []
+      self.config["apps"].each do |a|
+        self.apps << App.new(self, self.apps_path + a["name"], a["mount"])
+      end
+      
+    end
+
+    def build
+      unless files_changed?
+        return
+      end
+      
+      puts "Building site..."
+      
+      begin
+        self.reset
+        self.preprocess
+        self.generate
+      rescue Exception => e
+        puts "ERROR BUILDING SITE"
+        puts "-------------------"
+        puts e
+      end
+      
+      puts "Building site finished..."
+      
+    end
+    
+    def reset
+      if self.output_path.exist?
+        self.output_path.rmtree
+      end
+      self.output_path.mkpath
+    end
+    
+    def preprocess
+      self.liquid_context = {}
+      self.apps.each do |app|
+        app.preprocess
+        self.liquid_context[app.name] = app
+      end
+    end
+    
+    def generate
+      self.apps.each do |app|
+        app.generate
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/zwite/core/utils.rb

@@ -0,0 +1,41 @@
+module Zwite
+  
+  module Utils
+    
+    def self.markdownify(str)
+      return RDiscount.new(str, :smart).to_html
+    end
+    
+    def self.parse_date_and_slug(str)
+      regex = /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})-(?<hour>\d{2})(?<minute>\d{2})-(?<slug>.+)$/
+      matches = regex.match(str)
+      if matches.nil?
+        raise Exception::exception("error parsing date and slug #{str}")
+      end
+      
+      date = DateTime.new(matches["year"].to_i, matches["month"].to_i, matches["day"].to_i, matches["hour"].to_i, matches["minute"].to_i, 0, DateTime.now.offset)
+      slug = matches["slug"]
+      
+      yield date, slug
+    end
+    
+    def self.parse_metadata_and_markdown(str)
+      metadata = nil
+      markdown = nil
+      if str =~ /^(---\s*\n.*?\n?)^(---\s*$\n?)/m
+        markdown = markdownify($')
+        
+        unless $1.nil?
+          yaml_contents = $1.gsub(/\t/, "  ")
+          unless yaml_contents.nil?
+            metadata = YAML.load(yaml_contents)
+          end
+        end
+        
+      end
+      yield metadata, markdown
+    end
+    
+  end
+  
+end

data/lib/zwite/ext/class.rb

@@ -0,0 +1,16 @@
+class Object
+  
+  def self.attr_accessor(*vars)
+    @attributes ||= []
+    @attributes.concat vars
+    super
+  end
+  
+  def self.attributes
+    return @attributes
+  end
+  def attributes
+    return self.class.attributes
+  end
+  
+end

data/lib/zwite/ext/fixnum.rb

@@ -0,0 +1,16 @@
+class Fixnum
+  
+  def ordinalize
+    if (11..13).include?(self.abs % 100)
+      "#{self}th"
+    else
+      case self.abs % 10
+        when 1; "#{self}st"
+        when 2; "#{self}nd"
+        when 3; "#{self}rd"
+        else    "#{self}th"
+      end
+    end
+  end
+
+end

data/lib/zwite/ext/hash.rb

@@ -0,0 +1,15 @@
+class Hash
+  
+  def merge_recursive(other_hash)
+    target = dup
+    other_hash.keys.each do |key|
+      if other_hash[key].is_a?(Hash) and self[key].is_a?(Hash)
+        target[key] = target[key].merge_recursive(other_hash[key])
+        next
+      end
+      target[key] = other_hash[key]
+    end
+    return target
+  end
+  
+end

data/lib/zwite/ext/integer.rb

@@ -0,0 +1,16 @@
+class Integer
+  
+  def ordinalize
+    if (11..13).include?(self.abs % 100)
+      "#{self}th"
+    else
+      case self.abs % 10
+        when 1; "#{self}st"
+        when 2; "#{self}nd"
+        when 3; "#{self}rd"
+        else    "#{self}th"
+      end
+    end
+  end
+
+end

data/lib/zwite/ext/string.rb

@@ -0,0 +1,19 @@
+class String
+  
+  SLUGIFY_SEPARATORS = %w[- _ +]
+
+  def slugify(separator = "-")
+   unless SLUGIFY_SEPARATORS.include?(separator)
+     raise "Word separator must be one of #{SLUGIFY_SEPARATORS}"
+   end
+   re_separator = Regexp.escape(separator)
+   result = self.dup
+   result.gsub!(/[^\x00-\x7F]+/, '')                      # Remove non-ASCII (e.g. diacritics).
+   result.gsub!(/[^a-z0-9\-_\+]+/i, separator)            # Turn non-slug chars into the separator.
+   result.gsub!(/#{re_separator}{2,}/, separator)         # No more than one of the separator in a row.
+   result.gsub!(/^#{re_separator}|#{re_separator}$/, '')  # Remove leading/trailing separator.
+   result.downcase!
+   return result
+  end
+  
+end

data/lib/zwite/ext/time.rb

@@ -0,0 +1,5 @@
+class Time
+  def xmlschema
+    strftime("%Y-%m-%dT%H:%M:%S%Z")
+  end
+end

data/lib/zwite/liquid/block.rb

@@ -0,0 +1,31 @@
+module Zwite
+  
+  module Liquid
+    
+    class Block < ::Liquid::Block
+      Syntax = /(\w+)/
+    
+      attr_reader :name
+    
+      def initialize(tag_name, markup, tokens)
+        if markup =~ Syntax
+          @name = $1
+        else
+          raise SyntaxError.new("Syntax Error in 'block' - Valid syntax {% block [name] %}{% endblock %}")
+        end
+        super
+      end
+    
+      def render(context)
+        context.stack do
+          render_all(@nodelist, context)
+        end
+      end
+    
+    end
+    
+  end
+  
+end
+
+::Liquid::Template.register_tag('block', Zwite::Liquid::Block)

data/lib/zwite/liquid/ext/date.rb

@@ -0,0 +1,25 @@
+module Liquid
+  
+  module StandardFilters
+    
+    def date(input, format)
+      if format.to_s.empty?
+        return input.to_s
+      end
+
+      if ((input.is_a?(String) && !/^\d+$/.match(input.to_s).nil?) || input.is_a?(Integer)) && input.to_i > 0
+        input = Time.at(input.to_i)
+      end
+
+      date = input.is_a?(String) ? Time.parse(input) : input
+      date = date.to_datetime
+      
+      return Zwite::DateFormat::Formatter.new(date).format(format)
+      
+    rescue => e
+      input
+    end
+    
+  end
+  
+end

data/lib/zwite/liquid/ext/template.rb

@@ -0,0 +1,86 @@
+module Liquid
+  
+  class Template
+    
+    attr_accessor :parent_template
+    attr_accessor :child_template
+    
+    def parse(source)
+      # parse root normally
+      @root = Document.new(tokenize(source))
+      
+      # check if root has any nodes otherwise skip early
+      unless @root.nodelist.nil?
+        
+        # check if we have an "extends" node
+        extends = nil
+        @root.nodelist.each do |node|
+          if node.is_a?(::Zwite::Liquid::Extends)
+            extends = node
+            break
+          end
+        end
+        
+        unless extends.nil?
+          @parent_template = Template.new
+          @parent_template.child_template = self
+          @parent_template.parse(Template.file_system.read_template_file(extends.template_name))
+        end
+        
+      end
+      
+      # perform merge if we're the last template in the tree
+      if @parent_template && @child_template.nil?
+        
+        # get root template
+        template = self
+        while !template.parent_template.nil?
+          template = template.parent_template
+        end
+        
+        # merge blocks starting from root down to bottom
+        template.merge_blocks(template.root)
+        
+        # swap our root nodelist to the root templates nodelist
+        @root = template.root
+        
+        # discard parent/child templates
+        @parent_template = nil
+        @child_template = nil
+        
+      end
+     
+      self
+    end
+    
+    def find_blocks(root, stack = {})
+      if root.respond_to?(:nodelist) && !root.nodelist.nil?
+        root.nodelist.inject(stack) do |m, node|
+          if node.is_a?(Zwite::Liquid::Block)
+            m[node.name] = node
+          end
+          find_blocks(node, m)
+          m
+        end
+      end
+      return stack
+    end
+    
+    def merge_blocks(root)
+      unless @child_template.nil?
+        blocks = find_blocks(root)
+        child_blocks = find_blocks(@child_template.root)
+        
+        blocks.each do |name, block|
+          if child_block = child_blocks[name]
+            block.nodelist = child_block.nodelist
+          end
+        end
+        
+        @child_template.merge_blocks(root)
+      end
+    end
+    
+  end
+  
+end

data/lib/zwite/liquid/extends.rb

@@ -0,0 +1,40 @@
+module Zwite
+  
+  module Liquid
+    
+    class Extends < ::Liquid::Block
+      Syntax = /(#{::Liquid::QuotedFragment})/
+      
+      attr_accessor :template_name
+      
+      def initialize(tag_name, markup, tokens)     
+        if markup =~ Syntax 
+          @template_name = $1
+        else
+          raise ::Liquid::SyntaxError.new("Syntax Error in 'extends' - Valid syntax: {% extends \"[template]\" %}")
+        end
+      
+        case @template_name
+        when /^'(.*)'$/
+          @template_name = $1
+        when /^"(.*)"$/
+          @template_name = $1
+        else
+          raise ::Liquid::SyntaxError.new("Syntax Error in 'extends' - Valid syntax: {% extends \"[template]\" %}")
+        end
+      
+        super
+      
+      end
+
+      def assert_missing_delimitation!
+        # we cannot have a missing delimination on the extends block
+      end
+
+    end
+    
+  end
+  
+end
+
+::Liquid::Template.register_tag('extends', Zwite::Liquid::Extends)

data/lib/zwite/liquid/filesystem.rb

@@ -0,0 +1,35 @@
+module Zwite
+  
+  module Liquid
+    
+    class FileSystem
+    
+      attr_accessor :root
+    
+      def initialize(root)
+        @root = root
+      end
+    
+      def read_template_file(template_path)
+        full_path = full_path(template_path)
+        raise Exception::exception("No such template '#{template_path}'") unless File.exists?(full_path)
+        File.read(full_path)
+      end
+    
+      def full_path(template_path)
+        full_path = if template_path.include?('/')
+          File.join(root, File.dirname(template_path), "#{File.basename(template_path)}")
+        else
+          File.join(root, "#{template_path}")
+        end
+
+        raise Exception::exception("Illegal template path '#{File.expand_path(full_path)}'") unless File.expand_path(full_path) =~ /^#{File.expand_path(root)}/
+
+        full_path
+      end
+    
+    end
+    
+  end
+  
+end

data/lib/zwite/models/Template.rb

@@ -0,0 +1,14 @@
+module Zwite
+  
+  class Template
+    
+    def initialize(app, contents)
+      @app = app
+    end
+    
+    def render(context)
+    end
+    
+  end
+  
+end

data/lib/zwite/plugins/appcast.rb

@@ -0,0 +1,173 @@
+module Zwite
+  
+  class AppcastRelease
+    
+    ##
+    # Properties
+    ##
+    
+    attr_accessor :app
+    attr_accessor :path
+    
+    attr_accessor :date
+    attr_accessor :slug
+    
+    attr_accessor :output_path
+    attr_accessor :url
+    
+    attr_accessor :metadata
+    attr_accessor :notes
+    
+    attr_accessor :name
+    attr_accessor :version
+    attr_accessor :build
+    
+    attr_accessor :file_path
+    attr_accessor :file_name
+    attr_accessor :file_url
+    attr_accessor :file_size
+    attr_accessor :file_size_mb
+    attr_accessor :file_signature
+    
+    def to_liquid
+      return {
+        "date" => self.date,
+        "slug" => self.slug,
+        "url" => self.url,
+        "metadata" => self.metadata,
+        "notes" => self.notes,
+        "name" => self.name,
+        "version" => self.version,
+        "file_name" => self.file_name,
+        "file_url" => self.file_url,
+        "file_size" => self.file_size,
+        "file_size_mb" => self.file_size_mb,
+        "file_signature" => self.file_signature
+      }
+    end
+    
+    ##
+    # Initialization
+    ##
+    
+    def initialize(app, path, signature_key)
+      self.app = app
+      self.path = path
+      
+      Zwite::Utils.parse_date_and_slug(self.path.basename.to_s) do |date, slug|
+        self.date = date
+        self.slug = slug
+      end
+      
+      rel_path = (self.path.parent + self.slug).relative_path_from(self.app.path).to_s
+      self.output_path = self.app.output_path + rel_path
+      self.url = self.app.url + rel_path + "/"
+      
+      Zwite::Utils.parse_metadata_and_markdown((self.path + "release.md").read) do |metadata, markdown|
+        self.metadata = metadata
+        self.notes = markdown
+      end
+      
+      self.name = self.metadata["name"]
+      self.version = self.metadata["version"]
+      self.build = self.metadata["build"]
+      
+      self.file_path = self.path + self.metadata["file"]
+      self.file_name = self.file_path.basename.to_s
+      self.file_url = self.url + self.file_path.basename.to_s
+      self.file_size = self.file_path.size
+      self.file_size_mb = "%.2f" % (self.file_size / 1024.0 / 1024.0)
+      
+      signature = OpenSSL::Digest::SHA1.new
+      self.file_path.open("r") do |h|
+        while buffer = h.read(1024)
+          signature << buffer
+        end
+      end
+
+      self.file_signature = Base64.strict_encode64(signature_key.syssign(signature.digest))
+      
+    end
+    
+    ##
+    # Actions
+    ##
+    
+    def <=>(other)
+      if other.class == self.class
+        return other.date <=> self.date
+      end
+      return nil
+    end
+    
+  end
+  
+  class Appcast < Plugin
+    
+    ##
+    # Properties
+    ##
+    
+    attr_accessor :releases
+    
+    def name
+      return "appcast"
+    end
+    
+    def to_liquid
+      return {
+        "latest_release" => self.releases[0],
+        "releases" => self.releases
+      }
+    end
+    
+    ##
+    # Actions
+    ##
+    
+    def preprocess
+      super
+      self.releases = []
+      appcast_path = self.app.path + "appcast"
+      appcast_signature_key_path = appcast_path + "signature_key.pem"
+      appcast_signature_key = OpenSSL::PKey::DSA.new(appcast_signature_key_path.read)
+      
+      releases_path = appcast_path + "releases"
+      Dir[appcast_path + "releases/*"].each do |p|
+        self.releases << AppcastRelease.new(self.app, Pathname.new(p), appcast_signature_key)
+      end
+      
+      self.releases.sort!
+      
+    end
+    
+    def generate
+      appcast_output_path = self.app.output_path + "appcast"
+      appcast_output_path.mkpath
+      
+      feed_path = appcast_output_path + "index.xml"
+      feed_path.parent.mkpath
+      feed_path.open("w") do |h|
+        h.write(self.app.render_template("appcast/appcast.xml", {"releases" => self.releases}))
+      end
+      
+      index_path = appcast_output_path + "releases/index.html"
+      index_path.parent.mkpath
+      index_path.open("w") do |h|
+        h.write(self.app.render_template("appcast/notes.html", {"releases" => self.releases}))
+      end
+      
+      self.releases.each do |release|
+        release_path = release.output_path + "index.html"
+        release_path.parent.mkpath
+        release_path.open("w") do |h|
+          h.write(self.app.render_template("appcast/notes.html", {"releases" => [release]}))
+        end
+        FileUtils.copy(release.file_path, release_path.parent)
+      end
+      
+    end
+    
+  end
+  
+end