bemer 0.0.0 → 0.1.0

data/lib/bemer/template_list.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+
+module Bemer
+  class TemplateList < DefaultTemplateList
+    def initialize(view, path, cached: false, prefix: true, **options)
+      super(view, cached)
+
+      @options = options
+      @path    = build_full_path(prefix, path)
+    end
+
+    def compile
+      super
+
+      add_default_templates
+
+      output = view.render(template: template, locals: { **options })
+
+      remove_template_catalog!
+
+      output
+    end
+
+    protected
+
+    attr_reader :options, :path
+
+    def add_default_templates
+      default_template = template('index.bemhtml')
+
+      return unless view.lookup_context.exists?(default_template)
+
+      view.render(template: default_template)
+    end
+
+    def template(name = 'index')
+      [path, name].join('/')
+    end
+
+    def build_full_path(prefix, path)
+      return path if prefix.blank?
+
+      path_prefix = prefix.instance_of?(TrueClass) ? default_path_prefix(path) : prefix
+
+      [path_prefix, path].reject(&:blank?).join('/')
+    end
+
+    def default_path_prefix(path)
+      return Bemer.default_path_prefix.to_s unless Bemer.default_path_prefix.respond_to?(:call)
+
+      Bemer.default_path_prefix.call(path.to_s, view)
+    end
+
+    def remove_template_catalog!
+      return unless template_catalog.owner.eql?(object_id)
+
+      view.remove_instance_variable(:@bemer_template_catalog)
+    end
+  end
+end

data/lib/bemer/tree.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/output_safety'
+require 'active_support/dependencies/autoload'
+
+module Bemer
+  class Tree
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :BaseNode
+      autoload :Node
+      autoload :TextNode
+    end
+
+    attr_accessor :parent_node
+    attr_reader   :node_metadata, :pipeline
+
+    def initialize(template_catalog, **params)
+      @node_metadata = {}
+      @params        = params
+      @parent_node   = nil
+      @pipeline      = Pipeline.new(template_catalog)
+      @root_nodes    = []
+    end
+
+    def render(&block)
+      return unless block_given?
+
+      builder = Builders::Tree.new(self)
+      output  = ActiveSupport::SafeBuffer.new
+
+      output << block.binding.receiver.capture(builder, &block)
+      output << render_root_nodes
+    end
+
+    def replace(node) # rubocop:disable Metrics/AbcSize
+      siblings = parent_node.nil? ? root_nodes : parent_node.children
+      metadata = node_metadata.delete(node.object_id)
+      position = metadata[:position]
+      offset   = position + node.replacers.length
+
+      insert_metadata(position, metadata[:last], node.replacers)
+      update_metadata(offset, siblings[position..-1])
+
+      siblings[position - 1...position] = node.replacers
+    end
+
+    def print
+      root_nodes.each(&:print)
+    end
+
+    def add(node)
+      if need_replace_parent_node?
+        parent_node.replacers << node
+      else
+        add_metadata(node.object_id)
+
+        parent_node.nil? ? root_nodes << node : parent_node.children << node
+      end
+
+      nil
+    end
+
+    def add_node(block = '', element = nil, bem_cascade: nil, **options, &content)
+      bem_cascade = inherited_bem_cascade if bem_cascade.nil?
+      new_options = { **params, bem_cascade: bem_cascade, **options }
+
+      add Node.new(self, block, element, new_options, &content)
+    end
+
+    def add_text_node(content = nil, &callback)
+      add TextNode.new(self, content, &callback)
+    end
+
+    protected
+
+    attr_reader :root_nodes, :params
+
+    def inherited_bem_cascade
+      parent_node.nil? ? params[:bem_cascade] : parent_node.bem_cascade
+    end
+
+    def need_replace_parent_node?
+      !parent_node.nil? && parent_node.need_replace?
+    end
+
+    def render_root_nodes
+      output   = ActiveSupport::SafeBuffer.new
+      position = 0
+
+      while position < root_nodes.length
+        root_node = root_nodes[position]
+
+        pipeline.run!(root_node)
+
+        next replace(root_node) if root_node.need_replace?
+
+        position += 1
+
+        output << root_node.render
+      end
+
+      output
+    end
+
+    def add_metadata(node_id)
+      siblings     = parent_node.nil? ? root_nodes : parent_node.children
+      last_sibling = siblings.last
+
+      node_metadata[last_sibling.object_id][:last] = false if last_sibling
+
+      node_metadata[node_id] = { position: siblings.length + 1, last: true }
+    end
+
+    def insert_metadata(position, last, replacers)
+      index         = 0
+      length        = replacers.length
+      last_position = length - 1
+
+      while index < length
+        data = { position: position + index, last: last && last_position.eql?(index) }
+
+        node_metadata[replacers[index].object_id] = data
+
+        index += 1
+      end
+    end
+
+    def update_metadata(offset, siblings)
+      index  = 0
+      length = siblings.length
+
+      while index < length
+        sibling = siblings[index]
+
+        node_metadata[sibling.object_id][:position] = offset + index
+
+        index += 1
+      end
+    end
+  end
+end

data/lib/bemer/tree/base_node.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Bemer
+  class Tree
+    class BaseNode
+      extend Forwardable
+
+      attr_reader :entity, :entity_builder, :tree
+
+      def_delegators :entity, :attrs, :bem, :bem_cascade, :block, :block?, :cls,
+                     :content, :elem, :elem?, :element?, :js, :mix, :mods, :name, :tag
+
+      def initialize(tree, block = '', element = nil, **options, &content)
+        @entity         = Entity.new(block, element, options, &content)
+        @entity_builder = EntityBuilder.new(block, element, options, &content)
+        @renderer       = Renderer.new
+        @tree           = tree
+      end
+
+      def render
+        entity_builder.content = capture_content
+
+        renderer.render(entity_builder)
+      end
+
+      def print(level = 0)
+        prefix = '   ' * level
+
+        puts [prefix, name, "(#{object_id})"].join
+      end
+
+      def need_replace?
+        false
+      end
+
+      protected
+
+      attr_reader :renderer
+
+      def capture_content
+        return content unless content.respond_to?(:call)
+
+        content.binding.receiver.capture(&content)
+      end
+    end
+  end
+end

data/lib/bemer/tree/node.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/output_safety'
+
+module Bemer
+  class Tree
+    class Node < BaseNode
+      attr_accessor :content_replaced, :need_replace, :params
+      attr_reader   :applied_modes, :children, :replacers
+
+      alias content_replaced? content_replaced
+      alias need_replace?     need_replace
+
+      def initialize(tree, block = '', element = nil, **options, &content)
+        super(tree, block, element, options, &content)
+
+        @applied_modes    = Pipeline::MODES.map { |mode| [mode, false] }.to_h
+        @children         = []
+        @content_replaced = false
+        @need_replace     = false
+        @params           = tree.parent_node.nil? ? {} : Hash[tree.parent_node.params]
+        @replacers        = []
+      end
+
+      def last?
+        tree.node_metadata[object_id][:last]
+      end
+
+      def first?
+        position.eql?(1)
+      end
+
+      def position
+        tree.node_metadata[object_id][:position]
+      end
+
+      def add_child_nodes
+        return content unless content.respond_to?(:call)
+
+        builder = Builders::Tree::Element.new(tree, block) if block?
+
+        content.binding.receiver.capture(builder, &content)
+      end
+
+      def replace_parent_and_execute
+        return unless block_given?
+
+        old_parent_node  = tree.parent_node
+        tree.parent_node = self
+
+        output = yield
+
+        tree.parent_node = old_parent_node
+
+        output
+      end
+
+      def print(level = 0)
+        super(level)
+
+        children.each do |node|
+          node.print(level + 1)
+        end
+      end
+
+      def apply_next(template, **params)
+        tree.pipeline.apply_next(template, self, params)
+      end
+
+      def apply(mode, template, **params)
+        tree.pipeline.apply(mode, template, self, params)
+      end
+
+      protected
+
+      def capture_content
+        output     = ActiveSupport::SafeBuffer.new
+        plain_text = replace_parent_and_execute { add_child_nodes } if need_add_child_nodes?
+
+        output << entity_builder.content if need_include_builder_content?
+        output << plain_text
+        output << render_child_nodes
+      end
+
+      def need_include_builder_content?
+        !entity_builder.content.respond_to?(:call) && !need_replace?
+      end
+
+      def need_add_child_nodes?
+        content.respond_to?(:call) && children.empty? && !content_replaced
+      end
+
+      def render_child_nodes # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        return if children.empty?
+
+        position = 0
+        output   = ActiveSupport::SafeBuffer.new
+
+        replace_parent_and_execute do
+          while position < children.length
+            node = children[position]
+
+            tree.pipeline.run!(node)
+
+            next tree.replace(node) if node.need_replace?
+
+            position += 1
+
+            output << node.render
+          end
+        end
+
+        output
+      end
+
+      def initialize_copy(original)
+        @applied_modes          = Hash[original.applied_modes]
+        @children               = []
+        @content_replaced       = false
+        @entity                 = original.entity.dup
+        @entity_builder         = original.entity_builder.dup
+        @entity_builder.content = @entity.content
+        @need_replace           = false
+        @params                 = Hash[original.params]
+        @replacers              = []
+      end
+    end
+  end
+end

data/lib/bemer/tree/text_node.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Bemer
+  class Tree
+    class TextNode < BaseNode
+      def initialize(tree, content = nil, &callback)
+        super(tree, tag: false, content: content, &callback)
+      end
+    end
+  end
+end

data/lib/bemer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bemer
-  VERSION = '0.0.0'
+  VERSION = '0.1.0'.freeze
 end

data/spec/bemer/entity_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+RSpec.describe Bemer::Entity do
+  subject(:entity) { described_class.new(:block, cls: 'class-1 class_2', class: [:class_3, 'class_4']) }
+
+  describe '#cls' do
+    it { expect(entity.cls).to match_array(%w[class-1 class_2 class-3 class_4]) }
+  end
+
+  context 'when a block' do
+    subject(:block) { described_class.new(:block) }
+
+    it { is_expected.to be_block }
+
+    describe '#name' do
+      it { expect(block.name).to eq 'block' }
+    end
+
+    describe '#bem_class' do
+      it { expect(block.bem_class).to eq 'block' }
+    end
+  end
+
+  context 'when an element' do
+    subject(:elem) { described_class.new('', :elem) }
+
+    it { is_expected.to be_element }
+
+    describe '#name' do
+      it { expect(elem.name).to eq '__elem' }
+    end
+
+    describe '#bem_class' do
+      it { expect(elem.bem_class).to eq '' }
+    end
+  end
+end

data/spec/bemer/mixin_list_spec.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+RSpec.describe Bemer::MixinList, focus: true do
+  describe 'mixins from an empty params' do
+    subject(:mixin_list) { described_class.new([nil, '', {}]) }
+
+    it 'returns an empty string' do
+      expect(mixin_list.to_s).to be_empty
+    end
+
+    it 'returns an empty array' do
+      expect(mixin_list.to_a).to be_empty
+    end
+  end
+
+  describe 'mixins from an empty array' do
+    subject(:mixin_list) { described_class.new([]) }
+
+    it 'returns an empty string' do
+      expect(mixin_list.to_s).to be_empty
+    end
+
+    it 'returns an empty array' do
+      expect(mixin_list.to_a).to be_empty
+    end
+  end
+
+  describe 'mixins from an empty hash' do
+    subject(:mixin_list) { described_class.new({}) }
+
+    it 'returns an empty string' do
+      expect(mixin_list.to_s).to be_empty
+    end
+
+    it 'returns an empty array' do
+      expect(mixin_list.to_a).to be_empty
+    end
+  end
+
+  describe 'mixins from an array' do
+    subject(:mixin_list) { described_class.new([:block_name, { block_name: %i[elem_name1 elem_name2] }, block: :elem]) }
+
+    it 'returns mixins as a string' do
+      expect(mixin_list.to_s).to eq 'block-name block-name__elem-name1 block-name__elem-name2 block__elem'
+    end
+
+    it 'returns mixins as an array' do
+      expect(mixin_list.to_a).to match_array %w[block-name block-name__elem-name1 block-name__elem-name2 block__elem]
+    end
+  end
+
+  describe 'mixins from a hash' do
+    subject(:mixin_list) { described_class.new(block_name: [nil, :elem_name1, :elem_name2], block: :elem) }
+
+    it 'returns mixins as a string' do
+      expect(mixin_list.to_s).to eq 'block-name block-name__elem-name1 block-name__elem-name2 block__elem'
+    end
+
+    it 'returns mixins as an array' do
+      expect(mixin_list.to_a).to match_array %w[block-name block-name__elem-name1 block-name__elem-name2 block__elem]
+    end
+  end
+
+  describe 'mixins from a symbol' do
+    subject(:mixin_list) { described_class.new(:block_name) }
+
+    it 'returns mixins as a string' do
+      expect(mixin_list.to_s).to eq 'block-name'
+    end
+
+    it 'returns mixins as an array' do
+      expect(mixin_list.to_a).to match_array %w[block-name]
+    end
+  end
+
+  describe 'mixins from a string' do
+    subject(:mixin_list) { described_class.new('block_name block__elem') }
+
+    it 'returns mixins as a string' do
+      expect(mixin_list.to_s).to eq 'block_name block__elem'
+    end
+
+    it 'returns mixins as an array' do
+      expect(mixin_list.to_a).to match_array %w[block_name block__elem]
+    end
+  end
+
+  describe 'mixins from a hash with string values' do
+    subject(:mixin_list) { described_class.new('BlockName' => [nil, 'ElemName', :elem_name], 'Block' => 'ElemName') }
+
+    it 'returns mixins as a string' do
+      expect(mixin_list.to_s).to eq 'BlockName BlockName__ElemName BlockName__elem-name Block__ElemName'
+    end
+
+    it 'returns mixins as an array' do
+      expect(mixin_list.to_a).to match_array %w[BlockName BlockName__ElemName BlockName__elem-name Block__ElemName]
+    end
+  end
+end