amiba 0.0.2

data/lib/amiba/reverse_markdown.rb

@@ -0,0 +1,199 @@
+require 'rexml/document'
+include REXML
+
+# reverse markdown for ruby
+# author: JO
+# e-mail: xijo@gmx.de
+# date: 14.7.2009
+# version: 0.1
+# license: GPL
+
+# TODO
+# - ol numbering is buggy, in fact doesn't matter for markdown code
+# - 
+
+module Amiba
+  class ReverseMarkdown
+
+    # set basic variables:
+    # - @li_counter: numbering list item (li) tags in an ordered list (ol)
+    # - @links:      hold the links for adding them to the bottom of the @output
+    #                this means 'reference style', please take a look at http://daringfireball.net/projects/markdown/syntax#link
+    # - @outout:     fancy markdown code in here!
+    # - @indent:     control indention level for nested lists
+    # - @errors:     appearing errors, like unknown tags, go into this array
+    def initialize()
+      @li_counter = 0
+      @links = []
+      @output = ""
+      @indent = 0
+      @errors = []
+    end
+
+    # Invokes the HTML parsing by using a string. Returns the markdown code in @output.
+    # To garantuee well-formed xml for REXML a <root> element will be added, but has no effect.
+    # After parsing all elements, the 'reference style'-links will be inserted.
+    def parse_string(string)
+      doc = Document.new("<root>\n"+string+"\n</root>")
+      root = doc.root
+      root.elements.each do |element|
+        parse_element(element, :root)
+      end
+      insert_links()
+      @output
+    end
+
+    # Parsing an element and its children (recursive) and writing its markdown code to @output
+    # 1. do indent for nested list items
+    # 2. add the markdown opening tag for this element
+    # 3a. if element only contains text, handle it like a text node
+    # 3b. if element is a container handle its children, which may be text- or element nodes
+    # 4. finally add the markdown ending tag for this element
+    def parse_element(element, parent)
+      name = element.name.to_sym
+      # 1.
+      @output << indent() if name.eql?(:li)
+      # 2.
+      @output << opening(element, parent)
+
+      # 3a.
+      if (element.has_text? and element.children.size < 2)
+        @output << text_node(element, parent)
+      end
+
+      # 3b.
+      if element.has_elements?
+        element.children.each do |child|
+          # increase indent if nested list
+          @indent += 1 if element.name=~/(ul|ol)/ and parent.eql?(:li)
+
+          if child.node_type.eql?(:element)
+            parse_element(child, element.name.to_sym)
+          else
+            if parent.eql?(:blockquote)
+              @output << child.to_s.gsub("\n ", "\n>")
+            else
+              @output << child.to_s
+            end
+          end
+
+          # decrease indent if end of nested list
+          @indent -= 1 if element.name=~/(ul|ol)/ and parent.eql?(:li)
+        end
+      end
+
+      # 4.
+      @output << ending(element, parent)
+    end
+
+    # Returns opening markdown tag for the element. Its parent matters sometimes!
+    def opening(type, parent)
+      case type.name.to_sym
+      when :h1
+        "# "
+      when :li
+        parent.eql?(:ul) ? " - " : " "+(@li_counter+=1).to_s+". "
+      when :ol
+        @li_counter = 0
+        ""
+      when :ul
+        ""
+      when :h2
+        "## "
+      when :em
+        "*"
+      when :strong
+        "**"
+      when :blockquote
+        # remove leading newline
+        type.children.first.value = ""
+        "> "
+      when :code
+        parent.eql?(:pre) ? "    " : "`"
+      when :a
+        "["
+      when :img
+        "!["
+      when :hr
+        "----------\n\n"
+      else
+        @errors << "unknown start tag: "+type.name.to_s
+        ""
+      end
+    end
+
+    # Returns the closing markdown tag, like opening()
+    def ending(type, parent)
+      case type.name.to_sym
+      when :h1
+        " #\n\n"
+      when :h2
+        " ##\n\n"
+      when :p
+        parent.eql?(:root) ? "\n\n" : "\n"
+      when :ol
+        parent.eql?(:li) ? "" : "\n"
+      when :ul
+        parent.eql?(:li) ? "" : "\n"
+      when :em
+        "*"
+      when :strong
+        "**"
+      when :li
+        ""
+      when :blockquote
+        ""
+      when :code
+        parent.eql?(:pre) ? "" : "`"
+      when :a
+        @links << type.attribute('href').to_s
+        "][" + @links.size.to_s + "] "
+      when :img
+        @links << type.attribute('src').to_s
+        "" + type.attribute('alt').to_s + "][" + @links.size.to_s + "] "
+        "#{type.attribute('alt')}][#{@links.size}] "
+      else
+        @errors << "  unknown end tag: "+type.name.to_s
+        ""
+      end
+    end
+
+    # Perform indent: two space, @indent times - quite simple! :)
+    def indent
+      str = ""
+      @indent.times do
+        str << "  "
+      end
+      str
+    end
+
+    # Return the content of element, which should be just text.
+    # If its a code block to indent of 4 spaces.
+    # For block quotation add a leading '>'
+    def text_node(element, parent)
+      if element.name.to_sym.eql?(:code) and parent.eql?(:pre)
+        element.text.gsub("\n","\n    ") << "\n"
+      elsif parent.eql?(:blockquote)
+        element.text.gsub!("\n ","\n>")
+      else
+        element.text
+      end
+    end
+
+    # Insert the mentioned reference style links.
+    def insert_links
+      @output << "\n"
+      @links.each_index do |index|
+        @output << "  [#{index+1}]: #{@links[index]}\n"
+      end
+    end
+
+    # Print out all errors, that occured and have been written to @errors.
+    def print_errors
+      @errors.each do |error|
+        puts error
+      end
+    end
+
+  end
+end

data/lib/amiba/scope.rb

@@ -0,0 +1,49 @@
+module Amiba
+  class Scope
+
+    attr_reader :page
+    
+    def initialize(page)
+      @page = page
+    end
+
+    def title
+      page.title
+    end
+
+    def description
+      page.description
+    end
+
+    def content
+      page_renderer.render(self)
+    end
+
+    def entries
+      Amiba::Source::Entry
+    end
+
+    def partial(path, locals={})
+      p = Amiba::Source::Partial.new path
+      Tilt.new(p.filename).render(Amiba::Scope.new(p), locals)
+    end
+
+    def site_name
+      Amiba::Configuration.site_name.nil? ? "" : "http://#{Amiba::Configuration.site_name}/"
+    end
+
+    def full_url(frag)
+      if site_name.empty?
+        frag
+      else
+        URI.join(site_name, frag).to_s
+      end
+    end
+
+    protected
+
+    def page_renderer
+      Tilt.new page.staged_filename
+    end
+  end
+end

data/lib/amiba/site.rb

@@ -0,0 +1,166 @@
+module Amiba
+  module Site
+
+    class S3Upload < Thor::Group
+      include Amiba::Generator
+
+      namespace :"site:upload:s3"
+
+      class_option :credentials, :default => :default
+
+      def init_s3
+        Fog.credential = options[:credentials].to_sym
+        @s3 ||= Fog::Storage.new(:provider=>'AWS')
+      end
+
+      def create
+        invoke Amiba::Site::Generate
+      end
+
+      def configure_s3
+        if ! @s3.directories.get bucket 
+          @bucket = @s3.directories.create(:key=>bucket, :public=>true, :location=>location)
+          say_status "Created", @bucket.key, :green
+          @s3.put_bucket_website(bucket,"index.html")
+          say_status "Configured", @bucket.key, :green
+        else
+          @bucket = @s3.directories.get bucket 
+        end
+      end
+
+      def upload_files
+        Dir[File.join(Amiba::Configuration.site_dir, "public", "**/*")].each do |ent|
+          next if File.directory? ent
+          path = File.expand_path ent
+          name = File.relpath(path, File.join(Amiba::Configuration.site_dir, "public"))
+          data = File.open path
+          file = @bucket.files.create(:key=>name, :body=>data, :public=>true)
+          say_status "Uploaded", name, :green
+        end
+      end
+
+      def complete
+        host = "http://#{bucket}.s3-website-#{Fog.credentials[:region]}.amazonaws.com/"
+        say_status "Available at", host, :green
+      end
+
+      private
+      def bucket
+        Amiba::Configuration.site_name
+      end
+
+      def location
+        Amiba::Configuration.s3_location || "EU"
+      end
+
+    end
+
+    class Generate < Thor::Group
+      include Amiba::Generator
+
+      namespace :"site:generate"
+
+      def self.source_root
+        Dir.pwd
+      end
+
+      def cleardown
+        remove_dir Amiba::Configuration.site_dir
+        remove_dir Amiba::Configuration.staged_dir
+      end
+
+      def create_site_structure
+        empty_directory Amiba::Configuration.site_dir
+      end
+      
+      def copy_favicon
+        if File.exists? "public/images/favicon.ico"
+          copy_file "public/images/favicon.ico", File.join(Amiba::Configuration.site_dir, "public/favicon.ico")
+        end
+      end
+
+      def copy_xdomain
+        if File.exists? "public/crossdomain.xml"
+          copy_file "public/crossdomain.xml", File.join(Amiba::Configuration.site_dir, "public/crossdomain.xml")
+        end
+      end
+
+      def copy_javascript
+        directory "public/js", File.join(Amiba::Configuration.site_dir, "public/js")
+      end
+
+      def copy_images
+        directory "public/images", File.join(Amiba::Configuration.site_dir, "public/images")
+      end
+      
+      def copy_css
+        Dir.glob('public/css/*.css').each do |css_file|
+          copy_file css_file, File.join(Amiba::Configuration.site_dir, "public/css/", File.basename(css_file))
+        end
+      end
+      
+      def process_and_copy_sass
+        Dir.glob('public/css/[^_]*.scss').each do |scss_file|
+          create_file File.join(Amiba::Configuration.site_dir,"public/css/", File.basename(scss_file).gsub('scss', 'css')) do
+            Tilt.new(scss_file).render
+          end
+        end
+      end
+    
+      def build_pages
+        Dir.glob('pages/**/[^_]*').each do |page_file|
+          next if File.directory? page_file
+          page = Amiba::Source::Page.new(File.relpath(page_file, "pages"))
+          next unless page.state == "published"
+          build_page page
+        end
+      end
+
+      def build_entries
+        Amiba::Source::Entry.all.each do |entry|
+          build_page entry
+        end
+      end
+
+      def build_json
+        Dir.glob('entries/*').each do |cat|
+          c = File.basename cat
+          create_file(File.join(Amiba::Configuration.site_dir, "public", c, "latest.json")) do
+            Amiba::Source::Entry.send(c.to_sym.pluralize).limit(20).each.inject([]) do |acc, ent|
+              a = ent.metadata
+              a["content"] = ent.render
+              acc << a
+            end.to_json
+          end
+        end
+      end
+
+      def build_feeds
+        Dir.glob('feeds/*.builder').each do |feed_file|
+          feed = Amiba::Source::Feed.new(feed_file)
+          create_file(feed.output_filename) do
+            Tilt.new(feed.filename).render(Amiba::Scope.new(feed), :xml => Builder::XmlMarkup.new)
+          end
+        end
+      end
+
+      private
+
+      def build_layout(page)
+        layout = Amiba::Source::Layout.new(page.layout)
+        return layout if File.exists? layout.staged_filename
+        create_file(layout.staged_filename) do layout.content end
+        layout
+      end
+
+      def build_page(page)
+        layout = build_layout(page)
+        create_file(page.staged_filename) do page.content end
+        create_file(page.output_filename) do
+          Tilt.new(layout.staged_filename).render(Amiba::Scope.new(page))
+        end
+      end
+
+    end
+  end
+end

data/lib/amiba/source/entry.rb

@@ -0,0 +1,42 @@
+module Amiba
+  module Source
+    class Entry
+      extend Amiba::Source::EntryFinder
+      include Amiba::Source
+      
+      attr_accessor :category
+      metadata_fields :title, :slug, :state, :layout
+
+      validates_presence_of :title, :state, :layout
+
+      def initialize(category, name, format, metadata = nil, content = nil)
+        self.category = category
+        self.name = name
+        self.format = format
+        self.metadata = metadata
+        self.content = content
+      end
+
+      def filename
+        File.join("entries", category.to_s.downcase.pluralize, name + ".#{format.to_s}")
+      end
+      
+      def staged_filename
+        File.join(Amiba::Configuration.staged_dir, filename)
+      end
+
+      def output_filename
+        File.join(Amiba::Configuration.site_dir, 'public', category.to_s.downcase.pluralize, "#{name}.html")
+      end
+
+      def link
+        URI.escape( ["", category.to_s.downcase.pluralize, "#{name}.html"].join("/") )
+      end
+
+      def render
+        Tilt.new(self.staged_filename).render(Amiba::Scope.new(self))
+      end
+
+    end
+  end
+end

data/lib/amiba/source/entry_finder.rb

@@ -0,0 +1,136 @@
+module Amiba
+  module Source
+    module EntryFinder
+      
+      def method_missing(method_name, *args, &block)
+        proxy = FinderProxy.new
+        proxy.send(method_name, *args, &block)
+      rescue
+        raise ArgumentError.new("#{method_name} does not exist")
+      end
+      
+    end
+
+    class FinderProxy
+      include Amiba::Repo
+      include Enumerable
+
+      def each(&blk)
+        entries.each(&blk)
+      end
+
+      def first
+        entries.first
+      end
+
+      def last
+        entries.last
+      end
+
+      def count
+        entries.count
+      end
+
+      def [](index)
+        entries[index]
+      end
+
+      def entries
+        result = (scopes[:category] || CategoryScope.new).apply
+        result = (scopes[:state] || StateScope.new).apply(result)
+        # reverse sorting is a more natural approach
+        result.sort! do |a, b|
+          last_commit_date(b.filename) <=> last_commit_date(a.filename)
+        end
+        result = scopes[:offset].apply(result) if scopes[:offset]
+        result = scopes[:limit].apply(result) if scopes[:limit]
+        result
+      end
+
+      [:draft, :published, :any].each do |state|
+        define_method state do
+          self[:state] = StateScope.new(state)
+          self
+        end
+      end
+
+      def method_missing(method_name, *args, &block)
+        entry_types = (Dir.glob('entries/*') << "all").map {|c| File.basename(c).to_sym}
+        if entry_types.include?(method_name)
+          self[:category] = CategoryScope.new(method_name)
+        else
+          raise ArgumentError
+        end
+        self
+      end
+
+      def offset(index)
+        self[:offset] = OffsetScope.new(index)
+        self
+      end
+      
+      def limit(count)
+        self[:limit] = LimitScope.new(count)
+        self
+      end
+
+      protected
+      
+      def []=(key, val)
+        scopes[key] = val
+        self
+      end
+
+      def scopes
+        @scopes ||= {}
+      end
+
+    end
+
+    class CategoryScope
+      include Amiba::Repo
+      def initialize(category = :all)
+        @category = category
+      end
+      def apply
+        entry_files.map do |ef|
+          _, category, filename = ef.split('/')
+          name, format = filename.split('.')
+          Amiba::Source::Entry.new(category, name, format)
+        end
+      end
+      def entry_files
+        globstring = "entries/#{@category == :all ? '*' : @category.to_s}/*"
+        Dir.glob(globstring).select {|e| !repo.log(e).empty?}
+      end
+    end
+    
+    class StateScope
+      def initialize(state = :published)
+        @state = state
+      end
+      def apply(entries)
+        return entries if @state == :any
+        entries.select {|e| e.state.to_sym == @state}
+      end
+    end
+
+    class OffsetScope
+      def initialize(offset = 0)
+        @offset = offset
+      end
+      def apply(entries)
+        entries[@offset..-1]
+      end
+    end
+      
+    class LimitScope
+      def initialize(limit = -1)
+        @limit = (limit == -1 ? -1 : limit - 1)
+        end
+      def apply(entries)
+        entries[0..@limit]
+      end
+    end
+  end
+end

data/lib/amiba/source/feed.rb

@@ -0,0 +1,34 @@
+
+module Amiba
+  module Source
+    class Feed
+      include Amiba::Source
+
+      attr_accessor :type, :name
+      def initialize(fn)
+        self.name, self.type = File.basename(fn, ".builder").split(".")
+      end
+
+      def filename 
+        @filename ||= File.join("feeds", "#{@name}.#{@type}.builder")
+      end
+
+      def content=(c)
+        @content ||= self.new? ? c : File.read(filename)
+      end
+
+      def staged_filename
+        File.join(Amiba::Configuration.staged_dir, filename)
+      end
+
+      def output_filename
+        File.join(Amiba::Configuration.site_dir, "public/#{name}.#{type}")
+      end
+
+      def link
+        URI.escape "/#{name}.#{type}"
+      end
+
+    end
+  end
+end

data/lib/amiba/source/partial.rb

@@ -0,0 +1,22 @@
+module Amiba
+  module Source
+    class Partial
+      include Amiba::Source
+
+      attr_accessor :dir, :name
+      def initialize(path)
+        self.dir, self.name = File.split path
+      end
+
+      def filename 
+        @filename ||= File.join("pages", @dir, "_#{@name}.haml")
+      end
+
+      def staged_filename
+        File.join(Amiba::Configuration.staged_dir, filename)
+      end
+      alias_method :output_filename, :staged_filename
+
+    end
+  end
+end