releaf-core 0.2.1

data/lib/releaf/core/route_mapper.rb

@@ -0,0 +1,59 @@
+module Releaf::Core::RouteMapper
+  # Pass given resource to "resources" mount method and
+  # add extra routes for members and collections needed by releaf
+  def releaf_resources(*args, &block)
+    resources *args do
+      yield if block_given?
+      member do
+        get :confirm_destroy if route_enabled?(:destroy, args.last)
+        get :toolbox if route_enabled?(:toolbox, args.last)
+      end
+      collection do
+        post :create_releaf_richtext_attachment if route_enabled?(:releaf_richtext_attachments, args.last)
+      end
+    end
+  end
+
+  def initialize_releaf_components
+    Releaf.application.config.components.each do|component_class|
+      if component_class.respond_to? :draw_component_routes
+        component_class.draw_component_routes(self)
+      end
+    end
+  end
+
+  def mount_releaf_at(mount_location, options={}, &block)
+    mount_location_namespace = mount_location.gsub("/", "").to_sym
+    Releaf.application.config.mount_location = mount_location_namespace.to_s
+    scope mount_location do
+      initialize_releaf_components
+
+      if mount_location_namespace.empty?
+        yield if block_given?
+      else
+        namespace mount_location_namespace, path: nil do
+          yield if block_given?
+        end
+      end
+
+      namespace :releaf, path: nil do
+        get '/*path' => 'core/errors#page_not_found'
+      end
+    end
+  end
+
+  private
+
+  def route_enabled?(route, options)
+    include_route = true
+    if options.is_a? Hash
+      if options[:only] && !options[:only].include?(route.to_sym)
+        include_route = false
+      elsif options[:except].try(:include?, route.to_sym)
+        include_route = false
+      end
+    end
+
+    include_route
+  end
+end

data/lib/releaf/core/settings_ui_component.rb

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

data/lib/releaf/core/validation_error_codes.rb

@@ -0,0 +1,36 @@
+module ActiveModel
+  class ErrorMessage < String
+    attr_accessor :error_code, :data
+
+    def initialize(message, error_code = nil, data = nil)
+      super message
+      @error_code = error_code
+      @data = data
+    end
+  end
+
+  class Errors
+    def add(attribute, message = nil, options = {})
+      # build error code from message symbol
+      error_code = normalize_error_code(attribute, message, options)
+      message = normalize_message(attribute, message, options)
+      if exception = options[:strict]
+        exception = ActiveModel::StrictValidationFailed if exception == true
+        raise exception, full_message(attribute, message)
+      end
+
+      # use customized String subclass with "error_code" attribute
+      self[attribute] << ErrorMessage.new(message, error_code, options[:data])
+    end
+
+    def normalize_error_code(attribute, message, options)
+      if !options[:error_code].blank?
+        options[:error_code]
+      elsif message.class == Symbol
+        message
+      else
+        :invalid
+      end
+    end
+  end
+end

data/lib/releaf/version.rb

@@ -0,0 +1,3 @@
+module Releaf
+  VERSION = "0.2.1"
+end

data/lib/releaf-core.rb

@@ -0,0 +1,14 @@
+module Releaf
+  require 'releaf/core/engine'
+  require 'releaf/core/configuration'
+  require 'releaf/core/application'
+  require 'releaf/core/route_mapper'
+  require 'releaf/core/exceptions'
+  require 'releaf/core/validation_error_codes'
+
+  class << self
+    def application
+      @@application ||= Releaf::Core::Application.new
+    end
+  end
+end

data/lib/tasks/releaf_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :releaf do
+#   # Task goes here
+# end

data/releaf-core.gemspec

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

data/spec/builders/builders/association_reflector_spec.rb

@@ -0,0 +1,138 @@
+require 'rails_helper'
+
+describe Releaf::Builders::AssociationReflector, type: :class do
+  let(:reflection){ Book.reflect_on_association("chapters") }
+  subject{ described_class.new(reflection, :b, "xx") }
+
+  describe "#initialize" do
+    it "assigns given reflection" do
+      expect(subject.reflection).to eq(reflection)
+    end
+
+    it "assigns given fields" do
+      expect(subject.fields).to eq(:b)
+    end
+
+    it "normalizes to symbol and assigns given sortable name" do
+      expect(subject.sortable_column_name).to eq(:xx)
+    end
+  end
+
+  describe "#destroyable?" do
+    context "when reflection allow to destroy through nested attributes" do
+      it "returns true" do
+        subject.reflection = Book.reflect_on_association("book_sequels")
+        expect(subject.destroyable?).to be true
+      end
+    end
+
+    context "when reflection does not allow to destroy through nested attributes" do
+      it "returns false" do
+        expect(subject.destroyable?).to be false
+      end
+    end
+
+    it "caches result" do
+      expect(subject.reflection.active_record).to receive(:nested_attributes_options).and_call_original.once
+      subject.destroyable?
+      subject.destroyable?
+      subject.destroyable?
+    end
+  end
+
+  describe "#sortable?" do
+    context "when expected and actual order clauses are same" do
+      it "returns true" do
+        allow(subject).to receive(:expected_order_clause).and_return(:a)
+        allow(subject).to receive(:actual_order_clause).and_return(:a)
+        expect(subject.sortable?).to be true
+      end
+    end
+
+    context "when expected and actual order clauses differs" do
+      it "returns false" do
+        allow(subject).to receive(:expected_order_clause).and_return(:a)
+        allow(subject).to receive(:actual_order_clause).and_return(:b)
+        expect(subject.sortable?).to be false
+      end
+    end
+
+    it "caches result" do
+      expect(subject).to receive(:expected_order_clause).and_return(:x).once
+      expect(subject).to receive(:actual_order_clause).and_return(:y).once
+      subject.sortable?
+      subject.sortable?
+      subject.sortable?
+    end
+  end
+
+  describe "#actual_order_clause" do
+    context "when scope exists within reflection" do
+      it "returns actual reflection klass order clause with evaluated scope" do
+        relation = reflection.klass.all.order(:item_position)
+        allow(subject).to receive(:extract_order_clause).with(relation).and_return(:y)
+        expect(subject.actual_order_clause).to eq(:y)
+      end
+    end
+
+    context "when no scope exists within reflection" do
+      it "returns actual reflection klass order clause" do
+        subject.reflection = Book.reflect_on_association("sequels")
+        relation = subject.reflection.klass.all
+        allow(subject).to receive(:extract_order_clause).with(relation).and_return(:y)
+        expect(subject.actual_order_clause).to eq(:y)
+      end
+    end
+  end
+
+  describe "#expected_order_clause" do
+    it "returns expected reflection klass order clause for sortable column name" do
+      subject.sortable_column_name = :title
+      relation = reflection.klass.all.order(:title)
+      allow(subject).to receive(:extract_order_clause).with(relation).and_return(:y)
+      expect(subject.expected_order_clause).to eq(:y)
+    end
+  end
+
+  describe "#extract_order_clause" do
+    it "returns order clauses normalized to string for given relation" do
+      relation = Book.order(genre: :desc)
+      expected_result = if mysql?
+                          "`books`.`genre` DESC"
+                        elsif postgresql?
+                          '"books"."genre" DESC'
+                        else
+                          fail
+                        end
+      expect(subject.extract_order_clause(relation)).to eq(expected_result)
+    end
+
+    context "when relation has no order clauses" do
+      it "returns empty string" do
+        relation = Book.all
+        expect(subject.extract_order_clause(relation)).to eq("")
+      end
+    end
+  end
+
+  describe "#value_as_sql" do
+    context "when given value respond to sql" do
+      it "return resulting sql" do
+        expected_result = if mysql?
+                            "SELECT `books`.* FROM `books`"
+                          elsif postgresql?
+                            'SELECT "books".* FROM "books"'
+                          else
+                            fail
+                          end
+        expect(subject.value_as_sql(Book.all)).to eq(expected_result)
+      end
+    end
+
+    context "when given value does not respond to sql" do
+      it "return given value" do
+        expect(subject.value_as_sql(12)).to eq(12)
+      end
+    end
+  end
+end

data/spec/builders/builders/base_spec.rb

@@ -0,0 +1,276 @@
+require "rails_helper"
+
+describe Releaf::Builders::Base, type: :module do
+  class FormBuilderTestHelper < ActionView::Base
+    include Releaf::ButtonHelper
+    include Releaf::ApplicationHelper
+    include FontAwesome::Rails::IconHelper
+  end
+  class BuilderIncluder
+    include Releaf::Builders::Base
+    attr_accessor :template
+  end
+
+  let(:subject){ BuilderIncluder.new }
+  let(:template){ FormBuilderTestHelper.new }
+
+  before do
+    subject.template = template
+  end
+
+  describe "delegations" do
+    [:controller, :controller_name, :url_for, :form_for,
+     :releaf_button, :params, :form_tag, :file_field_tag,
+     :request, :check_box_tag, :label_tag, :content_tag, :hidden_field_tag,
+     :render, :link_to, :flash, :truncate, :radio_button_tag,
+     :options_for_select, :action_name, :options_from_collection_for_select,
+     :select_tag, :text_field_tag,
+     :image_tag, :jquery_date_format, :cookies, :button_tag, :merge_attributes
+    ].each do|method_name|
+      it "deletages #{method_name} to template" do
+        expect(subject).to delegate_method(method_name).to(:template)
+      end
+    end
+
+    [:layout_settings, :access_control, :controller_scope_name, :feature_available?,
+     :index_url].each do|method_name|
+      it "delegates #{method_name} to controller" do
+        expect(subject).to delegate_method(method_name).to(:controller)
+      end
+    end
+  end
+
+  describe "#html_escape" do
+    it "escapes given value with " do
+      allow(ERB::Util).to receive(:html_escape).with("a").and_return("b")
+      expect(subject.html_escape("a")).to eq("b")
+    end
+  end
+
+
+  it "aliases #button to #releaf_button" do
+    allow(subject.template).to receive(:releaf_button).with("x", a: "y", b: "z").and_return("xx")
+    expect(subject.button("x", a: "y", b: "z")).to eq("xx")
+  end
+
+  describe "#icon" do
+    it "returns template fa_icon output" do
+      expect(subject.icon("check")).to eq('<i class="fa fa-check"></i>')
+    end
+  end
+
+  describe "#tag" do
+    context "when block is not given" do
+      context "when passing string as content" do
+        let(:output) do
+          subject.tag(:span, "<p>x</p>", class: "red")
+        end
+
+        it "returns an instance of ActiveSupport::SafeBuffer" do
+          expect( output ).to be_a ActiveSupport::SafeBuffer
+
+        end
+
+        it "passes all arguments to template #content_tag method and returns properly escaped result" do
+          expect( output ).to eq('<span class="red">&lt;p&gt;x&lt;/p&gt;</span>')
+        end
+      end
+
+      context "when passing safe buffer as content" do
+        let(:output) do
+          subject.tag(:span, ActiveSupport::SafeBuffer.new("<p>x</p>"), class: "red")
+        end
+
+        it "returns an instance of ActiveSupport::SafeBuffer" do
+          expect( output ).to be_a ActiveSupport::SafeBuffer
+
+        end
+
+        it "passes all arguments to template #content_tag method and returns properly escaped result" do
+          expect( output ).to eq('<span class="red"><p>x</p></span>')
+        end
+      end
+
+    end
+
+    context "when block is given" do
+      context "when block evaluates to array" do
+        let(:content) do
+          [
+            '<p>foo</p>',
+            'bar',
+            ActiveSupport::SafeBuffer.new('<p>baz</p>')
+          ]
+        end
+
+        let(:output) do
+          subject.tag(:div, class: 'important') { content }
+        end
+
+        it "returns an instance of ActiveSupport::SafeBuffer" do
+          expect( output ).to be_a ActiveSupport::SafeBuffer
+        end
+
+        it "safely joins array" do
+          expect( template ).to receive(:safe_join).with(content).and_call_original
+          output
+        end
+
+        it "passes joined result to #template#content_tag as content" do
+          allow( template ).to receive(:safe_join).with(content).and_return('super duper')
+          expect( output ).to eq('<div class="important">super duper</div>')
+        end
+
+        it "returns properly escaped result" do
+          expect( output ).to eq('<div class="important">&lt;p&gt;foo&lt;/p&gt;bar<p>baz</p></div>')
+        end
+
+      end
+
+      context "when block evaluates to other than array" do
+        let(:output) do
+          subject.tag(:div, class: 'important') { '<p>content</p>' }
+        end
+
+        it "returns an instance of ActiveSupport::SafeBuffer" do
+          expect( output ).to be_a ActiveSupport::SafeBuffer
+        end
+
+        it "doesn't call #template#safe_join" do
+          expect( template ).to_not receive(:safe_join)
+          output
+        end
+
+        it "keeps safe buffer unmodified and pass to #template#content_tag as content which won't be escaped" do
+          expect( subject.tag(:div, class: 'important') { ActiveSupport::SafeBuffer.new('<p>content</p>') } ).to eq '<div class="important"><p>content</p></div>'
+        end
+
+        it "passes block result to #template#content_tag as content which will be escaped" do
+          expect( output ).to eq '<div class="important">&lt;p&gt;content&lt;/p&gt;</div>'
+        end
+
+        it "casts block result to string" do
+          expect( subject.tag(:div, class: 'important') { 1 } ).to eq '<div class="important">1</div>'
+        end
+      end
+    end
+  end
+
+  describe "#wrapper" do
+    context "when block is given" do
+      let(:output) do
+        subject.wrapper(class: 'c') do
+          '<span class="a">b</span>'.html_safe
+        end
+      end
+
+      it "wrapps given content within div element with given attributes" do
+        expect(output).to eq('<div class="c"><span class="a">b</span></div>')
+      end
+    end
+
+    context "when block is not given" do
+      it "wrapps given content within div element with given attributes" do
+        expect(subject.wrapper('<span class="a">b</span>'.html_safe, class: "c")).to eq('<div class="c"><span class="a">b</span></div>')
+      end
+    end
+  end
+
+  describe "#template_variable" do
+    it "returns template instance variable value for given key" do
+      template.instance_variable_set("@test", "xx")
+      expect(subject.template_variable("test")).to eq("xx")
+    end
+  end
+
+  describe "#safe_join" do
+    let(:content) do
+      ['foo', '<p>bar</p>', ActiveSupport::SafeBuffer.new('<p>baz</p>')]
+    end
+
+    let(:output) do
+      subject.safe_join { content }
+    end
+
+    it "returns an instance of ActiveSupport::SafeBuffer" do
+      expect( output ).to be_a ActiveSupport::SafeBuffer
+    end
+
+    it "passes block result to #template#safe_join" do
+      expect( template ).to receive(:safe_join).with(content).and_call_original
+      output
+    end
+
+    it "returns correctly escaped result" do
+      expect( output ).to eq 'foo&lt;p&gt;bar&lt;/p&gt;<p>baz</p>'
+    end
+  end
+
+  describe "#t" do
+    before do
+      allow(subject).to receive(:default_translation_scope).and_return("_default_scope_")
+    end
+
+    it "passes all arguments to I18n.t and returns translation" do
+      allow(I18n).to receive(:t).with("x", default: "y", scope: "z").and_return("translated value")
+      expect(subject.t("x", default: "y", scope: "z")).to eq("translated value")
+    end
+
+    context "when :scope option passed" do
+      it "uses default translation scope controller translation scope" do
+        expect(I18n).to receive(:t).with("x", scope: "zzz").and_return("asd")
+        subject.t("x", scope: "zzz")
+      end
+    end
+
+    context "when no :scope option passed" do
+      it "adds controller translation scope" do
+        expect(I18n).to receive(:t).with("x", scope: "_default_scope_").and_return("asd")
+        subject.t("x")
+      end
+    end
+  end
+
+  describe "#translate_locale" do
+    it "returns translated locale within `locales` scope" do
+      allow(subject).to receive(:t).with("de", scope: "locales").and_return("dzerman")
+      expect(subject.translate_locale("de")).to eq("dzerman")
+    end
+  end
+
+  describe "#locale_options" do
+    it "returns array with translated locales usable for rails options helper" do
+      allow(subject).to receive(:t).with("de", scope: "locales").and_return("dzerman")
+      allow(subject).to receive(:t).with("lv", scope: "locales").and_return("latvian")
+      expect(subject.locale_options(["de", "lv"])).to eq([["dzerman", "de"], ["latvian", "lv"]])
+    end
+  end
+
+  describe "#resource_to_text" do
+    let(:resource){ Releaf::Permissions::User.new(name: "a", surname: "b") }
+
+    context "when given resource respond to #to_text method" do
+      it "returns resource #to_text output" do
+        expect(subject.resource_to_text(resource)).to eq("a b")
+      end
+    end
+
+    context "when given resource does not respond to #to_text method" do
+      it "returns resource #to_s output" do
+        allow(resource).to receive(:respond_to?).and_call_original
+        allow(resource).to receive(:respond_to?).with(:to_text).and_return(false)
+        allow(resource).to receive(:to_s).and_return("x")
+        expect(subject.resource_to_text(resource)).to eq("x")
+      end
+    end
+  end
+
+  describe "#default_translation_scope" do
+    it "returns controller scope" do
+      controller = Releaf::BaseController.new
+      allow(subject).to receive(:controller).and_return(controller)
+      allow(controller).to receive(:controller_scope_name).and_return("x")
+      expect(subject.default_translation_scope).to eq("x")
+    end
+  end
+end