card-mod-bootstrap 0.11.2 → 0.12.0

data/lib/card/bootstrap/component/layout.rb

@@ -0,0 +1,107 @@
+class Card
+  class Bootstrap
+    class Component
+      # generate bootstrap column layout
+      # @example
+      #   layout container: true, fluid: true, class: "hidden" do
+      #     row 6, 6, class: "unicorn" do
+      #       column "horn",
+      #       column "rainbow", class: "colorful"
+      #     end
+      #   end
+      # @example
+      #   layout do
+      #     row 3, 3, 4, 2, class: "unicorn" do
+      #       [ "horn", "body", "tail", "rainbow"]
+      #     end
+      #     add_html "<span> some extra html</span>"
+      #     row 6, 6, ["unicorn", "rainbow"], class: "horn"
+      #   end
+      class Layout < OldComponent
+        def render
+          @rendered = begin
+            render_content
+            @content[-1]
+          end
+        end
+
+        def render_content
+          content = instance_exec(*@args, &@build_block)
+          add_content content
+          opts = @args.first
+          return unless opts&.delete(:container)
+
+          content = @content.pop
+          @content = ["".html_safe]
+          container content, opts
+        end
+
+        add_div_method :container, nil do |opts, _extra_args|
+          prepend_class opts, opts.delete(:fluid) ? "container-fluid" : "container"
+          opts
+        end
+
+        # @param args column widths, column content and html attributes
+        # @example
+        #   row 6, 6, ["col one", "col two"], class: "count", id: "count"
+        # @example
+        #   row md: 12, xs: 8, "single column content"
+        # @example
+        #   row md: [1, 11], xs: [2, 10] do
+        #     col "A"
+        #     col "B"
+        #   end
+        add_div_method :row, "row", content_processor: :column do |opts, extra_args|
+          cols_content = extra_args.pop if extra_args.last.is_a? Array
+          [opts, col_widths(extra_args, opts), cols_content].compact
+        end
+
+        # default column width type is for medium devices (col-md-)
+        add_div_method :column, nil do |opts, _extra_args|
+          @child_args.last.each do |medium, size|
+            if medium == :xs
+              prepend_class opts, "col-#{size.shift}"
+            else
+              prepend_class opts, "col-#{medium}-#{size.shift}"
+            end
+          end
+          opts
+        end
+
+        alias_method :col, :column
+
+        private
+
+        def standardize_row_args args
+          opts = args.last.is_a?(Hash) ? args.pop : {}
+          cols = (args.last.is_a?(Array) || args.last.is_a?(String)) &&
+                 Array.wrap(args.pop)
+          [cols, opts, col_widths(args, opts)]
+        end
+
+        def col_widths args, opts
+          opts = args.pop if args.one? && args.last.is_a?(Hash)
+          if args.present?
+            col_widths_from_args args
+          else
+            col_widths_from_opts opts
+          end
+        end
+
+        def col_widths_from_args args
+          raise Error, "bad argument" unless args.all? { |a| a.is_a? Integer }
+
+          { md: Array.wrap(args) }
+        end
+
+        def col_widths_from_opts opts
+          %i[lg xs sm md].each_with_object({}) do |k, cols_w|
+            next unless (widths = opts.delete(k))
+
+            cols_w[k] = Array.wrap widths
+          end
+        end
+      end
+    end
+  end
+end

data/lib/card/bootstrap/component/panel.rb

@@ -0,0 +1,11 @@
+class Card
+  class Bootstrap
+    class Component
+      class Panel < OldComponent
+        def_div_method :panel, "card"
+        def_div_method :heading, "card-header"
+        def_div_method :body, "card-body"
+      end
+    end
+  end
+end

data/lib/card/bootstrap/component_klass.rb

@@ -0,0 +1,37 @@
+class Card
+  class Bootstrap
+    # class methods for Bootstrap::Component
+    module ComponentKlass
+      def render format, *args, &block
+        new(format, *args, &block).render
+      end
+
+      # Like def_tag_method but always generates a div tag
+      # The tag option is not available
+      def def_div_method name, html_class, opts={}, &tag_block
+        def_tag_method name, html_class, opts.merge(tag: :div), &tag_block
+      end
+
+      # Defines a method that generates a html tag
+      # @param method_name [Symbol, String] the name of the method. If no :tag option
+      #   in tag_opts is defined then the name is also the name of the tag that the
+      #   method generates
+      # @param html_class [String] a html class that is added to tag. Use nil if you
+      #   don't want a html_class
+      # @param tag_opts [Hash] additional argument that will be added to the tag
+      # @option tag_opts [Symbol, String] tag the name of the tag
+      # @example
+      #   def_tag_method :link, "known-link", tag: :a, id: "uniq-link"
+      #   link  # => <a class="known-link" id="uniq-link"></a>
+      def def_tag_method method_name, html_class, tag_opts={}, &tag_opts_block
+        tag = tag_opts.delete(:tag) || method_name
+        define_method method_name do |*args, &content_block|
+          @html.tag! tag,
+                     tag_method_opts(args, html_class, tag_opts, &tag_opts_block) do
+            instance_exec(&content_block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/card/bootstrap/component_loader.rb

@@ -0,0 +1,30 @@
+class Card
+  class Bootstrap
+    module ComponentLoader
+      def load_components
+        components.each do |component|
+          require_relative "component/#{component}"
+          include_component component
+        end
+      end
+
+      def include_component component
+        component_class = to_const component.camelcase
+        define_method component do |*args, &block|
+          component_class.render self, *args, &block
+        end
+      end
+
+      def components
+        path = File.expand_path "component/*.rb", __dir__
+        Dir.glob(path).map do |file|
+          File.basename file, ".rb"
+        end
+      end
+
+      def to_const name
+        self.class.const_get "::Card::Bootstrap::Component::#{name.camelcase}"
+      end
+    end
+  end
+end

data/lib/card/bootstrap/content.rb

@@ -0,0 +1,42 @@
+class Card
+  class Bootstrap
+    # shared methods for OldComponent and TagMethod
+    module Content
+      private
+
+      def process_collected_content tag_name, opts
+        collected_content = @content.pop
+        tag_name = opts.delete(:tag) if tag_name == :yield
+        add_content content_tag(tag_name, collected_content, opts, false)
+      end
+
+      def process_content &content_block
+        content, opts = yield
+        wrappers = @wrap.pop
+        if wrappers.present?
+          process_wrappers wrappers, content, &content_block
+        else
+          add_content content
+        end
+        opts
+      end
+
+      def process_append
+        @append.pop.each do |block|
+          add_content instance_exec(&block)
+        end
+      end
+
+      def process_wrappers wrappers, content, &content_block
+        while wrappers.present?
+          wrapper = wrappers.shift
+          if wrapper.is_a? Symbol
+            send wrapper, &content_block
+          else
+            instance_exec content, &wrappers.shift
+          end
+        end
+      end
+    end
+  end
+end

data/lib/card/bootstrap/delegate.rb

@@ -0,0 +1,18 @@
+class Card
+  class Bootstrap
+    module Delegate
+      def method_missing method_name, *args, &block
+        # return super unless @context.respond_to? method_name
+        if block_given?
+          @context.send(method_name, *args, &block)
+        else
+          @context.send(method_name, *args)
+        end
+      end
+
+      def respond_to_missing? method_name, _include_private=false
+        @context.respond_to? method_name
+      end
+    end
+  end
+end

data/lib/card/bootstrap/old_component.rb

@@ -0,0 +1,108 @@
+class Card
+  class Bootstrap
+    # not-yet-obviated component handling
+    class OldComponent < Component
+      include Content
+
+      def initialize context, *args, &block
+        @context = context
+        @content = ["".html_safe]
+        @args = args
+        @child_args = []
+        @append = []
+        @wrap = []
+        @build_block = block
+      end
+
+      class << self
+        def render format, *args, &block
+          new(format, *args, &block).render
+        end
+
+        # Like add_tag_method but always generates a div tag
+        # The tag option is not available
+        def add_div_method name, html_class, opts={}, &tag_block
+          add_tag_method name, html_class, opts.merge(tag: :div), &tag_block
+        end
+
+        # Defines a method that generates a html tag
+        # @param name [Symbol, String] the name of the method. If no :tag option in
+        #   tag_opts is defined then the name is also the name of the tag that the method
+        #   generates
+        # @param html_class [String] a html class that is added to tag. Use nil if you
+        #   don't want a html_class
+        # @param tag_opts [Hash] additional argument that will be added to the tag
+        # @option tag_opts [Symbol, String] tag the name of the tag
+        # @example
+        #   add_tag_method :link, "known-link", tag: :a, id: "uniq-link"
+        #   link  # => <a class="known-link" id="uniq-link"></a>
+        def add_tag_method name, html_class, tag_opts={}, &tag_block
+          define_method name do |*args, &block|
+            process_tag tag_opts[:tag] || name do
+              content, opts, new_child_args = standardize_args args, &tag_block
+              add_classes opts, html_class, tag_opts.delete(:optional_classes)
+              if (attributes = tag_opts.delete(:attributes))
+                opts.merge! attributes
+              end
+
+              content = with_child_args new_child_args do
+                generate_content content,
+                                 tag_opts[:content_processor],
+                                 &block
+              end
+
+              [content, opts]
+            end
+          end
+        end
+
+        alias_method :def_div_method, :add_div_method
+        alias_method :def_tag_method, :add_tag_method
+      end
+
+      def render
+        @rendered = begin
+          render_content
+          @content[-1]
+        end
+      end
+
+      private
+
+      def process_tag tag_name, &content_block
+        @content.push "".html_safe
+        @append << []
+        @wrap << []
+
+        opts = process_content(&content_block)
+        process_collected_content tag_name, opts
+        process_append
+        ""
+      end
+
+      # include BasicTags
+      def html content
+        add_content String(content).html_safe
+        ""
+      end
+
+      add_div_method :div, nil do |opts, extra_args|
+        prepend_class opts, extra_args.first if extra_args.present?
+        opts
+      end
+
+      add_div_method :span, nil do |opts, extra_args|
+        prepend_class opts, extra_args.first if extra_args.present?
+        opts
+      end
+
+      add_tag_method :tag, nil, tag: :yield do |opts, extra_args|
+        prepend_class opts, extra_args[1] if extra_args[1].present?
+        opts[:tag] = extra_args[0]
+        opts
+      end
+
+      include Delegate
+    end
+  end
+end

data/lib/card/bootstrap/tag_method.rb

@@ -0,0 +1,56 @@
+class Card
+  class Bootstrap
+    # support html tag generation
+    class TagMethod
+      include Content
+
+      def initialize component, name, html_class, tag_opts={}, &tag_block
+        @component = component
+        @name = name
+        @html_class = html_class
+        @tag_opts = tag_opts
+        @tag_block = tag_block
+        @append = []
+        @wrap = []
+        @xm = Builder::XmlMarkup.new
+      end
+
+      def call *_args, &content_block
+        component.content.push "".html_safe
+
+        opts = process_content(&content_block)
+        process_collected_content tag_name, opts
+        process_append
+        ""
+      end
+
+      def method_missing method, *args, &block
+        return super unless respond_to_missing? method
+
+        @component.send method, *args, &block
+      end
+
+      def respond_to_missing? method, _include_private=false
+        @component.respond_to? method
+      end
+
+      def prepend &block
+        tmp = @content.pop
+        instance_exec(&block)
+        @content << tmp
+      end
+
+      def wrap &block
+        instance_exec(&block)
+      end
+
+      def append &block
+        @append[-1] << block
+      end
+
+      def wrapInner tag=nil, &block
+        @wrap[-1] << (block_given? ? block : tag)
+      end
+    end
+  end
+end

data/lib/card/bootstrapper.rb

@@ -0,0 +1,17 @@
+class Card
+  module Bootstrapper
+    extend Bootstrap::ComponentLoader
+
+    def bootstrap
+      @bootstrap ||= Bootstrap.new(self)
+    end
+
+    def bs *args, &block
+      bootstrap.render(*args, &block)
+    end
+
+    components.each do |component|
+      delegate component, to: :bootstrap, prefix: :bs
+    end
+  end
+end

data/lib/card/tab.rb

@@ -5,11 +5,18 @@ class Card
     class << self
       def tab_objects format, tab_hash, active_name, klass=nil
         klass ||= Card::Tab
-        active_name ||= tab_hash.keys.first
+        active_name = active active_name, tab_hash.keys
         tab_hash.map do |name, config|
           klass.new format, name, active_name, config
         end
       end
+
+      private
+
+      def active requested, keys
+        r = requested.to_name
+        r && keys.find { |k| k.to_name == r } || keys.first
+      end
     end
 
     delegate :add_class, :wrap_with, :unique_id, :link_to, to: :format