mist 0.6.0

data/gemfiles/rails-3.2.0

@@ -0,0 +1,4 @@
+common = File.expand_path('common', File.dirname(__FILE__))
+eval File.read(common), binding, common
+
+gem 'rails', '= 3.2.0'

data/lib/generators/mist/USAGE

@@ -0,0 +1,13 @@
+Description:
+    Installs Mist into your Rails application.
+    
+Next Steps:
+    After running this generator, edit config/initializers/mist.rb
+    and hook up your authentication so that you can control who is
+    or isn't allowed to change posts.
+    
+    Mist extracts its views and assets into your app/ directory.
+    You should personalize the look and feel of the blog by editing
+    those views.
+    
+

data/lib/generators/mist/setup_generator.rb

@@ -0,0 +1,21 @@
+class Mist::SetupGenerator < Rails::Generators::Base
+  source_root File.expand_path('../../..', File.dirname(__FILE__))
+  
+  def copy_views
+    copy_file 'app/views/layouts/mist/posts.html.erb'
+  end
+  
+  def install_assets
+    copy_file template_path('mist.js.coffee'), 'app/assets/javascripts/mist.js.coffee'
+    copy_file template_path('mist.css.scss'),  'app/assets/stylesheets/mist.css.scss'
+  end
+  
+  def create_initializer
+    copy_file template_path('initializer.rb'), 'config/initializers/mist.rb'
+  end
+  
+  private
+  def template_path(relative_path)
+    File.expand_path(File.join('templates', relative_path), File.dirname(__FILE__))
+  end
+end

data/lib/generators/mist/templates/initializer.rb

@@ -0,0 +1,17 @@
+# This hook is called whenever Mist needs to know if a user
+# is allowed to do something. You can also pass in specific
+# actions such as :create_post, :edit_post and so on. See
+# documentation for details.
+Mist.authorize :all do |controller|
+  true
+end
+
+
+Mist.title = "Blog Title"
+Mist.author.name = "John Doe"
+Mist.author.email = "john@example.com"
+
+# GitHub credentails -- without these you can't edit Gists
+# because they're anonymous
+ActiveGist::API.username = ENV['GITHUB_USERNAME']
+ActiveGist::API.password = ENV['GITHUB_PASSWORD']

data/lib/generators/mist/templates/mist.css.scss

@@ -0,0 +1,2 @@
+// You can place stylesheets related to Mist here.
+// Styles here will override the Mist defaults.

data/lib/generators/mist/templates/mist.js.coffee

@@ -0,0 +1 @@
+# You can place customized Mist JavaScripts here.

data/lib/generators/mist/views_generator.rb

@@ -0,0 +1,11 @@
+class Mist::ViewsGenerator < Rails::Generators::Base
+  source_root File.expand_path('../../..', File.dirname(__FILE__))
+  
+  def copy_views
+    directory 'app/views/mist'
+  end
+  
+  def install_assets
+    directory 'app/assets'
+  end
+end

data/lib/mist.rb

@@ -0,0 +1,26 @@
+require 'git'
+require 'github/markup'
+require 'active_gist'
+
+module Mist
+  require 'mist/engine'
+  require 'mist/configuration'
+  require 'mist/repository'
+  require 'mist/version'
+  require 'mist/permalink'
+  require 'mist/git_model'
+  require "mist/code_example_parser"
+  
+  extend Mist::Configuration
+  extend Mist::Repository
+  
+  class << self
+    delegate :log, :to => :repository
+    
+    # Returns an array of all possible actions which Mist will authorize against
+    # at one point or another
+    def authorized_actions
+      [ :create_post, :edit_post, :destroy_post, :view_drafts ]
+    end
+  end
+end

data/lib/mist/code_example_parser.rb

@@ -0,0 +1,86 @@
+class Mist::CodeExampleParser
+  attr_reader :examples, :content
+  
+  class Example < String
+    attr_accessor :start_offset
+    attr_accessor :whitespace_skipped
+    attr_writer :filename
+    FILENAME_REGEXP = /\A[\s\t\n]*file: (.*?)[\n\r]+/
+    
+    def initialize(start_offset)
+      @whitespace_skipped = 0
+      @start_offset = start_offset
+      super()
+    end
+    
+    def explicit_filename
+      @explicit_filename ||= if self =~ FILENAME_REGEXP
+        # omit filename from self
+        match = $~
+        @whitespace_skipped += match.offset(0)[1] - match.offset(0)[0]
+        sub! match[0], ''
+        match[1]
+      else
+        nil
+      end
+    end
+    
+    def filename
+      @filename || explicit_filename
+    end
+    
+    def offset
+      start_offset...(start_offset+length+whitespace_skipped)
+    end
+  end
+  
+  def initialize(content)
+    @content = content.to_s.dup
+    @examples = parse
+  end
+  
+  def parse
+    in_example = false
+    offset = 0
+    
+    [].tap do |examples|
+      while match = /^    ([^\n]+(\n|\z))/m.match(content[offset..-1])
+        in_example = examples.last && match.offset(0)[0] == 0 && offset > 0
+        examples << Example.new(match.offset(0)[0]+offset) unless in_example
+        line = match[1]
+        examples.last.whitespace_skipped += 4
+        examples.last.concat match[1]
+
+        offset += match.offset(0)[1]
+      end
+      
+      # detect multiple examples separated only by white space
+      # -- they are part of the same example
+      pass = proc do
+        call_again = false
+        examples.length.times do |index|
+          current = examples[index]
+          next if index == 0 or current.explicit_filename
+          
+          previous = examples[index-1]
+          min = previous.offset.max
+          max = current.offset.min
+          
+          if content[(min+1)...max] =~ /\A[\s\t\n]*\z/
+            previous.whitespace_skipped += current.whitespace_skipped
+            previous.concat $~[0] + current
+            examples.delete current
+            call_again = true
+            break
+          end
+        end
+
+        pass.call if call_again
+      end
+      pass.call
+      
+      # Last pass: assign default filenames as needed
+      examples.each_with_index { |example, index| example.filename ||= "Example #{index+1}" }
+    end
+  end
+end

data/lib/mist/configuration.rb

@@ -0,0 +1,68 @@
+module Mist::Configuration
+  require 'mist/configuration/author'
+
+  def repository_location
+    @respository_location ||= default_repository_location
+  end
+  
+  def repository_location=(dir)
+    @respository_location = dir
+  end
+  
+  def default_repository_location
+    Rails.root.join("db/mist.repo.#{Rails.env}")
+  end
+  
+  def reset_authorizations!
+    authorizations.clear
+  end
+  
+  def authorizations
+    @authorizations ||= {}.with_indifferent_access
+  end
+  
+  def commit_meta_data
+    @commit_meta_data = true if @commit_meta_data.nil?
+  end
+  
+  def commit_meta_data=(a)
+    @commit_meta_data = a
+  end
+  
+  def author
+    @author ||= Mist::Configuration::Author.new
+  end
+  
+  def title=(title)
+    @title = title
+  end
+  
+  def title
+    @title ||= "Blog Title"
+  end
+  
+  # Register a block to be invoked whenever Mist needs to know if a user is allowed
+  # to perform some action, such as :create_post, :edit_post, :view_post, :destroy_post,
+  # or :all.
+  #
+  #   Mist.authorize { |controller| ... }               # invoke for any action not otherwise registered
+  #   Mist.authorize(:all) { |controller| ... }         # same as above
+  #   Mist.authorize(:create_post) { |controller| ... } # use this block only for :create_post
+  #
+  # By default, all authorization requests will return false (denied).
+  #
+  def authorize(*types, &block)
+    raise ArgumentError, "Expected a block which will be evaluated at runtime" unless block_given?
+    types.push :all if types.empty?
+    types.each { |type| authorizations[type] = block }
+  end
+  
+  # Invokes the blocks registered by Mist::Configuration#authorize to see if the specified
+  # action is authorized. Passes *args into the block.
+  def authorized?(action, *args)
+    if authorizations.key?(action) then authorizations[action].call *args
+    elsif authorizations.key?(:all) then authorizations[:all].call *args
+    else nil
+    end
+  end
+end

data/lib/mist/configuration/author.rb

@@ -0,0 +1,8 @@
+class Mist::Configuration::Author
+  attr_accessor :name, :email
+  
+  def initialize
+    @name = "John Doe"
+    @email = "john@example.com"
+  end
+end

data/lib/mist/engine.rb

@@ -0,0 +1,12 @@
+require 'rails'
+
+module Mist
+  class Engine < Rails::Engine
+    engine_name 'mist'
+    isolate_namespace Mist
+    
+    initializer "mist.assets" do |app|
+      app.config.assets.precompile += ['mist_core.js', 'mist_core.css', 'mist.js', 'mist.css']
+    end
+  end
+end

data/lib/mist/git_file_system_history.rb

@@ -0,0 +1,66 @@
+class Mist::GitFileSystemHistory
+  def initialize(path_or_repo)
+    @files = ActiveSupport::OrderedHash.new
+    @repo = path_or_repo.kind_of?(Git::Base) ? path_or_repo : Git.open(path_or_repo)
+  end
+  
+  # Returns files in order of discovery. Since they are discovered
+  # by traveling up the tree and backward in time, this is the
+  # REVERSE of the order of their actual creation.
+  def files
+    @files.keys.select { |filename| @files[filename] > 0 }
+  end
+  
+  def mark_file(path, mode)
+    @files[path] ||= 0
+    case mode
+      when :created then @files[path] += 1
+      when :deleted then @files[path] -= 1
+    end
+  end
+  
+  def mark_tree(tree, mode, path = /./)
+    tree.full_tree.each do |entry|
+      file = entry.split(/\t/)[1]
+      next unless file[path]
+      mark_file file, mode
+    end
+  end
+  
+  # Finds and returns `count` files, in the order of creation,
+  # in descending order (most recent files first),
+  # after accounting for deletion.
+  #
+  # If count is nil, all matches will be returned.
+  def find(count, path = /./)
+    begin
+      commit = @repo.log(1).first
+    rescue Git::GitExecuteError => err
+      # empty repository, no commits = no matches
+      return [] if err.message =~ /bad default revision 'HEAD'/
+      raise err
+    end
+    
+    while commit.parent
+      commit.diff_parent.each do |diff|
+        next if diff.type == 'modified' # only care about new or deleted files
+        next unless diff.path[path]
+        
+        case diff.type                               # because parent is B, changes are reversed.
+          when 'deleted' then mark_file diff.path, :created # file was created in this commit
+          when 'new'     then mark_file diff.path, :deleted # file was deleted in this commit
+        end
+        
+        return files if count and files.length == count
+      end
+      
+      commit = commit.parent
+    end
+    
+    # if we made it this far then commit is the initial commit
+    # so at this stage, mark each file in the tree.
+    mark_tree commit.gtree, :created, path
+    
+    count && files.length > count ? files[0...count] : files
+  end
+end

data/lib/mist/git_model.rb

@@ -0,0 +1,154 @@
+class Mist::GitModel
+  require 'mist/git_model/attributes'
+  require 'mist/git_model/class_methods'
+  require 'mist/git_file_system_history'
+  
+  extend ActiveModel::Callbacks
+  extend ActiveModel::Naming
+  include ActiveModel::Validations
+  include ActiveModel::Validations::Callbacks
+  include ActiveModel::Dirty
+  include ActiveModel::Conversion
+  include ActiveModel::Observing
+  extend Mist::GitModel::ClassMethods
+  
+  define_model_callbacks :save, :create, :update, :initialize, :destroy
+
+  delegate :table_name, :record_path, :default_attributes, :to => 'self.class'
+  attribute :id, :default => proc { (self.class.count + 1).to_s }
+  attribute :id_on_record
+  
+  validate do |record|
+    unless record.id.blank?
+      if record.id_changed? and self.class.find(record.id)
+        record.errors.add :id, "has already been taken"
+      end
+    end
+  end
+  
+  def initialize(attributes = {})
+    run_callbacks :initialize do
+      default_attributes!
+      attributes.each do |key, value|
+        self.send(:"#{key}=", value)
+      end
+    end
+  end
+  
+  def class_name
+    self.class.name
+  end
+  
+  def ==(other)
+    id == (other.kind_of?(self.class) ? other.id : other)
+  end
+  
+  def commit_message
+    if new_record?
+      "Post created"
+    else
+      "Post updated"
+    end
+  end
+  
+  def commit(commit_message = self.commit_message)
+    Mist.repository.add path
+    Mist.repository.commit commit_message
+  end
+
+  def path
+    record_path id
+  end
+  
+  def path_was
+    record_path id_was
+  end
+  
+  def destroy
+    return if new_record?
+    run_callbacks :destroy do
+      Mist.repository.remove path, :recursive => true
+      Mist.repository.commit "Destroyed #{class_name} #{id.inspect}"
+      FileUtils.rm_rf path
+    end
+  end
+  
+  def update_attributes(attributes)
+    attributes.each { |k,v| self.send(:"#{k}=", v) }
+    save
+  end
+  
+  def attributes
+    @attributes ||= Mist::GitModel::Attributes.new(self)
+  end
+  
+  def default_attributes!
+    default_attributes.each do |key, value|
+      if value.kind_of?(Proc)
+        attributes[key] = instance_eval &value
+      else
+        attributes[key] = value
+      end
+    end
+    
+    changed_attributes.clear
+  end
+  
+  def persisted?
+    !changed? && !new_record?
+  end
+  
+  def new_record?
+    id_was.blank? || !File.file?(path_was)
+  end
+  
+  def save
+    return false unless valid?
+    
+    if new_record? || changed?
+      create_or_update_callback = new_record? ? :create : :update
+      run_callbacks create_or_update_callback do
+        run_callbacks :save do
+          Mist.repository.lib.mv path_was, path if !new_record? && id_changed?
+          save_record_file
+          commit
+        end
+      end
+    end
+    
+    if !(files = Mist.repository.lib.diff_files).empty?
+      # if false, there's nothing we can reliably do to sync up unless we
+      # forcefully commit all changes, which the user may not want. However,
+      # if true, then this record was probably renamed from id_on_record
+      # to id. So, commit the deletion.
+      old_path = record_path(id_on_record).to_s.sub(/^#{Regexp::escape Mist.repository_location.to_s}\/?/, '')
+      if files.keys.include?(old_path) && files[old_path][:type] == 'D'
+        save_record_file
+        Mist.repository.lib.remove old_path
+        Mist.repository.lib.add path
+        Mist.repository.commit "Syncing to external filesystem changes"
+      else
+        Rails.logger.warn "Found uncommitted changes in git repo but didn't recognize them, so didn't commit them"
+        # no need to show the diff in the log, as the Git library has done that for us
+      end
+    end
+    
+    @previously_changed = changes
+    changed_attributes.clear
+    true
+  end
+  
+  def save_record_file
+    self.id_on_record = id
+    FileUtils.mkdir_p File.dirname(path)
+    File.open(path, "w") { |f| f.print attributes.to_yaml }
+  end
+  
+  def save!
+    raise "Record not saved: #{errors.full_messages.join('; ')}" unless save
+  end
+  
+  def inspect
+    "#<#{self.class.name} #{attributes.collect { |a| [a[0], a[1].inspect].join('=') }.join(' ')}>"
+  end
+end