artifact 0.0.2

data/lib/artifact/app.rb

@@ -0,0 +1,55 @@
+require File.join(File.dirname(__FILE__), 'helpers')
+%w(sinatra/base active_support/inflector json).each { |lib| require lib }
+
+module Artifact
+
+  class App < Sinatra::Base
+
+    set :method_override, true
+    set :sessions, true
+    set :views, File.expand_path(File.join(File.dirname(__FILE__), 'views'))
+
+    use Rack::ShowExceptions
+    # use Rack::CommonLogger, LOGGER
+    # use Rack::Flash
+    use Rack::Static,
+      :urls => %w(/css /img /js),
+      :root => File.expand_path(File.join(File.dirname(__FILE__), 'public'))
+
+    helpers do
+      # include Rack::Utils # provides escape, parse_query and unescape
+      # include Sinatra::ContentFor
+      include Helpers
+      def logger; LOGGER; end
+    end
+
+    error do
+      if request.env['sinatra.error'].class.name['DocumentNotFound']
+        not_found
+      else
+        erb :'errors/500', :layout => false
+      end
+    end
+
+    not_found do
+      not_found
+    end
+
+    private
+
+    # FIXME: SOON!
+    def current_user
+      author = {
+        :email => "ofofofof@gmail.com",
+        :time  => Time.now,
+        :name  => "The User"
+      }
+    end
+
+    def not_found
+      erb :'errors/404', :layout => false
+    end
+
+  end
+
+end

data/lib/artifact/files.rb

@@ -0,0 +1,60 @@
+require File.join(File.dirname(__FILE__), 'app')
+
+module Artifact
+
+  def self.files
+    @files ||= Tree.new(config.root)
+  end
+
+  class Files < App
+
+    get '/' do
+      redirect to('/files')
+    end
+
+    get '/files' do
+      @files = Artifact.files.all
+      view 'files/index'
+    end
+
+    get '/files/new' do
+      view 'files/new'
+    end
+
+    post '/files/create' do
+      @file = Artifact.files.new(params[:path])
+      @file.update(params[:content], params[:meta])
+      redirect to('/')
+    end
+
+    get '/files/edit/*' do
+      get_file
+      view 'files/edit'
+    end
+
+    post '/files/update/*' do
+      get_file
+      @file.update(params[:content], params[:meta])
+
+      if params[:submit] and params[:submit][/push/i]
+        return redirect to("/commit/#{params[:splat][0]}")
+      end
+
+      redirect to('/')
+    end
+
+    get '/commit/*' do
+      get_file
+      Artifact.repo.save(@file.full_path, current_user)
+      redirect to('/')
+    end
+
+    private
+
+    def get_file
+      Artifact.open_file(params[:splat][0]) or raise 'File not found!'
+    end
+
+  end
+
+end

data/lib/artifact/helpers.rb

@@ -0,0 +1,130 @@
+require 'uri'
+
+module Artifact
+
+  module Helpers
+
+    #########################################
+    # main
+    #########################################
+
+    def app_name
+      'Artifact'
+    end
+
+    def action
+      request.path_info.gsub('/','').empty? ? 'home' : request.path_info.gsub('/',' ')
+    end
+
+    def requires!(required, hash = params)
+      if required.is_a?(Hash)
+        required.each { |k, vals| requires!(vals, hash[k]) }
+      elsif hash.nil? or hash.is_a?(String) or required.any?{ |p| hash[p].nil? }
+        halt(400, 'Missing parameters.')
+      end
+    end
+
+    #########################################
+    # rendering
+    #########################################
+
+    def partial(name, *args)
+      partial_name = name.to_s["/"] ? name.to_s.reverse.sub("/", "_/").reverse : "_#{name}"
+      erb(partial_name.to_sym, {:layout => false}, *args)
+    end
+
+    def view(view_name, *args)
+      layout = request.xhr? ? false : @mobile_host ? :'layout.mobile' : true
+      erb(view_name.to_sym, {:layout => layout}, *args)
+    end
+
+    #########################################
+    # paths, links
+    #########################################
+
+    def base_path
+      env['SCRIPT_NAME']
+    end
+
+    def get_class_name(klass)
+      klass.name.to_s.split("::").last
+    end
+
+    def guess_model_path(m)
+      base_path + '/' + get_class_name(m).pluralize.downcase
+    end
+
+    def url_for(object)
+      object.nil? ? "#" : object.is_a?(String) ? object \
+      : object.respond_to?(:path) ? object.path : "#{guess_model_path(object.class)}/#{object.to_param}"
+    end
+
+    def link_to(string, resource)
+      "<a href='#{url_for(resource)}'>#{string}</a>"
+    end
+
+    def active?(link)
+      request.path[link] ? 'active' : ''
+    end
+
+    def view_upload_path(file)
+      url(upload_relative_path(file))
+    end
+
+    def upload_relative_path(file)
+      # we need to start with a /, otherwise middleman will insert his image_path as prefix
+      '/' + Artifact.config.uploads_path + file.path.sub(Artifact.uploads.path, '')
+    end
+
+    def is_image?(filename)
+      filename.match(/\.(png|jpg|jpeg|gif|bmp)$/i)
+    end
+
+    def post_preview_path(post)
+      str = post.path.sub(Artifact.config.source_root, '')
+      if Artifact.config.directory_indexes
+        str.sub(post.filename, post.filename.split('.').first)
+      end
+    end
+
+    def delete_link(resource, options = {})
+      css_class = options[:class] || ''
+      text = options[:text] || 'Delete'
+      path = url_for(resource)
+      '<form class="destroy" style="display:inline" method="post" action="'+ path +'" onsubmit="return confirm(\'Are you sure?\');">
+        <input type="hidden" name="_method" value="delete" />
+        <button type="submit" class="' + css_class +' btn btn-danger">' + text + '</button>
+      </form>'
+    end
+
+    def in_words(time)
+      minutes = (((Time.now - time).abs)/60).round
+      return nil if minutes < 0
+
+      case minutes
+        when 0..1            then 'less than a minute'
+        when 2..4            then 'less than 5 minutes'
+        when 5..14           then 'less than 15 minutes'
+        when 15..29          then "half an hour"
+        when 30..59          then "#{minutes} minutes"
+        when 60..119         then '1 hour'
+        when 120..239        then '2 hours'
+        when 240..479        then '4 hours'
+        when 480..719        then '8 hours'
+        when 720..1439       then '12 hours'
+        when 1440..11519     then "#{(minutes/1440).floor} days"
+        when 11520..43199    then "#{(minutes/11520).floor} weeks"
+        when 43200..525599   then "#{(minutes/43200).floor} months"
+        else                      "#{(minutes/525600).floor} years"
+      end
+    end
+
+    def time_ago_in_words(time)
+      if str = in_words(time)
+        "#{str} ago"
+      end
+    end
+
+  end
+
+end

data/lib/artifact/middleman.rb

@@ -0,0 +1,213 @@
+require File.join(File.dirname(__FILE__), 'app')
+require 'active_support'
+
+class Middleman::Sitemap::Store
+
+  alias_method :original_initialize, :initialize
+
+  def initialize(app)
+    Artifact.middleman = app
+    original_initialize(app)
+  end
+
+end
+
+class Middleman::CoreExtensions::FrontMatter
+
+  # extension's clear_data method doesn't work
+  # because it uses the full file path, while
+  # the cache setter uses only the relative path
+  def flush_cache!
+    @cache = {}
+  end
+
+end
+
+module Artifact
+
+  def self.middleman=(app)
+    @app = app
+  end
+
+  def self.middleman
+    @app
+  end
+
+  def self.source_root
+    File.join(config.root, config.source_root)
+  end
+
+  def self.posts
+    @posts ||= Tree.new(File.join(source_root, Artifact.config.posts_path))
+  end
+
+  def self.drafts
+    opts = {:new_file_path => ''} # flat, no date
+    @drafts ||= Tree.new(File.join(source_root, Artifact.config.drafts_path), opts)
+  end
+
+  def self.uploads
+    @uploads ||= Tree.new(File.join(source_root, Artifact.config.uploads_path))
+  end
+
+  class Middleman < App
+
+    POST_EXTENSION = '.html.markdown'
+
+    get '/' do
+      redirect to('/posts')
+    end
+
+    post '/build' do
+      # updated! and rebuild!
+      rebuild!
+      redirect to('/')
+    end
+
+    get '/search' do
+      if params[:q].present?
+        normalized = params[:q].gsub(' ', '-').downcase
+        @list = filter_and_sort(Artifact.posts.find(normalized), :date)
+      else
+        @list = filter_and_sort(Artifact.posts.all.last(10), :date)
+      end
+      partial 'posts/list'
+    end
+
+    get '/posts' do
+      @posts  = filter_and_sort(Artifact.posts.all.last(10), :date)
+      @drafts = filter_and_sort(Artifact.drafts.all, :last_modified)
+      view 'posts/index'
+    end
+
+    get '/posts/new' do
+      view 'posts/new'
+    end
+
+    post '/posts' do
+      data = params[:meta] # includes title and maybe something else
+      filename = data[:title].parameterize
+
+      @file = Artifact.drafts.new(filename, POST_EXTENSION)
+      @file.update(params[:content], data)
+      redirect to('/posts')
+    end
+
+    get '/drafts/*' do
+      @post  = MarkdownFile.new(params[:splat][0])
+      @draft = true
+      view 'posts/edit'
+    end
+
+    get '/posts/*' do
+      @post = MarkdownFile.new(params[:splat][0])
+      view 'posts/edit'
+    end
+
+    post '/posts/*' do
+      @post = MarkdownFile.new(params[:splat][0])
+
+      meta = (params[:meta] || {}).merge('last_updated_by' => current_user[:email])
+      @post.update(params[:content].gsub("\r\n", "\n"), meta)
+
+      if params[:save] # user clicked on 'save' or 'published'
+        # if draft was previously saved this will raise 'coz no changes.
+        Artifact.repo.save(@post.path, current_user, false)
+
+        if params[:save] == 'Publish'
+          @post.update_meta(:date, Time.now.utc.strftime("%Y-%m-%d %H:%M %Z"))
+          publish_post!(@post)
+        elsif params[:save] == 'Unpublish'
+          unpublish_post!(@post)
+        end
+      end
+
+      updated!
+      redirect to('/posts')
+    end
+
+    delete '/posts/*' do
+      @post = MarkdownFile.new(params[:splat][0])
+      @post.delete
+      Artifact.repo.remove(@post.path, current_user) if Artifact.repo.exists?(@post.path)
+      updated!
+
+      redirect to('/posts')
+    end
+
+    get '/uploads/*' do
+      file = params[:splat].first
+      send_file File.join(Artifact.uploads.path, file)
+    end
+
+    get '/uploads' do
+      get_uploads
+      # @uploads.select! {|i| i.match(/\.(png|jpg|jpeg|gif)/i) }
+      partial 'uploads/list'
+    end
+
+    post '/uploads' do
+      unless params[:file] &&
+        (tmpfile = params[:file][:tempfile]) &&
+        (name = params[:file][:filename])
+        raise 'No file uploaded.'
+      else
+        filename = File.basename(name, File.extname(name)).parameterize # without extension
+        file = Artifact.uploads.new(filename, File.extname(name))
+        file.update(tmpfile.read)
+        Artifact.repo.save(file.path, current_user) # pass relative path
+
+        updated!
+        redirect to('/')
+      end
+    end
+
+    private
+
+    def get_uploads
+      @uploads = Artifact.uploads.all.last(10).reverse
+    end
+
+    def filter_and_sort(posts, criteria)
+      posts.select { |f| f.is_a?(WritableFile) }.sort do |a,b|
+        b.send(criteria) <=> a.send(criteria)
+      end
+    end
+
+    def publish_post!(post)
+      filename = post.title.parameterize
+      new_file = Artifact.posts.new(filename, POST_EXTENSION)
+      Artifact.repo.move(post.path, new_file.path, current_user)
+    end
+
+    def unpublish_post!(post)
+      filename = post.title.parameterize
+      new_file = Artifact.drafts.new(filename, POST_EXTENSION)
+      Artifact.repo.move(post.path, new_file.path, current_user)
+    end
+
+    def rebuild!
+      puts `bundle exec middleman build`
+    end
+
+    def updated!
+      return if Artifact.middleman.nil? # not loaded yet!
+
+      puts "Reloading Middleman..."
+      Artifact.middleman.files.reload_path(Artifact.drafts.path)
+      Artifact.middleman.files.reload_path(Artifact.posts.path)
+      Artifact.middleman.files.reload_path(Artifact.uploads.path)
+
+      Artifact.middleman.cache.clear # Tilt (template) cache
+      # Artifact.middleman.sitemap.send(:reset_lookup_cache!)
+      Artifact.middleman.sitemap.rebuild_resource_list!
+
+      if Artifact.middleman.extensions[:frontmatter]
+        puts "Flushing frontmatter cache..."
+        Artifact.middleman.extensions[:frontmatter].flush_cache!
+      end
+    end
+
+  end
+
+end