releaf-core 0.2.1

data/lib/generators/releaf/templates/migrations/create_releaf_nodes.rb

@@ -0,0 +1,28 @@
+class CreateReleafNodes < ActiveRecord::Migration
+  def change
+    create_table "nodes", :force => true do |t|
+      t.string   "name"
+      t.string   "slug"
+      t.integer  "parent_id"
+      t.integer  "lft"
+      t.integer  "rgt"
+      t.integer  "depth"
+      t.string   "locale",          :limit => 6
+      t.string   "content_type"
+      t.integer  "content_id"
+      t.datetime "created_at",      :null => false
+      t.datetime "updated_at",      :null => false
+      t.integer  "item_position"
+      t.boolean  'active',          :null => false, :default => true
+    end
+    add_index :nodes, :parent_id
+    add_index :nodes, [:content_type, :content_id]
+    add_index :nodes, :lft
+    add_index :nodes, :rgt
+    add_index :nodes, :depth
+    add_index :nodes, :slug
+    add_index :nodes, :name
+    add_index :nodes, :active
+    add_index :nodes, :locale
+  end
+end

data/lib/generators/releaf/templates/migrations/create_releaf_permissions.rb

@@ -0,0 +1,12 @@
+class CreateReleafPermissions < ActiveRecord::Migration
+  def change
+    create_table :releaf_permissions do |t|
+      t.integer :owner_id
+      t.string :owner_type
+      t.string  :permission
+      t.timestamps(null: false)
+    end
+    add_index :releaf_permissions, [:owner_id, :owner_type]
+    add_index :releaf_permissions, :permission
+  end
+end

data/lib/generators/releaf/templates/migrations/create_releaf_richtext_attachments.rb

@@ -0,0 +1,12 @@
+class CreateReleafRichtextAttachments < ActiveRecord::Migration
+  def change
+    create_table :releaf_richtext_attachments do |t|
+      t.string  :file_uid
+      t.string  :file_name
+      t.string  :file_type
+      t.string  :title
+
+      t.timestamps(null: false)
+    end
+  end
+end

data/lib/generators/releaf/templates/migrations/create_releaf_roles.rb

@@ -0,0 +1,9 @@
+class CreateReleafRoles < ActiveRecord::Migration
+  def change
+    create_table :releaf_roles do |t|
+      t.string  :name,        :null => false
+      t.string  :default_controller
+      t.timestamps(null: false)
+    end
+  end
+end

data/lib/generators/releaf/templates/migrations/create_releaf_settings.rb

@@ -0,0 +1,17 @@
+class CreateReleafSettings < ActiveRecord::Migration
+  def self.up
+    create_table :settings do |t|
+      t.string :var, :null => false
+      t.text   :value, :null => true
+      t.integer :thing_id, :null => true
+      t.string :thing_type, :limit => 30, :null => true
+      t.timestamps(null: false)
+    end
+
+    add_index :settings, [ :thing_type, :thing_id, :var ], :unique => true
+  end
+
+  def self.down
+    drop_table :settings
+  end
+end

data/lib/generators/releaf/templates/migrations/create_releaf_translations.rb

@@ -0,0 +1,21 @@
+class CreateReleafTranslations < ActiveRecord::Migration
+  def change
+    create_table :releaf_translations do |t|
+      t.string  :key,       :null => false
+
+      t.timestamps(null: false)
+    end
+    add_index :releaf_translations, :key, :unique => true
+
+    create_table :releaf_translation_data do |t|
+      t.integer :translation_id, :null => false
+      t.string :lang, :null => false, :limit => 5
+      t.text :localization
+
+      t.timestamps(null: false)
+    end
+    add_index :releaf_translation_data, :lang
+    add_index :releaf_translation_data, :translation_id
+    add_index :releaf_translation_data, [:lang, :translation_id], :unique => true
+  end
+end

data/lib/generators/releaf/templates/migrations/create_releaf_users.rb

@@ -0,0 +1,52 @@
+class CreateReleafUsers < ActiveRecord::Migration
+  def change
+    create_table :releaf_users do |t|
+      t.string  :name,                :null => false
+      t.string  :surname,             :null => false
+      t.string  :locale
+      t.integer :role_id
+
+
+      ## Database authenticatable
+      t.string :email,              :null => false, :default => ""
+      t.string :encrypted_password, :null => false, :default => ""
+
+      ## Recoverable
+      t.string   :reset_password_token
+      t.datetime :reset_password_sent_at
+
+      ## Rememberable
+      t.datetime :remember_created_at
+
+      ## Trackable
+      t.integer  :sign_in_count, :default => 0
+      t.datetime :current_sign_in_at
+      t.datetime :last_sign_in_at
+      t.string   :current_sign_in_ip
+      t.string   :last_sign_in_ip
+
+      ## Confirmable
+      # t.string   :confirmation_token
+      # t.datetime :confirmed_at
+      # t.datetime :confirmation_sent_at
+      # t.string   :unconfirmed_email # Only if using reconfirmable
+
+      ## Lockable
+      # t.integer  :failed_attempts, :default => 0 # Only if lock strategy is :failed_attempts
+      # t.string   :unlock_token # Only if unlock strategy is :email or :both
+      # t.datetime :locked_at
+
+      ## Token authenticatable
+      # t.string :authentication_token
+
+      t.timestamps(null: false)
+    end
+
+    add_index :releaf_users, :role_id
+    add_index :releaf_users, :email,                :unique => true
+    add_index :releaf_users, :reset_password_token, :unique => true
+    # add_index :releaf_users, :confirmation_token,   :unique => true
+    # add_index :releaf_users, :unlock_token,         :unique => true
+    # add_index :releaf_users, :authentication_token, :unique => true
+  end
+end

data/lib/generators/releaf/templates/models/node.rb

@@ -0,0 +1,3 @@
+class Node < ActiveRecord::Base
+  include Releaf::Content::Node
+end

data/lib/generators/releaf/templates/seeds/seeds.rb

@@ -0,0 +1,54 @@
+[
+  Releaf::Permissions::User,
+  Releaf::Permissions::Role,
+  Releaf::Permissions::Permission
+].each do |descendant|
+  descendant.unscoped.delete_all
+end
+
+# Role {{{
+
+puts "Creating roles"
+super_admin = Releaf::Permissions::Role.new(name: "super admin", default_controller: "releaf/permissions/users")
+Releaf.application.config.available_controllers.each do|controller|
+  super_admin.permissions.build(permission: "controller.#{controller}")
+end
+super_admin.save!
+
+content_manager = Releaf::Permissions::Role.new(name: "content mager", default_controller: "releaf/content/nodes")
+content_manager.permissions.build(permission: "controller.releaf/content/nodes")
+content_manager.save!
+
+# }}}
+# User {{{
+
+puts "Creating users"
+users = {
+  user: {
+    name: 'Admin',
+    surname: 'User',
+    password: 'password',
+    password_confirmation: 'password',
+    locale: "en",
+    email: 'admin@example.com',
+    role: super_admin,
+  },
+  simple_user: {
+    name: 'Simple',
+    surname: 'User',
+    password: 'password',
+    password_confirmation: 'password',
+    locale: "en",
+    email: 'user@example.com',
+    role: content_manager,
+  }
+}
+
+users.each_value do |attributes|
+  Releaf::Permissions::User.create!(attributes)
+end
+
+# }}}
+
+# vim: set fdm=marker:
+

data/lib/releaf/core/application.rb

@@ -0,0 +1,17 @@
+module Releaf::Core
+  class Application
+    attr_accessor :config
+
+    def configure(&block)
+      self.config = Releaf::Core::Configuration.new
+      instance_eval(&block)
+      config.configure
+    end
+
+    def render_layout(template, &block)
+      builder_class = config.layout_builder_class_name.constantize
+      builder_class.new(template).output{ yield }.html_safe
+    end
+  end
+end
+

data/lib/releaf/core/builders_autoload.rb

@@ -0,0 +1,27 @@
+root_path = File.expand_path('../..', File.dirname(__dir__))
+files = %w(
+  builders/tags/releaf_associated_set_field
+  builders
+  builders/base
+  builders/orderer
+  builders/template
+  builders/toolbox
+  builders/view
+  builders/collection
+  builders/resource
+  builders/resource_dialog
+  builders/resource_view
+  builders/confirm_dialog_builder
+  builders/confirm_destroy_dialog_builder
+  builders/edit_builder
+  builders/form_builder
+  builders/index_builder
+  builders/refused_destroy_dialog_builder
+  builders/table_builder
+  builders/toolbox_builder
+  core/settings/form_builder
+  core/settings/table_builder
+)
+files.each do|file|
+ require "#{root_path}/app/builders/releaf/#{file}"
+end

data/lib/releaf/core/component.rb

@@ -0,0 +1,9 @@
+module Releaf::Core::Component
+  def resource_route(router, namespace, resource)
+    router.namespace :releaf, path: nil do
+      router.namespace namespace, path: nil do
+        router.releaf_resources(resource)
+      end
+    end
+  end
+end

data/lib/releaf/core/configuration.rb

@@ -0,0 +1,101 @@
+module Releaf::Core
+  class Configuration
+    attr_accessor :available_locales, :available_admin_locales, :all_locales
+    attr_accessor :access_control_module_name, :assets_resolver_class_name, :layout_builder_class_name
+    attr_accessor :menu, :devise_for, :mount_location, :components,
+      :available_controllers, :additional_controllers, :controllers
+
+    def configure
+      initialize_defaults
+      initialize_locales
+      initialize_controllers
+      initialize_components
+    end
+
+    def assets_resolver
+      assets_resolver_class_name.constantize
+    end
+
+    def access_control_module
+      access_control_module_name.constantize
+    end
+
+    def initialize_defaults
+      default_values.each_pair do|key, value|
+        send("#{key}=", value) if send(key).nil?
+      end
+    end
+
+    def initialize_locales
+      ::I18n.available_locales = available_locales
+      self.available_admin_locales = available_locales if available_admin_locales.nil?
+      self.all_locales = (available_locales + available_admin_locales).map(&:to_s).uniq
+    end
+
+    def initialize_components
+      self.components = flatten_components(components)
+      components.each do|component_class|
+        component_class.initialize_component if component_class.respond_to? :initialize_component
+      end
+    end
+
+    def flatten_components(raw_components)
+      raw_components.each.inject([]) do |list, component_class|
+        list += flatten_components(component_class.components) if component_class.respond_to? :components
+        list << component_class # add component itself latter as there can be dependancy to be loadable first
+      end
+    end
+
+    def initialize_controllers
+      self.menu = normalize_controllers(menu)
+      self.additional_controllers = normalize_controllers(additional_controllers)
+      self.controllers = extract_controllers(menu + additional_controllers)
+      self.available_controllers = controllers.keys
+    end
+
+    def extract_controllers(list)
+      list.each.inject({}) do |controller_list, item|
+        controller_list[item[:controller]] = item if item.has_key? :controller
+        controller_list.merge!(extract_controllers(item[:items])) if item.has_key? :items
+        controller_list
+      end
+    end
+
+    def normalize_controllers(list)
+     list.map{|item| normalize_controller_item(item)}
+    end
+
+    def normalize_controller_item(item_data)
+      if item_data.is_a? String
+        item = {controller: item_data}
+      elsif item_data.is_a? Hash
+        item = item_data
+      end
+
+      item[:name] = item[:controller] unless item.has_key? :name
+
+      if item.has_key? :helper
+        item[:url_helper] = item[:helper].to_sym
+      elsif item.has_key? :controller
+        item[:url_helper] = item[:controller].gsub('/', '_').to_sym
+      end
+
+      item[:items] = normalize_controllers(item[:items]) if item.has_key?(:items)
+
+      item
+    end
+
+    def default_values
+      {
+        menu: [],
+        devise_for: 'releaf/permissions/user',
+        additional_controllers: [],
+        controllers: {},
+        components: [],
+        assets_resolver_class_name:  'Releaf::Core::AssetsResolver',
+        layout_builder_class_name: 'Releaf::Builders::Page::LayoutBuilder',
+        access_control_module_name: 'Releaf::Permissions'
+      }
+    end
+  end
+end

data/lib/releaf/core/engine.rb

@@ -0,0 +1,35 @@
+require 'jquery-cookie-rails'
+require 'rails-settings-cached'
+require 'ckeditor_rails'
+require 'will_paginate'
+require 'font-awesome-rails'
+require 'haml'
+require 'haml-rails'
+require 'jquery-rails'
+require 'jquery-ui-rails'
+require 'acts_as_list'
+require 'dragonfly'
+require 'globalize'
+require 'globalize-accessors'
+
+module Releaf::Core
+  require 'releaf/core/component'
+  require 'releaf/core/settings_ui_component'
+  require 'releaf/core/route_mapper'
+  require 'releaf/core/builders_autoload'
+
+  def self.components
+    [Releaf::Core::SettingsUIComponent]
+  end
+
+  class Engine < ::Rails::Engine
+    initializer 'precompile', group: :all do |app|
+      app.config.assets.precompile += %w(ckeditor/*)
+      app.config.assets.precompile += %w(releaf/application.css releaf/controllers/*.css releaf/*.js releaf/*.png releaf/*.gif releaf/*.ico)
+    end
+  end
+
+  ActiveSupport.on_load :action_controller do
+    ActionDispatch::Routing::Mapper.send(:include, Releaf::Core::RouteMapper)
+  end
+end

data/lib/releaf/core/exceptions.rb

@@ -0,0 +1,38 @@
+module Releaf::Core
+  # A general Releaf exception
+  class Error < StandardError; end
+
+  # This error is raised when a user isn't allowed to access a given controller action.
+  # This usually happens within a call to ControllerAdditions#authorize! but can be
+  # raised manually.
+  #
+  #   raise Releaf::AccessDenied.new("Not authorized!", AdminArticles, :read)
+  #
+  # The passed message, action, and subject are optional and can later be retrieved when
+  # rescuing from the exception.
+  #
+  #   exception.message # => "Not authorized!"
+  #   exception.action # => :read
+  #   exception.subject # => Article
+  #
+  # If the message is not specified (or is nil) it will default to "You are not authorized
+  # to access this page." This default can be overridden by setting default_message.
+  #
+  #   exception.default_message = "Default error message"
+  #   exception.message # => "Default error message"
+  #
+  # See ControllerAdditions#authorized! for more information on rescuing from this exception
+  # and customizing the message using I18n.
+  class AccessDenied < Error
+    attr_reader :action, :subject
+    attr_writer :default_message
+
+    def initialize(controller = nil, action = nil, message = nil)
+      @message = message
+      @controller = controller
+      @action = action
+      @default_message = I18n.t(:"unauthorized.default", :default => "You are not authorized to access this page.")
+    end
+
+  end
+end