releaf-core 0.2.1 → 1.0.3

data/lib/generators/dummy/templates/models/publisher.rb

@@ -1,9 +1,4 @@
 class Publisher < ActiveRecord::Base
   validates_presence_of :title
-
   has_many :authors, dependent: :restrict_with_exception
-
-  def to_text
-    title
-  end
 end

data/lib/generators/dummy/templates/models/text_page.rb

@@ -1,5 +1,4 @@
 class TextPage < ActiveRecord::Base
   acts_as_node
   validates_presence_of :text_html
-  alias_attribute :to_text, :id
 end

data/lib/generators/dummy/templates/views/contacts/show.html.haml

@@ -1 +1 @@
-= link_to "Releaf gihub repository", 'https://github.com/cubesystems/releaf'
+= link_to "Releaf github repository", 'https://github.com/cubesystems/releaf'

data/lib/generators/dummy/templates/views/layouts/application.html.haml

@@ -13,7 +13,15 @@
     #body_wrap
       #content_wrap
         #header
-          Header
+          %p
+            Site:
+            = site
+          %p
+            Node class:
+            = node_class
+          %p
+            Node name:
+            = @node.name if @node.present?
         #content= yield
       #footer
         Footer

data/lib/generators/dummy/templates/views/text_pages/show.haml

@@ -1 +1 @@
-=@text.text_html.html_safe
+=@content.text_html.html_safe

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

@@ -3,28 +3,17 @@ Releaf.application.configure do
 
   ### setup menu items and therefore available controllers
   config.menu = [
-    {
-      :controller => 'releaf/content/nodes',
-      :icon => 'sitemap',
-    },
-    {
-      :name => "permissions",
-      :items =>   %w[releaf/permissions/users releaf/permissions/roles],
-      :icon => 'user',
-    },
-    {
-      :controller => 'releaf/i18n_database/translations',
-      :icon => 'group',
-    },
+    "releaf/content/nodes",
+    {name: "permissions", items: %w[releaf/permissions/users releaf/permissions/roles]},
+    "releaf/i18n_database/translations"
   ]
 
   # controllers that must be accessible by user, but are not visible in menu
   # should be added to this list
-  config.additional_controllers = ['releaf/permissions/profile']
-
-  config.components = [Releaf::I18nDatabase, Releaf::Permissions, Releaf::Content]
+  # config.additional_controllers = %w[admin/chapters]
+  config.components = [Releaf::Core, Releaf::I18nDatabase, Releaf::Permissions, Releaf::Content]
 
   config.available_locales = ["en"]
   # config.layout_builder_class_name = 'CustomLayoutBuilder'
-  # config.devise_for 'releaf/admin'
+  # conf.permissions.devise_for 'releaf/admin'
 end

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

@@ -1,21 +1,20 @@
 class CreateReleafTranslations < ActiveRecord::Migration
   def change
-    create_table :releaf_translations do |t|
-      t.string  :key,       :null => false
-
-      t.timestamps(null: false)
+    create_table :releaf_i18n_entries 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
+    add_index :releaf_i18n_entries, :key
 
-      t.timestamps(null: false)
+    create_table :releaf_i18n_entry_translations do |t|
+      t.integer :i18n_entry_id, null: false
+      t.string :locale, null: false, limit: 5
+      t.text :text
+      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
+    add_index :releaf_i18n_entry_translations, :locale
+    add_index :releaf_i18n_entry_translations, :i18n_entry_id
+    add_index :releaf_i18n_entry_translations, [:locale, :i18n_entry_id], unique: true,
+      name: :index_releaf_i18n_entry_translations_on_locale_i18n_entry_id
   end
 end

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

@@ -1,7 +1,12 @@
+# This file should contain all the record creation needed to seed the database with its default values.
+# The data can then be loaded with the rake db:seed (or created alongside the db with db:setup).
+#
 [
   Releaf::Permissions::User,
   Releaf::Permissions::Role,
-  Releaf::Permissions::Permission
+  Releaf::Permissions::Permission,
+  Releaf::I18nDatabase::I18nEntry,
+  Releaf::I18nDatabase::I18nEntryTranslation
 ].each do |descendant|
   descendant.unscoped.delete_all
 end
@@ -9,46 +14,37 @@ end
 # Role {{{
 
 puts "Creating roles"
-super_admin = Releaf::Permissions::Role.new(name: "super admin", default_controller: "releaf/permissions/users")
+role = 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}")
+  role.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!
+role.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
+Releaf::Permissions::User.create!(
+  name: 'Admin',
+  surname: 'User',
+  password: 'password',
+  password_confirmation: 'password',
+  locale: "en",
+  email: 'admin@example.com',
+  role: role,
+)
+
+
 
 # }}}
+# Translations {{{
 
-# vim: set fdm=marker:
+puts "Importing translations"
+import_file_path = File.join(Gem.loaded_specs["releaf"].full_gem_path, "releaf-i18n_database", "misc", "translations.xlsx")
+translations = Releaf::I18nDatabase::ParseSpreadsheetTranslations.call(file_path: import_file_path, extension: "xlsx")
+translations.each{|translation| translation.save! }
 
+# }}}
+
+# vim: set fdm=marker:

data/lib/releaf/{core/application.rb → application.rb}

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

data/lib/releaf/{core/component.rb → component.rb}

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

data/lib/releaf/configuration.rb

@@ -0,0 +1,95 @@
+module Releaf
+  class Configuration
+    include Virtus.model(strict: true)
+    attribute :components, Array, default: []
+    attribute :available_locales, Array, default: []
+    attribute :available_admin_locales, Array, default: []
+    attribute :layout_builder_class_name, String, default: 'Releaf::Builders::Page::LayoutBuilder'
+    attribute :settings_manager, Class
+    attribute :menu, Array, default: []
+    attribute :mount_location, String, default: ""
+    attribute :additional_controllers, Array, default: []
+
+    def components=(value)
+      super(flatten_components(value))
+      components.each do|component_class|
+        component_class.configure_component if component_class.respond_to? :configure_component
+      end
+    end
+
+    def initialize_components
+      components.each do|component_class|
+        component_class.initialize_component if component_class.respond_to? :initialize_component
+      end
+    end
+
+    def add_configuration(configuration)
+      configuration_name = configuration.class.name.gsub(/Configuration$/, "").split("::").last.underscore
+
+      self.class.send(:attr_accessor, configuration_name)
+      send("#{configuration_name}=", configuration)
+    end
+
+    def initialize_defaults
+      self.class.default_values.each_pair do|key, value|
+        send("#{key}=", value)
+      end
+    end
+
+    def initialize_locales
+      ::I18n.available_locales = available_locales
+      self.available_admin_locales = available_locales if available_admin_locales.empty?
+    end
+
+    def all_locales
+      @all_locales ||= (available_locales + available_admin_locales).map(&:to_s).uniq
+    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 available_controllers
+      @available_controllers ||= controllers.keys
+    end
+
+    def controllers
+      @controllers ||= extract_controllers(menu + additional_controllers)
+    end
+
+    def menu=(value)
+      super(self.class.normalize_controllers(value))
+    end
+
+    def additional_controllers=(value)
+      super(self.class.normalize_controllers(value))
+    end
+
+    def extract_controllers(list)
+      list.each.inject({}) do |controller_list, item|
+        if item.respond_to? :controllers
+          controller_list.merge!(extract_controllers(item.controllers))
+        else
+          controller_list[item.controller_name] = item
+        end
+
+        controller_list
+      end
+    end
+
+    def self.normalize_controllers(list)
+      list.map do |item|
+        if item.is_a?(Hash) && item.has_key?(:items)
+          ControllerGroupDefinition.new(item)
+        elsif item.is_a?(Hash) || item.is_a?(String)
+          ControllerDefinition.new(item)
+        else
+          item
+        end
+      end
+    end
+  end
+end

data/lib/releaf/core_ext/array/reorder.rb

@@ -0,0 +1,5 @@
+class Array
+  def reorder(values, options)
+    Array::Reorder.call(array: self, values: values, options: options)
+  end
+end

data/lib/releaf/engine.rb

@@ -0,0 +1,12 @@
+module Releaf
+  class Engine < ::Rails::Engine
+    initializer 'releaf.assets_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
+
+    initializer 'releaf.route_mapper', after: 'action_dispatch.prepare_dispatcher' do
+      ActionDispatch::Routing::Mapper.send(:include, Releaf::RouteMapper)
+    end
+  end
+end

data/lib/releaf/exceptions.rb

@@ -0,0 +1,5 @@
+module Releaf
+  class Error < StandardError; end
+  class AccessDenied < Error; end
+  class FeatureDisabled < Error; end
+end

data/lib/releaf/instance_cache.rb

@@ -0,0 +1,72 @@
+module Releaf::InstanceCache
+  extend ActiveSupport::Concern
+
+  included do
+    cattr_accessor :cached_instance_methods, :instance_methods_to_cache
+
+    self.cached_instance_methods   = []
+    self.instance_methods_to_cache = []
+
+    def self.instance_cache_original_method_name(method_name)
+      "instance_cache_original_#{method_name}"
+    end
+
+    if respond_to?(:method_added)
+      # preserve any previous definitions of method_added
+      singleton_class.send(:alias_method, instance_cache_original_method_name(:method_added), :method_added)
+    end
+
+    def self.method_added(method_name)
+      # call previous definition of method_added if present
+      parent_method_added = instance_cache_original_method_name(:method_added)
+      send(parent_method_added, method_name) if respond_to?(parent_method_added)
+
+      # see if the newly added method is in the queue needing to be cached
+      method_needs_to_be_cached = instance_methods_to_cache.delete(method_name)
+      if method_needs_to_be_cached.present?
+        create_instance_cache_method_alias(method_name)
+      end
+    end
+
+    def self.cache_instance_methods(*method_names)
+      method_names.each { |method_name| cache_instance_method(method_name) }
+    end
+
+    def self.cache_instance_method method_name
+      if instance_methods.include?(method_name)
+        # method already defined, alias it
+        create_instance_cache_method_alias method_name
+      else
+        # method not defined yet, add to queue
+        instance_methods_to_cache << method_name
+      end
+    end
+
+    def self.create_instance_cache_method_alias method_name
+      original_method_name = instance_cache_original_method_name( method_name )
+      alias_method original_method_name, method_name
+      define_method(method_name) do
+        instance_cache(method_name) do
+          send(original_method_name)
+        end
+      end
+      self.cached_instance_methods << method_name
+    end
+  end
+
+  def instance_cache_store
+    @instance_cache_store ||= {}
+  end
+
+  def reset_instance_cache
+    @instance_cache_store = {}
+  end
+
+  def instance_cache(key)
+    if instance_cache_store.key?(key)
+      instance_cache_store[key]
+    else
+      instance_cache_store[key] = yield
+    end
+  end
+end

data/lib/releaf/{core → rails_ext}/validation_error_codes.rb

@@ -23,7 +23,7 @@ module ActiveModel
       self[attribute] << ErrorMessage.new(message, error_code, options[:data])
     end
 
-    def normalize_error_code(attribute, message, options)
+    def normalize_error_code(_attribute, message, options)
       if !options[:error_code].blank?
         options[:error_code]
       elsif message.class == Symbol

data/lib/releaf/root/configuration.rb

@@ -0,0 +1,6 @@
+module Releaf::Root
+  class Configuration
+    include Virtus.model(strict: true)
+    attribute :default_controller_resolver, Class
+  end
+end

data/lib/releaf/root/default_controller_resolver.rb

@@ -0,0 +1,37 @@
+module Releaf::Root
+  class DefaultControllerResolver
+    include Releaf::Service
+    attribute :current_controller
+
+    def call
+      controllers.each do |controller_name|
+        path = controller_index_path(controller_name)
+        return path if path
+      end
+
+      nil
+    end
+
+    def controller_index_path(controller_name)
+      route_options = {controller: controller_name, action: "index"}
+
+      subdomain.present? && route_path(route_options.merge(subdomain: subdomain)) || route_path(route_options)
+    end
+
+    def route_path(route_options)
+      Rails.application.routes.url_helpers.url_for(route_options.merge(only_path: true)) if route_exists?(route_options)
+    end
+
+    def controllers
+      Releaf.application.config.available_controllers
+    end
+
+    def route_exists?(route_options)
+      Rails.application.routes.routes.map(&:defaults).include?(route_options)
+    end
+
+    def subdomain
+      current_controller.request.subdomain
+    end
+  end
+end

data/lib/releaf/root/settings_manager.rb

@@ -0,0 +1,12 @@
+module Releaf::Root
+  class SettingsManager
+
+    def self.read(controller:, key:)
+      controller.send(:cookies)[key]
+    end
+
+    def self.write(controller:, key:, value:)
+      controller.send(:cookies)[key] = value
+    end
+  end
+end

data/lib/releaf/root.rb

@@ -0,0 +1,17 @@
+module Releaf::Root
+  extend Releaf::Component
+
+  def self.configure_component
+    Releaf.application.config.add_configuration(
+      Releaf::Root::Configuration.new(default_controller_resolver: Releaf::Root::DefaultControllerResolver)
+    )
+    Releaf.application.config.settings_manager = Releaf::Root::SettingsManager
+  end
+
+  def self.draw_component_routes(router)
+    router.namespace :releaf, path: nil do
+      router.root to: "root#home", as: :root
+      router.post "store_settings", to: "root#store_settings"
+    end
+  end
+end

data/lib/releaf/{core/route_mapper.rb → route_mapper.rb}

@@ -1,8 +1,8 @@
-module Releaf::Core::RouteMapper
+module Releaf::RouteMapper
   # Pass given resource to "resources" mount method and
   # add extra routes for members and collections needed by releaf
-  def releaf_resources(*args, &block)
-    resources *args do
+  def releaf_resources(*args)
+    resources(*args) do
       yield if block_given?
       member do
         get :confirm_destroy if route_enabled?(:destroy, args.last)
@@ -22,8 +22,8 @@ module Releaf::Core::RouteMapper
     end
   end
 
-  def mount_releaf_at(mount_location, options={}, &block)
-    mount_location_namespace = mount_location.gsub("/", "").to_sym
+  def mount_releaf_at(mount_location)
+    mount_location_namespace = mount_location.delete("/").to_sym
     Releaf.application.config.mount_location = mount_location_namespace.to_s
     scope mount_location do
       initialize_releaf_components
@@ -37,7 +37,7 @@ module Releaf::Core::RouteMapper
       end
 
       namespace :releaf, path: nil do
-        get '/*path' => 'core/errors#page_not_found'
+        get '/*path' => 'errors#page_not_found'
       end
     end
   end

data/lib/releaf/service.rb

@@ -0,0 +1,11 @@
+module Releaf::Service
+  extend ActiveSupport::Concern
+
+  included do
+    include Virtus.model(strict: true)
+
+    def self.call(*args)
+      new(*args).call
+    end
+  end
+end

data/lib/releaf/settings_ui.rb

@@ -0,0 +1,7 @@
+module Releaf::SettingsUI
+  extend Releaf::Component
+
+  def self.draw_component_routes router
+    resource_route(router, nil, :settings)
+  end
+end

data/lib/releaf/version.rb

@@ -1,3 +1,3 @@
 module Releaf
-  VERSION = "0.2.1"
+  VERSION = "1.0.3"
 end

data/lib/releaf-core.rb

@@ -1,14 +1,43 @@
+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 'vanilla-ujs'
+require 'acts_as_list'
+require 'dragonfly'
+require 'globalize'
+require 'virtus'
+require 'globalize-accessors'
+
 module Releaf
-  require 'releaf/core/engine'
-  require 'releaf/core/configuration'
-  require 'releaf/core/application'
-  require 'releaf/core/route_mapper'
-  require 'releaf/core/exceptions'
-  require 'releaf/core/validation_error_codes'
+  module Core
+    require 'releaf/engine'
+    require 'releaf/service'
+    require 'releaf/instance_cache'
+    require 'releaf/component'
+    require 'releaf/settings_ui'
+    require 'releaf/route_mapper'
+    require 'releaf/configuration'
+    require 'releaf/root'
+    require 'releaf/root/configuration'
+    require 'releaf/root/default_controller_resolver'
+    require 'releaf/root/settings_manager'
+    require 'releaf/application'
+    require 'releaf/route_mapper'
+    require 'releaf/exceptions'
+    require 'releaf/core_ext/array/reorder'
+    require 'releaf/rails_ext/validation_error_codes'
 
-  class << self
-    def application
-      @@application ||= Releaf::Core::Application.new
+    def self.components
+      [Releaf::SettingsUI, Releaf::Root]
     end
   end
+
+  def self.application
+    @@application ||= Releaf::Application.new
+  end
 end