releaf-core 0.2.1

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

@@ -0,0 +1,5 @@
+class Releaf::Core::ErrorsController < Releaf::BaseController
+  def page_not_found
+    respond_with(nil, responder: action_responder(:page_not_found))
+  end
+end

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

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

@@ -0,0 +1,53 @@
+module Releaf
+  module ApplicationHelper
+    def merge_attributes(a, b)
+      if a.key?(:class) || b.key?(:class)
+        classes = {class: [a[:class], b[:class]].flatten.reject(&:blank?)}
+      else
+        classes = {}
+      end
+
+      a.deep_merge(b).merge(classes)
+    end
+
+    def releaf_table(collection, resource_class, options = {})
+      builder_class = options[:builder]
+      options.delete(:builder)
+      builder_class.new(collection, resource_class, self, options).output
+    end
+
+    def translate(key, options = {})
+      # prevent I18n from raising errors when translation is missing
+      options.merge!(raise: false) unless options.key?(:raise)
+      super(key, options)
+    end
+    alias :t :translate
+
+    def i18n_options_for_select container, selected, prefix, i18n_options={}
+      i18n_options = { scope: controller_scope_name }.merge(i18n_options)
+
+      translated_container = []
+
+      container.each do|element|
+        text, value = i18n_option_text_and_value(element).map { |item| item.to_s }
+        text = I18n.t("#{prefix.to_s}-#{text}", i18n_options.merge(default: text))
+        translated_container << [text, value]
+      end
+
+      return options_for_select(translated_container, selected)
+    end
+
+    private
+
+    def i18n_option_text_and_value(option)
+      # Options are [text, value] pairs or strings used for both.
+      if !option.is_a?(String) && option.respond_to?(:first) && option.respond_to?(:last)
+        option = option.reject { |e| Hash === e } if Array === option
+        [option.first, option.last]
+      else
+        [option, option]
+      end
+    end
+
+  end
+end

data/app/helpers/releaf/button_helper.rb

@@ -0,0 +1,50 @@
+module Releaf
+  module ButtonHelper
+
+    def releaf_button(text, icon, attributes = {})
+      attributes = releaf_button_attributes( text, icon, attributes )
+      tag = attributes.key?(:href) ? :a : :button
+      content_tag(tag, attributes) do
+        releaf_button_content( text, icon, attributes )
+      end
+    end
+
+
+    def releaf_button_attributes( text, icon, attributes = {} )
+      default_attributes = {
+        class: ["button"],
+        title: text
+      }
+
+      unless attributes.key? :href
+        default_attributes[:type] = :button
+        default_attributes[:autocomplete] = "off"
+      end
+
+      if icon.present?
+        icon_class = (text.present?) ? "with-icon" : "only-icon"
+        default_attributes[:class] << icon_class
+      end
+
+      merge_attributes(default_attributes, attributes)
+    end
+
+
+    def releaf_button_content( text, icon, attributes = {} )
+      if text.blank? && icon.present?
+        raise ArgumentError, "Title is required for icon-only buttons" if attributes[:title].blank?
+      end
+
+      html = "".html_safe
+      html << fa_icon(icon) if icon.present?
+      html << text if text.present?
+
+      if html.length < 1
+        raise ArgumentError, "Either text or icon is required for buttons"
+      end
+
+      html
+    end
+
+  end
+end

data/app/helpers/releaf/javascript_helper.rb

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

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

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

@@ -0,0 +1,43 @@
+module Releaf::Core
+  class DefaultSearchableFields
+    attr_accessor :klass
+
+    def initialize(klass)
+      self.klass = klass
+    end
+
+    def find
+      search_columns = possible_field_names & string_columns
+      search_columns << { translations: searchable_translated_string_columns } if has_searchable_translated_string_columns?
+      search_columns
+    end
+
+    def string_columns
+      klass.columns.select { |column| column.type == :string }.map(&:name)
+    end
+
+    def searchable_translated_string_columns
+      @searchable_translated_string_columns ||= self.class.new(klass::Translation).find
+    end
+
+    def has_searchable_translated_string_columns?
+      return false unless klass.translates?
+      searchable_translated_string_columns.present?
+    end
+
+    def possible_field_names
+      %w[
+        email
+        first_name
+        forename
+        last_name
+        login
+        middle_name
+        name
+        surname
+        title
+        username
+      ]
+    end
+  end
+end

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

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