bemer 0.0.0 → 0.1.0

data/lib/bemer/entity.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/keys'
+
+module Bemer
+  class Entity
+    attr_accessor :bem_cascade
+    attr_reader   :bem, :bem_class, :block, :content, :elem, :js, :name, :tag
+
+    alias element elem
+
+    def initialize(block = '', element = nil, **options, &content)
+      @bem_class = Bemer.bem_class(block, element)
+      @block     = block
+      @content   = extract_content(options.delete(:content), &content)
+      @elem      = element
+      @name      = Bemer.entity_name(block, element)
+
+      extract_options!(options)
+    end
+
+    def attrs
+      @attrs ||= build_attrs(html_attrs)
+    end
+
+    def block?
+      !element?
+    end
+
+    def cls
+      @cls ||= build_css_classes(css_classes)
+    end
+
+    def elem?
+      !elem.nil?
+    end
+
+    alias element? elem?
+
+    def mix
+      @mix ||= mixins.to_a
+    end
+
+    def mods
+      @mods ||= modifiers.to_h
+    end
+
+    protected
+
+    attr_reader :css_classes, :html_attrs, :mixins, :modifiers
+
+    def extract_content(plain_text, &content)
+      block_given? ? content : plain_text
+    end
+
+    def extract_options!(options) # rubocop:disable Metrics/AbcSize
+      @bem         = options.delete(:bem)
+      @bem_cascade = options.delete(:bem_cascade)
+      @css_classes = [options.delete(:class), options.delete(:cls)]
+      @js          = options.delete(:js)
+      @mixins      = MixinList.new(options.delete(:mix))
+      @modifiers   = ModifierList.new(block, element, options.delete(:mods))
+      @tag         = build_tag(options.delete(:tag))
+      @html_attrs  = options
+    end
+
+    def build_css_classes(*classes)
+      classes.map do |css_class|
+        next [] if css_class.blank?
+
+        case css_class
+        when String then css_class.split
+        when Array  then css_class.map { |css_cls| build_css_classes(css_cls) }
+        else Bemer.css_class(css_class)
+        end
+      end.flatten.uniq
+    end
+
+    def build_tag(new_tag)
+      return new_tag if new_tag.nil? || new_tag.instance_of?(Symbol)
+
+      new_tag.blank? ? '' : new_tag.to_sym
+    end
+
+    def build_attrs(new_attrs)
+      case new_attrs
+      when Array then new_attrs.to_h.symbolize_keys
+      when Hash  then new_attrs.symbolize_keys
+      else {}
+      end
+    end
+  end
+end

data/lib/bemer/entity_builder.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/deep_merge'
+
+module Bemer
+  class EntityBuilder < Entity
+    def attrs
+      attributes         = Hash[super]
+      attributes[:class] = cls
+
+      return attributes unless bem?
+
+      attributes.deep_merge!(js)
+    end
+
+    def attrs=(new_attrs, save = true)
+      new_attrs = build_attrs(new_attrs)
+
+      save ? @attrs = new_attrs : new_attrs
+    end
+
+    def bem
+      bem_via_option? ? super : true
+    end
+
+    def bem=(new_bem, save = true)
+      save ? @bem = new_bem : new_bem
+    end
+
+    def bem?
+      bem_enabled_via_option? || bem_cascade_enabled_via_option? || bem_enabled_fully?
+    end
+
+    def bem_cascade
+      bem_cascade_via_option? ? super : true
+    end
+
+    def bem_cascade=(new_bem_cascade, save = true)
+      save ? @bem_cascade = new_bem_cascade : new_bem_cascade
+    end
+
+    def cls
+      return super unless bem?
+
+      js_class = 'i-bem' if @js.present? && bem_class.present?
+
+      [bem_class, mods, mix, super, js_class].reject(&:blank?)
+    end
+
+    def cls=(new_cls, save = true)
+      new_cls = build_css_classes(new_cls)
+
+      save ? @cls = new_cls : new_cls
+    end
+
+    def content=(new_content, save = true)
+      save ? @content = new_content : new_content
+    end
+
+    def js
+      return {} if @js.blank? || bem_class.blank?
+
+      attrs = @js.instance_of?(TrueClass) ? {} : super
+
+      { data: { bem: { name => attrs } } }
+    end
+
+    def js=(new_js, save = true)
+      save ? @js = new_js : new_js
+    end
+
+    def mix=(new_mix, save = true)
+      new_mix = MixinList.new(new_mix).to_a
+
+      save ? @mix = new_mix : new_mix
+    end
+
+    def mods
+      modifiers.to_a
+    end
+
+    def mods=(new_mods, save = true)
+      modifiers  = ModifierList.new(block, element, new_mods)
+      @modifiers = modifiers if save
+
+      modifiers.to_h
+    end
+
+    def tag
+      super.nil? ? default_tag : @tag
+    end
+
+    def tag=(new_tag, save = true)
+      new_tag = build_tag(new_tag)
+
+      save ? @tag = new_tag : new_tag
+    end
+
+    protected
+
+    def bem_via_option?
+      !@bem.nil?
+    end
+
+    def bem_cascade_via_option?
+      !@bem_cascade.nil?
+    end
+
+    def bem_enabled_via_option?
+      bem_via_option? && bem
+    end
+
+    def bem_cascade_enabled_via_option?
+      bem_cascade_via_option? && bem_cascade && bem
+    end
+
+    def bem_enabled_fully?
+      Bemer.bem && bem_cascade && bem
+    end
+
+    def default_tag
+      block? ? Bemer.default_block_tag : Bemer.default_element_tag
+    end
+  end
+end

data/lib/bemer/helpers.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Bemer
+  module Helpers
+    def block_tag(name = '', **options, &content)
+      Bemer::Tag.new(name, options, &content).render
+    end
+
+    def elem_tag(block = '', element = '', **options, &content)
+      Bemer::Tag.new(block, element, options, &content).render
+    end
+
+    def bem_mix(*mix)
+      Bemer::MixinList.new(mix).to_s
+    end
+
+    def bem_mods(*block_and_element, mods)
+      block, element = *block_and_element
+
+      Bemer::ModifierList.new(block, element, mods).to_s
+    end
+
+    def render_component(path, **options, &block)
+      Bemer::TemplateList.new(self, path, options).compile(&block)
+    end
+
+    alias refine_component render_component
+
+    def define_templates(cached: true, &block)
+      Bemer::DefaultTemplateList.new(self, cached).compile(&block)
+    end
+
+    def define_component(**options, &block)
+      Bemer::Component.new(self).render(options, &block)
+    end
+
+    def component_pack(&block)
+      Bemer::ComponentPack.new(self).render(&block)
+    end
+  end
+end

data/lib/bemer/mixin_list.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+
+module Bemer
+  class MixinList
+    def initialize(mix)
+      @mix    = mix
+      @mixins = nil
+    end
+
+    def to_a
+      build_mixins
+    end
+
+    def to_s
+      @mix_as_string ||= to_a.join(' ')
+    end
+
+    protected
+
+    attr_reader :mixins
+
+    def build_mixins
+      return mixins unless mixins.nil?
+
+      mix = @mix.instance_of?(Hash) ? build_mixins_from_hash : build_mixins_from_array
+
+      @mixins = mix.flatten.reject(&:blank?).uniq
+    end
+
+    def build_mixin(mixin)
+      return mixin.split if mixin.instance_of?(String)
+
+      case mixin
+      when Symbol then Bemer.bem_class(mixin)
+      when Array  then build_mixin_from_array(mixin)
+      when Hash   then build_mixin_from_hash(mixin)
+      end
+    end
+
+    def build_mixin_from_hash(mixin)
+      mixin.map do |block, element|
+        next Bemer.bem_class(block, element) unless element.instance_of?(Array)
+
+        element.map { |elem| Bemer.bem_class(block, elem) }
+      end
+    end
+
+    def build_mixin_from_array(mixin)
+      block, element = *mixin
+
+      return Bemer.bem_class(block, element) unless element.instance_of?(Array)
+
+      element.map { |elem| Bemer.bem_class(block, elem) }
+    end
+
+    def build_mixins_from_hash
+      @mix.map do |mixin|
+        next if mixin.blank?
+
+        build_mixin(mixin)
+      end
+    end
+
+    def build_mixins_from_array
+      Array(@mix).map do |mixin|
+        next if mixin.blank?
+
+        mixin.instance_of?(Array) ? mixin.map { |mix| build_mixin(mix) } : build_mixin(mixin)
+      end
+    end
+  end
+end

data/lib/bemer/modifier_list.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/indifferent_access'
+
+module Bemer
+  class ModifierList
+    def initialize(block, element, mods)
+      @bem_class = Bemer.bem_class(block, element)
+      @modifiers = nil
+      @mods      = mods
+    end
+
+    def to_a
+      @mods_as_array ||= to_h.map { |name, value| build_css_class(name, value) }
+    end
+
+    def to_s
+      @mods_as_string ||= to_a.join(' ')
+    end
+
+    def to_h
+      modifiers.nil? ? build_modifiers : modifiers
+    end
+
+    protected
+
+    attr_reader :modifiers
+
+    def build_modifiers
+      @modifiers = ActiveSupport::HashWithIndifferentAccess.new
+
+      return modifiers if @mods.blank? || @bem_class.blank?
+
+      Array(@mods).each do |mods|
+        next if mods.blank?
+
+        mods.is_a?(Hash) ? mods.each { |attrs| add_modifier(attrs) } : add_modifier(mods)
+      end
+
+      modifiers
+    end
+
+    def add_modifier(attrs)
+      name, value = normalize(attrs)
+
+      return if name.blank? || value.blank?
+
+      modifiers[name] = value
+    end
+
+    def normalize(attrs)
+      name, value = *attrs, true
+
+      value = Bemer.css_class(value) unless [TrueClass, FalseClass, NilClass].include?(value.class)
+
+      [Bemer.css_class(name), value]
+    end
+
+    def build_css_class(name, value)
+      # rubocop:disable Metrics/LineLength
+      modifier = value.instance_of?(TrueClass) ? name : [name, value].join(Bemer.modifier_value_separator)
+      # rubocop:enable Metrics/LineLength
+
+      [@bem_class, modifier].join(Bemer.modifier_name_separator)
+    end
+  end
+end

data/lib/bemer/pipeline.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'active_support/dependencies/autoload'
+
+module Bemer
+  class Pipeline
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :Handler
+    end
+
+    ADD_ATTRS_MODE = :add_attrs
+    ADD_CLS_MODE   = :add_cls
+    ADD_MIX_MODE   = :add_mix
+    ADD_MODS_MODE  = :add_mods
+    ATTRS_MODE     = :attrs
+    BEM_MODE       = :bem
+    CLS_MODE       = :cls
+    CONTENT_MODE   = :content
+    JS_MODE        = :js
+    MIX_MODE       = :mix
+    MODS_MODE      = :mods
+    REPLACE_MODE   = :replace
+    TAG_MODE       = :tag
+
+    ADD_MODES               = [ADD_ATTRS_MODE, ADD_CLS_MODE, ADD_MIX_MODE, ADD_MODS_MODE].freeze
+    STRUCTURE_RELATED_MODES = [REPLACE_MODE, CONTENT_MODE].freeze
+    BEM_RELATED_MODES       = [MODS_MODE, MIX_MODE, JS_MODE].freeze
+    TAG_RELATED_MODES       = [CLS_MODE, ATTRS_MODE, BEM_MODE, *BEM_RELATED_MODES].freeze
+    MODES                   = [REPLACE_MODE, CONTENT_MODE, TAG_MODE, *TAG_RELATED_MODES].freeze
+
+    def initialize(template_catalog)
+      @handlers         = {}
+      @template_catalog = template_catalog
+    end
+
+    def run!(node)
+      return node if node.instance_of?(Tree::TextNode)
+
+      MODES.each do |mode|
+        handler_by(node.name).apply!(mode, node)
+
+        break if processing_completed?(mode, node)
+      end
+
+      node
+    end
+
+    def apply_next(template, node, **params)
+      handler_by(node.name).apply_next(template, node, params)
+    end
+
+    def apply(mode, template, node, **params)
+      handler_by(node.name).apply(mode, template, node, params)
+    end
+
+    protected
+
+    attr_reader :handlers, :template_catalog
+
+    def processing_completed?(mode, node)
+      return true if JS_MODE.eql?(mode)
+
+      case mode
+      when REPLACE_MODE then node.need_replace?
+      when TAG_MODE then node.entity_builder.tag.blank?
+      when BEM_MODE then !node.entity_builder.bem?
+      else false
+      end
+    end
+
+    def handler_by(name)
+      return handlers[name] if handlers.key?(name)
+
+      templates = compiled_templates.select { |template| template.name_match?(name) }
+
+      handlers[name] = Handler.new(templates)
+    end
+
+    def compiled_templates
+      @compiled_templates ||= template_catalog.compiled_templates
+    end
+  end
+end