regulate 0.0.1

data/lib/generators/templates/regulate.css

@@ -0,0 +1,2 @@
+.editable {}
+

data/lib/generators/templates/regulate.js

@@ -0,0 +1,44 @@
+(function($){
+  var Regulate = window.Regulate || Regulate || {};
+
+  Regulate = {
+    init: function Regulate_init(){
+      // some code that needs to be executed after doc ready
+      Regulate.bindEvents();
+    },
+    bindEvents: function Regulate_liveEvents(){
+      // more globally bound events
+    },
+    helpers: function Regulate_helpers(){
+      // helper for searching through arrays
+      Regulate.helpers.arraySearch = function(a){
+        var o = {};
+        for(var i=0;i<a.length;i++){
+          o[a[i]]='';
+        }
+        return o;
+      };
+      //j. resigs array remove overload
+      Array.prototype.remove = function(from, to) {
+        var rest = this.slice((to || from) + 1 || this.length);
+        this.length = from < 0 ? this.length + from : from;
+        return this.push.apply(this, rest);
+      };
+      // duck punch Array.indexOf into IE browsers
+      if(!Array.indexOf){
+        Array.prototype.indexOf = function(obj){
+          for(var i=0; i<this.length; i++){
+            if(this[i]==obj){
+              return i;
+            }
+          }
+          return -1;
+        };
+      }
+    }
+  };
+
+  window.Regulate = Regulate;
+  $(document).ready(Regulate.init);
+
+})(jQuery);

data/lib/generators/templates/regulate.rb

@@ -0,0 +1,13 @@
+Regulate.setup do |config|
+
+  # Role that allows a user to manage pages and define what parts are editable, default is :admin
+  # The namespace that you would like to use for the routes. The default is 'cms'.
+  # @example Setting a custom route namespace
+  #   Regulate.setup do |config|
+  #     config.route_namespace = 'my_custom_route_namespace'
+  #   end
+  #
+  # config.route_namespace = 'my_custom_route_namespace'
+
+end
+

data/lib/generators/templates/regulate.yml

@@ -0,0 +1,10 @@
+development:
+  repo: db/repos/development.git
+test: &test
+  repo: db/repos/test.git  
+production:
+  repo: db/repos/production.git
+daily:
+  repo: db/repos/daily.git
+cucumber:
+  <<: *test

data/lib/regulate.rb

@@ -0,0 +1,30 @@
+# Requires
+require 'active_support/dependencies'
+
+# Our top level module to contain all of our engine gem functionality
+module Regulate
+
+  # Autoloads
+  autoload :Git , 'regulate/git'
+
+  # Our host application root path
+  # We set this when the engine is initialized
+  mattr_accessor :app_root
+
+  # The repo we'll be using
+  # We set this when the engine is initialized
+  mattr_accessor :repo
+
+  # Route namespace
+  mattr_accessor :route_namespace
+  @@route_namespace = "cms"
+
+  # Yield self on setup for nice config blocks
+  def self.setup
+    yield self
+  end
+
+end # module Regulate
+
+# Requires
+require 'regulate/engine' if defined?(Rails)

data/lib/regulate/engine.rb

@@ -0,0 +1,50 @@
+module Regulate
+
+  # Our instance of the Rails::Engine class that will allow us to load our functionality
+  # in to a host app
+  class Engine < Rails::Engine
+
+    initializer 'regulate.load_app_instance_data' do |app|
+
+      Regulate.setup do |config|
+
+        # Set our host app root path
+        config.app_root = Rails.root
+
+        # Check for the existence of a custom YAML file in the host app
+        if( File.exists?( File.join( config.app_root , 'config' , 'regulate.yml') ) )
+          yaml_path = File.join(config.app_root, "config", "regulate.yml")
+        else
+          # Use the provided default in our gem
+          yaml_path = File.join(root , "config", "regulate.yml")
+        end
+
+        yaml_data = YAML.load_file(yaml_path)[Rails.env]
+
+        # Now set our repo
+        repo_path = File.join(config.app_root, yaml_data['repo'])
+        repo = File.join(repo_path, ".git")
+        init = false
+
+        if !File.directory?(repo_path)
+          FileUtils.mkdir_p(repo_path)
+          init = true
+        elsif !File.directory?(repo)
+          init = true
+        end
+
+        Grit::Repo.init(repo_path) if init
+        config.repo = Grit::Repo.new(repo_path)
+
+      end
+
+    end
+
+    initializer "static assets" do |app|
+      app.middleware.use ::ActionDispatch::Static, "#{root}/public"
+    end
+
+  end # class Engine
+
+end # module Regulate
+

data/lib/regulate/git.rb

@@ -0,0 +1,17 @@
+# Requires
+require 'grit'
+
+module Regulate
+
+  # Our module to contain all get related functionality
+  module Git
+
+    # Autoloads
+    autoload :Errors    , 'regulate/git/errors'
+    autoload :Model     , 'regulate/git/model'
+    autoload :Interface , 'regulate/git/interface'
+
+  end # module Git
+
+end # module Regulate
+

data/lib/regulate/git/errors.rb

@@ -0,0 +1,22 @@
+module Regulate
+
+  module Git
+
+    # The module that will hold all Git related errors
+    module Errors
+
+      # Used when attempting to save a Git resource that already exists
+      class DuplicatePageError < StandardError; end
+
+      # Used when there is a problem with a Git resource
+      class InvalidGitResourceError < StandardError; end
+
+      # Used when attempting to persist a Git resource that doesn't already exist
+      class PageDoesNotExist < StandardError; end
+
+    end
+
+  end
+
+end
+

data/lib/regulate/git/interface.rb

@@ -0,0 +1,249 @@
+module Regulate
+
+  module Git
+
+    # The class that we'll use to interact with our Git repositories
+    class Interface
+
+      class << self
+
+        # Find all commits for a given id
+        # Essentially looks for all folders in our repo whose names match the given id
+        #
+        # @param [String] id The id to search for
+        # @return [Array] An array of Grit::Commit objects
+        def commits( id )
+          Regulate.repo.log( 'master' , id )
+        end
+
+        # Find and return relavant data for a given id
+        #
+        # @param [String] id The id to search for
+        # @return [String] The contents of the attributes.json file for the given id
+        def find( id )
+          begin
+            ( Regulate.repo.tree / File.join( id , 'attributes.json' ) ).data
+          rescue
+            nil
+          end
+        end
+
+        # Return an array of attributes.json data strings for all IDs in the repo
+        #
+        # @return [Array] An array of JSON strings
+        def find_all
+          Regulate.repo.tree.contents.collect { |tree|
+            attributes_json = ( tree / 'attributes.json' )
+            attributes_json.data unless attributes_json.nil?
+          }.compact
+        end
+
+        # Find and return the rendered HTML for a given id
+        #
+        # @param [String] id The id to search for
+        # @return [String] The contents of the rendered.html file for the given id
+        def find_rendered( id )
+          begin
+            ( Regulate.repo.tree / File.join( id , 'rendered.html' ) ).data
+          rescue
+            nil
+          end
+        end
+
+        # Find the contents of a file given it's version SHA
+        # @param [String] version The version SHA hash of the blob
+        # @return [String] The contents of the blob at that version
+        def find_by_version( id , version )
+          begin
+            ( Regulate.repo.commit(version).tree / File.join( id , 'attributes.json' ) ).data
+          rescue
+            nil
+          end
+        end
+
+        # Save changes to a resource directory with a commit
+        # All of the keys in the example are expected!
+        #
+        # @param [Hash] options A hash containing all the data we'll need to make a commit
+        # @example A sample save call
+        #   Regulate::Git::Interface.save({
+        #     :id => id,
+        #     :commit_message => commit_message,
+        #     :author_name => author_name,
+        #     :author_email => author_email,
+        #     :attributes => attributes_json,
+        #     :rendered => rendered_html
+        #   })
+        def save( options = {} )
+          # Begin a commit operation
+          commit( options , :create ) do |index|
+            # Persist changes to both of our needed files
+            index.add(File.join(options[:id], 'attributes.json'), options[:attributes])
+            index.add(File.join(options[:id], 'rendered.html'), options[:rendered])
+          end
+        end
+
+        # Delete a resource directory with a commit
+        # All of the keys in the example are expected!
+        #
+        # @param [Hash] options A hash containing all the data we'll need to make a commit
+        # @example A sample delete call
+        #   Regulate::Git::Interface.delete({
+        #     :id => id,
+        #     :commit_message => commit_message,
+        #     :author_name => author_name,
+        #     :author_email => author_email
+        #   })
+        def delete( options = {} )
+          # Begin a commit operation
+          commit( options , :delete ) do |index|
+            # Delete both of our files in the resource directory to delete the directory
+            index.delete(File.join(options[:id],'attributes.json'))
+            index.delete(File.join(options[:id],'rendered.html'))
+          end
+        end
+
+        # Create a commit
+        #
+        # @param [Hash] options A hash containing all the data we'll need to make a commit
+        # @param [Symbol] type The type of commit that we're making - used to create commit messages and set other standard data
+        # @param [Proc] &blk The meat of the commit to be performed in other convenience functions
+        # @yield [index] Our actual commit operations performed in their respective convenience functions
+        # @yieldparam [Grit::Index] Our repo index
+        def commit( options , type , &blk )
+          # Build up commit data
+          commit = build_commit(options[:commit_message],
+                                options[:author_name],
+                                options[:author_email],
+                                type)
+
+          # Get the index
+          index  = Regulate.repo.index
+
+          # Read the tree if we are on master
+          if parent_commit = Regulate.repo.commit('master')
+            index.read_tree(parent_commit.tree.id)
+          end
+
+          yield index
+
+          # Determine if we have a parent so we can do stuff like git log
+          parents = parent_commit ? [parent_commit] : []
+
+          # Make a new commit and return the sha
+          actor   = Grit::Actor.new(commit[:name], commit[:email])
+          sha     = index.commit(commit[:message], parents, actor)
+
+          # Update our working directory so that the repo truly reflects the desired state
+          # Do this for each of our files that we might have made changes to
+          update_working_dir( index, File.join(options[:id],'attributes.json') )
+          update_working_dir( index, File.join(options[:id], 'rendered.html') )
+
+          sha
+        end
+
+        # Update the given file in the repository's working directory if there
+        # is a working directory present.
+        #
+        # index  - The Grit::Index with which to sync.
+        # dir    - The String directory in which the file lives.
+        # name   - The String name of the page (may be in human format).
+        # format - The Symbol format of the page.
+        #
+        # Returns nothing.
+        # @see https://github.com/github/gollum/blob/79a1fb860d261d7f836fe75f5f8b4b88fc541a0c/lib/gollum/wiki.rb#L417
+        #
+        # @param [Grit::Index] index The git index that we are working on
+        # @param [String] path The path/path-to-file that we want to update to represent the true state of the repo
+        # @return [NilClass]
+        def update_working_dir( index , path )
+          unless Regulate.repo.bare
+            Dir.chdir(::File.join(Regulate.repo.path, '..')) do
+              if file_path_scheduled_for_deletion?(index.tree, path)
+                Regulate.repo.git.rm({'f' => true}, '--', path)
+              else
+                Regulate.repo.git.checkout({}, 'HEAD', '--', path)
+              end
+            end
+          end
+        end
+
+        # Determine if a given file is scheduled to be deleted in the next commit
+        # for the given Index.
+        #
+        # map   - The Hash map:
+        #         key - The String directory or filename.
+        #         val - The Hash submap or the String contents of the file.
+        # path - The String path of the file including extension.
+        #
+        # Returns the Boolean response.
+        # @see https://github.com/github/gollum/blob/79a1fb860d261d7f836fe75f5f8b4b88fc541a0c/lib/gollum/wiki.rb#L459
+        #
+        # @param [Grit::Tree] map The tree containing our path that we are checking
+        # @param [String] path The path/path-to-file to check
+        # @return [TrueClass,FalseClass]
+        def file_path_scheduled_for_deletion?( map , path )
+          parts = path.split('/')
+          if parts.size == 1
+            deletions = map.keys.select { |k| !map[k] }
+            deletions.any? { |d| d == parts.first }
+          else
+            part = parts.shift
+            if rest = map[part]
+              file_path_scheduled_for_deletion?(rest, parts.join('/'))
+            else
+              false
+            end
+          end
+        end
+
+
+        # Setup some standard commit data
+        #
+        # @param [String] commit_message Our commit message
+        # @param [String] author_name Our author name
+        # @param [String] author_email Our author email
+        # @param [String] mode The type of action being taken in the commit
+        def build_commit( commit_message , author_name , author_email , mode )
+          {
+            :name     => author_name.nil? ? "Anonymous" : author_name,
+            :email    => author_email    ||= "anon@anonymous.com",
+            :message  => commit_message  ||= mode.eql?(:create) ? "Creating new page." : "Updating page."
+          }
+        end
+
+        # Return whether or not a resource directory exists in the repo with the given ID
+        #
+        # @param [String] id The ID that we are checking
+        # @return [TrueClass,FalseClass]
+        def exists?( id )
+          Regulate.repo.commits.any? && !(current_tree / File.join(id, 'attributes.json')).nil?
+        end
+
+        # Return a commit object representing the last commit on the active repo
+        #
+        # @return [Grit::Commit] A Grit::Commit object representing the most recent commit on the active repository
+        def last_commit
+          branch = 'master'
+          return nil unless Regulate.repo.commits(branch).any?
+
+          # We should be able to use just repo.commits(branch).first here but
+          # this is a workaround for this bug: 
+          # http://github.com/mojombo/grit/issues/issue/38
+          Regulate.repo.commits("#{branch}^..#{branch}").first || Regulate.repo.commits(branch).first
+        end
+
+        # The tree for the last commit on the active repo
+        def current_tree
+          c = last_commit
+          c ? c.tree : nil
+        end
+
+      end # Interface class methods ( class << self )
+
+    end # class Interface
+
+  end # module Git
+
+end # module Regulate
+