statixite 1.0.0

data/app/helpers/statixite/application_helper.rb

@@ -0,0 +1,63 @@
+module Statixite
+  module ApplicationHelper
+
+    ALERT_TYPES = [:success, :info, :warning, :danger] unless const_defined?(:ALERT_TYPES)
+
+    def bootstrap_flash(options = {})
+      flash_messages = []
+      flash.each do |type, message|
+        # Skip empty messages, e.g. for devise messages set to nothing in a locale file.
+        next if message.blank?
+
+        type = type.to_sym
+        type = :success if type == :notice
+        type = :danger  if type == :alert
+        type = :danger  if type == :error
+        next unless ALERT_TYPES.include?(type)
+
+        tag_class = options.extract!(:class)[:class]
+        tag_options = {
+          class: "alert fade in alert-#{type} #{tag_class}"
+        }.merge(options)
+
+        close_button = content_tag(:button, raw("×"), class: "close", "data-dismiss" => "alert")
+
+        Array(message).each do |msg|
+          text = content_tag(:div, close_button + msg.html_safe, tag_options)
+          flash_messages << text if msg
+        end
+      end
+      flash_messages.join("\n").html_safe
+    end
+
+    def bootstrap_form_flash(obj)
+      errors = obj.errors
+      return unless obj.errors.any?
+      flash_messages = []
+      errors.full_messages.each do |message|
+        tag_options = {
+          class: "alert fade in alert-danger"
+        }
+        close_button = content_tag(:button, raw("&times;"), class: "close", "data-dismiss" => "alert")
+        flash_messages << content_tag(:div, close_button + message, tag_options)
+      end
+      flash_messages.join("\n").html_safe
+    end
+
+    def current_class?(path)
+      return 'active' if current_page?(path)
+      ''
+    end
+
+    def current_parent_class?(obj)
+      return 'active' if current_page?(site_path(obj)) || (params[:site_id].present? && obj == Site.find(params[:site_id])) || current_page?(settings_site_path(id: params[:id]))
+      ''
+    end
+
+    def post_date(post)
+      return Date.today if post.new_record?
+      return post.front_matter['date'].to_date if post.front_matter['date'].present?
+      return post.updated_at.to_date
+    end
+  end
+end

data/app/models/statixite/deployment.rb

@@ -0,0 +1,5 @@
+module Statixite
+  class Deployment < ActiveRecord::Base
+    belongs_to :site, :class_name => 'Statixite::Site'
+  end
+end

data/app/models/statixite/media.rb

@@ -0,0 +1,7 @@
+module Statixite
+  class Media < ActiveRecord::Base
+    mount_uploader :file, FileUploader
+
+    belongs_to :site, :class_name => 'Statixite::Site'
+  end
+end

data/app/models/statixite/post.rb

@@ -0,0 +1,76 @@
+module Statixite
+  class Post < ActiveRecord::Base
+    belongs_to :site, :class_name => 'Statixite::Site'
+    validates_presence_of :title
+
+    before_save :save_layout_and_title
+    before_create :write_slug
+    after_create :write_to_tmp
+    before_update :check_title_change
+    after_update :write_to_tmp
+
+    include ActiveModel::Validations
+    validates_with LiquidValidator
+
+    def write_to_tmp(env='preview')
+      FileUtils.mkdir_p(site.site_posts_path)
+      write_content
+    end
+
+    def post_pathname
+      Rails.root.join(site.site_posts_path, self.filename)
+    end
+
+    def write_slug
+      self.slug = append_suffix(self.title.parameterize)
+    end
+
+    private
+
+    def post_date
+      return Time.now if front_matter.nil?
+      front_matter['date'].present? ? front_matter['date'].to_time : Time.now
+    end
+
+    def proposed_post_pathname(str)
+      File.join(site.site_posts_path, post_date.strftime("%Y-%m-%d-#{str}.markdown"))
+    end
+
+    def append_suffix(str, i=0)
+      self.filename = File.basename(proposed_post_pathname(str)).to_s
+      return str unless File.exist?(proposed_post_pathname(str))
+      i += 1
+      str = i == 1 ? str << "-#{i}" : str.gsub(/\-#{i-1}\z/, "-#{i}")
+      append_suffix(str, i)
+    end
+
+    def write_content
+      new_contents = "#{front_matter.to_yaml}---\n" << content.to_s
+      File.open(post_pathname, 'w') do |f|
+        f.write(new_contents)
+      end
+    end
+
+    def check_title_change
+      if changed.include?("title")
+        write_slug
+      end
+      if changed.include?("filename")
+        File.delete(File.join(site.site_posts_path, changes[:filename][0]))
+      end
+    end
+
+    def save_layout_and_title
+      front_matter['title'] = title
+      front_matter['layout'] = check_for_layout
+    end
+
+    def check_for_layout
+      if File.exist?(File.join(site.site_clone_path, "_layouts", "post.html"))
+        "post"
+      else  
+        "default"
+      end
+    end
+  end
+end

data/app/models/statixite/site.rb

@@ -0,0 +1,76 @@
+module Statixite
+  class Site < ActiveRecord::Base
+    has_many :posts, :dependent => :destroy, :class_name => 'Statixite::Post'
+    has_many :deployments, :dependent => :destroy, :class_name => 'Statixite::Deployment'
+    has_many :media, :class_name => 'Statixite::Media'
+
+    SLUG_FORMAT = /[a-z0-9]+(?:-[a-z0-9]+)*/
+    REPO_FORMAT = /((git|ssh|http(s)?)|(git@[\w\.]+))(:(\/\/)?)([\w\.@\:\/\-~]+)(\.git)(\/)?/
+    validates_presence_of :site_name
+    validates_uniqueness_of :site_name
+    validates_length_of :site_name, :maximum => 50
+    validates_format_of :site_name, :with => Regexp.new('\A' + SLUG_FORMAT.source + '\z')
+    validates_format_of :template_repo, :with => Regexp.new('\A' + REPO_FORMAT.source + '\z'), :message => "Please enter a valid url for a git repository", :on => :create, :if => :custom_build_option?
+    
+    include ActiveModel::Validations
+    validates :domain_name, :hostname => true, :allow_blank => true
+
+    def statixite_name
+      site_name
+    end
+
+    def preview_url
+      "/statixite/previews/#{site_name}"
+    end
+
+    def build_url
+      if domain_name.present?
+        "http://#{domain_name}"
+      else
+        settings["url"]
+      end
+    end
+
+    def github_repo_name
+      "statixite-#{site_name}"
+    end
+
+    def site_root_path
+      File.join(sites_path, site_name)
+    end
+
+    def site_clone_path
+      File.join(site_root_path, "clone")
+    end
+
+    def site_posts_path
+      File.join(site_clone_path, "_posts")
+    end
+
+    def site_build_path
+      File.join(site_root_path, "build")
+    end
+
+    def site_preview_path
+      File.join(Rails.public_path, "statixite", "previews", site_name)
+    end
+
+    def site_remote
+      File.join(site_root_path, "repo")
+    end
+
+    def site_main_config
+      File.join(site_clone_path, "_config.yml")
+    end
+
+    private
+
+    def sites_path
+      Rails.root.join("sites").to_s
+    end
+
+    def custom_build_option?
+      self.build_option == 'custom'
+    end
+  end
+end

data/app/services/statixite/deployment_service.rb

@@ -0,0 +1,73 @@
+module Statixite
+  class DeploymentService
+    attr_reader :error_message, :directory
+
+    def initialize(site)
+      @site = site
+    end
+
+    def deploy
+      gs = GitService.new(@site.site_build_path, @site.site_remote)
+      if gs.successful?
+        begin
+          git_info_from_build = build_deploy_branch(gs)
+          perform_deploy
+          deployment = @site.deployments.create(
+            :version => git_info_from_build[0],
+            :sha => git_info_from_build[1]
+          )
+          @status = :success
+        rescue => e
+          Rails.logger.error e
+          @error_message = e.message
+          @status = :failed
+        end
+      else
+        @error_message = gs.error_message
+        @status = :failed
+      end
+      self
+    end
+
+    def successful?
+      @status == :success
+    end
+
+    private
+
+    def perform_deploy
+      case Statixite.config.deploy_sites_to
+      when :local
+      when :github
+        create_repo
+      when :fog
+        Statixite::CloudSync.new(@site, "statixite-#{@site.site_name}-#{@site.id}").sync
+      else
+      end
+    end
+
+    def build_deploy_branch(gs)
+      gs.build_branch
+      sos = SiteOperationService.new(@site)
+      sos.jekyll_write_config('deploy')
+      sos.check_and_save_posts_from_file
+      sos.jekyll_build('deploy')
+      gs.build_deploy(next_version)
+    end
+
+    def next_version
+      ((@site.deployments.count + 1).to_f / 10).round(1)
+    end
+
+    def create_repo
+      g = GitService.new(@site.site_build_path, @site.site_remote).clone_or_open
+      if @site.deployments.empty?
+        response = Excon.post("https://#{Statixite.config.github_user}:#{Statixite.config.github_token}@api.github.com/user/repos", :body => { :name => @site.github_repo_name }.to_json )      
+        g.add_remote("github", JSON.parse(response.body)["ssh_url"])
+      end
+      g.branch("gh-pages").checkout
+      g.branch("gh-pages").merge("statixite_build")
+      g.push(g.remote("github"), 'gh-pages', { :tags => true })
+    end
+  end
+end

data/app/services/statixite/git_service.rb

@@ -0,0 +1,102 @@
+module Statixite
+  class GitService
+    attr_reader :local_path, :remote, :remote_name, :local_parent, :error_message
+
+    def initialize(local_path, remote, status = nil)
+      @local_path = local_path
+      @remote = remote
+      @remote_name = File.basename(local_path)
+      @local_parent = File.expand_path("..", local_path)
+      begin
+        Git.ls_remote(@remote)
+        @status = :success
+      rescue Git::GitExecuteError => e
+        @status = :failed
+        @error_message = e.message
+      end
+    end
+
+    def clone_or_open
+      if successful?
+        Git.clone(remote, remote_name, :path => local_parent) unless Dir.exist?(local_path)
+        Git.open(local_path, :log => Logger.new("/dev/null") )
+      end
+    end
+
+    def self.create(local_path, remote, options={})
+      FileUtils.mkdir_p(local_path)
+      git_path = File.join(local_path, ".git")
+      FileUtils.rm_rf(git_path) if Dir.exist?(git_path)
+      File.open(File.join(local_path, ".gitignore"), 'a') do |f|
+        f << "\n_config_preview.yml\n_config_deploy.yml"
+      end
+      FileUtils.mkdir_p(remote)
+      Git.init(remote, :bare => true)
+      g = Git.init(local_path)
+      g.add_remote('origin', remote)
+      g.config('user.name', 'Statixite')
+      g.config('user.email', 'git@git.statixite.com')
+      g.add(:all => true)
+      g.commit('Initial')
+      begin
+        g.push
+        new(local_path, remote)
+      rescue Git::GitExecuteError => e
+        Rails.logger.error e
+        new(local_path, nil)
+      end
+    end
+
+    def make_changes(&block)
+      if successful?
+        begin
+          g = clone_or_open
+          g.checkout('master')
+          g.pull
+          yield
+          g.add(:all => true)
+          g.commit('Auto commit', :allow_empty => true)
+          g.push
+        rescue Git::GitExecuteError => e
+          @status = :failed
+          @error_message = e.message
+        end
+      end
+      self
+    end
+
+    def build_branch
+      g = clone_or_open
+      unless g.branches.remote.map(&:name).include?("statixite_build")
+        g.branch('statixite_build').checkout
+        g.remove('.', {:recursive => true})
+        g.add(:all => true)
+        g.commit("Initial", :allow_empty => true)
+        g.push('origin', 'statixite_build')
+      end
+      g.checkout('statixite_build')
+      g.pull('origin', 'statixite_build')
+    end
+
+    def build_deploy(next_version)
+      g = clone_or_open
+      g.add(:all => true)
+      g.commit("Deployment for #{@remote_name}", :allow_empty => true)
+      version_to_try = next_version
+      begin
+        g.add_tag("v#{version_to_try}")
+      rescue Git::GitExecuteError => e
+        Rails.logger.info "v#{version_to_try} exists retrying"
+        version_to_try = (version_to_try + 0.1).round(1)
+        retry
+      end
+      g.commit("Release tag created #{@remote_name}: v#{version_to_try}", :allow_empty => true)
+      g.push('origin', 'statixite_build')
+      [version_to_try, g.tags.last.sha]
+    end
+
+    def successful?
+      @status == :success
+    end
+  end
+end

data/app/services/statixite/site_deactivation_service.rb

@@ -0,0 +1,52 @@
+module Statixite
+  class SiteDeactivationService
+    attr_reader :status, :site
+    def initialize(site, options={})
+      @site = site
+      @options = options
+    end
+
+    def deactivate
+      FileUtils.rm_rf(@site.site_root_path) if Dir.exist?(@site.site_root_path)
+      if site.deployments.any?
+        begin
+          clean_site
+          @site.destroy
+          @status = :success
+        rescue => e
+          @status = :failed
+          Rails.logger.error e
+        end
+      else
+        @site.destroy
+        @status = :success
+      end
+      self
+    end
+
+    def successful?
+      @status == :success
+    end
+    
+    private
+
+    def delete_container
+      client = Fog::Storage.new(Statixite.config.fog_credentials)
+      begin
+        client.delete_multiple_objects(@site.statixite_name, client.get_container(@site.statixite_name).body.map { |val| val["name"] })
+        client.delete_container(@site.statixite_name) 
+      rescue => e
+        Rails.logger.error e
+      end
+    end
+
+    def clean_site
+      case Statixite.config.deploy_sites_to
+      when :fog
+        delete_container
+      when :github
+        Excon.delete("https://#{Statixite.config.github_user}:#{Statixite.config.github_token}@api.github.com/repos/#{Statixite.config.github_user}/#{@site.github_repo_name}")      
+      end
+    end
+  end
+end