releaf-core 0.2.1 → 1.0.3

data/app/builders/releaf/builders/orderer.rb

@@ -1,5 +0,0 @@
-module Releaf::Builders::Orderer
-  def orderer(items)
-    Releaf::Core::ItemOrderer.new(*items.to_a)
-  end
-end

data/app/builders/releaf/builders/tags/releaf_associated_set_field.rb

@@ -1,40 +0,0 @@
-module Releaf::Tags
-  module AssociatedSetField
-    def releaf_associated_set_field(name, input: {}, label: {}, field: {}, options: {}, &block)
-      options = {field: {type: "associated-set"}}.deep_merge(options)
-      content = releaf_associated_set_content(name, input: input, options: options)
-      input_wrapper_with_label(name, content, label: label, field: field, options: options, &block)
-    end
-
-    def releaf_associated_set_content(name, input: {}, options: {})
-      association_options = options[:association]
-      association = object.send(name)
-      key_field = association_options[:field]
-
-      list = []
-
-      association_options[:items].each_pair do|value, label_text|
-        item = association.find_by(key_field => value) || association.build(key_field => value)
-
-        list << fields_for(name, item, relation_name: name, builder: self.class) do |builder|
-          builder.releaf_associated_set_item(association_options, label_text)
-        end
-      end
-
-      safe_join do
-        list
-      end
-    end
-
-
-    def releaf_associated_set_item(association_options, label_text)
-      wrapper(class: "type-associated-set-item") do
-        [hidden_field(:_destroy, value: object.new_record?, class: "destroy"),
-         check_box(association_options[:field], {class: "keep", name: "keep"}, (object.send(association_options[:field]) if object.persisted?)),
-         label(association_options[:field], label_text),
-         hidden_field(association_options[:field])
-        ]
-      end
-    end
-  end
-end

data/app/builders/releaf/core/settings/form_builder.rb

@@ -1,21 +0,0 @@
-module Releaf::Core::Settings
-  class FormBuilder < Releaf::Builders::FormBuilder
-    def field_names
-      [:value]
-    end
-
-    def render_value
-      method_name = "releaf_#{settings_field_type}_field"
-      send(method_name, :value, options: { label: { label_text: settings_field_label_text }})
-    end
-
-    def settings_field_label_text
-      label_text = Releaf::Settings.registry[object.var][:description]
-      label_text.present? ? t(label_text, scope: "settings") : "Value"
-    end
-
-    def settings_field_type
-      Releaf::Settings.registry[object.var].fetch(:type, :text)
-    end
-  end
-end

data/app/builders/releaf/core/settings/table_builder.rb

@@ -1,11 +0,0 @@
-module Releaf::Core::Settings
-  class TableBuilder < Releaf::Builders::TableBuilder
-    def column_names
-      [:var, :value, :updated_at]
-    end
-
-    def value_content(resource)
-      resource.value.to_s
-    end
-  end
-end

data/app/controllers/concerns/releaf/breadcrumbs.rb

@@ -1,42 +0,0 @@
-module Releaf
-  module Breadcrumbs
-    extend ActiveSupport::Concern
-
-    included do
-      before_filter :build_breadcrumbs
-    end
-
-    def build_breadcrumbs
-      @breadcrumbs = [home_breadcrumb, controller_breadcrumb].compact
-    end
-
-    def home_breadcrumb
-       { name: I18n.t('Home', scope: 'admin.breadcrumbs'), url: releaf_root_path }
-    end
-
-    def controller_breadcrumb
-      controller_params = Releaf.application.config.controllers[self.class.name.sub(/Controller$/, '').underscore]
-      if controller_params
-        {
-          name: I18n.t(controller_params[:name], scope: "admin.controllers"),
-          url: send("#{controller_params[:url_helper]}_path")
-        }
-      end
-    end
-
-    def add_resource_breadcrumb resource, url = nil
-      if resource.new_record?
-        name=  I18n.t('New record', scope: 'admin.breadcrumbs')
-        url = url_for(action: :new, only_path: true) if url.nil?
-      else
-        if resource.respond_to?(:to_text)
-          name = resource.send(:to_text)
-        else
-          name = I18n.t('Edit record', scope: 'admin.breadcrumbs')
-        end
-        url = url_for(action: :edit, id: resource.id, only_path: true) if url.nil?
-      end
-      @breadcrumbs << { name: name, url: url }
-    end
-  end
-end

data/app/controllers/releaf/base_controller.rb

@@ -1,458 +0,0 @@
-module Releaf
-  class FeatureDisabled < StandardError; end
-
-  class BaseController < ActionController::Base
-    respond_to :html
-    respond_to :json, only: [:create, :update]
-    protect_from_forgery
-    include Releaf.application.config.access_control_module
-    include Releaf::Breadcrumbs
-    include Releaf::RichtextAttachments
-    include Releaf::Core::Responders
-
-    before_filter :manage_ajax, :setup, :verify_feature_availability!
-
-    rescue_from Releaf::Core::AccessDenied, with: :access_denied
-    rescue_from Releaf::FeatureDisabled, with: :feature_disabled
-
-    layout :layout
-
-    helper_method \
-      :form_options,
-      :table_options,
-      :ajax?,
-      :controller_scope_name,
-      :current_url,
-      :active_view,
-      :index_url,
-      :page_title,
-      :resource_class,
-      :feature_available?,
-      :builder_class,
-      :searchable_fields
-
-    def search(text)
-      return if text.blank?
-      return if searchable_fields.blank?
-      @collection = searcher_class.prepare(relation: @collection, fields: searchable_fields, text: text)
-    end
-
-    def searcher_class
-      Releaf::Core::Search
-    end
-
-    def index
-      prepare_index
-      respond_with(@collection)
-    end
-
-    def new
-      prepare_new
-      respond_with(@resource)
-    end
-
-    def show
-      if feature_available?(:show)
-        prepare_show
-      else
-        redirect_to url_for(action: 'edit', id: params[:id])
-      end
-    end
-
-    def edit
-      prepare_edit
-      respond_with(@resource)
-    end
-
-    def create
-      prepare_create
-      @resource.save
-      respond_with(@resource, location: (success_url if @resource.persisted?), redirect: true)
-    end
-
-    def update
-      prepare_update
-      @resource.update_attributes(resource_params)
-      respond_with(@resource, location: success_url)
-    end
-
-    def confirm_destroy
-      prepare_destroy
-      @restricted_relations = Releaf::Core::ResourceUtilities.restricted_relations(@resource)
-      respond_with(@resource, destroyable: destroyable?)
-    end
-
-    def toolbox
-      prepare_toolbox
-      respond_with(@resource)
-    end
-
-    def destroy
-      prepare_destroy
-      @resource.destroy if destroyable?
-      respond_with(@resource, location: index_url)
-    end
-
-    # Check if @resource has existing restrict relation and it can be deleted
-    #
-    # @return boolean true or false
-    def destroyable?
-      Releaf::Core::ResourceUtilities.destroyable?(@resource)
-    end
-
-    # Helper methods ##############################################################################
-
-    # Returns current url without internal params
-    #
-    # @return String
-    def current_url
-      @current_url ||= [request.path, (request.query_parameters.to_query if request.query_parameters.present?)].compact.join("?")
-    end
-
-    # Returns index url for current request
-    #
-    # @return String
-    def index_url
-      if @index_url.nil?
-        # use current url
-        if action_name == "index"
-          @index_url = current_url
-        # use from get params
-        elsif params[:index_url].present?
-          @index_url = params[:index_url]
-        # fallback to index view
-        else
-          @index_url = url_for(action: 'index')
-        end
-      end
-
-      @index_url
-    end
-
-    # Tries to return resource class.
-    #
-    # If it fails to return proper resource class for your controller, or your
-    # controllers name has no relation to resource class name, then simply
-    # override this method to return class that you want.
-    #
-    # @return class
-    def self.resource_class
-      self.name.split('::', 2).last.sub(/Controller$/, '').classify.constantize
-    end
-
-    # Tries to return resource class.
-    #
-    # If it fails to return proper resource class for your controller, or your
-    # controllers name has no relation to resource class name, then simply
-    # override this method to return class that you want.
-    #
-    # @return class
-    def resource_class
-      @resource_class ||= self.class.resource_class
-    end
-
-    # Returns action > view translation hash
-    # @return Hash
-    def action_views
-      {
-        new: :edit,
-        update: :edit,
-        create: :edit,
-      }
-    end
-
-    # Returns generic view name for given action
-    # @return String
-    def action_view(_action_name)
-      action_views[_action_name.to_sym] || _action_name
-    end
-
-    # Returns generic view name for current action
-    # @return String
-    def active_view
-      action_view(action_name)
-    end
-
-    def form_url(form_type, object)
-      url_for(action: object.new_record? ? 'create' : 'update', id: object.id)
-    end
-
-    def form_attributes(form_type, object, object_name)
-      action = object.respond_to?(:persisted?) && object.persisted? ? :edit : :new
-      action_object_name = "#{action}-#{object_name}"
-      classes = [ action_object_name ]
-      classes << "has-error" if object.errors.any?
-      {
-        multipart: true,
-        id: action_object_name,
-        class: classes,
-        data: {
-          "remote" => true,
-          "remote-validation" => true,
-          "type" => :json,
-        },
-        novalidate: ''
-      }
-    end
-
-
-
-    def builder_class(builder_type)
-      Releaf::Builders.builder_class(builder_scopes, builder_type)
-    end
-
-    def application_builder_scope
-      [application_scope, "Builders"].reject(&:blank?).join("::")
-    end
-
-    def application_scope
-      scope = Releaf.application.config.mount_location.capitalize
-      scope if scope.present? && Releaf::Builders.constant_defined_at_scope?(scope, Object)
-    end
-
-    def builder_scopes
-      [self.class.name.gsub(/Controller$/, ""), application_builder_scope]
-    end
-
-    def form_options(form_type, object, object_name)
-      {
-        builder: builder_class(:form),
-        as: object_name,
-        url: form_url(form_type, object),
-        html: form_attributes(form_type, object, object_name)
-      }
-    end
-
-    def table_options
-      {
-        builder: builder_class(:table),
-        toolbox: feature_available?(:toolbox)
-      }
-    end
-
-    # return contoller translation scope name for using
-    # with I18.translation call within hash params
-    # ex. t("save", scope: controller_scope_name)
-    def controller_scope_name
-      @controller_scope_name ||= 'admin.' + self.class.name.sub(/Controller$/, '').underscore.gsub('/', '_')
-    end
-
-    def feature_available? feature
-      @features[feature].present?
-    end
-
-    def page_title
-      I18n.t(params[:controller], scope: "admin.controllers") + " - " + Rails.application.class.parent_name
-    end
-
-    def render_notification(status, success_message_key: "#{params[:action]} succeeded", failure_message_key: "#{params[:action]} failed", now: false)
-      if now == true
-        flash_target = flash.now
-      else
-        flash_target = flash
-      end
-
-      if status
-        flash_target["success"] = { "id" => "resource_status", "message" => I18n.t(success_message_key, scope: notice_scope_name) }
-      else
-        flash_target["error"] = { "id" => "resource_status", "message" => I18n.t(failure_message_key, scope: notice_scope_name) }
-      end
-    end
-
-    def prepare_index
-      # load resource only if they are not loaded yet
-      @collection = resources unless collection_given?
-
-      search(params[:search])
-
-      unless @resources_per_page.nil?
-        @collection = @collection.page( params[:page] ).per_page( @resources_per_page )
-      end
-    end
-
-    def prepare_new
-      # load resource only if is not initialized yet
-      new_resource unless resource_given?
-      add_resource_breadcrumb(@resource)
-    end
-
-    def prepare_create
-      # load resource only if is not initialized yet
-      new_resource unless resource_given?
-      @resource.assign_attributes(resource_params)
-    end
-
-    def prepare_show
-      prepare_resource_view
-    end
-
-    def prepare_edit
-      prepare_resource_view
-    end
-
-    def prepare_resource_view
-      # load resource only if is not loaded yet
-      load_resource unless resource_given?
-      add_resource_breadcrumb(@resource)
-    end
-
-    def prepare_update
-      # load resource only if is not loaded yet
-      load_resource unless resource_given?
-    end
-
-    def prepare_destroy
-      load_resource
-    end
-
-    def prepare_toolbox
-      load_resource
-    end
-
-    def new_resource
-      @resource = resource_class.new
-    end
-
-    def load_resource
-      @resource = resource_class.find(params[:id])
-    end
-
-    def verify_feature_availability!
-      feature = action_feature(params[:action])
-      raise FeatureDisabled, feature.to_s if (feature.present? && !feature_available?(feature))
-    end
-
-    def action_feature action
-      action_features[action]
-    end
-
-    def action_features
-      {
-        index: :index,
-        new: :create,
-        create: :create,
-        show: (feature_available?(:show) ? :show : :edit),
-        edit: :edit,
-        update: :edit,
-        confirm_destroy: :destroy,
-        destroy: :destroy
-      }.with_indifferent_access
-    end
-
-    # Returns true if @resource is assigned (even if it's nil)
-    def resource_given?
-      !!defined? @resource
-    end
-
-    # Returns true if @collection is assigned (even if it's nil)
-    def collection_given?
-      !!defined? @collection
-    end
-
-    # Returns notice scope name
-    def notice_scope_name
-      'notices.' + controller_scope_name
-    end
-
-    # Return ActiveRecord::Relation used in index
-    #
-    # @return ActiveRecord::Relation
-    def resources
-      resource_class.all
-    end
-
-    def required_params
-      params.require(:resource)
-    end
-
-    # Called before each request by before_filter.
-    # It sets various instance variables, that are later used in views and # controllers
-    #
-    # == Defines
-    # @features::
-    #   Hash with symbol keys and boolean values. Each key represents action
-    #   (currently only `:edit`, `:create`, `:destroy` are supported). If one
-    #   of features is disabled, then routing to it will raise <tt>Releaf::FeatureDisabled</tt>
-    #   error
-    #
-    # @resources_per_page::
-    #   Integer - sets the number of resources to display on `#index` view
-    #
-    # To change controller settings `setup` method should be overriden like this
-    #
-    # @example
-    #   def setup
-    #     super
-    #     @features[:edit] = false
-    #     @resources_per_page = 20
-    #   end
-    def setup
-      @features = {
-        show:              false,
-        edit:              true,
-        create:            true,
-        create_another:    true,
-        destroy:           true,
-        index:             true,
-        toolbox:           true
-      }
-      @panel_layout = true
-      @resources_per_page = 40
-    end
-
-    def searchable_fields
-      @searchable_fields ||= Releaf::Core::DefaultSearchableFields.new(resource_class).find
-    end
-
-    def resource_params
-      required_params.permit(*permitted_params)
-    end
-
-    # Returns which resource attributes can be updated with mass assignment.
-    #
-    # The resulting array will be passed to strong_parameters ``permit``
-    def permitted_params
-      Releaf::Core::ResourceParams.new(resource_class).values
-    end
-
-    # Returns url to redirect after successul resource create/update actions
-    #
-    # @return [String] url
-    def success_url
-      if create_another?
-        url_for(action: 'new')
-      else
-        url_for(action: 'edit', id: @resource.id, index_url: index_url)
-      end
-    end
-
-    def create_another?
-      params[:after_save] == "create_another" && feature_available?(:create_another)
-    end
-
-    def feature_disabled exception
-      @feature = exception.message
-      respond_with(nil, responder: action_responder(:feature_disabled))
-    end
-
-    def access_denied
-      respond_with(nil, responder: action_responder(:access_denied))
-    end
-
-    def ajax?
-      @_ajax || false
-    end
-
-    def layout
-      ajax? ? false : "releaf/admin"
-    end
-
-    def manage_ajax
-      @_ajax = params.has_key? :ajax
-      if @_ajax
-        request.query_parameters.delete(:ajax)
-        params.delete(:ajax)
-      end
-    end
-  end
-end

data/app/controllers/releaf/core/settings_controller.rb

@@ -1,50 +0,0 @@
-class Releaf::Core::SettingsController < ::Releaf::BaseController
-
-  def self.resource_class
-    ::Releaf::Settings
-  end
-
-  def resources
-    super.where(thing_type: nil, var: resource_class.registered_keys)
-  end
-
-  def normalize_value(value)
-    case resource_class.registry[@resource.var][:type]
-    when :boolean
-      value == '1'
-    when :date
-      Date.parse(value)
-    when :time
-      Time.parse(value)
-    when :datetime
-      DateTime.parse(value)
-    when :integer
-      value.to_i
-    when :float
-      value.to_s.sub(",", ".").to_f
-    when :decimal
-      value.to_s.sub(",", ".").to_d
-    else
-      value
-    end
-  end
-
-  def searchable_fields
-    [:var]
-  end
-
-  protected
-
-  def prepare_update
-    @resource = resource_class.find(params[:id]) unless resource_given?
-    params[:resource][:value] = normalize_value(params[:resource][:value])
-  end
-
-  def setup
-    super
-    @features = {
-      edit: true,
-      index: true,
-    }
-  end
-end

data/app/helpers/releaf/javascript_helper.rb

@@ -1,75 +0,0 @@
-module Releaf
-  module JavascriptHelper
-
-    # converts date format used by ruby to dateformat used by jquery (when possible)
-    #
-    # references:
-    #   http://www.ruby-doc.org/core-2.0/Time.html#strftime-method
-    #   http://api.jqueryui.com/datepicker/#utility-formatDate
-    #   http://trentrichardson.com/examples/timepicker/#tp-formatting
-    def jquery_date_format date_format
-
-      raise ArgumentError, "date_format is not a string" unless date_format.is_a? String
-
-      ruby2jquery = {
-        '%'   => '%',
-        '-d'  => 'd',
-        '-j'  => 'o',
-        '-m'  => 'm',
-        '3N'  => 'l',
-        ':z'  => 'Z',
-        'A'   => nil,
-        'B'   => 'MM',
-        'C'   => nil,
-        'D'   => 'mm/dd/y',
-        'F'   => 'yy-mm-dd',
-        'G'   => nil,
-        'H'   => 'HH',
-        'I'   => 'h',
-        'L'   => 'l',
-        'M'   => 'mm',
-        'P'   => 'tt',
-        'R'   => 'HH:mm',
-        'S'   => 'ss',
-        'T'   => 'HH:mm:ss',
-        'U'   => nil,
-        'V'   => nil,
-        'W'   => nil,
-        'X'   => 'HH:mm:ss',
-        'Y'   => 'yy',
-        'Z'   => nil,
-        '_m'  => 'm',
-        'a'   => nil,
-        'b'   => 'M',
-        'c'   => 'M d HH:mm:ss yy', # not exact translation
-        'd'   => 'dd',
-        'e'   => 'd',
-        'g'   => nil,
-        'h'   => 'M',
-        'j'   => 'oo',
-        'k'   => 'H',
-        'l'   => 'hh',
-        'm'   => 'mm',
-        'n'   => nil,
-        'p'   => 'TT',
-        'r'   => 'h:mm:ss TT',
-        's'   => '@',
-        't'   => nil,
-        'u'   => nil,
-        'v'   => nil,
-        'w'   => nil,
-        'x'   => 'mm/dd/y',
-        'y'   => 'y',
-        'z'   => nil
-      }
-
-      match_regexp = Regexp.new "%( #{ruby2jquery.reject { |k,v| v.nil? }.keys.join('|') })"
-      jquery_date_format = date_format.gsub(match_regexp) do |match|
-        ruby2jquery[match[1..-1]]
-      end
-
-      return jquery_date_format
-    end
-
-  end
-end