annex-cms 0.1.0

data/app/controllers/annex/application_controller.rb

@@ -0,0 +1,18 @@
+module Annex
+
+  class ApplicationController < ::ApplicationController
+    protect_from_forgery with: :null_session
+
+    before_filter :annex_authenticate!
+    before_filter :annex_authorize!
+
+    def annex_authenticate!
+      instance_eval &Annex::Config.authenticate_with
+    end
+
+    def annex_authorize!
+      instance_eval &Annex::Config.authorize_with
+    end
+  end
+
+end

data/app/controllers/annex/blocks_controller.rb

@@ -0,0 +1,28 @@
+require_dependency "annex/application_controller"
+
+module Annex
+  class BlocksController < ApplicationController
+
+    # POST /annex/blocks
+    def create
+      @block = Block.where(:route => params[:route]).first_or_create
+      @block.content ||= {}
+
+      params[:content].keys.each do |key|
+        @block.content[key] = params[:content][key]
+      end
+
+      if @block.save
+        render json: {status: :success}, status: :ok
+      else
+        render json: @block.errors, status: :unprocessable_entity
+      end
+    end
+
+    private
+
+      def block_params
+        params.require(:user).permit(:route, :content)
+      end
+  end
+end

data/app/controllers/annex/files_controller.rb

@@ -0,0 +1,12 @@
+require_dependency "annex/application_controller"
+
+module Annex
+  class FilesController < ApplicationController
+
+    # POST /annex/documents
+    def create
+      puts 'create called'
+    end
+
+  end
+end

data/app/models/annex/block.rb

@@ -0,0 +1,12 @@
+module Annex
+  class Block
+    include Mongoid::Document
+    include Mongoid::Timestamps
+    include Mongoid::Attributes::Dynamic
+
+    field :route, type: String
+    field :content, type: Hash
+
+    validates_presence_of :route
+  end
+end

data/app/models/annex/file.rb

@@ -0,0 +1,7 @@
+module Annex
+  class File
+    include Mongoid::Document
+    include Mongoid::Timestamps
+    include Mongoid::Attributes::Dynamic
+  end
+end

data/app/views/annex/_block.html.haml

@@ -0,0 +1,2 @@
+.redactor{ { :data => { :identifier => identifier, :route => route } }.deep_merge(opts) }
+  = content.html_safe if content

data/app/views/annex/_clips.html.haml

@@ -0,0 +1,11 @@
+#clipsmodal
+  %section
+    %ul.redactor_clips_box
+      %li
+        %a.redactor_clip_link{href: "#"} Lorem ipsum …
+        .redactor_clip{style: "display: none;"}
+          Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+      %li
+        = content_for :annex_clip
+  %footer
+    %a.redactor_modal_btn.redactor_btn_modal_close{href: "#"} Close

data/config/routes.rb

@@ -0,0 +1,5 @@
+Rails.application.routes.draw do
+  namespace :annex do
+    resources :blocks, :only => [:create], :defaults => { :format => 'json' }
+  end
+end

data/lib/annex.rb

@@ -0,0 +1,8 @@
+require 'annex/engine'
+require 'annex/config'
+require 'annex/extension'
+require 'annex/extensions/cancan'
+require 'annex/railtie'
+
+module Annex
+end

data/lib/annex/config.rb

@@ -0,0 +1,87 @@
+module Annex
+  module Config
+    # Annex is setup to try and authenticate with warden
+    # If warden is found, then it will try to authenticate
+    #
+    # This is valid for custom warden setups, and also devise
+    # If you're using the admin setup for devise, you should set Annex to use the admin
+    #
+    # @see Annex::Config.authenticate_with
+    # @see Annex::Config.authorize_with
+    DEFAULT_AUTHENTICATION = Proc.new do
+      request.env['warden'].try(:authenticate!)
+    end
+
+    DEFAULT_AUTHORIZE = Proc.new {}
+
+    DEFAULT_CURRENT_USER = Proc.new do
+      request.env["warden"].try(:user) || respond_to?(:current_user) && current_user
+    end
+
+
+    class << self
+
+      # Setup authentication to be run as a before filter
+      # This is run inside the controller instance so you can setup any authentication you need to
+      #
+      # By default, the authentication will run via warden if available
+      # and will run the default.
+      #
+      # If you use devise, this will authenticate the same as _authenticate_user!_
+      #
+      # @example Devise admin
+      #   Annex.config do |config|
+      #     config.authenticate_with do
+      #       authenticate_admin!
+      #     end
+      #   end
+      #
+      # @example Custom Warden
+      #   Annex.config do |config|
+      #     config.authenticate_with do
+      #       warden.authenticate! :scope => :paranoid
+      #     end
+      #   end
+      #
+      # @see Annex::Config::DEFAULT_AUTHENTICATION
+      def authenticate_with(&blk)
+        @authenticate = blk if blk
+        @authenticate || DEFAULT_AUTHENTICATION
+      end
+
+      # Setup authorization to be run as a before filter
+      # This is run inside the controller instance so you can setup any authorization you need to.
+      #
+      # By default, there is no authorization.
+      #
+      # @example Custom
+      #   Annex.config do |config|
+      #     config.authorize_with do
+      #       redirect_to root_path unless warden.user.is_admin?
+      #     end
+      #   end
+      #
+      # To use an authorization adapter, pass the name of the adapter. For example,
+      # to use with CanCan[https://github.com/ryanb/cancan], pass it like this.
+      #
+      # @example CanCan
+      #   Annex.config do |config|
+      #     config.authorize_with :cancan
+      #   end
+      #
+      # @see Annex::Config::DEFAULT_AUTHORIZE
+      def authorize_with(*args, &block)
+        extension = args.shift
+        if(extension)
+          @authorize = Proc.new {
+            @authorization_adapter = Annex::AUTHORIZATION_ADAPTERS[extension].new(*([self] + args).compact)
+          }
+        else
+          @authorize = block if block
+        end
+        @authorize || DEFAULT_AUTHORIZE
+      end
+
+    end
+  end
+end

data/lib/annex/engine.rb

@@ -0,0 +1,5 @@
+module Annex
+  class Engine < ::Rails::Engine
+    isolate_namespace Annex
+  end
+end

data/lib/annex/extension.rb

@@ -0,0 +1,18 @@
+module Annex
+  EXTENSIONS = []
+  AUTHORIZATION_ADAPTERS = {}
+
+  # Extend Annex
+  #
+  # The extension may define various adapters (e.g., for authorization) and
+  # register those via the options hash.
+  def self.add_extension(extension_key, extension_definition, options = {})
+    options.assert_valid_keys(:authorization, :configuration, :auditing)
+
+    EXTENSIONS << extension_key
+
+    if(authorization = options[:authorization])
+      AUTHORIZATION_ADAPTERS[extension_key] = extension_definition::AuthorizationAdapter
+    end
+  end
+end

data/lib/annex/extensions/cancan.rb

@@ -0,0 +1,5 @@
+require 'annex/extensions/cancan/authorization_adapter'
+
+Annex.add_extension(:cancan, Annex::Extensions::CanCan, {
+  :authorization => true
+})

data/lib/annex/extensions/cancan/authorization_adapter.rb

@@ -0,0 +1,59 @@
+module Annex
+  module Extensions
+    module CanCan
+      # This adapter is for the CanCan[https://github.com/ryanb/cancan] authorization library.
+      # You can create another adapter for different authorization behavior, just be certain it
+      # responds to each of the public methods here.
+      class AuthorizationAdapter
+        # See the +authorize_with+ config method for where the initialization happens.
+        def initialize(controller, ability = ::Ability)
+          @controller = controller
+          @controller.instance_variable_set '@ability', ability
+          @controller.extend ControllerExtension
+          @controller.current_ability.authorize! :access, :annex
+        end
+
+        # This method is called in every controller action and should raise an exception
+        # when the authorization fails. The first argument is the name of the controller
+        # action as a symbol (:create, :bulk_delete, etc.). The second argument is the
+        # AbstractModel instance that applies. The third argument is the actual model
+        # instance if it is available.
+        def authorize(action, abstract_model = nil, model_object = nil)
+          @controller.current_ability.authorize!(action, model_object || abstract_model && abstract_model.model) if action
+        end
+
+        # This method is called primarily from the view to determine whether the given user
+        # has access to perform the action on a given model. It should return true when authorized.
+        # This takes the same arguments as +authorize+. The difference is that this will
+        # return a boolean whereas +authorize+ will raise an exception when not authorized.
+        def authorized?(action, abstract_model = nil, model_object = nil)
+          @controller.current_ability.can?(action, model_object || abstract_model && abstract_model.model) if action
+        end
+
+        # This is called when needing to scope a database query. It is called within the list
+        # and bulk_delete/destroy actions and should return a scope which limits the records
+        # to those which the user can perform the given action on.
+        def query(action, abstract_model)
+          abstract_model.model.accessible_by(@controller.current_ability, action)
+        end
+
+        # This is called in the new/create actions to determine the initial attributes for new
+        # records. It should return a hash of attributes which match what the user
+        # is authorized to create.
+        def attributes_for(action, abstract_model)
+          @controller.current_ability.attributes_for(action, abstract_model && abstract_model.model)
+        end
+
+        private
+
+        module ControllerExtension
+          def current_ability
+            # use _current_user instead of default current_user so it works with
+            # whatever current user method is defined with Annex
+            @current_ability ||= @ability.new(_current_user)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/annex/railtie.rb

@@ -0,0 +1,9 @@
+require 'annex/view_helpers'
+
+module Annex
+  class Railtie < Rails::Railtie
+    initializer "annex.view_helpers" do
+      ActionView::Base.send :include, ViewHelpers
+    end
+  end
+end

data/lib/annex/version.rb

@@ -0,0 +1,3 @@
+module Annex
+  VERSION = "0.1.0"
+end

data/lib/annex/view_helpers.rb

@@ -0,0 +1,32 @@
+require 'active_support/hash_with_indifferent_access'
+
+module Annex
+  module ViewHelpers
+    def annex_block(identifier, opts = {})
+      if opts.try(:route)
+        route = opts[:route]
+        opts[:route].delete
+      else
+        route = current_route
+      end
+
+      doc = Annex::Block.where(:route => route.to_s).first_or_create
+
+      if doc.content
+        content = doc.content[identifier.to_s] || ''
+      else
+        content = ''
+      end
+
+      render partial: 'annex/block', locals: { content: content, route: route, identifier: identifier, opts: opts }
+    end
+
+    def annex_clips(clip)
+      render partial: 'annex/clips'
+    end
+
+    def current_route
+      "#{I18n.locale}_#{params[:controller]}_#{params[:action]}".to_sym
+    end
+  end
+end

data/lib/tasks/annex_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :annex do
+#   # Task goes here
+# end

data/test/annex_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class AnnexTest < ActiveSupport::TestCase
+  test "truth" do
+    assert_kind_of Module, Annex
+  end
+end

data/test/controllers/annex/block_controller_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+
+module Annex
+  class BlockControllerTest < ActionController::TestCase
+    # test "the truth" do
+    #   assert true
+    # end
+  end
+end

data/test/controllers/annex/blocks_controller_test.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+module Annex
+  class BlocksControllerTest < ActionController::TestCase
+    setup do
+      @block = blocks(:one)
+    end
+
+    test "should get index" do
+      get :index
+      assert_response :success
+      assert_not_nil assigns(:blocks)
+    end
+
+    test "should get new" do
+      get :new
+      assert_response :success
+    end
+
+    test "should create block" do
+      assert_difference('Block.count') do
+        post :create, block: { content: @block.content, route: @block.route }
+      end
+
+      assert_redirected_to block_path(assigns(:block))
+    end
+
+    test "should show block" do
+      get :show, id: @block
+      assert_response :success
+    end
+
+    test "should get edit" do
+      get :edit, id: @block
+      assert_response :success
+    end
+
+    test "should update block" do
+      patch :update, id: @block, block: { content: @block.content, route: @block.route }
+      assert_redirected_to block_path(assigns(:block))
+    end
+
+    test "should destroy block" do
+      assert_difference('Block.count', -1) do
+        delete :destroy, id: @block
+      end
+
+      assert_redirected_to blocks_path
+    end
+  end
+end

data/test/dummy/README.rdoc

@@ -0,0 +1,28 @@
+== README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
+
+
+Please feel free to use a different markup language if you do not plan to run
+<tt>rake doc:app</tt>.