releaf 0.1.2 → 1.0.2

data/app/helpers/releaf/application_helper.rb

@@ -1,4 +0,0 @@
-module Releaf
-  module ApplicationHelper
-  end
-end

data/app/helpers/releaf/pagination_renderer.rb

@@ -1,44 +0,0 @@
-module Releaf
-  module PaginationRenderer
-    # This class does the heavy lifting of actually building the pagination
-    # links. It is used by +will_paginate+ helper internally.
-
-    # This is used in admin/base/_index.footer view
-
-    class LinkRenderer < WillPaginate::ActionView::LinkRenderer
-
-      protected
-
-      def page_number(page)
-        unless page == current_page
-          link(page, page, :rel => rel_value(page), :class => 'button')
-        else
-          tag(:em, "<span>#{page}</span>", :class => 'current active button')
-        end
-      end
-
-      def gap
-        text = '&hellip;'
-        %(<span class="gap button disabled">#{text}</span>)
-      end
-
-      def previous_or_next_page(page, text, classname)
-        if page
-          link(text, page, :class => classname + ' button')
-        else
-          tag(:span, "<span>#{text}</span>", :class => classname + ' button disabled')
-        end
-      end
-
-      def link(text, target, attributes = {})
-        if target.is_a? Fixnum
-          attributes[:rel] = rel_value(target)
-          target = url(target)
-        end
-        attributes[:href] = target
-        tag(:a, "<span>#{text}</span>", attributes)
-      end
-
-    end
-  end
-end

data/app/helpers/releaf/releaf_devise_helper.rb

@@ -1,8 +0,0 @@
-module Releaf
-  module ReleafDeviseHelper
-    # FIXME need better name
-    def self.devise_admin_model_name
-      Releaf.devise_for.underscore.tr('/', '_')
-    end
-  end
-end

data/app/models/releaf/admin.rb

@@ -1,60 +0,0 @@
-module Releaf
-  class Admin < ActiveRecord::Base
-    self.table_name = 'releaf_admins'
-
-    # Include default devise modules. Others available are:
-    # :token_authenticatable, :confirmable,
-    # :lockable, :timeoutable and :omniauthable
-    # :registerable
-    devise :database_authenticatable, :recoverable, :rememberable, :trackable, :validatable
-
-    validates_presence_of :name, :surname, :role_id, :email
-    validates_uniqueness_of :email, :case_sensitive => false
-    belongs_to :role
-
-    image_accessor :avatar
-
-    attr_accessible \
-      :avater,
-      :name,
-      :surname,
-      :role_id,
-      :email,
-      :password,
-      :password_confirmation
-
-    scope :filter, lambda {|params|
-        fields = []
-        values = {}
-
-        if !params.empty?
-          if !params[:search].blank?
-            params[:search].strip.split(" ").each_with_index do|word, i|
-              fields << "email LIKE :email#{i}"
-              values["email#{i}".to_sym] = '%' + word + '%'
-            end
-          end
-        end
-
-        if !fields.empty?
-          where(fields.join(' AND '), values)
-        end
-    }
-
-    def display_name
-      [self.name, self.surname].join(' ')
-    end
-    alias :to_text :display_name
-
-    def role
-      super || Role.default
-    end
-
-    protected
-
-    def password_required?
-      self.new_record? || self.encrypted_password.blank?
-    end
-
-  end
-end

data/app/models/releaf/blank_node_base.rb

@@ -1,29 +0,0 @@
-module Releaf
-  class BlankNodeBase
-    # returns only bottom level, not /^Releaf::/ subclasses
-    def self.node_classes
-      return _node_classes(self).reject { |n| n.name =~ /^Releaf::/ }
-    end
-
-    def self.releaf_fields_to_display action
-      []
-    end
-
-    def self.node_type
-      "Releaf::BlankNodeBase"
-    end
-
-    private
-
-    def self._node_classes(klass)
-      classes = [klass]
-
-      klass.subclasses.each do |sublcass|
-        classes += _node_classes(sublcass)
-      end
-
-      return classes
-    end
-
-  end
-end

data/app/models/releaf/node.rb

@@ -1,222 +0,0 @@
-module Releaf
-  class Node < ActiveRecord::Base
-    COMMON_FIELD_NAME_PREFIX = 'data_'
-
-    acts_as_nested_set
-    acts_as_list :scope => :parent_id
-    include Slug
-    self.table_name = 'releaf_nodes'
-
-    serialize :data, Hash
-    default_scope :order => 'position'
-
-    validates_presence_of :name, :slug, :content_type
-    validates_uniqueness_of :slug, :scope => :parent_id
-
-    alias_attribute :to_text, :name
-
-    belongs_to :content, :polymorphic => true, :dependent => :destroy
-    accepts_nested_attributes_for :content
-
-    # FIXME get rid of attr_protected
-    attr_protected :none
-
-    acts_as_url :name, :url_attribute => :slug, :scope => :parent_id #, :only_when_blank => true, :limit => 255
-
-    def content_object
-      self.content
-    end
-
-    def content_object_attributes=(new_attr)
-      if self.content
-        self.content.update_attributes(new_attr)
-      else
-        nc = new_content(new_attr)
-        nc.save
-
-        self.content = nc
-        self.update_attribute(:content_id, nc.id)
-      end
-    end
-
-    ##
-    # Return node public url
-
-    def url
-      if parent_id
-        url = parent.url + "/" + slug.to_s
-      else
-        url = "/" + slug.to_s
-      end
-
-      url
-    end
-
-    ##
-    # Return node content object public controller
-
-    def controller
-      raise "Missing content object" if content_type.blank?
-      return "#{content_type.classify.pluralize}Controller".constantize
-    end
-
-    def self.get_object_from_path path, params = {}
-      raise ArgumentError, 'path must be String or Array' unless path.is_a?(String) || path.is_a?(Array)
-      node = nil
-      parent_node = nil
-
-      if path.is_a? String
-        path = path.split('?').first.split("/").reject(&:empty?)
-      end
-
-      unless params[:locale].nil?
-        parent_node = Node.roots.find_by_slug(params[:locale])
-      end
-
-      path.each do |part|
-        node = Node.where(:parent_id => (parent_node ? parent_node.id : nil), :slug => part).first
-        if node
-          parent_node = node
-        else
-          unless params[:strict].blank?
-            node = nil
-          else
-            node = parent_node
-          end
-          break
-        end
-      end
-
-      unless params[:controller].nil?
-        if params[:controller] != node.controller.to_s
-          node = nil
-        end
-      end
-
-      node
-    end
-
-    def to_s
-      name
-    end
-
-    def method_missing(method, *args, &block)
-      if self.class.column_names.include?('data')
-        case method.to_s
-        when /^(#{COMMON_FIELD_NAME_PREFIX}(.+))=$/ then
-          if common_field_names.include? $1
-            return common_field_setter($2, args[0])
-          end
-        when /^(#{COMMON_FIELD_NAME_PREFIX}(.+))$/ then
-          if common_field_names.include? $1
-            return common_field_getter($2)
-          end
-        end
-      end
-
-      return super(method, *args, &block)
-    end
-
-    def respond_to? method_id, include_private = false
-      # this is needed for mass asignment (update_attributes) to work with common_fields
-      rt = super(method_id, include_private)
-      return true if rt
-      return common_field_names.include?(method_id.to_s.sub(/=$/, ''))
-    end
-
-    def common_fields_schema
-      @_common_fields_schema ||= common_fields_schema_for_instance
-    end
-
-    def common_field_names
-      @_common_field_names ||= common_fields_schema.map { |f| "#{COMMON_FIELD_NAME_PREFIX}#{f['field_name']}" }
-    end
-
-    def common_field_field_type(field_name)
-      common_field_options(field_name.sub(/^#{COMMON_FIELD_NAME_PREFIX}/, ''))['field_type']
-    end
-
-    def self.load_common_fields_schema
-
-      common_fields_schema_file = Rails.root.to_s+ '/config/common_fields.yml'
-      cfschema = if File.exists?(common_fields_schema_file)
-        YAML::load_file(common_fields_schema_file)
-      else
-        []
-      end
-
-      raise "common_fields common_fields_schema is not an array" unless cfschema.is_a? Array
-      cfschema.each_with_index do |field,i|
-        raise "common_fields common_fields_schema contains non-hash element in root node"       unless field.is_a? Hash
-        raise "field_name not defined for field ##{i}"                            unless field.has_key?('field_name')
-        raise "field_name must be string"                                         unless field['field_name'].is_a? String
-        raise "field_type not defined for #{field['field_type']} field"           unless field.has_key?('field_type')
-        raise "apply_to not defined for #{field['apply_to']} field"               unless field.has_key?('apply_to')
-      end
-      return cfschema
-    end
-
-    private
-
-    def common_fields_schema_for_instance
-
-      full_schema =if defined?(COMMON_FIELDS_SCHEMA)
-                     COMMON_FIELDS_SCHEMA.dup
-                   else
-                     self.class.load_common_fields_schema.dup
-                   end
-
-      full_schema.delete_if do |field|
-        keep = false
-
-        if field['apply_to'].is_a?(String) && (field['apply_to'] == '*' || field['apply_to'] == self.content_type)
-          keep = true
-        elsif field['apply_to'].is_a?(Array) && field['apply_to'].include?(self.content_type)
-          keep = true
-        else
-          keep = false
-        end
-
-        if keep == true && field.has_key?('deny_for')
-          if field['deny_for'].is_a?(String) && (field['deny_for'] == '*' || field['deny_for'] == self.content_type)
-            keep = false
-          elsif field['deny_for'].is_a?(Array) && field['deny_for'].include?(self.content_type)
-            keep = false
-          end
-        end
-
-        if keep == true && field.has_key?('levels')
-          keep = false unless field['levels'].include? level
-        end
-
-        !keep
-      end
-
-      return full_schema
-    end
-
-    def common_field_setter(key, value)
-      self.data[key] = value
-    end
-
-    def common_field_getter(key)
-      self.data.has_key?(key) ? self.data[key] : common_field_default_value(key)
-    end
-
-    def common_field_options(key)
-      common_fields_schema.each do |field|
-        return field if field['field_name'] == key
-      end
-    end
-
-    def common_field_default_value(key)
-      common_field_options(key)['default']
-    end
-
-    def new_content(attr)
-      raise RuntimeError, 'content_type must be set' unless content_type
-      self.content_type.constantize.new(attr)
-    end
-
-  end
-end

data/app/models/releaf/node_base.rb

@@ -1,31 +0,0 @@
-module Releaf
-  class NodeBase < ActiveRecord::Base
-    self.abstract_class = true
-
-    # returns only bottom level, not /^Releaf::/ subclasses
-    def self.node_classes
-      return _node_classes(self).reject { |n| n.name =~ /^Releaf::/ }
-    end
-
-    def self.releaf_fields_to_display action
-      column_names - %w[id created_at updated_at position]
-    end
-
-    def self.node_type
-      "Releaf::NodeBase"
-    end
-
-    private
-
-    def self._node_classes(klass)
-      classes = [klass]
-
-      klass.subclasses.each do |sublcass|
-        classes += _node_classes(sublcass)
-      end
-
-      return classes
-    end
-
-  end
-end

data/app/models/releaf/role.rb

@@ -1,126 +0,0 @@
-module Releaf
-  class Role < ActiveRecord::Base
-    self.table_name = 'releaf_roles'
-
-    validates_presence_of :name
-    validates_uniqueness_of :name, :case_sensitive => false
-
-    has_many :admins
-
-    before_save :update_permissions
-    after_save :update_default_role
-
-    attr_accessible \
-      :name,
-      :default,
-      :default_controller
-
-    alias_attribute :to_text, :name
-
-    ::AdminAbility::PERMISSIONS.each do |perms|
-      if perms.is_a? Array
-        attr_accessible :"#{perms[0]}_permissions"
-        define_method :"#{perms[0]}_permissions=" do |p|
-          return if p.nil?
-          raise ArgumentError, "permission must be one of: #{perms[1].join(', ')}" unless perms[1].include? p.to_s
-          self.instance_variable_set "@#{perms[0]}_permissions", p.to_s
-        end
-
-        define_method "#{perms[0]}_permissions" do
-          iv = self.instance_variable_get "@#{perms[0]}_permissions"
-          return iv unless iv.nil?
-          perms[1].each do |perm|
-            xperm = [perms[0], perm].join('__')
-            return perm if permissions.include? xperm
-          end
-          return perms[1].first
-        end
-        alias_method "#{perms[0]}_permissions?", "#{perms[0]}_permissions"
-
-      elsif perms.is_a? String
-        attr_accessible :"#{perms}_permission"
-        define_method "#{perms}_permission=" do |p|
-          return if p.nil?
-
-          raise ArgumentError, "permission must be one of: true, false, '0', '1'" unless [true, false, '0', '1'].include? p
-          self.instance_variable_set "@#{perms}_permission", (p == true || p == '1')
-        end
-
-        define_method "#{perms}_permission" do
-          iv = self.instance_variable_get "@#{perms}_permission"
-          return (iv == '1' || iv == true) unless iv.nil?
-          permissions.include? perms
-        end
-        alias_method "#{perms}_permission?", "#{perms}_permission"
-      end
-    end
-
-    scope :order_by, lambda { |field=:name| order(field) }
-
-    def self.default
-      Role.find_by_default(true)
-    end
-
-    def default
-      return true if @set_default
-      self.default?
-    end
-
-    def default=(is_default=true)
-      return unless is_default == true or is_default == '1'
-      @set_default = true
-    end
-
-    def destroy
-      if (self.default? == false) && (!self.permissions.include?('admin') || (self.permissions.include?('admin') && Role.admin_roles_count > 1))
-        super
-      end
-    end
-
-    def self.admin_roles_count
-      Role.where('permissions LIKE "%\n- admin\n%"').count
-    end
-
-    protected
-
-    def permissions
-      perm = read_attribute :permissions
-      return YAML::load(perm) if perm
-      return []
-    end
-
-    def permissions=(perm=[])
-      raise ArgumentError unless perm.is_a? Array
-      new_perm = perm.clone
-      new_perm.delete_if { |p| p.blank? }
-      write_attribute :permissions, YAML::dump(new_perm)
-    end
-
-    private
-
-    def update_default_role
-      if @set_default && self.id
-        Role.update_all 'releaf_roles.default = false', ['releaf_roles.id <> ?', self.id]
-        Role.update_all 'releaf_roles.default = true', ['releaf_roles.id = ?', self.id]
-        @set_default = false
-        self.reload
-      end
-    end
-
-    def update_permissions
-      my_permissions = []
-      AdminAbility::PERMISSIONS.each do |perms|
-        p = nil
-        if perms.is_a? Array
-          p = [perms[0], self.send(:"#{perms[0]}_permissions")].join('__')
-          p = nil if p == [perms[0], perms[1].first].join('__')
-        elsif perms.is_a? String
-          p = perms if self.send(:"#{perms}_permission")
-        end
-        my_permissions.push p if p.blank? == false
-      end
-      self.permissions = my_permissions
-    end
-
-  end
-end