releaf-core 0.2.1 → 1.0.3

data/app/lib/releaf/core/assets_resolver.rb

@@ -1,58 +0,0 @@
-module Releaf::Core
-  class AssetsResolver
-    NONCOMPILED_PATTERN = /app\/assets\/(javascripts|stylesheets)\/((releaf\/)?controllers\/(.*?))\..*/
-    COMPILED_PATTERN = /(releaf\/)?controllers\/(.*?)\.(js|css)$/
-
-    def self.base_assets
-      ["releaf/application"]
-    end
-
-    def self.controller_assets(controller, type)
-      base_assets + assets.fetch(controller, {}).fetch(type, [])
-    end
-
-    def self.noncompiled_assets
-      list = {}
-
-      Rails.application.assets.each_file do|file|
-        match = file.to_s.match(NONCOMPILED_PATTERN)
-        if match
-          controller = match[4]
-          asset_type = match[1].to_sym
-          list[controller] ||= {stylesheets: [], javascripts: []}
-          list[controller][asset_type] << match[2]
-        end
-      end
-
-      list
-    end
-
-    def self.compiled_assets
-      list = {}
-
-      Rails.application.assets_manifest.files.each_pair do|asset_path, asset|
-        match = asset["logical_path"].match(COMPILED_PATTERN)
-        if match
-          controller = match[2]
-          asset_type = match[3] == "css" ? :stylesheets : :javascripts
-          list[controller] ||= {stylesheets: [], javascripts: []}
-          list[controller][asset_type] << asset["logical_path"]
-        end
-      end
-
-      list
-    end
-
-    def self.compiled_assets?
-      Rails.application.assets.nil?
-    end
-
-    def self.assets
-      if compiled_assets?
-        @@compiled_assets ||= compiled_assets
-      else
-        noncompiled_assets
-      end
-    end
-  end
-end

data/app/lib/releaf/core/error_formatter.rb

@@ -1,103 +0,0 @@
-module Releaf::Core
-  class ErrorFormatter
-    attr_reader :errors
-
-    def self.format_errors(resource, field_name_prefix = "resource")
-      validator = new(resource, field_name_prefix)
-      validator.errors
-    end
-
-    def initialize(resource, field_name_prefix)
-      @resource = resource
-      @klass = @resource.class
-      @field_name_prefix = field_name_prefix
-      @errors = {}
-      @error_message_i18n_scope = "activerecord.errors.messages.#{@klass.name.underscore}"
-      format_errors
-    end
-
-    private
-
-    def format_errors
-      @resource.errors.each do |attribute, message|
-        if models_attribute? attribute
-          add_error attribute, message
-        else
-          process_nested_resource_errors attribute
-        end
-      end
-    end
-
-    def process_nested_resource_errors(attribute)
-      association_name = attribute.to_s.split('.', 2).first
-      if single_association? association_name
-        prefix_template = "#{@field_name_prefix}[#{association_name}_attributes]"
-        nested_resources = [@resource.send(association_name)]
-      else
-        prefix_template = "#{@field_name_prefix}[#{association_name}_attributes][%d]"
-        nested_resources = @resource.send(association_name)
-      end
-
-      nested_resources.each_with_index do |resource, i|
-        prefix = prefix_template % i
-        resource_errors = ErrorFormatter.format_errors(resource, prefix)
-        @errors.merge!(resource_errors)
-      end
-    end
-
-    def models_attribute?(attribute)
-      attribute !~ /\./
-    end
-
-    def add_error(attribute, message)
-      @errors[field_id(attribute)] ||= []
-      @errors[field_id(attribute)] << error_hash(attribute, message)
-    end
-
-    def error_hash(attribute, message)
-      h = {
-        error_code: message.error_code,
-        message: I18n.t(message, scope: @error_message_i18n_scope),
-        full_message: full_error_message(attribute, message)
-      }
-      h[:data] = message.data unless message.data.nil?
-      h
-    end
-
-    def full_error_message(attribute, message)
-      template = "%{class} with id %{id} has error \"#{message}\""
-      template += ' on attribute "%{attribute}"' unless attribute.to_sym == :base
-      options = {
-        default: template,
-        attribute: attribute,
-        class: @resource.class.name,
-        id: @resource.id ? @resource.id.to_s : 'null',
-        scope: @error_message_i18n_scope
-      }
-      I18n.t(template, options)
-    end
-
-    def field_id(attribute)
-      return @field_name_prefix if attribute.to_sym == :base
-      field = attribute
-      if association(attribute).present?
-        field = association(attribute).foreign_key.to_s
-      end
-
-      "#{@field_name_prefix}[#{field}]"
-    end
-
-    def single_association?(association_name)
-      [:belongs_to, :has_one].include? association_type(association_name)
-    end
-
-    def association_type(association_name)
-      association(association_name).macro
-    end
-
-    def association(association_name)
-      @klass.reflect_on_association(association_name.to_sym)
-    end
-
-  end
-end

data/app/lib/releaf/core/item_orderer.rb

@@ -1,102 +0,0 @@
-module Releaf::Core
-  # Utility class for array items reordering.
-  #
-  # There are 4 possible reordering options: <code>:first, :last, :before and :after</code>.
-  #
-  # All reorder methods are chainable, so:
-  #     Releaf::Core::ItemOrderer.new(:a, :b, :c, :d, :e, :f).reorder(:c, :last).reorder([:a, :b], after: :d).result
-  # will return
-  #     [:d, :a, :b, :e, :f, :c]
-  #
-  # For reordering with <code>`first`</code> and <code>`last`</code> options you must give this option as symbols.
-  # Example:
-  #    Releaf::Core::ItemOrderer.new(:a, :b, :c).reorder(:c, :first)
-  #
-  # For reorderind with <code>`before`</code> and <code>`after`</code> options you must give option together with target value as hash.
-  # Example:
-  #    Releaf::Core::ItemOrderer.new(:a, :b, :c).reorder(:a, after: :b)
-  class ItemOrderer
-
-    attr_accessor :list
-
-    def initialize(*args)
-      self.list = args
-    end
-
-    def result
-      list
-    end
-
-    def to_a
-      result
-    end
-
-    def reorder(values, options)
-      values = [values] unless values.is_a? Array
-      deleted_values = delete(values)
-      index = reorder_index(options)
-
-      values.reverse.each do|value|
-        list.insert(index, deleted_values[value])
-      end
-
-      self
-    end
-
-    def reorder_index(options)
-      if options == :first
-        index = 0
-      elsif options == :last
-        index = list.length
-      elsif options[:after]
-        index = index(options[:after]) + 1
-      elsif options[:before]
-        index = index(options[:before])
-      else
-        raise ArgumentError, "unknown reorder option"
-      end
-    end
-
-    def delete(values)
-      deleted = {}
-
-      values.each do|value|
-        index = index(value)
-        deleted[value] = list[index]
-        list.delete_at(index)
-      end
-
-      deleted
-    end
-
-    def index(value)
-      value = value.to_s
-      list.index do |existing_value|
-        if existing_value.is_a? Hash
-          existing_value.keys.first.to_s == value
-        else
-          existing_value.to_s == value
-        end
-      end
-    end
-
-    # Shortcut for creating new ItemOrderer class, ordering and result retrieving.
-    #
-    #    Releaf::Core::ItemOrderer.reorder([:a, :b, :c, :d, :e, :f], c: :last, [:a, :b] => {after: :d})
-    # is same as
-    #    Releaf::Core::ItemOrderer.new(:a, :b, :c, :d, :e, :f).reorder(:c, :last).reorder([:a, :b], after: :d).result
-    #
-    # @param list [Array] array to reorder
-    # @param options_list [Hash] hash with reorder options
-    # @return [Array] reordered array
-    def self.reorder(list, options_list)
-      orderer = new(*list)
-
-      options_list.each_pair do|values, options|
-        orderer.reorder(values, options)
-      end
-
-      orderer.result
-    end
-  end
-end

data/app/lib/releaf/core/resource_table_fields.rb

@@ -1,10 +0,0 @@
-class Releaf::Core::ResourceTableFields < Releaf::Core::ResourceFields
-
-  def excluded_attributes
-    super + table_excluded_attributes
-  end
-
-  def table_excluded_attributes
-    resource_class.column_names.select{|c| c.match(/.*_html$/) }
-  end
-end

data/app/lib/releaf/core/responders.rb

@@ -1,31 +0,0 @@
-module Releaf::Core::Responders
-
-  def respond_with(resource = nil, options = {}, &block)
-    options[:responder] = active_responder unless options.has_key? :responder
-    super
-  end
-
-  def action_responders
-    {
-      create: Releaf::Core::Responders::AfterSaveResponder,
-      update: Releaf::Core::Responders::AfterSaveResponder,
-      confirm_destroy: Releaf::Core::Responders::ConfirmDestroyResponder,
-      destroy: Releaf::Core::Responders::DestroyResponder,
-      access_denied: Releaf::Core::Responders::AccessDeniedResponder,
-      feature_disabled: Releaf::Core::Responders::FeatureDisabledResponder,
-      page_not_found: Releaf::Core::Responders::PageNotFoundResponder,
-    }
-  end
-
-  # Returns generic view name for given action
-  # @return String
-  def action_responder(_action_name)
-    action_responders[_action_name.to_sym]
-  end
-
-  # Returns generic view name for current action
-  # @return String
-  def active_responder
-    action_responder(action_name)
-  end
-end

data/app/lib/releaf/core/template_field_type_mapper.rb

@@ -1,127 +0,0 @@
-module Releaf::Core
-  module TemplateFieldTypeMapper
-
-    # Helps to determinate which template to render in :edit feature
-    # for given objects attribute.
-    #
-    # @return field_type
-    #
-    # where field_type is a string representing field type
-    # and use_i18n is a `true` or `false`. If use_i18n is true, then template
-    # with localization features should be used (if exists)
-    #
-    # This helper is used by views.
-    #
-    # @todo document rendering conventions
-    def self.field_type_name obj, attribute_name
-      field_type = nil
-      column_type = nil
-
-      if use_i18n?(obj, attribute_name)
-        begin
-          column_type = obj.class::Translation.columns_hash[attribute_name.to_s].try(:type)
-        rescue
-        end
-      else
-        column_type = obj.class.columns_hash[attribute_name.to_s].try(:type)
-      end
-
-      column_type ||= 'string'
-
-      if respond_to?("field_type_name_for_#{column_type}")
-        field_type = send("field_type_name_for_#{column_type}", attribute_name, obj)
-      end
-
-      return field_type || 'text'
-    end
-
-    # should localized template be preffered?
-    def self.use_i18n? obj, attribute_name
-      return false unless obj.class.respond_to? :translates?
-      return false unless obj.class.translates?
-      return obj.class.translated_attribute_names.include?(attribute_name.to_sym)
-    end
-
-    protected
-
-    def self.image_or_error attribute_name, obj
-      field_type_or_error 'image', attribute_name, obj
-    end
-
-    def self.file_or_error attribute_name, obj
-      field_type_or_error 'file', attribute_name, obj
-    end
-
-    def self.field_type_or_error type, attribute_name, obj
-      raise ArgumentError, 'attribute_name must end with _uid' unless attribute_name =~ /_uid$/
-      file_method_name = attribute_name.to_s.sub(/_uid$/, '')
-      if obj.respond_to? file_method_name
-        return type
-      else
-        raise "object doesn't respond to `#{file_method_name}` method. Did you forgot to add `#{type}_accessor :#{file_method_name}` to `#{obj.class.name}` model?"
-      end
-    end
-
-    def self.field_type_name_for_string attribute_name, obj
-      case attribute_name.to_s
-      when /(thumbnail|image|photo(graphy)?|picture|avatar|logo|banner|icon)_uid$/
-        return image_or_error attribute_name, obj
-
-      when /_uid$/
-        return file_or_error attribute_name, obj
-
-      when /password/, 'pin'
-        return 'password'
-
-      when /_email$/, 'email'
-        return 'email'
-
-      when /_link$/, 'link'
-        return 'link'
-
-      else
-        return 'text'
-      end
-    end
-
-    def self.field_type_name_for_text attribute_name, obj
-      case attribute_name.to_s
-      when /_(url|homepage|link)$/, 'homepage', 'url'
-        'link'
-      when /_html$/, 'html'
-        'richtext'
-      else
-        'textarea'
-      end
-    end
-
-    def self.field_type_name_for_datetime attribute_name, obj
-      'datetime'
-    end
-
-    def self.field_type_name_for_date attribute_name, obj
-      'date'
-    end
-
-    def self.field_type_name_for_time attribute_name, obj
-      'time'
-    end
-
-    def self.field_type_name_for_float attribute_name, obj
-      'float'
-    end
-
-    def self.field_type_name_for_decimal attribute_name, obj
-      'decimal'
-    end
-
-    def self.field_type_name_for_integer attribute_name, obj
-      return 'item' if attribute_name.to_s =~ /_id$/ && obj.class.reflect_on_association(attribute_name[0..-4].to_sym)
-      return 'integer'
-    end
-
-    def self.field_type_name_for_boolean attribute_name, obj
-      return 'boolean'
-    end
-  end
-end

data/lib/releaf/core/builders_autoload.rb

@@ -1,27 +0,0 @@
-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/configuration.rb

@@ -1,101 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

data/lib/releaf/core/settings_ui_component.rb

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

data/releaf-core.gemspec

@@ -1,35 +0,0 @@
-require File.expand_path('../lib/releaf/version', __FILE__)
-
-Gem::Specification.new do |s|
-  s.name        = "releaf-core"
-  s.version     = Releaf::VERSION
-
-  s.summary     = "core gem for releaf"
-  s.description = "Admin interface for RubyOnRails projects inspired by Leaf CMS"
-  s.authors     = ["CubeSystems"]
-  s.email       = 'info@cubesystems.lv'
-  s.homepage    = 'https://github.com/cubesystems/releaf'
-
-  s.files             = `git ls-files`.split("\n")
-  s.test_files = Dir["spec/**/*"]
-
-  s.add_dependency 'rails', '~> 4.2', '>= 4.2.0'
-  s.add_dependency 'i18n', '~> 0.7', '>= 0.7.0'
-  s.add_dependency 'sprockets-rails', '~> 3.0', '>= 3.0.0'
-  s.add_dependency 'sass-rails'
-  s.add_dependency 'jquery-rails'
-  s.add_dependency 'jquery-ui-rails'
-  s.add_dependency 'railties'
-  s.add_dependency 'haml-rails'
-  s.add_dependency 'dragonfly'
-  s.add_dependency 'rails-settings-cached', '>= 0.4.5'
-  s.add_dependency 'ckeditor_rails'
-  s.add_dependency 'acts_as_list'
-  s.add_dependency 'will_paginate'
-  s.add_dependency 'font-awesome-rails'
-  s.add_dependency 'jquery-cookie-rails'
-  s.add_dependency 'globalize-accessors'
-  s.add_dependency 'rack-cache'
-
-  s.required_ruby_version = '>= 2.2.0'
-end