mist 0.6.0

data/lib/mist/git_model/attributes.rb

@@ -0,0 +1,21 @@
+class Mist::GitModel::Attributes < HashWithIndifferentAccess
+  def initialize(model)
+    @model = model
+    super()
+  end
+  
+  def []=(key, value)
+    @model.send(:"#{key}_will_change!") unless !@model || value == self[key]
+    super
+  end
+  
+  # Yamlers using Psych will call this method, we just delegate it into
+  # `HashWithIndifferentAccess`. If we don't, the yaml tag will be
+  # "!ruby/object:Mist::GitModel::Attributes" so that when the record
+  # is deserialized, this class will be instantiated, resulting in an
+  # error. (This class should only be instantiated directly by
+  # `Mist::GitModel`.)
+  def to_yaml(*args)
+    HashWithIndifferentAccess.new(self).to_yaml(*args)
+  end
+end

data/lib/mist/git_model/class_methods.rb

@@ -0,0 +1,141 @@
+module Mist::GitModel::ClassMethods
+  def self.extended(base) #:nodoc:
+    base.class_attribute :default_attributes
+    base.default_attributes ||= HashWithIndifferentAccess.new
+  end
+  
+  # this is necessary because without it default_attributes will be
+  # inherited and shared across all subclasses of base, which we
+  # don't exactly want.
+  def inherited(subclass) #:nodoc:
+    if subclass.default_attributes
+      subclass.default_attributes = subclass.default_attributes.dup
+    else
+      subclass.default_attributes = HashWithIndifferentAccess.new
+    end
+  end
+  
+  def timestamps
+    attribute :created_at, :default => proc { Time.now }
+    attribute :updated_at, :default => proc { Time.now }
+    before_save { |record| record.updated_at = Time.now }
+  end
+  
+  def attribute(name, options = {})
+    name = name.to_sym
+    default_attributes[name] = options[:default]
+    define_attribute_methods [name.to_s]
+    add_attribute_default(name, options)
+    add_attribute_getter(name)
+    add_attribute_setter(name)
+  end
+  
+  def add_attribute_getter(name)
+    define_method(name) do                                # def id
+      attributes[name]                                    #   attributes[:id]
+    end                                                   # end
+  end
+  
+  def add_attribute_setter(name)
+    define_method(:"#{name}=") do |value|                 # def id=(value)
+      unless value == attributes[name]                    #   unless value == attributes[:id]
+        attributes[name] = value                          #     attributes[:id] = value
+      end                                                 # end
+    end
+  end
+  
+  def add_attribute_default(name, options)
+    define_method(:"default_#{name}") do                  # def default_id
+      if options[:default].kind_of?(Proc)                 #   if options[:default].kind_of?(Proc)
+        options[:default].call                            #     options[:default].call
+      else                                                #   else
+        options[:default]                                 #     options[:default]
+      end                                                 #   end
+    end                                                   # end
+  end
+  
+  def table_name
+    if name =~ /GitModel/
+      raise
+    end
+    name.underscore.pluralize
+  end
+  
+  # Returns meta data for this model.
+  def [](type)
+    @meta ||= {}
+    @meta[type] ||= if File.file?(meta_file_path(type))
+      YAML.load(File.read(meta_file_path(type))) || {}
+    else
+      {}
+    end.with_indifferent_access
+  end
+  
+  # Assigns, saves and commits meta data for this model.
+  def save_meta_data(type)
+    FileUtils.mkdir_p File.dirname(meta_file_path(type))
+    File.open(meta_file_path(type), 'w') { |f| f.print self[type].to_yaml }
+    if Mist.commit_meta_data
+      Mist.repository.add meta_file_path(type)
+      Mist.repository.commit '%s meta changes to %s' % [type, table_name]
+    end
+
+    # we must force meta to be reloaded because otherwise it could get out of sync with filesystem
+    @meta = nil
+  end
+  
+  def meta_file_path(type)
+    Mist.repository_location.join('.meta', table_name, type.to_s)
+  end
+  
+  def all
+    # it's dangerous to rely on Dir[] because we have no guarantee of the
+    # returned order. Git will be more reliable.
+    files = Mist::GitFileSystemHistory.new(Mist.repository).find(nil, /^#{Regexp::escape table_name}\/?/)
+    files.collect! { |path| load Mist.repository_location.join(path) }
+  end
+  
+  def load(path, attributes = {})
+    # id is always the filename, ensure id isn't changed by yaml
+    attributes = attributes.with_indifferent_access.reverse_merge(YAML.load(File.read(path)))
+    attributes['id'] = File.basename(path)
+    new(attributes).tap do |instance|
+      instance.changed_attributes.clear
+    end
+  end
+  
+  def record_path(id)
+    Mist.repository_location.join(table_name, id.to_s)
+  end
+  
+  def find(id, new_attributes = {})
+    if path = exist?(id)
+      load path, new_attributes
+    else
+      nil
+    end
+  end
+  
+  # If the id exists, its file path is returned. Otherwise, nil.
+  def exist?(id)
+    path = record_path(id)
+    File.exist?(path) ? path : nil
+  end
+  
+  def last(count = nil)
+    files = Mist::GitFileSystemHistory.new(Mist.repository).find(count || 1, /^#{Regexp::escape table_name}\/?/)
+    files.collect! { |path| load Mist.repository_location.join(path) }
+    count.nil? ? files.first : files
+  end
+  
+  def create!(attributes = {})
+    new(attributes).tap do |record|
+      record.save!
+    end
+  end
+  
+  def count
+    Dir[Mist.repository_location.join(table_name, '*')].length
+  end
+end
+

data/lib/mist/permalink.rb

@@ -0,0 +1,5 @@
+module Mist::Permalink
+  def permalink(text)
+    text.underscore.gsub(/[^a-zA-Z0-9]+/, '-').sub(/-$/, '')
+  end
+end

data/lib/mist/repository.rb

@@ -0,0 +1,15 @@
+module Mist::Repository
+  def repository
+    @repository ||= begin
+      if File.directory? Mist.repository_location.join('.git')
+        Git.open(Mist.repository_location.to_s, :log => Rails.logger)
+      else
+        Git.init(Mist.repository_location.to_s, :log => Rails.logger)
+      end
+    end
+  end
+  
+  def reload_repository!
+    @repository = nil
+  end
+end

data/lib/mist/version.rb

@@ -0,0 +1,8 @@
+module Mist
+  module Version
+    MAJOR, MINOR, PATCH = 0, 6, 0
+    STRING = [MAJOR, MINOR, PATCH].join('.')
+  end
+  
+  VERSION = Version::STRING
+end

data/mist.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "mist/version"
+
+Gem::Specification.new do |s|
+  s.name        = "mist"
+  s.version     = Mist::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Colin MacKenzie IV"]
+  s.email       = ["sinisterchipmunk@gmail.com"]
+  s.homepage    = "http://github.com/sinisterchipmunk/mist"
+  s.summary     = %q{a git-powered, gist-backed blogging engine for Rails 3}
+  s.description = %q{a git-powered, gist-backed blogging engine for Rails 3}
+
+  s.add_dependency 'git',           '~> 1.2'
+  s.add_dependency 'github-markup', '~> 0.7'
+  s.add_dependency 'redcarpet',     '~> 2.0'
+  s.add_dependency 'activegist',    '~> 0.6'
+  
+  s.add_development_dependency 'cucumber-rails',     '~> 1.2.1'
+  s.add_development_dependency 'database_cleaner',   '~> 0.7.0'
+  s.add_development_dependency 'rspec-rails',        '~> 2.8.1'
+  s.add_development_dependency 'fakeweb',            '~> 1.3.0'
+  # v1.5.0 has gemspec errors under ree, so force v1.4.0 until that's fixed
+  s.add_development_dependency 'factory_girl_rails', '=  1.4.0'
+
+  s.rubyforge_project = "mist"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/controllers/posts_controller_spec.rb

@@ -0,0 +1,263 @@
+require 'spec_helper'
+
+describe Mist::PostsController do
+  before { Mist.authorize :all do true end }
+  
+  # This should return the minimal set of attributes required to create a valid
+  # Post. As you add validations to Post, be sure to
+  # update the return value of this method accordingly.
+  def valid_attributes
+    attributes_for :post
+  end
+  
+  # This should return the minimal set of values that should be in the session
+  # in order to pass any filters (e.g. authentication) defined in
+  # PostsController. Be sure to keep this updated too.
+  def valid_session
+    {}
+  end
+  
+  describe "GET feed .rss" do
+    it "redirects to feed .atom" do
+      get :feed, {:format => :rss}, valid_session
+      response.should redirect_to(feed_posts_path :format => :atom)
+    end
+  end
+
+  describe "GET index" do
+    it "assigns all posts as @posts" do
+      post = create :post, :published_at => Time.now
+      get :index, {:use_route => :mist}, valid_session
+      assigns(:posts).should eq([post])
+    end
+  end
+
+  describe "GET show" do
+    describe "draft while unauthorized" do
+      before { Mist.authorize(:view_drafts) { false } }
+      
+      it "does not assign the requested post as @post" do
+        post = Mist::Post.create! valid_attributes
+        get :show, {:id => post.to_param}, valid_session
+        assigns(:post).should eq(post)
+      end
+
+      it "does not increment the post popularity" do
+        post = Mist::Post.create! valid_attributes
+        popularity = post.popularity
+        get :show, {:id => post.to_param}, valid_session
+        popularity.should == Mist::Post.popularity_for(post.id)
+      end
+      
+      it "redirects out" do
+        post = Mist::Post.create! valid_attributes
+        get :show, {:id => post.to_param}, valid_session
+        response.should redirect_to(posts_path)
+      end
+    end
+    
+    it "assigns the requested post as @post" do
+      post = Mist::Post.create! valid_attributes.merge(:published => true)
+      get :show, {:id => post.to_param}, valid_session
+      assigns(:post).should eq(post)
+    end
+    
+    it "increments the post popularity" do
+      post = Mist::Post.create! valid_attributes.merge(:published_at => Time.now)
+      popularity = post.popularity
+      get :show, {:id => post.to_param}, valid_session
+      popularity.should be < Mist::Post.popularity_for(post.id)
+    end
+  end
+
+  describe "GET new" do
+    describe "while unauthorized" do
+      before { Mist.authorize(:create_post) { false } }
+      
+      it "should redirect" do
+        post = Mist::Post.create! valid_attributes
+        get :new, {}, valid_session
+        response.status.should redirect_to(posts_path)
+      end
+    end
+    
+    it "assigns a new post as @post" do
+      get :new, {}, valid_session
+      assigns(:post).should be_a_new(Mist::Post)
+    end
+  end
+
+  describe "GET edit" do
+    describe "while unauthorized" do
+      before { Mist.authorize(:update_post) { false } }
+      
+      it "should redirect" do
+        post = Mist::Post.create! valid_attributes
+        get :edit, {:id => post.to_param}, valid_session
+        response.status.should redirect_to(posts_path)
+      end
+    end
+    
+    it "assigns the requested post as @post" do
+      post = Mist::Post.create! valid_attributes
+      get :edit, {:id => post.to_param}, valid_session
+      assigns(:post).should eq(post)
+    end
+  end
+
+  describe "POST create" do
+    describe "while unauthorized" do
+      before { Mist.authorize(:create_post) { false } }
+      
+      it "should not create a new post" do
+        expect {
+          post :create, {:post => valid_attributes}, valid_session
+        }.to_not change(Mist::Post, :count).by(1)
+      end
+      
+      it "should not assign post" do
+        post :create, {:post => valid_attributes}, valid_session
+        assigns(:post).should_not be_a(Mist::Post)
+      end
+      
+      it "should redirect out" do
+        post :create, {:post => valid_attributes}, valid_session
+        response.should redirect_to(posts_path)
+      end
+    end
+
+    describe "with valid params" do
+      it "creates a new Post" do
+        expect {
+          post :create, {:post => valid_attributes}, valid_session
+        }.to change(Mist::Post, :count).by(1)
+      end
+
+      it "assigns a newly created post as @post" do
+        post :create, {:post => valid_attributes}, valid_session
+        assigns(:post).should be_a(Mist::Post)
+        assigns(:post).should be_persisted
+      end
+
+      it "redirects to the created post" do
+        post :create, {:post => valid_attributes}, valid_session
+        response.should redirect_to(Mist::Post.last)
+      end
+    end
+
+    describe "with invalid params" do
+      it "assigns a newly created but unsaved post as @post" do
+        # Trigger the behavior that occurs when invalid params are submitted
+        Mist::Post.any_instance.stub(:save).and_return(false)
+        post :create, {:post => {}}, valid_session
+        assigns(:post).should be_a_new(Mist::Post)
+      end
+
+      it "re-renders the 'new' template" do
+        # Trigger the behavior that occurs when invalid params are submitted
+        Mist::Post.any_instance.stub(:save).and_return(false)
+        post :create, {:post => {}}, valid_session
+        response.should render_template("new")
+      end
+    end
+  end
+
+  describe "PUT update" do
+    describe "with valid params" do
+      describe "while unauthorized" do
+        before { Mist.authorize(:update_post) { false } }
+
+        it "should not update the post" do
+          post = Mist::Post.create! valid_attributes
+          Mist::Post.any_instance.should_not_receive(:update_attributes).with({'these' => 'params'})
+          put :update, {:id => post.to_param, :post => {'these' => 'params'}}, valid_session
+        end
+
+        it "should not assign post" do
+          post = Mist::Post.create! valid_attributes
+          put :update, {:id => post.to_param, :post => valid_attributes}, valid_session
+          assigns(:post).should_not be_a(Mist::Post)
+        end
+
+        it "should redirect out" do
+          post = Mist::Post.create! valid_attributes
+          put :update, {:id => post.to_param, :post => valid_attributes}, valid_session
+          response.should redirect_to(posts_path)
+        end
+      end
+
+      it "updates the requested post" do
+        post = Mist::Post.create! valid_attributes
+        # Assuming there are no other posts in the database, this
+        # specifies that the Mist::Post created on the previous line
+        # receives the :update_attributes message with whatever params are
+        # submitted in the request.
+        Mist::Post.any_instance.should_receive(:update_attributes).with({'these' => 'params'})
+        put :update, {:id => post.to_param, :post => {'these' => 'params'}}, valid_session
+      end
+
+      it "assigns the requested post as @post" do
+        post = Mist::Post.create! valid_attributes
+        put :update, {:id => post.to_param, :post => valid_attributes}, valid_session
+        assigns(:post).should eq(post)
+      end
+
+      it "redirects to the post" do
+        post = Mist::Post.create! valid_attributes
+        put :update, {:id => post.to_param, :post => valid_attributes}, valid_session
+        response.should redirect_to(post)
+      end
+    end
+
+    describe "with invalid params" do
+      it "assigns the post as @post" do
+        post = Mist::Post.create! valid_attributes
+        # Trigger the behavior that occurs when invalid params are submitted
+        Mist::Post.any_instance.stub(:save).and_return(false)
+        put :update, {:id => post.to_param, :post => {}}, valid_session
+        assigns(:post).should eq(post)
+      end
+
+      it "re-renders the 'edit' template" do
+        post = Mist::Post.create! valid_attributes
+        # Trigger the behavior that occurs when invalid params are submitted
+        Mist::Post.any_instance.stub(:save).and_return(false)
+        put :update, {:id => post.to_param, :post => {}}, valid_session
+        response.should render_template("edit")
+      end
+    end
+  end
+
+  describe "DELETE destroy" do
+    describe "while unauthorized" do
+      before { Mist.authorize(:destroy_post) { false } }
+
+      it "does not destroy the requested post" do
+        post = Mist::Post.create! valid_attributes
+        expect {
+          delete :destroy, {:id => post.to_param}, valid_session
+        }.to_not change(Mist::Post, :count).by(-1)
+      end
+
+      it "redirects to the posts list" do
+        post = Mist::Post.create! valid_attributes
+        delete :destroy, {:id => post.to_param}, valid_session
+        response.should redirect_to(posts_path)
+      end
+    end
+
+    it "destroys the requested post" do
+      post = Mist::Post.create! valid_attributes
+      expect {
+        delete :destroy, {:id => post.to_param}, valid_session
+      }.to change(Mist::Post, :count).by(-1)
+    end
+
+    it "redirects to the posts list" do
+      post = Mist::Post.create! valid_attributes
+      delete :destroy, {:id => post.to_param}, valid_session
+      response.should redirect_to(posts_path)
+    end
+  end
+
+end