releaf 0.1.1 → 0.1.2

data/lib/generators/releaf/templates/javascripts/lib/init_jcarousel.js

@@ -0,0 +1,40 @@
+//= require ../3rd_party/jquery.jcarousel
+
+jQuery(document).ready(function() {
+
+    jQuery(document.body).on('initcarousel', function(e) {
+        var target = jQuery(e.target);
+
+        target.find('.carousel_wrap').each(function() {
+            var carousel_wrap = jQuery(this);
+            var carousel_controls_wrap = carousel_wrap.find('.carousel_controls');
+            var carousel_controls = carousel_controls_wrap.find('a[data-nr], button[data-nr]');
+
+            carousel_wrap.find('.jcarousel').jcarousel({
+                wrap: 'circular',
+                vertical: false,
+                scroll: 1,
+                buttonNextHTML: null,
+                buttonPrevHTML: null,
+                auto: 5,
+                itemVisibleInCallback: {
+                    onBeforeAnimation: function (carousel, item, idx, state) {
+                        var jitem = jQuery(item);
+                        carousel_controls.removeClass('active');
+                        jQuery(carousel_controls[jitem.attr('data-nr')]).addClass('active');
+                    }
+                },
+                initCallback: function(carousel) {
+                    carousel_controls_wrap.on('click', 'a[data-nr], button[data-nr]', function() {
+                        var link = jQuery(this);
+                        carousel.scroll(jQuery.jcarousel.intval(link.attr('data-nr')));
+                    });
+                }
+            });
+        });
+    });
+
+    jQuery(document.body).trigger('initcarousel');
+
+});
+

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

@@ -4,6 +4,7 @@ class CreateReleafRoles < ActiveRecord::Migration
       t.string  :name,        :null => false
       t.text    :permissions
       t.boolean :default,     :null => false, :default => false
+      t.text    :default_controller
 
       t.timestamps
     end

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

@@ -3,6 +3,7 @@ class CreateReleafTinymceAssets < ActiveRecord::Migration
     create_table :releaf_tinymce_assets do |t|
       t.string :file_uid
       t.string :file_name
+      t.string :file_type
 
       t.timestamps
     end

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

@@ -29,7 +29,7 @@ class AdminAbility
 
     if role.manage_translations_permission
       # Only manage is available for translation
-      can :manage, Translation
+      can :manage, I18n::Backend::Releaf::Translation
     end
 
     ## Example:

data/lib/i18n/backend/releaf.rb

@@ -40,7 +40,7 @@ module I18n
 
         # Lookup translation from database
         def lookup(locale, key, scope = [], options = {})
-          if scope.blank?
+          if scope.blank? && key !~ /\./
             scope = DEFAULT_SCOPE
           end
 
@@ -59,14 +59,15 @@ module I18n
             keys_to_check_for_other_locales.push check_key
 
             next if result.nil? # nothing in cache was found
-            return search_key.humanize if result == false # found nil translaiton in cache
+            return nil if result == false # found nil translaiton in cache
             return result unless result.blank? # found translation in cache
           end while chain.empty? == false
 
-          return search_key.humanize if Translation.where('releaf_translations.key IN (?)', keys_to_check_for_other_locales).exists?
+          return nil if I18N_CACHE.read [:missing, [locale, check_key]]
+          I18N_CACHE.write([:missing, [locale, check_key]], true) if Translation.where('releaf_translations.key IN (?)', keys_to_check_for_other_locales).exists?
 
           save_missing_translation(locale, key)
-          return search_key.humanize
+          return nil
         rescue ::ActiveRecord::StatementInvalid
           # is the translations table missing?
           nil

data/lib/i18n/backend/releaf/translation.rb

@@ -9,9 +9,14 @@ module I18n
 
         validates_presence_of :group_id, :key
         validates_uniqueness_of :key, :scope => :group_id
+
         belongs_to :translation_group, :foreign_key => :group_id
         has_many :translation_data, :dependent => :destroy, :class_name => 'Releaf::TranslationData'
 
+        attr_accessible \
+          :group_id,
+          :key
+
         scope :joined, select('releaf_translations.*, releaf_translation_data.lang as "lang", releaf_translation_data.localization as "localization", releaf_translation_groups.scope as "scope"').
           joins(:translation_data, :translation_group)
 

data/lib/i18n/backend/releaf/translation_data.rb

@@ -9,9 +9,16 @@ module I18n
 
         validates_presence_of :translation_id, :lang
         validates_uniqueness_of :translation_id, :scope => :lang
+
         belongs_to :translation
 
+        attr_accessible \
+          :lang,
+          :localization,
+          :translation_id
+
         scope :available_locales, where('lang IS NOT NULL').group(:lang).pluck(:lang)
+
         after_commit :reload_cache
 
         def text

data/lib/i18n/backend/releaf/translation_group.rb

@@ -10,6 +10,10 @@ module I18n
         validates_presence_of :scope
 
         has_many :translations, :dependent => :destroy, :foreign_key => :group_id, :order => 'releaf_translations.key'
+
+        attr_accessible \
+          :scope
+
         after_commit :reload_cache
 
         def to_s

data/lib/releaf.rb

@@ -1,5 +1,9 @@
 require "releaf/slug"
+require 'releaf/globalize3/fallbacks'
 require "releaf/engine"
+require "releaf/resources"
+require "releaf/boolean_at"
+
 
 module Releaf
   mattr_accessor :main_menu

data/lib/releaf/boolean_at.rb

@@ -0,0 +1,77 @@
+module Releaf
+  # Adds boolean_at class method, that can be used to create boolean setter and
+  # getter for DateTime, Date and Time fields. It will also create scopes for
+  # when given attribute is set and when it is not set.
+  module BooleanAt
+    module ClassMethods
+
+      # Create boolean setter and getter for given DateTime, Date and Time
+      # attributes.
+      #
+      # Setter will accept "0", 0, false as false, everything else will
+      # evaluate to true. Setter accepts TrueClass, FalseClass, String, Fixnum.
+      # If you pass nil, it not change current value.
+      #
+      # Getter returns true or false
+      #
+      # Unless you add <tt>:without_scopes => true</tt> as last argument, two scopes
+      # will be created. One to list all resources with given attribute set and
+      # one that does the opposite.
+      #
+      # For example, if you use
+      #
+      # @example
+      #   boolean_at :published_at
+      #
+      # it will create +published+, +published?+, +published=+ methods and
+      # +published+ and +unpublished+ scopes.
+      #
+      # @param args list of DateTime, Date and Time attributes that ends with
+      #   _at or _on for which you'd like to create boolean setter and getter
+      #   and scopes
+      def boolean_at *args
+        options = {}
+        options = args.pop if args.last.is_a? Hash
+
+        my_table_name = self.table_name
+
+        args.each do |name|
+          # raise ArgumentError, "column must be of type DateTime, Date or Time" unless [:datetime, :date, :time].include?(self.columns_hash[name.to_s].try(:type).try(:to_sym))
+          raise ArgumentError, "column name must end with _at or _on" unless name =~ /_(at|on)$/
+
+          fun_name = name.to_s.sub(/_(at|on)$/, '')
+
+          # create getter
+          define_method fun_name do
+            self.send(:"#{name}?")
+          end
+          alias_method :"#{fun_name}?", :"#{fun_name}"
+
+          # create setter
+          define_method :"#{fun_name}=" do |b|
+            return if b.nil?
+            raise ArgumentError unless b.is_a?(FalseClass) or b.is_a?(TrueClass) or b.is_a?(String) or b.is_a?(Fixnum)
+            if b == false or b == "0" or b == 0
+              self.send(:"#{name}=", nil)
+            else
+              self.send(:"#{name}=", Time.now)
+            end
+          end
+
+          unless options[:without_scopes]
+            # create scopes
+            self.class_eval do
+              scope   "#{fun_name}",  where("#{my_table_name}.#{name} IS NOT NULL")
+              scope "un#{fun_name}",  where("#{my_table_name}.#{name} IS NULL")
+            end
+          end
+        end
+
+      end
+    end
+
+    def self.included base
+      base.extend ClassMethods
+    end
+  end
+end

data/lib/releaf/globalize3/fallbacks.rb

@@ -0,0 +1,19 @@
+module Releaf
+  module Globalize3
+    module Fallbacks
+      def self.set
+        i18n_fallbacks = {}
+
+        I18n.default_locale ||= 'en'
+        I18n.locale ||= 'en'
+
+        valid_locales = Settings.i18n_locales || []
+
+        (valid_locales + [I18n.default_locale, I18n.locale]).uniq.each do |locale|
+          i18n_fallbacks[locale] = valid_locales - [locale]
+        end
+        Globalize.fallbacks = i18n_fallbacks
+      end
+    end
+  end
+end

data/lib/releaf/resources.rb

@@ -0,0 +1,101 @@
+require 'action_dispatch/routing/mapper'
+
+module ActionDispatch::Routing
+  class Mapper
+
+    def releaf_resources(*args, &block)
+      resources *args do
+        yield if block_given?
+
+        add_urls = true
+        add_confirm_destroy = true
+
+        if args.last.is_a? Hash
+          options = args.last
+          if options.has_key? :only
+            add_urls            = false unless options[:only].include? :urls
+            add_confirm_destroy = false unless options[:only].include? :destroy
+          end
+
+          if options.has_key? :except
+            add_urls            = false if options[:except].include? :urls
+            add_confirm_destroy = false if options[:except].include? :destroy
+          end
+        end
+
+        match :urls,            :on => :collection  if add_urls
+        get   :confirm_destroy, :on => :member      if add_confirm_destroy
+      end
+    end
+
+    def slugged_resources(*args, &block)
+      add_routes = {
+        :new      => true,
+        :create   => true,
+        :edit     => true,
+        :update   => true,
+        :show     => true,
+        :index    => true,
+        :destroy  => true
+      }
+
+      new_resources = args
+
+      if args.last.is_a? Hash
+
+        options = new_resources.pop
+
+        if options.has_key? :only
+          add_routes.each_key do |key|
+            add_routes[key] = false unless options[:only].include? key
+          end
+        end
+
+        if options.has_key? :except
+          add_routes.each_key do |key|
+            add_routes[key] = false if options[:only].include? key
+          end
+        end
+
+      end
+
+      new_resources.each do |resource_name|
+        res_name = resource_name.to_s
+        get     res_name,                  :to => "#{res_name}#index",       :as => res_name                          if add_routes[:index]
+        post    res_name,                  :to => "#{res_name}#create"                                                if add_routes[:create]
+        get     "#{res_name}/new",         :to => "#{res_name}#new",         :as => "new_#{res_name.singularize}"     if add_routes[:new]
+        yield if block_given?
+        get     "#{res_name}/*slug/edit",  :to => "#{res_name}#edit",        :as => "edit_#{res_name.singularize}"    if add_routes[:edit]
+        get     "#{res_name}/*slug",       :to => "#{res_name}#show",        :as => "show_#{res_name.singularize}"    if add_routes[:show]
+        put     "#{res_name}/*slug",       :to => "#{res_name}#update"                                                if add_routes[:update]
+        post    "#{res_name}/*slug",       :to => "#{res_name}#create"                                                if add_routes[:create]
+        delete  "#{res_name}/*slug",       :to => "#{res_name}#destroy"                                               if add_routes[:destroy]
+      end
+
+    end
+
+    def mount_releaf_at mount_location
+
+      post '/tinymce_assets' => 'releaf/tinymce_assets#create'
+
+      devise_for Releaf.devise_for, :path => mount_location, :controllers => { :sessions => "releaf/sessions" }
+
+      scope mount_location do
+        namespace :releaf, :path => nil do
+
+          releaf_resources :admins, :roles
+
+          releaf_resources :nodes, :controller => "content", :path => "content", :except => [:show], :path_names => { :edit => '' } do
+            get :generate_url, :on => :collection
+          end
+
+          releaf_resources :translation_groups, :controller => "translations", :path => "translations", :except => [:show], :path_names => { :edit => '' }
+
+          root :to => "content#index"
+        end
+      end
+    end
+
+
+  end # class Mapper
+end # module ActionDispatch::Routing

data/lib/releaf/slug.rb

@@ -1,79 +1,118 @@
 module Releaf
+  # Provides common methods for finding object by slug. Also overrides to_html
+  # method.
+  #
+  # Simply add this line to your models
+  #
+  #   include Releaf::Slug
+  #
+  # or
+  #
+  #    ActiveRecord::Base.send(:include, Releaf::Slug)
+  #
+  # to some initializer (<tt>config/initializers/releaf.rb</tt> for example).
+  # Then use find_object or find_object! instead of find
   module Slug
-    def self.included(base)
-      base.class_eval {
+    module ClassMethods
 
-        def self.find_object id_or_slug, scope=nil
-          raise ArgumentError unless id_or_slug.is_a?(String) or id_or_slug.is_a?(Fixnum)
+      # same as find_object, except that it will raise
+      # ActiveRecord::RecordNotFound error if no resource was found.
+      def find_object! id_or_slug, scope_name=nil, scope_args=nil
+        obj = find_object(id_or_slug, scope_name, scope_args)
+        raise ActiveRecord::RecordNotFound  unless obj
+        return obj
+      end
 
-          unless self.column_names.include?('slug')
-            if scope.blank?
-              return self.find(id_or_slug)
-            else
-              return self.send(scope).find(id_or_slug)
-            end
-          end
+      # Find object by slug or id.
+      #
+      # If id_or_slug looks like id, then tries to find by id first
+      # Otherwise it will search by slug field.
+      #
+      # If instance responds to children method, then it's possible to search
+      # for hierarchic resources
+      #
+      # @param id_or_slug either id of object to find (can be String or Fixnum)
+      #   or slug (string) slug, may contain slash ('/')
+      #
+      # @param scope_name optional scope_name to be used for searching. This is
+      #   especially useful when you are searching hierarchic resources. For
+      #   example you want to find 2nd level active resource.
+      #
+      # @param scope_args any arguments that are required for scope
+      #
+      # @return resource
+      def find_object id_or_slug, scope_name=nil, scope_args=nil
+        raise ArgumentError, "id_or_slug must be String or Fixnum" unless id_or_slug.is_a?(String) or id_or_slug.is_a?(Fixnum)
 
-          obj = nil
+        unless column_names.include?('slug')
+          return scoped_for_find_by_slug(self, scope_name, scope_args).find(id_or_slug)
+        end
 
-          # if it looks like id, search by id
-          if id_or_slug.to_s =~ /\A\d+\z/
-            if scope.blank?
-              obj = self.find_by_id(id_or_slug)
-            else
-              obj = self.send(scope).find_by_id(id_or_slug)
-            end
-          end
+        # if it looks like id, search by id first
+        if id_or_slug.to_s =~ /\A\d+\z/
+          obj = scoped_for_find_by_slug(self, scope_name, scope_args).find_by_id(id_or_slug)
+          return obj if obj
+        end
 
-          unless obj
-            unless self.column_names.include?('ancestry')
-              if scope.blank?
-                obj = self.find_by_slug(id_or_slug)
-              else
-                obj = self.send(scope).find_by_slug(id_or_slug)
-              end
-            else
-              slugs = id_or_slug.split('/')
-              if scope.blank?
-                obj = self.find_by_slug( slugs.shift )
-              else
-                obj = self.send(scope).find_by_slug( slugs.shift )
-              end
-              raise ActiveRecord::RecordNotFound unless obj
-              slugs.each do |slug_part|
-                if scope.blank?
-                  obj = obj.children.find_by_slug(slug_part)
-                else
-                  obj = obj.children.send(scope).find_by_slug(slug_part)
-                end
-                raise ActiveRecord::RecordNotFound unless obj
-              end
-            end
-          end
+        unless column_names.include?('ancestry') || self.new.respond_to?(:children)
+          return scoped_for_find_by_slug(self, scope_name, scope_args).find_by_slug(id_or_slug)
+        else
+          slugs = id_or_slug.split('/')
 
-          raise ActiveRecord::RecordNotFound unless obj
+          obj = scoped_for_find_by_slug(self, scope_name, scope_args).find_by_slug( slugs.shift )
+          return nil unless obj
+          slugs.each do |slug_part|
+            obj = scoped_for_find_by_slug(obj.children, scope_name, scope_args).find_by_slug( slug_part )
+            return nil unless obj
+          end
           return obj
         end
+      end
 
-        def to_param
-          return id unless self.class.column_names.include?('slug')
-          return id if self.slug.blank?
-          col_names = self.class.column_names
+      private
 
-          if col_names.include?('ancestry')
-            return path.pluck(:slug).join('/')
-          elsif col_names.include?('lft') && col_names.include?('rgt') && col_names.include?('parent_id') && self.class.respond_to?(:in_list?)
-            unless parent_id.blank?
-              return parent.to_param + '/' + slug
-            else
-              return slug
-            end
+      def scoped_for_find_by_slug obj, scope_name=nil, scope_args=nil
+        unless scope_name.blank?
+          if scope_args.nil?
+            obj.send(scope_name.to_sym)
           else
-            return slug
+            obj.send(scope_name.to_sym, *scope_args)
           end
+        else
+          obj
         end
-      }
+      end
 
     end
+
+
+    module InstanceMethods
+      # Ovverrides to_param method to prefer slug field over id (when
+      # possible).  It will also generate hearachical uri part if instance
+      # supports parrent method, or has ancestry column (ancestry gem
+      # {http://rubygems.org/gems/ancestry})
+      #
+      # @return String or Fixnum
+      def to_param
+        return id unless self.class.column_names.include?('slug')
+        return id if self.slug.blank?
+        col_names = self.class.column_names
+
+        if col_names.include?('ancestry')
+          return path.pluck(:slug).join('/')
+        elsif self.respond_to?(:parent) && parent
+          return parent.to_param + '/' + slug
+        else
+          return slug
+        end
+      end
+    end
+
+
+    def self.included base
+      base.extend ClassMethods
+      include InstanceMethods
+    end
+
   end
 end