artifact 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e79feef5a99e24c60cc8a5bd3cc45e9b8c02739c
+  data.tar.gz: 1cc7825dad9f2d6240626055db3c1f863bd9f88f
+SHA512:
+  metadata.gz: 1bb13911e6984f007950ca058d7959538547d9410f73481350c54721870b3a96be2eec8acfd5d755bcf3e857b3d3ff141eb2b60c23a68203598b6cdc4f63205a
+  data.tar.gz: 4b07499de205b9248530b699f5a016fd01b9ea4afa253d2a1fd3ad819cb1129bc2175b7332ef68a12adbaac5df9a8afe3fd412723c4bb61c258f53ad1e12d260

data/.gitignore

@@ -0,0 +1,5 @@
+*~
+pkg
+site
+Gemfile.lock
+site.base

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in artifact.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Tomás Pollak
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Artifact
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'artifact'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install artifact
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/artifact.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'artifact/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "artifact"
+  spec.version       = Artifact::VERSION
+  spec.authors       = ["Tomás Pollak"]
+  spec.email         = ["tomas@forkhq.com"]
+  spec.description   = %q{Frontend UI for git blogging.}
+  spec.summary       = %q{Frontend UI for git blogging.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.6"
+
+  spec.add_dependency "rack"
+  spec.add_dependency "activesupport"
+  spec.add_dependency "rugged"
+  spec.add_dependency "sinatra"
+  spec.add_dependency "sinatra-contrib"
+  spec.add_dependency "rack-flash3"
+end

data/bin/artifact

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'artifact/cli'
+Artifact::CLI.start

data/lib/artifact.rb

@@ -0,0 +1,337 @@
+require 'yaml'
+require 'rugged'
+require 'artifact/version'
+
+module Artifact
+
+  FORMATS = {
+    '.markdown' => "Artifact::MarkdownFile",
+    '.html'     => "Artifact::HTMLFile"
+  }
+
+  def self.config
+    @config ||= Config.new
+  end
+
+  def self.configure
+    yield config
+  end
+
+  def self.root
+    config.root
+  end
+
+  def self.full_path(path)
+    File.join(root, path)
+  end
+
+  def self.relative_path(path)
+    path.sub(root + '/', '')
+  end
+
+  def self.open_file(path)
+    load_file(path, ReadableFile)
+  end
+
+  def self.new_file(path)
+    load_file(path, WritableFile)
+  end
+
+  def self.load_file(path, fallback)
+    if klass = FORMATS[File.extname(path)]
+      Kernel.const_get(klass).new(path)
+    else
+      fallback.new(path)
+    end
+  end
+
+  def self.repo
+    @repo ||= Repo.new(File.expand_path(config.root))
+  end
+
+  def self.ensure_dir!(full_path)
+    dir = File.dirname(full_path)
+    FileUtils.mkdir_p(dir) unless File.exist?(dir)
+  end
+
+  class Config
+
+    attr_accessor *%w(
+      root source_root posts_path drafts_path uploads_path directory_indexes
+    )
+
+    def initialize
+      @root              = Dir.pwd # current working path
+      @source_root       = 'source'
+      @posts_path        = 'posts'
+      @drafts_path       = 'drafts'
+      @uploads_path      = 'uploads'
+      @directory_indexes = true
+    end
+
+  end
+
+  class Tree
+
+    DEFAULT_NEW_FILE_PATH = '%Y/%m'
+
+    attr_reader :path, :full_path
+
+    def initialize(full_path, options = {})
+      @full_path = File.expand_path(full_path)
+      @path      = Artifact.relative_path(full_path)
+      @options   = options
+
+      Artifact.ensure_dir!(full_path)
+    end
+
+    def new(filename, extension = nil)
+      file_path = File.join(new_file_path, [filename, extension].compact.join)
+
+      if File.exist?(file_path)
+        appended = filename.sub(/\-?(\d{1,2})?$/) { |a| "-#{((a || 0).to_i*-1)+1}" }
+        return new(appended, extension)
+      end
+
+      file_path.sub(filename, filename + '-1')
+      Artifact.new_file(file_path)
+    end
+
+    def new_file_path
+      path = File.join(full_path, @options[:new_file_path] || DEFAULT_NEW_FILE_PATH)
+      path.split(File::SEPARATOR).map do |n|
+        n['%'] ? Time.now.strftime(n) : n
+      end.join(File::SEPARATOR)
+    end
+
+    def all
+      file_list.map { |f| Artifact.open_file(f) }.sort
+    end
+
+    def find(match)
+      file_list.select { |f| f[match] }.map { |f| Artifact.open_file(f) }.sort
+    end
+
+    def file_list
+      file_list_at(full_path)
+    end
+
+    def file_list_at(dir, matching = '*')
+      files = []
+      Dir.glob(File.join(dir, matching)).each do |entry|
+        if File.directory?(entry)
+          files = files + file_list_at(entry, matching)
+        elsif File.file?(entry) # skip sockets and symlinks
+          files << entry
+        end
+      end
+      files
+    end
+
+  end
+
+  class Repo
+
+    def initialize(full_path)
+      @root = full_path
+      @git = Rugged::Repository.new(full_path)
+    end
+
+    def save(path, author, check = true)
+      if check && !new_file?(path) && !modified?(path)
+        raise "No changes in file: #{path}"
+      end
+
+      @git.index.add(path)
+      @git.index.write
+      write_commit("Saved #{path}", author)
+    end
+
+    def move(from, to, author)
+      Artifact.ensure_dir!(Artifact.full_path(to))
+      FileUtils.mv(Artifact.full_path(from), Artifact.full_path(to))
+
+      @git.index.remove(from)
+      @git.index.add(to)
+      @git.index.write
+      write_commit("Moved #{from} --> #{to}", author)
+    end
+
+    def remove(path, author)
+      @git.index.remove(path)
+      @git.index.write
+      write_commit("Removed #{path}", author)
+    end
+
+    def exists?(path)
+      !!file_status(path) rescue false
+    end
+
+    private
+
+    def new_file?(file_path)
+      file_status(file_path) == 'new'
+    end
+
+    def modified?(file_path)
+      file_status(file_path) == 'modified'
+    end
+
+    def file_status(file_path)
+      if s = @git.status(file_path).first
+        return s.to_s.sub('worktree_', '')
+      end
+    end
+
+    def write_commit(message, author)
+      commit_sha = Rugged::Commit.create(@git,
+        :author     => author,
+        :message    => message,
+        :committer  => author,
+        :parents    => @git.empty? ? [] : [ @git.head.target ].compact,
+        :tree       => @git.index.write_tree,
+        :update_ref => 'HEAD'
+      )
+    end
+
+  end
+
+  class ReadableFile
+
+    attr_reader :path, :full_path
+
+    def initialize(path)
+      if path[Artifact.root] # path contains root, meaning absolute path
+        @path      = Artifact.relative_path(path)
+        @full_path = path
+      else
+        @path      = path
+        @full_path = Artifact.full_path(path)
+      end
+    end
+
+    def filename
+      File.basename(path)
+    end
+
+    def slug
+      File.basename(path, File.extname(path))
+    end
+
+    def dirname
+      File.dirname(full_path)
+    end
+
+    def last_modified
+      File.mtime(full_path)
+    end
+
+    def body
+      @content
+    end
+
+    def meta
+      {}
+    end
+
+    def exists?
+      File.exist?(full_path)
+    end
+
+    private
+
+    def content
+      @content ||= read
+    end
+
+    def read
+      IO.read(@full_path)
+    end
+
+    def <=>(other_file)
+      self.last_modified <=> other_file.last_modified
+    end
+
+  end
+
+  class WritableFile < ReadableFile
+
+    def update(content, meta = nil)
+      Artifact.ensure_dir!(@full_path)
+      # File.open(@full_path, 'wb') { |f| f.write(content.gsub("\r\n", "\n")) }
+      File.open(@full_path, 'wb') { |f| f.write(content) }
+      @content = nil
+    end
+
+    def delete
+      FileUtils.rm(full_path)
+    end
+
+  end
+
+  class HTMLFile < WritableFile
+
+  end
+
+  class MarkdownFile < WritableFile
+
+    def title
+      data['title']
+    end
+
+    def date
+      data['date']
+    end
+
+    def author
+      data['author']
+    end
+
+    def category
+      data['category']
+    end
+
+    def last_updated_by
+      data['last_updated_by']
+    end
+
+    def update(content, meta = {})
+      yaml_data = sanitized_meta(meta)
+      body = "#{yaml_data}---\n\n#{content}"
+      super(body)
+      @data = nil
+    end
+
+    def update_meta(key, val)
+      hash = {}
+      hash[key.to_s] = val
+      update(content, data.merge(hash))
+    end
+
+    def content
+      parts[1..-1].join("---\n\n")
+    end
+
+    def data
+      @data ||= YAML.load(parts[0])
+    rescue Psych::SyntaxError => e
+      raise "Invalid YAML at #{path}: #{parts[0]}"
+    end
+
+    def parts
+      read.split("---\n\n")
+    end
+
+    def sanitized_meta(hash)
+      hash.stringify_keys!
+      if exists?
+        %w(date author).each do |key|
+          hash[key] = self.send(key) if !hash[key] and self.send(key)
+        end
+      end
+      hash.to_yaml
+    end
+
+  end
+
+end