bemer 0.0.0 → 0.1.0

data/lib/bemer/builders/template.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Bemer
+  module Builders
+    class Template
+      ALL_METHODS            = [*Pipeline::MODES, *Pipeline::ADD_MODES].freeze
+      MULTI_ARGUMENT_METHODS = [Pipeline::ADD_CLS_MODE, Pipeline::ADD_MIX_MODE,
+                                Pipeline::CLS_MODE, Pipeline::MIX_MODE].freeze
+
+      private_constant :ALL_METHODS, :MULTI_ARGUMENT_METHODS
+
+      def initialize(templates, block: '*', elem: nil, condition: true, **options)
+        @block     = block
+        @element   = elem
+        @condition = condition
+        @options   = options
+        @predicate = Bemer::Predicate.new(block: block, elem: elem, condition: condition, **options)
+        @templates = templates
+      end
+
+      (ALL_METHODS - MULTI_ARGUMENT_METHODS - Pipeline::STRUCTURE_RELATED_MODES).each do |mode|
+        define_method(mode) do |body|
+          templates.unshift Bemer::Template.new(mode, body, predicate)
+        end
+      end
+
+      MULTI_ARGUMENT_METHODS.each do |mode|
+        define_method(mode) do |*body|
+          body, = *body if body[0].respond_to?(:call)
+
+          templates.unshift Bemer::Template.new(mode, body, predicate)
+        end
+      end
+
+      Pipeline::STRUCTURE_RELATED_MODES.each do |mode|
+        define_method(mode) do |body = nil, &block|
+          body = block if block.respond_to?(:call)
+
+          templates.unshift Bemer::Template.new(mode, body, predicate)
+        end
+      end
+
+      def specify(condition = @condition, block: @block, elem: @element, **new_options)
+        block   = @block.eql?('*') ? block : @block
+        elem    = @element.nil? || @element.eql?('*') ? elem : @element
+        params  = { **new_options, **options, condition: condition, block: block, elem: elem }
+        builder = Builders::Template.new(templates, params)
+
+        block_given? ? yield(builder) : builder
+      end
+
+      protected
+
+      attr_reader :templates, :predicate, :options
+    end
+  end
+end

data/lib/bemer/builders/template_list.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Bemer
+  module Builders
+    class TemplateList
+      def initialize(templates)
+        @templates = templates
+      end
+
+      def block(name = '*', condition = true, **options)
+        params = { **options, condition: condition, block: name, elem: nil }
+
+        builder = Builders::Template.new(templates, params)
+
+        block_given? ? yield(builder) : builder
+      end
+
+      def elem(name = '*', condition = true, block: '*', **options)
+        params = { **options, condition: condition, block: block || '*', elem: name }
+
+        builder = Builders::Template.new(templates, params)
+
+        block_given? ? yield(builder) : builder
+      end
+
+      def match(condition = true, block: '*', elem: '*', **options)
+        entities = []
+
+        entities << { block: block } if need_block?(block, elem)
+        entities << { block: block || '*', elem: elem } if need_element?(elem)
+
+        builders = entities.map do |entity|
+          Builders::Template.new(templates, **options, condition: condition, **entity)
+        end
+
+        return yield(builders[0], builders[1]) if block_given?
+
+        builders.length.odd? ? builders[0] : builders
+      end
+
+      protected
+
+      attr_reader :templates
+
+      def need_block?(block, element)
+        return true if block.eql?('*') && element.eql?('*')
+
+        !block.nil? && !block.instance_of?(FalseClass) && !need_element?(element)
+      end
+
+      def need_element?(element)
+        !element.nil? && !element.instance_of?(FalseClass)
+      end
+    end
+  end
+end

data/lib/bemer/builders/tree.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'active_support/dependencies/autoload'
+
+module Bemer
+  module Builders
+    class Tree
+      extend ActiveSupport::Autoload
+
+      eager_autoload do
+        autoload :Element
+      end
+
+      def initialize(tree)
+        @tree = tree
+      end
+
+      def block(name = '', **options, &content)
+        tree.add_node(name, options, &content)
+      end
+
+      def elem(block = '', name = '', **options, &content)
+        tree.add_node(block, name, options, &content)
+      end
+
+      def text(content = nil, &callback)
+        tree.add_text_node(content, &callback)
+      end
+
+      protected
+
+      attr_reader :tree
+    end
+  end
+end

data/lib/bemer/builders/tree/element.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Bemer
+  module Builders
+    class Tree
+      class Element
+        def initialize(tree, block)
+          @tree  = tree
+          @block = block
+        end
+
+        def elem(name = '', **options, &content)
+          tree.add_node(block, name, options, &content)
+        end
+
+        protected
+
+        attr_reader :tree, :block
+      end
+    end
+  end
+end

data/lib/bemer/common_template.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Bemer
+  class CommonTemplate
+    attr_reader :mode
+
+    def initialize(mode)
+      @mode = mode.to_s.sub('add_', '').to_sym
+    end
+
+    def apply!(node)
+      case mode
+      when Pipeline::REPLACE_MODE then replace!(node)
+      when Pipeline::CONTENT_MODE then node.add_child_nodes
+      else node.public_send(mode)
+      end
+    end
+
+    protected
+
+    def replace!(node)
+      node.need_replace = true
+
+      node.replacers << node.dup
+
+      nil
+    end
+  end
+end

data/lib/bemer/component.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Bemer
+  class Component
+    def initialize(view)
+      @template_catalog = view.instance_variable_get(:@bemer_template_catalog)
+    end
+
+    def render(**options, &block)
+      return if !block_given? || template_catalog.nil?
+
+      Tree.new(template_catalog, options).render(&block)
+    end
+
+    protected
+
+    attr_reader :template_catalog
+  end
+end

data/lib/bemer/component_pack.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Bemer
+  class ComponentPack
+    def initialize(view)
+      @view = view
+    end
+
+    def render
+      return unless block_given?
+
+      create_template_catalog!
+
+      yield
+
+      remove_template_catalog!
+
+      nil
+    end
+
+    protected
+
+    attr_reader :view
+
+    def create_template_catalog!
+      return unless view.instance_variable_get(:@bemer_template_catalog).nil?
+
+      view.assign(bemer_template_catalog: TemplateCatalog.new(object_id))
+    end
+
+    def remove_template_catalog!
+      template_catalog = view.instance_variable_get(:@bemer_template_catalog)
+
+      return if template_catalog.nil? || !template_catalog.owner.eql?(object_id)
+
+      view.remove_instance_variable(:@bemer_template_catalog)
+    end
+  end
+end

data/lib/bemer/configuration.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module Bemer
+  class Configuration
+    include Singleton
+
+    attr_accessor :bem, :default_block_tag, :default_element_tag, :default_path_prefix,
+                  :element_name_separator, :modifier_name_separator, :modifier_value_separator,
+                  :prepend_asset_paths, :paths, :asset_paths
+    attr_reader   :can_use_new_matcher
+    attr_writer   :path
+
+    alias can_use_new_matcher? can_use_new_matcher
+
+    def initialize # rubocop:disable Metrics/MethodLength
+      @asset_paths              = []
+      @bem                      = false
+      @can_use_new_matcher      = RUBY_VERSION >= '2.4.0'
+      @default_block_tag        = :div
+      @default_element_tag      = :div
+      @default_path_prefix      = nil
+      @element_name_separator   = '__'
+      @modifier_name_separator  = '_'
+      @modifier_value_separator = '_'
+      @path                     = 'app/bemer_components'
+      @paths                    = []
+      @prepend_asset_paths      = true
+    end
+
+    def path
+      Rails.root.join(@path)
+    end
+  end
+end

data/lib/bemer/context.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Bemer
+  class Context
+    extend Forwardable
+
+    def_delegators :node, :bem, :bem_cascade, :block, :elem, :first?, :last?, :name, :position, :tag
+
+    def initialize(node, template = nil)
+      @node     = node
+      @template = template
+    end
+
+    def params
+      @params ||= Hash[node.params]
+    end
+
+    def attrs
+      @attrs ||= Hash[node.attrs]
+    end
+
+    def cls
+      @cls ||= node.cls.dup
+    end
+
+    def js
+      @js ||= node.js.dup
+    end
+
+    def mix
+      @mix ||= node.mix.dup
+    end
+
+    def mods
+      @mods ||= ActiveSupport::HashWithIndifferentAccess[node.mods]
+    end
+
+    protected
+
+    attr_reader :template, :node
+  end
+end

data/lib/bemer/context_extentions.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'active_support/dependencies/autoload'
+
+module Bemer
+  module ContextExtentions
+    extend ActiveSupport::Autoload
+
+    autoload :Structure
+    autoload :Template
+  end
+end

data/lib/bemer/context_extentions/structure.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Bemer
+  module ContextExtentions
+    module Structure
+      def content(**options)
+        old_params = Hash[node.params]
+
+        node.params.merge!(options)
+
+        output      = node.add_child_nodes
+        node.params = old_params
+
+        output
+      end
+
+      def ctx(**options)
+        duplicate = node.dup
+
+        duplicate.params.merge!(options)
+
+        bem_cascade                          = node.tree.parent_node.bem_cascade
+        duplicate.entity.bem_cascade         = bem_cascade
+        duplicate.entity_builder.bem_cascade = bem_cascade
+
+        node.tree.add(duplicate)
+
+        nil
+      end
+    end
+  end
+end

data/lib/bemer/context_extentions/template.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Bemer
+  module ContextExtentions
+    module Template
+      def apply_next(**options)
+        node.apply_next(template, options)
+      end
+
+      def apply(mode, **options)
+        node.apply(mode, template, options)
+      end
+    end
+  end
+end

data/lib/bemer/default_template_list.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Bemer
+  class DefaultTemplateList
+    def initialize(view, cached = true)
+      @path   = ''
+      @view   = view
+      @cached = cached
+    end
+
+    def compile(&block)
+      template_catalog.add(path, cached, &block)
+    end
+
+    protected
+
+    attr_reader :cached, :path, :view
+
+    def template_catalog
+      template_catalog = view.instance_variable_get(:@bemer_template_catalog)
+
+      return template_catalog unless template_catalog.nil?
+
+      build_template_catalog!
+    end
+
+    def build_template_catalog!
+      template_catalog = TemplateCatalog.new(object_id)
+
+      view.assign(bemer_template_catalog: template_catalog)
+
+      template_catalog
+    end
+  end
+end