releaf-core 0.2.1 → 1.0.3

data/spec/builders/builders/page/header_builder_spec.rb

@@ -1,143 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Builders::Page::HeaderBuilder, type: :class do
-  class PageHeaderBuilderTestHelper < ActionView::Base
-    include Rails.application.routes.url_helpers
-    include FontAwesome::Rails::IconHelper
-
-    def protect_against_forgery?
-      true
-    end
-
-    def form_authenticity_token
-      "xxx"
-    end
-
-    def request_forgery_protection_token
-      "yyy"
-    end
-  end
-
-  subject { described_class.new(template) }
-  let(:template){ PageHeaderBuilderTestHelper.new }
-
-  describe "#output" do
-    it "returns safely joined items" do
-      allow(subject).to receive(:items).and_return([ '<', ActiveSupport::SafeBuffer.new(">")])
-      expect(subject.output).to eq("&lt;>")
-    end
-  end
-
-  describe "#items" do
-    it "returns array of home link, profile block and logout form content" do
-      allow(subject).to receive(:home_link).and_return("a")
-      allow(subject).to receive(:profile_block).and_return("b")
-      allow(subject).to receive(:sign_out_form).and_return("c")
-      expect(subject.items).to eq(["a", "b", "c"])
-    end
-  end
-
-  describe "#home_link" do
-    it "returns home link with a logo" do
-      allow(subject).to receive(:home_url).and_return("www.xxx")
-      allow(subject).to receive(:home_text).and_return("Rrr")
-      allow(subject).to receive(:home_image_path).and_return("releaf/foo.png")
-      content = '<a class="home" href="www.xxx"><img alt="Rrr" src="/images/releaf/foo.png" /></a>'
-      expect(subject.home_link).to eq(content)
-    end
-  end
-
-  describe "#home_url" do
-    it "returns home url" do
-      expect(subject.home_url).to eq("/admin")
-    end
-  end
-
-  describe "#home_image_path" do
-    it "returns image to the logo image asset" do
-      expect(subject.home_image_path).to eq("releaf/logo.png")
-    end
-  end
-
-  describe "#home_text" do
-    it "returns releaf home link text" do
-      expect(subject.home_text).to eq("Releaf")
-    end
-  end
-
-
-  describe "#profile_url" do
-    it "returns profile edit url for defined profile controller" do
-      expect(subject.profile_url).to eq("/admin/profile")
-
-      allow(subject).to receive(:profile_controller).and_return("/releaf/home")
-      expect{ subject.profile_url }
-        .to raise_error(ActionController::UrlGenerationError, 'No route matches {:action=>"edit", :controller=>"releaf/home"}')
-    end
-  end
-
-  describe "#profile_settings_url" do
-    it "returns profile edit url for defined profile controller" do
-      expect(subject.profile_settings_url).to eq("/admin/profile/settings")
-
-      allow(subject).to receive(:profile_controller).and_return("/releaf/home")
-      expect{ subject.profile_settings_url }
-        .to raise_error(ActionController::UrlGenerationError, 'No route matches {:action=>"settings", :controller=>"releaf/home"}')
-    end
-  end
-
-  describe "#profile_controller" do
-    it "returns releaf permissions profile controller" do
-      expect(subject.profile_controller).to eq("/releaf/permissions/profile")
-    end
-  end
-
-  describe "#profile_block" do
-    it "returns profile block with content" do
-      allow(subject).to receive(:profile_user_name).and_return("neim")
-      allow(subject).to receive(:profile_settings_url).and_return("url_a")
-      allow(subject).to receive(:profile_url).and_return("url_b")
-      content = '<a class="button profile" href="url_b" data-settings-url="url_a"><span class="name">neim</span></a>'
-      expect(subject.profile_block).to eq(content)
-    end
-  end
-
-  describe "#user" do
-    it "returns permissions manager user" do
-      access_control = double(Releaf::Permissions::AccessControl)
-      allow(subject).to receive(:access_control).and_return(access_control)
-      allow(access_control).to receive(:user).and_return("x")
-      expect(subject.user).to eq("x")
-    end
-  end
-
-  describe "#profile_user_name" do
-    it "returns profile user name" do
-      admin = Releaf::Permissions::User.new(name: "a", surname: "b")
-      allow(subject).to receive(:user).and_return(admin)
-      expect(subject.profile_user_name).to eq("a b")
-    end
-  end
-
-  describe "#sign_out_url" do
-    it "returns sign out url" do
-      expect(subject.sign_out_url).to eq("/admin/sign_out")
-    end
-  end
-
-  describe "#sign_out_form" do
-    it "returns sign out form" do
-      allow(subject).to receive(:sign_out_url).and_return("url_a")
-      content = %Q[
-        <form class="sign-out" action="url_a" accept-charset="UTF-8" method="post">
-          <input name="utf8" type="hidden" value="&#x2713;" />
-          <input type="hidden" name="_method" value="delete" />
-          <input type="hidden" name="yyy" value="xxx" />
-          <button class="button only-icon" type="submit" title="Sign out">
-            <i class="fa fa-power-off fa-icon-header"></i>
-          </button>
-      </form>]
-      expect(subject.sign_out_form).to match_html( content )
-    end
-  end
-end

data/spec/builders/builders/page/layout_builder_spec.rb

@@ -1,73 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Builders::Page::LayoutBuilder, type: :class do
-  class PageHeaderBuilderTestHelper < ActionView::Base
-    include Rails.application.routes.url_helpers
-    include FontAwesome::Rails::IconHelper
-
-    def protect_against_forgery?
-      true
-    end
-
-    def form_authenticity_token
-      "xxx"
-    end
-
-    def request_forgery_protection_token
-      "yyy"
-    end
-  end
-
-  class NewRolesController < Releaf::Permissions::RolesController
-  end
-
-  subject { described_class.new(template) }
-  let(:template){ PageHeaderBuilderTestHelper.new }
-
-  describe "#controller_classes" do
-    it "returns array of ignorable ancester classes" do
-      allow(subject).to receive(:controller).and_return(NewRolesController.new)
-      expect(subject.controller_classes).to eq([Releaf::Permissions::RolesController, NewRolesController])
-
-      allow(subject).to receive(:controller).and_return(Releaf::Permissions::RolesController.new)
-      expect(subject.controller_classes).to eq([Releaf::Permissions::RolesController])
-
-      allow(subject).to receive(:controller).and_return(Releaf::Permissions::SessionsController.new)
-      expect(subject.controller_classes).to eq([Releaf::Permissions::SessionsController])
-    end
-  end
-
-  describe "#controller_body_classes" do
-    it "returns normalized html classes from controller classes" do
-      allow(subject).to receive(:controller_classes).and_return([Releaf::BaseController, Releaf::Permissions::RolesController])
-      expect(subject.controller_body_classes).to eq(["controller-releaf-base", "controller-releaf-permissions-roles"])
-    end
-  end
-
-  describe "#head_blocks" do
-    it "returns array" do
-      {
-        title: :title_sym,
-        meta: :meta_sym,
-        favicons: :favicon_sym,
-        ms_tile: :ms_tile_sym,
-        assets: :assets_sym,
-        csrf: :csrf_sym,
-      }.each_pair do |method, stub_answer|
-        allow(subject).to receive(method).and_return stub_answer
-      end
-
-      expect(subject.head_blocks).to match_array(
-        [
-          :title_sym,
-          :meta_sym,
-          :favicon_sym,
-          :ms_tile_sym,
-          :assets_sym,
-          :csrf_sym,
-        ]
-      )
-    end
-  end
-end
-

data/spec/builders/builders/page/menu_builder_spec.rb

@@ -1,160 +0,0 @@
-require "spec_helper"
-
-describe Releaf::Builders::Page::MenuBuilder, type: :class do
-  class MenuBuilderTestHelper < ActionView::Base
-    include FontAwesome::Rails::IconHelper
-  end
-
-  let(:controller){ Releaf::BaseController.new }
-  let(:template){ MenuBuilderTestHelper.new }
-  subject { described_class.new(template) }
-
-  before do
-    allow(template).to receive(:controller).and_return(controller)
-  end
-
-  it "includes Releaf::Builders::Base" do
-    expect(described_class.ancestors).to include(Releaf::Builders::Base)
-  end
-
-  it "includes Releaf::Builders::Template" do
-    expect(described_class.ancestors).to include(Releaf::Builders::Template)
-  end
-
-  describe "#output" do
-    pending
-  end
-
-  describe "#menu_level" do
-    pending
-  end
-
-  describe "#menu_item" do
-    pending
-  end
-
-  describe "#collapsed_item?" do
-    pending
-  end
-
-  describe "#item_attributes" do
-    pending
-  end
-
-  describe "#item_name_content" do
-    let(:item) { { name: :item_name } }
-
-    it "returns abbreviation and full name elements" do
-      allow(subject).to receive(:t).with( :item_name, scope: "admin.controllers" ).and_return('Item full name')
-      allow(subject).to receive(:item_name_abbreviation).with('Item full name').and_return('Item abbreviation')
-      expect( subject.item_name_content( item ) ).to eq('<abbr title="Item full name">Item abbreviation</abbr><span class="name">Item full name</span>')
-    end
-
-  end
-
-  describe "#item_name_abbreviation" do
-
-    it "returns first two letters of given text string" do
-      expect( subject.item_name_abbreviation( "Foo bar" )).to eq("Fo")
-    end
-
-    context "when the first two letters are lowercase" do
-      it "capitalizes the first letter" do
-        expect( subject.item_name_abbreviation( "foo bar" )).to eq("Fo")
-      end
-    end
-
-    context "when the first two letters are uppercase" do
-      it "makes the second letter lowercase" do
-        expect( subject.item_name_abbreviation( "FOO BAR" )).to eq("Fo")
-      end
-    end
-
-    context "when the string contains slashes" do
-
-      it "uses the first word after the last slash" do
-        expect( subject.item_name_abbreviation( "Releaf/core/settings" )).to eq("Se")
-      end
-
-      it "ignores slashes surrounded by spaces" do
-        expect( subject.item_name_abbreviation( "Inputs / Outputs" )).to eq("In")
-      end
-
-      it "ignores trailing slashes" do
-        expect( subject.item_name_abbreviation( "Releaf/core/settings/" )).to eq("Se")
-      end
-
-      context "when string consists of a single slash" do
-        it "returns an empty string" do
-          expect( subject.item_name_abbreviation( "/" )).to eq("")
-        end
-      end
-    end
-
-    it "works with non-latin characters" do
-      expect( subject.item_name_abbreviation( "žņ" )).to eq("Žņ")
-    end
-
-    context "when given an empty string value" do
-      it "returns an empty string" do
-        expect( subject.item_name_abbreviation( "" )).to eq("")
-      end
-    end
-
-    context "when given nil" do
-      it "returns an empty string" do
-        expect( subject.item_name_abbreviation( nil )).to eq("")
-      end
-    end
-  end
-
-  describe "#item_collapser" do
-
-    it "returns a collapser span with a button and collapser icon" do
-      allow(subject).to receive(:item_collapser_icon).with(:foo).and_return(subject.icon('dummy'))
-      expect(subject.item_collapser(:foo)).to eq '<span class="collapser"><button type="button"><i class="fa fa-dummy"></i></button></span>'
-    end
-
-  end
-
-  describe "#item_collapser_icon" do
-
-    before do
-      allow(subject).to receive(:layout_settings).with('releaf.side.compact').and_return(false)
-    end
-
-    let(:item) { {} }
-
-    context "when side is compacted in layout settings" do
-      it "returns a beak pointing right" do
-        allow(subject).to receive(:layout_settings).with('releaf.side.compact').and_return(true)
-        allow(subject).to receive(:icon).with('chevron-right').and_return("icon ok")
-        expect(subject.item_collapser_icon(item)).to eq "icon ok"
-      end
-    end
-
-    context "when side is not compacted in layout settings" do
-      context "when the given item is collapsed" do
-        it "returns a beak pointing down" do
-          allow(subject).to receive(:collapsed_item?).with(item).and_return(true)
-          allow(subject).to receive(:icon).with('chevron-down').and_return("icon ok")
-          expect(subject.item_collapser_icon(item)).to eq "icon ok"
-        end
-      end
-      context "when the given item is expanded" do
-        it "returns a beak pointing up" do
-          allow(subject).to receive(:collapsed_item?).with(item).and_return(false)
-          allow(subject).to receive(:icon).with('chevron-up').and_return("icon ok")
-          expect(subject.item_collapser_icon(item)).to eq "icon ok"
-        end
-      end
-    end
-
-  end
-
-
-  describe "#compacter" do
-    pending
-  end
-
-end

data/spec/builders/core/settings/form_builder_spec.rb

@@ -1,69 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Core::Settings::FormBuilder, type: :class do
-  class FormBuilderTestHelper < ActionView::Base; end
-  before do
-    Releaf::Settings.register([
-      { key: "myapp.rating", default: 5.65, description: "x", type: :decimal },
-      { key: "myapp.confirmed", default: true, type: :boolean },
-      { key: "myapp.intro" }
-    ])
-  end
-
-  let(:template){ FormBuilderTestHelper.new }
-
-  describe "#field_names" do
-    let(:subject){ described_class.new(:resource, Releaf::Settings.first, template, {}) }
-
-    it "returns :value as only editable field within array" do
-      expect(subject.field_names).to eq([:value])
-    end
-  end
-
-  describe "#render_value" do
-    let(:subject){ described_class.new(:resource, Releaf::Settings.first, template, {}) }
-
-    it "renders text field for value" do
-      allow(subject).to receive(:settings_field_label_text).and_return("x")
-      allow(subject).to receive(:settings_field_type).and_return("text")
-      allow(subject).to receive(:releaf_text_field).with(:value, { options: { label: { label_text: "x" }}}).and_return("y")
-      expect(subject.render_value).to eq("y")
-    end
-  end
-
-  describe "#settings_field_label_text" do
-    context "when description is available" do
-      let(:subject){ described_class.new(:resource, Releaf::Settings.first, template, {}) }
-
-      it "returns translated description text" do
-        allow(subject).to receive(:t).with("x", { scope: "settings"}).and_return("y")
-        expect(subject.settings_field_label_text).to eq("y")
-      end
-    end
-
-    context "when description is not available" do
-      let(:subject){ described_class.new(:resource, Releaf::Settings.last, template, {}) }
-
-      it "returns 'Value'" do
-        expect(subject.settings_field_label_text).to eq("Value")
-      end
-    end
-  end
-
-  describe "#settings_field_type" do
-    it "returns correct field type for the first setting" do
-      subject = described_class.new(:resource, Releaf::Settings.first, template, {})
-      expect(subject.settings_field_type).to eq(:decimal)
-    end
-
-    it "returns correct field type for the second setting" do
-      subject = described_class.new(:resource, Releaf::Settings.second, template, {})
-      expect(subject.settings_field_type).to eq(:boolean)
-    end
-
-    it "returns correct default field type" do
-      subject = described_class.new(:resource, Releaf::Settings.last, template, {})
-      expect(subject.settings_field_type).to eq(:text)
-    end
-  end
-end

data/spec/controllers/releaf/core/settings_controller_spec.rb

@@ -1,31 +0,0 @@
-require 'rails_helper'
-
-describe Releaf::Core::SettingsController do
-  login_as_user :user
-
-  describe "GET index" do
-    login_as_user :user
-    it "lists only settings that not scoped to any object and exists within `Releaf::Settings.registry`" do
-      Releaf::Settings.destroy_all
-      Releaf::Settings.registry = {}
-
-      Releaf::Settings.create(var: "a", value: "1")
-      Releaf::Settings.create(var: "b", value: "2")
-      Releaf::Settings.create(var: "c", value: "2")
-      Releaf::Settings.create(var: "a", value: "3", thing_type: "User", thing_id: "1")
-
-      Releaf::Settings.register(key: "a", default: "x", description: "some setting")
-      Releaf::Settings.register(key: "b", default: "xxxx", description: "some other setting")
-
-      get :index
-      expect(assigns(:collection).size).to eq(2)
-    end
-  end
-
-  describe "GET new" do
-    it "creation of new records is disabled" do
-      get :new
-      expect(response.status).to eq(403)
-    end
-  end
-end

data/spec/lib/releaf/core/assets_resolver_spec.rb

@@ -1,113 +0,0 @@
-require "rails_helper"
-
-describe Releaf::Core::AssetsResolver do
-  describe ".base_assets" do
-    it "returns array with `releaf/application`" do
-      expect(described_class.base_assets).to eq(["releaf/application"])
-    end
-  end
-
-  describe ".controller_assets" do
-    before do
-      allow(described_class).to receive(:base_assets).and_return(["a", "b"])
-    end
-
-    it "returns array with controller specific asset alognside base assets" do
-      allow(described_class).to receive(:assets).and_return(
-        "releaf/i18n_database/translations" => {
-          javascripts: ["c"],
-          stylesheets: ["d", "e"],
-        }
-      )
-      expect(described_class.controller_assets("releaf/i18n_database/translations", :javascripts))
-        .to eq(["a", "b", "c"])
-      expect(described_class.controller_assets("releaf/i18n_database/translations", :stylesheets))
-        .to eq(["a", "b", "d", "e"])
-    end
-
-    context "when no controller specific assets exists" do
-      it "returns only base assets" do
-        allow(described_class).to receive(:assets).and_return({})
-        expect(described_class.controller_assets("releaf/i18n_database/translations", :stylesheets))
-          .to eq(["a", "b"])
-      end
-    end
-  end
-
-  describe ".compiled_assets" do
-    it "returns array with controller scoped stylesheets and javascripts" do
-      allow(Rails.application.assets_manifest).to receive(:files).and_return(
-        "releaf/controllers/releaf/content/nodes-72ac849dd467fe827933f15c45ea77a2b7beac55379147f3be4a21779787f484.js"=>{"logical_path"=>"releaf/controllers/releaf/content/nodes.js", "mtime"=>"2015-12-01T13:55:41+02:00", "size"=>1530, "digest"=>"72ac849dd467fe827933f15c45ea77a2b7beac55379147f3be4a21779787f484", "integrity"=>"sha256-cqyEndRn/oJ5M/FcRep3ore+rFU3kUfzvkohd5eH9IQ="},
-        "releaf/controllers/releaf/content/nodes-2ac6b38702a01d9e0918f058f923b39c8320cdfa61f41c7494752b648a45e746.css"=>{"logical_path"=>"releaf/controllers/releaf/content/nodes.css", "mtime"=>"2016-01-18T13:36:15+02:00", "size"=>5919, "digest"=>"2ac6b38702a01d9e0918f058f923b39c8320cdfa61f41c7494752b648a45e746", "integrity"=>"sha256-KsazhwKgHZ4JGPBY+SOznIMgzfph9Bx0lHUrZIpF50Y="},
-        "releaf/controllers/releaf/permissions/sessions-9eb2f3275ea7578a6a95ca413d318a9984ef93c0d6645f11cf77fe82a2639cf0.css"=>{"logical_path"=>"releaf/controllers/releaf/permissions/sessions.css", "mtime"=>"2016-01-18T13:36:15+02:00", "size"=>2205, "digest"=>"9eb2f3275ea7578a6a95ca413d318a9984ef93c0d6645f11cf77fe82a2639cf0", "integrity"=>"sha256-nrLzJ16nV4pqlcpBPTGKmYTvk8DWZF8Rz3f+gqJjnPA="}
-      )
-
-      list = {
-        "releaf/content/nodes"=>{:stylesheets=>["releaf/controllers/releaf/content/nodes.css"],
-                                 :javascripts=>["releaf/controllers/releaf/content/nodes.js"]},
-        "releaf/permissions/sessions" => {:stylesheets=>["releaf/controllers/releaf/permissions/sessions.css"], :javascripts=>[]}
-      }
-      expect(described_class.compiled_assets).to eq(list)
-    end
-  end
-
-  describe ".noncompiled_assets" do
-    it "returns array with controller scoped stylesheets and javascripts" do
-      list = {
-        "releaf/content/nodes"=>{:stylesheets=>["releaf/controllers/releaf/content/nodes"],
-                                 :javascripts=>["releaf/controllers/releaf/content/nodes"]},
-        "releaf/i18n_database/translations"=>{:stylesheets=>["releaf/controllers/releaf/i18n_database/translations"],
-                                              :javascripts=>["releaf/controllers/releaf/i18n_database/translations"]},
-        "releaf/permissions/sessions" => {:stylesheets=>["releaf/controllers/releaf/permissions/sessions"], :javascripts=>[]}
-      }
-      expect(described_class.noncompiled_assets).to eq(list)
-    end
-  end
-
-  describe ".compiled_assets?" do
-    context "when `Rails.application.assets` is not nil" do
-      it "returns true" do
-        allow(Rails.application).to receive(:assets).and_return(nil)
-        expect(described_class.compiled_assets?).to be true
-      end
-    end
-
-    context "when `Rails.application.assets` is nil" do
-      it "returns false" do
-        allow(Rails.application).to receive(:assets).and_return("x")
-        expect(described_class.compiled_assets?).to be false
-      end
-    end
-  end
-
-  describe ".assets" do
-    before do
-      described_class.class_variable_set(:@@compiled_assets, nil)
-      allow(described_class).to receive(:compiled_assets).and_return("a")
-      allow(described_class).to receive(:noncompiled_assets).and_return("b")
-    end
-
-    context "when compiled assets is not available" do
-      it "returns non compiled assets" do
-        allow(described_class).to receive(:compiled_assets?).and_return(false)
-        expect(described_class.assets).to eq("b")
-      end
-    end
-
-    context "when compiled assets available" do
-      before do
-        allow(described_class).to receive(:compiled_assets?).and_return(true)
-      end
-
-      it "caches compiled assets list" do
-        expect(described_class).to receive(:compiled_assets).once.and_return("a")
-        described_class.assets
-        described_class.assets
-      end
-
-      it "returns compiled assets" do
-        expect(described_class.assets).to eq("a")
-      end
-    end
-  end
-end