railsstrap 3.3.4 → 4.0.0.beta2

data/lib/railsstrap/classes/base.rb

@@ -0,0 +1,149 @@
+require 'railsstrap/classes/stack'
+require 'ostruct'
+require 'active_support'
+require 'active_support/core_ext'
+
+module Railsstrap
+  # @api private
+  module Classes
+    class Base
+      def initialize(app = nil, *args, &block)
+        @app = app
+        @concat = block_given? && @app.respond_to?(:concat_content)
+        @options = extract_options_from(*args, &block).dup
+        @content = extract_content_from *args, &block
+      end
+
+      def extract!(*keys)
+        @attributes = @options.slice! *keys
+        @options.any?
+      end
+
+      def merge!(attributes = {})
+        html_attributes.deep_merge! attributes
+      end
+
+      def merge_html!(html)
+        @content ||= html
+      end
+
+      def append_class!(new_class, hash = html_attributes, attribute = :class)
+        existing_class = hash[attribute]
+        hash[attribute] = [existing_class, new_class].compact.join ' '
+      end
+
+      def append_class_to!(key, new_class)
+        append_class! new_class, (html_attributes[key] ||= {})
+      end
+
+      def prepend_html!(html)
+        @content = safe_join [html, @content]
+      end
+
+      def render_tag(tag)
+        render content_tag(tag)
+      end
+
+      def render_partial(partial)
+        file = File.expand_path "../../views/railsstrap/_#{partial}.html.erb", __FILE__
+        template = ERB.new(File.read file)
+        assigns = OpenStruct.new attributes.merge(content: @content)
+        render template.result(assigns.instance_eval {binding &nil}).html_safe
+      end
+
+      # @return [#to_s] the HTML to show a dismissible button.
+      # @options option :dismiss What the button should dismiss. Can be :alert, :modal
+      def dismissible_button
+        if @options[:dismissible] || @options[:priority]
+          path = '../../views/railsstrap/_dismiss_button.html.erb'
+          template = ERB.new(File.read File.expand_path(path, __FILE__))
+          assigns = OpenStruct.new dismiss: dismiss[@options[:dismiss]]
+          render template.result(assigns.instance_eval {binding &nil}).html_safe
+        end
+      end
+
+      def dismiss
+        HashWithIndifferentAccess.new(:alert).tap do |klass|
+          klass[:modal] = 'modal'
+          klass[:alert] = 'alert'
+        end
+      end
+
+      def tag
+        :div
+      end
+
+      def attributes
+        @attributes || @options
+      end
+
+      def content
+        items = Array.wrap(@content).map do |item|
+          item.is_a?(Base) ? item.content_tag(item.tag) : item
+        end
+        items.all?(&:html_safe?) ? safe_join(items) : items.join
+      end
+
+      def content_tag(tag)
+        @app.content_tag tag, content, attributes
+      end
+
+      def url
+        @url
+      end
+
+      def extract_from(option, attributes = [])
+        @attributes[option] = @options[option].except *attributes if @options[option]
+      end
+
+      def self.variant_types
+        %w[primary secondary success warning danger info dark light].freeze
+      end
+
+      private
+
+      def safe_join(array = [])
+        array.compact.join("\n").html_safe
+      end
+
+      def stack(&block)
+        Stack.unshift self
+        yield.tap {Stack.shift}
+      end
+
+      def html_attributes
+        @html_attributes || attributes
+      end
+
+      def render(html)
+        @concat && html ? @app.concat_content(html) : html
+      end
+
+      def extract_options_from(*args, &block)
+        args.shift unless block_given?
+        args.extract_options!
+      end
+
+      def extract_content_from(*args, &block)
+        if block_given?
+          stack {capture_content &block}
+        else
+          args.shift
+        end
+      end
+
+      def extract_url_from(*args)
+        args.delete_at(block_given? ? 0 : 1)
+      end
+
+      def capture_content(&block)
+        content = @app.capture &block
+        if content.is_a? String
+          ActiveSupport::SafeBuffer.new.safe_concat(content)
+        end
+      end
+    end
+  end
+
+  include Classes
+end

data/lib/railsstrap/classes/button.rb

@@ -0,0 +1,68 @@
+require 'railsstrap/classes/base'
+
+module Railsstrap
+  module Classes
+    class Button < Base
+      # @return [#to_s] the variant-related class to assign to the button.
+      def variant_class
+        Button.variants[@options[:variant]]
+      end
+
+      # @return [#to_s] the size-related class to assign to the button.
+      def size_class
+        Button.sizes[@options[:size]]
+      end
+
+      # @return [#to_s] the layout-related class to assign to the button.
+      def layout_class
+        Button.layouts[@options[:layout]]
+      end
+
+      # @return [Hash<Symbol, String>] the classes that Bootstrap requires to
+      #   append to buttons for each possible variant.
+
+      def self.variants
+        HashWithIndifferentAccess.new(:'btn-primary').tap do |klass|
+          variant_types.each do |variant|
+            klass[variant.to_sym] = :"btn-#{variant}"
+            klass[:"outline-#{variant}"] = :"btn-outline-#{variant}"
+          end
+          klass[:link] = :'btn-link'
+        end
+      end
+
+      # @return [Hash<Symbol, String>] the classes that Bootstrap requires to
+      #   append to buttons for each possible size.
+
+      def self.sizes
+        HashWithIndifferentAccess.new.tap do |klass|
+          klass[:extra_small] = :'btn-xs'
+          klass[:large]       = :'btn-lg'
+          klass[:lg]          = :'btn-lg'
+          klass[:sm]          = :'btn-sm'
+          klass[:small]       = :'btn-sm'
+          klass[:xs]          = :'btn-xs'
+        end
+      end
+
+      # @return [Hash<Symbol, String>] the classes that Bootstrap requires to
+      #   append to buttons for each possible layout.
+
+      def self.layouts
+        HashWithIndifferentAccess.new.tap do |klass|
+          klass[:block] = :'btn-block'
+        end
+      end
+
+      # @return [Hash<Symbol>, String] the javascript to toggle or dispose a button.
+      # @required @options[:id]
+
+      def self.js_methods
+        HashWithIndifferentAccess.new.tap do |klass|
+          klass[:toggle] = "$(#{@options[:id]}).button('toggle')"
+          klass[:dispose] = "$(#{@options[:id]}).button('dispose')"
+        end
+      end
+    end
+  end
+end

data/lib/railsstrap/classes/button_group.rb

@@ -0,0 +1,66 @@
+require 'railsstrap/classes/base'
+
+module Railsstrap
+  module Classes
+    class ButtonGroup < Base
+      # @return [#to_s] the variant-related class to assign to the button.
+      def variant_class
+        Button.variants[@options[:variant]]
+      end
+
+      # @return [#to_s] the size-related class to assign to the button group.
+      def size_class
+        Button.sizes[@options[:size]]
+      end
+
+      # @return [#to_s] the layout-related class to assign to the button group.
+      def layout_class
+        Button.layouts[@options[:layout]]
+      end
+
+      def vertical_class
+        @options[:vertical].present? ? 'btn-group-vertical' : nil
+      end
+
+      def toolbar_class
+        @options[:toolbar].present? ? 'btn-toolbar' : nil
+      end
+
+      def role_name
+        { role: @options[:role] ||= 'group' }
+      end
+
+      def aria_label
+        @options[:'aria-label'] ||= 'Button Group'
+      end
+
+      def buttons
+        @options[:buttons].map! {|button| @app.button(button)} if @options[:buttons]
+      end
+
+      # @return [Hash<Symbol, String>] the classes that Bootstrap requires to
+      #   append to buttons for each possible size.
+
+      def self.sizes
+        HashWithIndifferentAccess.new.tap do |klass|
+          klass[:extra_small] = :'btn-xs'
+          klass[:large]       = :'btn-lg'
+          klass[:lg]          = :'btn-lg'
+          klass[:sm]          = :'btn-sm'
+          klass[:small]       = :'btn-sm'
+          klass[:xs]          = :'btn-xs'
+        end
+      end
+
+      # @return [Hash<Symbol, String>] the classes that Bootstrap requires to
+      #   append to buttons for each possible layout.
+
+      def self.layouts
+        HashWithIndifferentAccess.new.tap do |klass|
+          klass[:block] = :'btn-block'
+        end
+      end
+      
+    end
+  end
+end

data/lib/railsstrap/classes/button_to.rb

@@ -0,0 +1,33 @@
+require 'railsstrap/classes/button'
+
+module Railsstrap
+  module Classes
+    class ButtonTo < Button
+      def initialize(app = nil, *args, &block)
+        @url = extract_url_from(*args, &block)
+        super
+      end
+
+      def append_button_class!(klass)
+        case Railsstrap.framework
+          when :rails then append_class! klass
+          when :padrino, :middleman then append_class_to! :submit_options, klass
+        end
+      end
+
+      def append_form_class!(klass)
+        case Railsstrap.framework
+          when :rails then append_class! klass, html_attributes, :form_class
+          when :padrino, :middleman then append_class! klass
+        end
+      end
+
+      def accepts_block?
+        case Railsstrap.framework
+          when :rails then defined?(ActionView::VERSION) # only Rails >= 4
+          when :padrino, :middleman then true
+        end
+      end
+    end
+  end
+end

data/lib/railsstrap/classes/card.rb

@@ -0,0 +1,74 @@
+require 'railsstrap/classes/base'
+
+module Railsstrap
+  module Classes
+    class Card < Base
+      # Differently from other classes, Panel works with no content or block,
+      # given that the options[:body] is passed, in which case it functions
+      # as the content.
+      def initialize(app = nil, *args, &block)
+        if args.first.is_a?(Hash) && !block_given?
+          args.unshift args.first.delete(:body)
+        end
+
+        super
+      end
+
+      # @return [#to_s] the content-related class to assign to the card.
+      def variant_class
+        Card.variants[@options[:variant]]
+      end
+
+      # @return [#to_s] the content-related class to assign to the card.
+      def text_variant_class
+        @options[:text_variant]
+      end
+
+      # @return [#to_s] the HTML tag to wrap the card in.
+      def tag
+        @options.fetch :tag, :div
+      end
+
+      # @return [#to_s] the text to display as the card header
+      def header
+        text = title || @options[:header]
+        @app.content_tag :div, text, class: 'card-header' if text
+      end
+
+      def image_cap
+        if @options[:img]
+          @app.content_tag :img, nil, class: 'card-img-top', src: @options[:img]
+        end
+      end
+      def body
+        if @options[:body]
+          @app.content_tag :div, @options[:body], class: 'card-body'
+        end
+      end
+
+
+      def extract_content_from(*args, &block)
+        if block_given?
+          super
+        else
+          @app.content_tag :div, super, class: 'card-body'
+        end
+      end
+
+      def title
+        if @options[:title]
+          @app.content_tag :h3, @options[:title], class: 'card-title'
+        end
+      end
+
+      # @return [Hash<Symbol, String>] the class that Bootstrap requires to
+      #   append to an card box based on its variant.
+      def self.variants
+        HashWithIndifferentAccess.new(:'bg-default').tap do |klass|
+          variant_types.each { |variant| klass[variant.to_sym] = :"bg-#{variant}" }
+        end
+      end
+
+    end
+  end
+end

data/lib/railsstrap/classes/card_group.rb

@@ -0,0 +1,22 @@
+require 'railsstrap/classes/base'
+
+module Railsstrap
+  module Classes
+    class CardGroup < Base
+
+      def layout
+        CardGroup.column_types[@options[:layout]]
+      end
+
+      # @return [#to_s] the grid-related class to assign to each card
+      #   nested in this card group.
+      def self.column_types
+        HashWithIndifferentAccess.new('card-group').tap do |klass|
+          klass[:deck] = :'card-deck'
+          klass[:group] = :'card-group'
+          klass[:column] = :'card-column'
+        end
+      end
+    end
+  end
+end

data/lib/railsstrap/classes/cdn.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'railsstrap/classes/base'
+
+module Railsstrap
+  module Classes
+    # @api private
+    class Cdn
+      # @note if unspecified, the version should match the latest available
+      #   version. If that's not the case, it's a bug and should be fixed.
+      def self.jquery_js(options = {})
+        options[:version] = options[:version].nil? ? '3.3.1' : options[:version]
+        cdn_asset options.merge(library: 'jquery')
+      end
+
+      # @note if unspecified, the version should match the latest available
+      #   version. If that's not the case, it's a bug and should be fixed.
+      def self.bootstrap_css(options = {})
+        defaults = {version: '4.0.0', scheme: :https, minified: true}
+        options.merge!(defaults)
+        "#{options[:scheme].to_s}://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/#{options[:version]}/css/bootstrap.#{options[:minified] ? 'min.' : '.'}css"
+      end
+
+      # @note if unspecified, the version should match the latest available
+      #   version. If that's not the case, it's a bug and should be fixed.
+      # @note Version 4 of bootstrap does not have a theme; use SASS in this situation and override variables
+      def self.bootstrap_theme(options = {})
+        defaults = {version: '3.3.7', scheme: :https, minified: true}
+        options.merge!(defaults)
+        return if options[:version] =~ !/^3/
+        "#{options[:scheme].to_s}://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/#{options[:version]}/css/bootstrap-theme.#{options[:minified] ? 'min.' : ''}css"
+      end
+
+      def self.bootstrap_js(options = {})
+        defaults = {version: '4.0.0', scheme: :https, minified: true}
+        options.merge!(defaults)
+        "#{options[:scheme].to_s}://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/#{options[:version]}/js/bootstrap.#{options[:minified] ? 'min.' : '.'}js"
+      end
+
+      # @note if unspecified, the version should match the latest available
+      #   version. If that's not the case, it's a bug and should be fixed.
+      def self.font_awesome(options = {})
+        defaults = {version: '4.7.0', scheme: :https, minified: true}
+        options.merge!(defaults)
+        "#{options[:scheme].to_s}://cdnjs.cloudflare.com/ajax/libs/font-awesome/#{options[:version]}/css/font-awesome.#{options[:minified] ? 'min.' : '.'}css"
+      end
+
+      # @description Use the cdn_asset method to build a URL
+      def self.font_awesome_js(options = {})
+        version = '5.0.6'
+        opts = {
+          version: version,
+          scheme: 'https',
+          host: '//use.fontawesome.com',
+          path: "releases/v#{version}/js",
+          name: 'all',
+          ext: 'js'
+        }.merge(options)
+        cdn_asset opts
+      end
+
+      # fetches popper js
+      def self.popper_js(options = {})
+        opts = {
+          version: '1.13.0',
+          path: 'ajax/libs/popper.js'
+        }.merge(options)
+        cdn_asset opts
+      end
+
+      # @return the url of the library from cdnjs.com
+      # def self.query(options = {})
+      #   return if options[:library].nil?
+      #   buffer = open("https://api.cdnjs.com/libraries?search=#{options[:library]}&fields=version,assets").read
+      #   JSON.parse(buffer)
+      # end
+
+      # @note The problem with this method is there is no real sanity with CDN naming conventions
+      # Considering using API to smartly figure out what is being asked of the helper to link in
+      def self.cdn_asset(options = {})
+        version = options[:version]
+        extension = options[:extension]
+        name = options[:name]
+        name = "#{name}.min" if options.fetch(:minified, true)
+        library = options[:library]
+        scheme = options[:scheme].nil? ? 'https:' : "#{options[:scheme]}:"
+        path = options[:path].nil? ? 'ajax/libs' : options[:path].to_s
+        host = options[:host].nil? ? "#{scheme}//cdnjs.cloudflare.com" : options[:host]
+        "#{host}/#{path}/#{library}/#{version}/#{name}.#{extension}"
+      end
+    end
+  end
+end