zwite 1.0.0

data/README.md

@@ -0,0 +1,4 @@
+# Introducing Zwite
+### the static site generator
+
+Zwite is a static site generator that is -very- pluggable built in ruby. It is very pluggable and works with apps/plugins instead of one monolithic site.

data/bin/zwite

@@ -0,0 +1,36 @@
+#!/usr/bin/env rvm-auto-ruby
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+
+help = <<HELP
+HELP
+
+require "optparse"
+require "zwite"
+
+options = {}
+opts = OptionParser.new do |opts|
+  opts.banner = help
+  
+  opts.on("--server [PORT]", "Start web server (default port 3030)") do |port|
+    options["server"] = true
+    unless port.nil?
+      options["server_port"] = port
+    else
+      options["server_port"] = "3030"
+    end
+  end
+  
+  opts.on("--path [PATH]", "Path to project folder") do |path|
+    unless path.nil?
+      options["path"] = File.absolute_path(path)
+    else
+      options["path"] = Dir.pwd
+    end
+  end
+  
+end
+
+opts.parse!
+
+Zwite::Engine.sharedEngine.run(options)

data/lib/zwite/core/app.rb

@@ -0,0 +1,122 @@
+module Zwite
+  
+  class App
+    
+    ##
+    # Properties
+    ##
+    
+    attr_accessor :site
+    attr_accessor :path
+    attr_accessor :url
+    attr_accessor :static_url
+    attr_accessor :name
+    attr_accessor :output_path
+    attr_accessor :plugins
+    attr_accessor :liquid_file_system
+    
+    def to_s
+      return "<Zwite::App> name: #{self.name}, mount: #{self.url}"
+    end
+    
+    def to_liquid
+      hash = {
+        "url" => self.url,
+        "static_url" => self.static_url,
+        "name" => self.name
+      }
+      self.plugins.each do |p|
+        hash[p.name] = p
+      end
+      return hash
+    end
+    
+    ##
+    # Initialization
+    ##
+    
+    def initialize(site, path, url)
+      self.site = site
+      self.path = path
+      self.url = url
+      self.static_url = self.url + "static/"
+      self.name = self.path.basename.to_s
+      self.output_path = self.site.output_path + self.url[1..self.url.length]
+      self.plugins = []
+      self.site.plugins.each do |p|
+        plugin = p.new(self)
+        if plugin.enabled?
+          self.plugins << plugin
+        end
+      end
+      self.liquid_file_system = Zwite::Liquid::FileSystem.new((self.path + "templates").to_s)
+    end
+    
+    ##
+    # Actions
+    ##
+    
+    def hash
+      return self.path.hash
+    end
+    
+    def eql?(other)
+      return self.path.eql?(other.path)
+    end
+    
+    def preprocess
+      self.plugins.each do |p|
+        p.preprocess
+      end
+    end
+    
+    def generate
+      self.plugins.each do |p|
+        p.generate
+      end
+    end
+    
+    def render(contents, context = {}, path = nil, validate = true)
+      ::Liquid::Template.file_system = self.liquid_file_system
+      template = ::Liquid::Template.parse(contents)
+      ctx = self.site.liquid_context
+      ctx = ctx.merge_recursive(context)
+      
+      output = template.render(ctx)
+      
+      # # nokogiri validate
+      # if validate
+      #   n = Nokogiri.parse(output)
+      #   if n.errors.any?
+      #     message = ["\n"]
+      #     unless path.nil?
+      #       message << "[VALIDATION ERROR]: #{path}"
+      #       
+      #     else
+      #       message << "[VALIDATION ERROR]"
+      #     end
+      #     n.errors.each do |error|
+      #       message << "\tline: #{error.line} error: #{error}"
+      #     end
+      #     
+      #     message << "\n\n"
+      #     raise message.join("\n")
+      #     
+      #   end
+      # end
+      
+      return output
+    end
+    
+    def render_file(path, context = {})
+      contents = path.read
+      return render(contents, context, path)
+    end
+    
+    def render_template(template, context = {})
+      return render_file((self.path + "templates" + template), context)
+    end
+    
+  end
+  
+end

data/lib/zwite/core/dateformat.rb

@@ -0,0 +1,339 @@
+module Zwite
+  
+  module DateFormat
+    
+    class Formatter < Object
+      
+      WEEKDAYS = {
+        0 => "Sunday",
+        1 => "Monday",
+        2 => "Tuesday",
+        3 => "Wednesday",
+        4 => "Thursday",
+        5 => "Friday",
+        6 => "Saturday"
+      }
+      WEEKDAYS_ABBR = {
+        0 => "Sun",
+        1 => "Mon",
+        2 => "Tue",
+        3 => "Wed",
+        4 => "Thu",
+        5 => "Fri",
+        6 => "Sat"
+      }
+      WEEKDAYS_REV = {
+        "sunday" => 0,
+        "monday" => 1,
+        "tuesday" => 2,
+        "wednesday" => 3,
+        "thursday" => 4,
+        "friday" => 5,
+        "saturday" => 6
+      }
+      MONTHS = {
+        1 => "January",
+        2 => "February",
+        3 => "March",
+        4 => "April",
+        5 => "May",
+        6 => "June",
+        7 => "July",
+        8 => "August",
+        9 => "September",
+        10 => "October",
+        11 => "November",
+        12 => "December"
+      }
+      MONTHS_3 = {
+        1 => "Jan",
+        2 => "Feb",
+        3 => "Mar",
+        4 => "Apr",
+        5 => "May",
+        6 => "Jun",
+        7 => "Jul",
+        8 => "Aug",
+        9 => "Sep",
+        10 => "Oct",
+        11 => "Nov",
+        12 => "Dec"
+      }
+      MONTHS_3_REV = {
+        "Jan" => 1,
+        "Feb" => 2,
+        "Mar" => 3,
+        "Apr" => 4,
+        "May" => 5,
+        "Jun" => 6,
+        "Jul" => 7,
+        "Aug" => 8,
+        "Sep" => 9,
+        "Oct" => 10,
+        "Nov" => 11,
+        "Dec" => 12
+      }
+      MONTHS_AP = {
+        1 => "Jan.",
+        2 => "Feb.",
+        3 => "March",
+        4 => "April",
+        5 => "May",
+        6 => "June",
+        7 => "July",
+        8 => "Aug.",
+        9 => "Sept.",
+        10 => "Oct.",
+        11 => "Nov.",
+        12 => "Dec."
+      }
+      
+      attr_accessor :data
+      
+      def initialize(datetime)
+        self.data = datetime
+      end
+      
+      def format(str)
+        pieces = []
+        str.each_char do |c|
+          if Formatter.method_defined?(c)
+            pieces << self.send(c)
+          elsif c
+            pieces << c
+          end
+        end
+        return pieces.join("")
+      end
+      
+      # a.m or p.m
+      def a
+        if self.data.hour > 11
+          return "p.m."
+        end
+        return "a.m"
+      end
+      
+      # 'AM' or 'PM'.
+      def A
+        if self.data.hour > 11
+          return "PM"
+        end
+        return "AM"
+      end
+      
+      # Month, textual, 3 letters, lowercase.
+      def b
+        return MONTHS_3[self.data.month].downcase
+      end
+      
+      # Unimplemented
+      def B
+        return "[B]Unimplemented"
+      end
+      
+      # ISO 8601 format. (Note: unlike others formatters, such as "Z", "O" or "r", the "c" formatter will not add timezone offset if value is a naive datetime (see datetime.tzinfo).
+      def c
+        return self.data.iso8601
+      end
+      
+      # Day of the month, 2 digits with leading zeros.
+      def d
+        return "%02d" % self.data.day
+      end
+      
+      # Day of the week, textual, 3 letters.
+      def D
+        return WEEKDAYS_ABBR[self.data.weekday]
+      end
+      
+      # Unimplemented
+      def e
+        return "[E]Unimplemented"
+      end
+      
+      # Month, locale specific alternative representation usually used for long date representation
+      def E
+        return MONTHS_ALT[self.data.month]
+      end
+      
+      # Time, in 12-hour hours and minutes, with minutes left off if they're zero. Proprietary extension.
+      def f
+        if self.data.minute == 0
+          return self.g
+        end
+        return "%s:%s" % self.g, self.i
+      end
+      
+      # Month, textual, long.
+      def F
+        return MONTHS[self.data.month]
+      end
+      
+      # Hour 12 hour format - without leading zeros
+      def g
+        if self.data.hour == 0
+          return 12
+        end
+        if self.data.hour > 12
+          return self.data.hour - 12
+        end
+        return self.data.hour
+      end
+      
+      # Hour 24 hour format - without leading zeros
+      def G
+        return self.data.hour
+      end
+      
+      # Hour 12 hour format
+      def h
+        return "%02d" % self.g
+      end
+      
+      # Hour 24 hour format
+      def H
+        return "%02d" % self.G
+      end
+      
+      # Minutes
+      def i
+        return "%02d" % self.data.minute
+      end
+      
+      # Unimplemented
+      def I
+        return "[I]Unimplemented"
+      end
+      
+      # Day of the month without leading zeros.
+      def j
+        return self.data.day
+      end
+      
+      # Day of the week, textual, long.
+      def l
+        return WEEKDAYS[self.data.wday]
+      end
+      
+      # Boolean for whether it's a leap year.
+      def L
+        return self.data.leap?
+      end
+      
+      # Month, 2 digits with leading zeros.
+      def m
+        return "%02d" % self.data.month
+      end
+      
+      # Month, textual, 3 letters.
+      def M
+        return MONTHS_3[self.data.month]
+      end
+      
+      # Month without leading zero
+      def n
+        return self.data.month
+      end
+      
+      # Month abbreviation in Associated Press style. Proprietary extension.
+      def N
+        return MONTHS_AP[self.data.month]
+      end
+      
+      # ISO-8601 week-numbering year, corresponding to the ISO-8601 week number (W)
+      def o
+        return self.data.strftime("%G")
+      end
+      
+      # Difference to Greenwich time in hours.
+      def O
+        return self.data.strftime("%z")
+      end
+      
+      # Time, in 12-hour hours, minutes and 'a.m.'/'p.m.', with minutes left off if they're zero and the special-case strings 'midnight' and 'noon' if appropriate. Proprietary extension.
+      def P
+        if self.data.minute == 0 && self.data.hour == 0
+          return "midnight"
+        elsif self.data.minute == 0 and self.data.hour == 12
+          return "noon"
+        end
+        return "%s %s" % self.f, self.a
+      end
+      
+      # RFC 2822 formatted date.
+      def r
+        return self.data.rfc2822
+      end
+      
+      # Seconds, 2 digits with leading zeros.
+      def s
+        return "%02d" % self.data.second
+      end
+      
+      # English ordinal suffix for day of the month, 2 characters.
+      def S
+        if (11..13).include?(self.data.day)
+          return "#{self}th"
+        end
+        last = self.data.day % 10
+        if last == 1
+          return "st"
+        elsif last == 2
+          return "nd"
+        elsif last == 3
+          return "rd"
+        end
+        return "th"
+      end
+      
+      # Number of days in the given month
+      def t
+        return (Date.new(self.data.year, 12, 31) << (12 - self.data.month)).day
+      end
+      
+      # Timezone of this machine
+      def T
+        return DateTime.now.strftime("%Z")
+      end
+      
+      # Microseconds
+      def u
+        return self.data.strftime("%6N").to_i
+      end
+      
+      # Seconds since the Unix Epoch (January 1 1970 00:00:00 UTC).
+      def U
+        return self.data.strftime("%s").to_i
+      end
+      
+      # ISO-8601 week number of year, weeks starting on Monday
+      def W
+        return self.data.strftime("%-V").to_i
+      end
+      
+      # Year 2 digits
+      def y
+        return self.data.year.to_s[2..3]
+      end
+      
+      # Year 4 digits
+      def Y
+        return self.data.year
+      end
+      
+      # Day of the year
+      def z
+        return self.data.yday - 1
+      end
+      
+      # Time zone offset in seconds. The offset for timezones west of UTC is always negative, and for those east of UTC is always positive.
+      def Z
+        return self.data.offset.numerator * 60 *60
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/zwite/core/pagination.rb

@@ -0,0 +1,100 @@
+module Zwite
+  
+  module Pagination
+    
+    class Page < Object
+      
+      ##
+      # Properties
+      ##
+      
+      attr_accessor :paginator
+      attr_accessor :objects
+      attr_accessor :number
+      attr_accessor :has_next
+      attr_accessor :has_prev
+      attr_accessor :has_other_pages
+      attr_accessor :next_page_number
+      attr_accessor :prev_page_number
+      attr_accessor :start_index
+      attr_accessor :end_index
+      
+      def to_liquid
+        return {
+          "objects" => self.objects,
+          "number" => self.number,
+          "has_next" => self.has_next,
+          "has_prev" => self.has_prev,
+          "has_other_pages" => self.has_other_pages,
+          "next_page_number" => self.next_page_number,
+          "prev_page_number" => self.prev_page_number,
+          "start_index" => self.start_index,
+          "end_index" => self.end_index
+        }
+      end
+      
+      ##
+      # Initialization
+      ##
+      def initialize(paginator, objects, number)
+        self.paginator = paginator
+        self.objects = objects
+        self.number = number
+        
+        self.has_next = (self.number < self.paginator.pages_count)
+        self.has_prev = (self.number > 1)
+        self.has_other_pages = (self.has_next || self.has_prev)
+        self.next_page_number = self.number + 1
+        self.prev_page_number = self.number - 1
+        self.start_index = (self.paginator.pages_count == 0) ? 0 : (self.paginator.per_page * (self.number - 1)) + 1
+        self.end_index = (self.paginator.pages_count == self.number) ? self.paginator.pages_count : self.number * self.paginator.per_page
+        
+      end
+      
+    end
+    
+    class Paginator < Object
+      
+      ##
+      # Properties
+      ##
+      
+      attr_accessor :objects
+      attr_accessor :per_page
+      attr_accessor :pages
+      attr_accessor :pages_count
+      
+      def to_liquid
+        return {
+          "objects" => self.objects,
+          "per_page" => self.per_page,
+          "pages" => self.pages,
+          "pages_count" => self.pages_count
+        }
+      end
+      
+      ##
+      # Initialization
+      ##
+      def initialize(objects, per_page)
+        self.objects = objects
+        self.per_page = per_page
+        
+        self.pages = []
+        unless objects.count == 0
+          self.pages_count = (self.objects.count / self.per_page.to_f).ceil
+          self.pages_count.times do |i|
+            page_start = self.per_page * i
+            page_objects = self.objects[page_start..page_start + self.per_page - 1]
+            page = Page.new(self, page_objects, i + 1)
+            self.pages << page
+          end
+        end
+        
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/zwite/core/plugin.rb

@@ -0,0 +1,50 @@
+module Zwite
+  
+  class Plugin
+    
+    ##
+    # properties
+    ##
+
+    attr_accessor :app
+    attr_reader :name
+    attr_reader :enabled
+    
+    def enabled?
+       return (self.app.path + self.name).exist?
+     end
+    
+    ##
+    # class methods
+    ##
+    
+    def self.inherited(base_class)
+      self.subclasses << base_class
+    end
+    
+    def self.subclasses
+      @subclasses ||= []
+      return @subclasses
+    end
+
+    ##
+    # initialization
+    ##
+  
+    def initialize(app)
+      self.app = app
+    end
+    
+    ##
+    # actions
+    ##
+    
+    def preprocess
+    end
+    
+    def generate
+    end
+    
+  end
+  
+end