bemer 0.0.0 → 0.1.0

data/lib/bemer/pipeline/handler.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+
+module Bemer
+  class Pipeline
+    class Handler
+      def initialize(templates)
+        @priorities = Pipeline::MODES.map { |mode| [mode, {}] }.to_h
+        @container  = Pipeline::MODES.map { |mode| [mode, []] }.to_h
+
+        prioritize(templates)
+      end
+
+      def apply!(mode, node)
+        return if node.applied_modes[mode].present? || !allowable_mode?(mode)
+
+        apply_template!(mode, node)
+      end
+
+      def apply_next(current_template, node, **params)
+        position = priorities[current_template.mode][current_template.object_id] + 1
+
+        apply_template(current_template.mode, node, position, params)
+      end
+
+      def apply(mode, current_template, node, **params)
+        return unless allowable_mode?(mode) && compatible_modes?(mode, current_template.mode)
+
+        if current_template.mode.eql?(mode)
+          apply_next(current_template, node, params)
+        else
+          apply_template(mode, node, params)
+        end
+      end
+
+      protected
+
+      attr_reader :priorities, :container
+
+      def compatible_modes?(mode, current_mode)
+        return true if Pipeline::STRUCTURE_RELATED_MODES.include?(current_mode)
+
+        !Pipeline::STRUCTURE_RELATED_MODES.include?(mode)
+      end
+
+      def allowable_mode?(mode)
+        Pipeline::MODES.include?(mode)
+      end
+
+      def apply_template(mode, node, position = 0, **params)
+        template   = find_template(mode, node, position)
+        old_params = Hash[node.params]
+
+        node.params.merge!(params)
+
+        output      = template.nil? ? CommonTemplate.new(mode).apply!(node) : template.apply(node)
+        node.params = old_params
+
+        output
+      end
+
+      def apply_template!(mode, node)
+        node.applied_modes[mode] = true
+        template                 = find_template(mode, node)
+        output                   = template ? template.apply!(node) : nil
+
+        disable_related_modes!(mode, node)
+
+        output
+      end
+
+      def disable_related_modes!(mode, node)
+        return unless [Pipeline::TAG_MODE, Pipeline::BEM_MODE].include?(mode)
+
+        if Pipeline::TAG_MODE.eql?(mode)
+          disable_tag_related_modes!(node)
+        else
+          disable_bem_related_modes!(node)
+        end
+      end
+
+      def disable_tag_related_modes!(node)
+        return if node.entity_builder.tag.present?
+
+        Pipeline::TAG_RELATED_MODES.each { |mode| node.applied_modes[mode] = true }
+      end
+
+      def disable_bem_related_modes!(node)
+        return if node.entity_builder.bem?
+
+        Pipeline::BEM_RELATED_MODES.each { |mode| node.applied_modes[mode] = true }
+      end
+
+      def prioritize(templates) # rubocop:disable Metrics/AbcSize
+        wildcard_container = Pipeline::MODES.map { |mode| [mode, []] }.to_h
+
+        templates.each do |template|
+          next wildcard_container[template.mode].push(template) if template.wildcard?
+
+          priorities[template.mode][template.object_id] = container[template.mode].length
+
+          container[template.mode].push(template)
+        end
+
+        wildcard_container.each do |mode, wildcard_templates|
+          prepend_wildcard_templates(mode, wildcard_templates)
+        end
+      end
+
+      def prepend_wildcard_templates(mode, templates)
+        return if templates.empty?
+
+        templates.reverse_each do |template|
+          priorities[mode].each { |id, priority| priorities[mode][id] = priority + 1 }
+
+          priorities[mode][template.object_id] = 0
+
+          container[mode].unshift(template)
+        end
+      end
+
+      def find_template(mode, node, start = 0)
+        templates = container[mode][start..-1]
+
+        return if templates.empty?
+
+        templates.detect { |template| template.match?(node) }
+      end
+    end
+  end
+end

data/lib/bemer/predicate.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Bemer
+  class Predicate
+    def initialize(**options)
+      @block     = options[:block]
+      @condition = options[:condition].nil? ? true : options[:condition]
+      @element   = options[:elem]
+      @mask      = build_mask(options[:block], options[:elem])
+      @mixins    = MixinList.new(options[:mix])
+      @modifiers = ModifierList.new(:block, :elem, options[:mods])
+      @wildcard  = nil
+    end
+
+    def match?(node)
+      condition?(node) && mix?(node.mix) && mods?(node.mods)
+    end
+
+    def name_match?(name)
+      Bemer.can_use_new_matcher? ? mask.match?(name) : mask =~ name
+    end
+
+    def wildcard?
+      return wildcard unless wildcard.nil?
+
+      @wildcard = name.include?('*')
+    end
+
+    protected
+
+    attr_reader :block, :element, :condition, :mask, :mixins, :name, :wildcard
+
+    def condition?(node)
+      return condition unless condition.respond_to?(:call)
+
+      condition.call Context.new(node)
+    end
+
+    def mix?(mix)
+      (mixins.to_a - mix).empty?
+    end
+
+    def mods?(mods)
+      return false if modifiers.keys.length > mods.keys.length
+
+      modifiers.all? do |name, value|
+        val = mods[name]
+
+        val.nil? ? false : (Array(value) - Array(val)).empty?
+      end
+    end
+
+    def modifiers
+      @modifiers.to_h
+    end
+
+    def build_mask(block, element)
+      @name = Bemer.entity_name(block, element)
+
+      name.eql?('*') ? /^((?!#{Bemer.element_name_separator}).)*$/ : /^#{name.gsub('*', '.*')}$/
+    end
+  end
+end

data/lib/bemer/railtie.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Bemer
+  class Railtie < ::Rails::Railtie
+    config.eager_load_namespaces << Bemer if config.respond_to?(:eager_load_namespaces)
+
+    config.after_initialize do
+      ActionController::Base.prepend_view_path([Bemer.path, *Bemer.paths])
+      ActionMailer::Base.prepend_view_path([Bemer.path, *Bemer.paths])
+    end
+
+    initializer 'bemer.helpers' do
+      ActiveSupport.on_load(:action_view) { include Bemer::Helpers }
+    end
+
+    initializer_name =
+      case ::Rails::VERSION::MAJOR
+      when 5    then :append_assets_path
+      when 3..4 then :load_config_initializers
+      end
+
+    initializer 'bemer.prepend_asset_paths', group: :all, after: initializer_name do |app|
+      next unless defined?(::Sprockets) && Bemer.prepend_asset_paths?
+
+      app.config.assets.paths.unshift(Bemer.path.to_s, *Bemer.asset_paths)
+    end
+
+    initializer 'bemer.assets_precompile', group: :all, after: :load_config_initializers do |app|
+      next if ::Rails::VERSION::MAJOR > 3 || !defined?(::Sprockets)
+
+      asset_matcher = Bemer::AssetMatcher.new(app.config.assets.precompile.shift)
+
+      app.config.assets.precompile.unshift(asset_matcher)
+    end
+  end
+end

data/lib/bemer/renderer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'action_view/helpers/tag_helper'
+
+module Bemer
+  class Renderer
+    include ::ActionView::Helpers::TagHelper
+
+    def render(builder)
+      return builder.content if builder.tag.blank?
+
+      content_tag(builder.tag, builder.content, builder.attrs)
+    end
+  end
+end

data/lib/bemer/tag.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Bemer
+  class Tag
+    extend Forwardable
+
+    def initialize(block = '', element = nil, **options, &content)
+      @bem_cascade = options[:bem_cascade]
+      @tag_builder = TagBuilder.new(block, element, options, &content)
+      @renderer    = Renderer.new
+    end
+
+    def render
+      tag_builder.content = capture_content
+
+      renderer.render(tag_builder)
+    end
+
+    protected
+
+    attr_reader :bem_cascade, :renderer, :tag_builder
+
+    def_delegators :tag_builder, :block, :block?, :content
+
+    def capture_content
+      return content unless content.respond_to?(:call)
+
+      builder = Builders::Tag::Element.new(block, bem_cascade) if block?
+
+      content.binding.receiver.capture(builder, &content)
+    end
+  end
+end

data/lib/bemer/tag_builder.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Bemer
+  class TagBuilder < EntityBuilder
+    protected
+
+    def bem_enabled_fully?
+      bem_cascade && bem
+    end
+  end
+end

data/lib/bemer/template.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Bemer
+  class Template < CommonTemplate
+    extend Forwardable
+
+    def_delegators :predicate, :wildcard?, :match?, :name_match?
+
+    def initialize(mode, body, predicate)
+      super(mode)
+
+      @add_mode  = !@mode.eql?(mode)
+      @body      = body
+      @method    = [@mode, '='].join.to_sym
+      @predicate = predicate
+    end
+
+    def apply(node)
+      case mode
+      when Pipeline::REPLACE_MODE then replace(node)
+      when Pipeline::CONTENT_MODE then capture_content(node)
+      else node.entity_builder.public_send(method, capture_body(node), false)
+      end
+    end
+
+    def apply!(node)
+      return replace!(node) if Pipeline::REPLACE_MODE.eql?(mode)
+
+      content = Pipeline::CONTENT_MODE.eql?(mode) ? capture_content!(node) : capture_body(node)
+
+      node.entity_builder.public_send(method, content)
+    end
+
+    protected
+
+    attr_reader :add_mode, :body, :method, :predicate
+
+    alias add_mode? add_mode
+
+    def capture_content(node)
+      return body unless body.respond_to?(:call)
+
+      builder = Builders::Tree.new(node.tree)
+
+      body.binding.receiver.capture(build_context(node), builder, &body)
+    end
+
+    def capture_body(node)
+      output = body.respond_to?(:call) ? body.call(build_context(node)) : body
+
+      return output unless add_mode?
+
+      normalized_output = node.entity_builder.public_send(method, output, false)
+
+      [*node.apply(mode, self), *normalized_output]
+    end
+
+    def replace(node)
+      output = capture_content(node)
+
+      return if output.blank?
+
+      node.replacers.unshift Tree::TextNode.new(node.tree, output)
+
+      nil
+    end
+
+    def replace!(node)
+      node.need_replace = true
+
+      node.replace_parent_and_execute { replace(node) }
+    end
+
+    def capture_content!(node)
+      node.content_replaced = true
+
+      node.replace_parent_and_execute { capture_content(node) }
+    end
+
+    def build_context(node)
+      context = Context.new(node, self).extend(ContextExtentions::Template)
+
+      return context unless Pipeline::STRUCTURE_RELATED_MODES.include?(mode)
+
+      context.extend(ContextExtentions::Structure)
+    end
+  end
+end

data/lib/bemer/template_catalog.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'active_support/dependencies/autoload'
+
+module Bemer
+  class TemplateCatalog
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :Drawer
+    end
+
+    attr_reader :owner
+
+    def initialize(owner)
+      @drawers        = {}
+      @owner          = owner
+      @template_queue = []
+    end
+
+    def compiled_templates
+      template_queue  = @template_queue
+      @template_queue = []
+
+      template_queue.flat_map { |id| drawers[id].compiled_templates }
+    end
+
+    def add(path, cached = false, &block)
+      return unless block_given?
+
+      id = [block.source_location, path].join(':')
+
+      @template_queue << id
+
+      drawers[id] = Drawer.new(cached, &block) unless drawers.key?(id) && drawers[id].cached?
+    end
+
+    protected
+
+    attr_reader :drawers
+  end
+end

data/lib/bemer/template_catalog/drawer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Bemer
+  class TemplateCatalog
+    class Drawer
+      attr_reader :cached
+
+      alias cached? cached
+
+      def initialize(cached = false, &block)
+        @block  = block
+        @cached = cached
+      end
+
+      def compiled_templates
+        @compiled_templates ||= begin
+          new_templates = []
+          builder       = Builders::TemplateList.new(new_templates)
+
+          block.binding.receiver.capture(builder, &block)
+
+          new_templates
+        end
+      end
+
+      protected
+
+      attr_reader :block
+    end
+  end
+end