hanami-helpers 0.0.0 → 0.3.0

data/lib/hanami/helpers/html_helper/html_fragment.rb

@@ -0,0 +1,45 @@
+module Hanami
+  module Helpers
+    module HtmlHelper
+      # HTML Fragment
+      #
+      # @since 0.2.6
+      # @api private
+      #
+      # @see Hanami::Helpers::HtmlHelper::HtmlFragment
+      class HtmlFragment
+        # Initialize a HTML Fragment
+        #
+        # @param blk [Proc,Hanami::Helpers::HtmlHelper::HtmlBuilder,NilClass] the content block
+        #
+        # @return [Hanami::Helpers::HtmlHelper::HtmlFragment]
+        def initialize(&blk)
+          @builder = HtmlBuilder.new
+          @blk = blk
+        end
+
+        # Resolve and return the output
+        #
+        # @return [String] the output
+        #
+        # @since 0.2.6
+        # @api private
+        #
+        # @see Hanami::Helpers::HtmlHelper::EmptyHtmlNode#to_s
+        def to_s
+          content.to_s
+        end
+
+        def content
+          result = @builder.resolve(&@blk)
+
+          if @builder.nested?
+            @builder.to_s
+          else
+            "#{ Utils::Escape.html(result) }"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/helpers/html_helper/html_node.rb

@@ -0,0 +1,70 @@
+require 'hanami/helpers/html_helper/empty_html_node'
+
+module Hanami
+  module Helpers
+    module HtmlHelper
+      # HTML node
+      #
+      # @since 0.1.0
+      # @api private
+      #
+      # @see Hanami::Helpers::HtmlHelper::EmptyHtmlNode
+      class HtmlNode < EmptyHtmlNode
+        # Initialize a new HTML node
+        #
+        # @param name [Symbol,String] the name of the tag
+        # @param content [String,Proc,Hanami::Helpers::HtmlHelper::HtmlBuilder,NilClass] the optional content
+        # @param attributes [Hash,NilClass] the optional tag attributes
+        # @param options [Hash] a optional set of data
+        #
+        # @return [Hanami::Helpers::HtmlHelper::HtmlNode]
+        def initialize(name, content, attributes, options = {})
+          @builder = HtmlBuilder.new
+          @name    = name
+          @content = case content
+                     when Hash
+                       @attributes = content
+                       nil
+                     else
+                       @attributes = attributes.to_h if attributes.respond_to?(:to_h)
+                       content
+                     end
+        end
+
+        # Resolve and return the output
+        #
+        # @return [String] the output
+        #
+        # @since 0.1.0
+        # @api private
+        #
+        # @see Hanami::Helpers::HtmlHelper::EmptyHtmlNode#to_s
+        def to_s
+          %(#{ super }#{ content }</#{ @name }>)
+        end
+
+        private
+        # Resolve the (nested) content
+        #
+        # @return [String] the content
+        #
+        # @since 0.1.0
+        # @api private
+        def content
+          case @content
+          when Proc
+            result = @builder.resolve(&@content)
+
+            if @builder.nested?
+              "\n#{ @builder }\n"
+            else
+              "\n#{ Utils::Escape.html(result) }\n"
+            end
+          else
+            Utils::Escape.html(@content)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/helpers/html_helper/text_node.rb

@@ -0,0 +1,33 @@
+module Hanami
+  module Helpers
+    module HtmlHelper
+      # Text node. Allows for text to be inserted between HTML tags.
+      #
+      # @since 0.2.5
+      # @api private
+      class TextNode
+        # Initialize a new text node
+        #
+        # @param content [String,#to_s] The content to be added.
+        #
+        # @return [Hanami::Helpers::HtmlHelper::TextNode]
+        #
+        # @since 0.2.5
+        # @api private
+        def initialize(content)
+          @content = content.to_s
+        end
+
+        # Resolve and return the output
+        #
+        # @return [String] the output
+        #
+        # @since 0.2.5
+        # @api private
+        def to_s
+          Utils::Escape.html(@content)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/helpers/link_to_helper.rb

@@ -0,0 +1,135 @@
+require 'hanami/helpers/html_helper'
+
+module Hanami
+  module Helpers
+    # LinkTo Helper
+    #
+    # Including <tt>Hanami::Helpers::LinkTo</tt> will include the
+    # <tt>link_to</tt> public method.
+    #
+    # This helper can be used both in views and templates.
+    #
+    # @since 0.2.0
+    module LinkToHelper
+      include Hanami::Helpers::HtmlHelper
+
+      # Generates an anchor tag for the given arguments.
+      #
+      # Contents are automatically escaped.
+      #
+      # @overload link_to(content, url, options)
+      #   Use string as content
+      #   @param content [String] content used in the a tag
+      #   @param url [String] url used in href attribute
+      #   @param options [Hash] HTML attributes to pass to the a tag
+      #
+      # @overload link_to(url, options, &blk)
+      #   Use block as content
+      #   @param url [String] url used in href attribute
+      #   @param options [Hash] HTML attributes to pass to the a tag
+      #   @param blk [Proc] A block that describes the contents of the a tag
+      #
+      # @return [String] HTML markup for the link
+      #
+      # @raise [ArgumentError] if the signature isn't respected
+      #
+      # @since 0.2.0
+      #
+      # @see Hanami::Helpers::HtmlHelper#html
+      #
+      # @example Both content and URL are strings
+      #   <%= link_to('Home', '/') %>
+      #     # => <a href="/">Home</a>
+      #
+      # @example Content string with route helper
+      #   <%= link_to('Home', routes.path(:home)) %>
+      #     # => <a href="/">Home</a>
+      #
+      # @example HTML attributes
+      #   <%= link_to('Home', routes.path(:home), class: 'button') %>
+      #     # => <a href="/" class="button">Home</a>
+      #
+      # @example Automatic content escape (XSS protection)
+      #   <%= link_to(%(<script>alert('xss')</script>), '/') %>
+      #     # => <a href="/">&lt;script&gt;alert(&apos;xss&apos;)&lt;&#x2F;script&gt;</a>
+      #
+      # @example Automatic content block escape (XSS protection)
+      #   <%=
+      #     link_to('/') do
+      #       %(<script>alert('xss')</script>)
+      #     end
+      #   %>
+      #     # => <a href="/">\n&lt;script&gt;alert(&apos;xss&apos;)&lt;&#x2F;script&gt;\n</a>
+      #
+      # @example Content as block with string URL
+      #   <%=
+      #     link_to('/') do
+      #       'Home'
+      #     end
+      #   %>
+      #     # => <a href="/">Home</a>
+      #
+      # @example Content as block
+      #   <%=
+      #     link_to(routes.path(:home)) do
+      #       'Home'
+      #     end
+      #   %>
+      #     # => <a href="/">Home</a>
+      #
+      # @example Content as block with HTML attributes
+      #   <%=
+      #     link_to(routes.path(:home), id: 'home-link') do
+      #       'Home'
+      #     end
+      #   %>
+      #     # => <a href="/" id: 'home-link'>Home</a>
+      #
+      # @example Content as HTML builder block
+      #   <%=
+      #     link_to(routes.path(:home)) do
+      #       strong 'Home'
+      #     end
+      #   %>
+      #     # => <a href="/"><strong>Home</strong></a>
+      #
+      # @example Provides both content as first argument and block
+      #   <%=
+      #     link_to('Home', routes.path(:home)) do
+      #       strong 'Home'
+      #     end
+      #   %>
+      #     # => ArgumentError
+      #
+      # @example Without any argument
+      #   <%= link_to %>
+      #     # => ArgumentError
+      #
+      # @example Without any argument and empty block
+      #   <%=
+      #     link_to do
+      #     end
+      #   %>
+      #     # => ArgumentError
+      #
+      # @example With only content
+      #   <%= link_to 'Home' %>
+      #     # => ArgumentError
+      def link_to(content, url = nil, options = {}, &blk)
+        if block_given?
+          options = url || {}
+          url     = content
+          content = nil
+        end
+
+        begin
+          options[:href] = url or raise ArgumentError
+        rescue TypeError
+          raise ArgumentError
+        end
+
+        html.a(blk || content, options).to_s
+      end
+    end
+  end
+end

data/lib/hanami/helpers/number_formatting_helper.rb

@@ -0,0 +1,220 @@
+module Hanami
+  module Helpers
+    # Number formatter
+    #
+    # You can include this module inside your view and
+    # the view will have access all methods.
+    #
+    # By including <tt>Hanami::Helpers::NumberFormattingHelper</tt> it will
+    # inject private method: <tt>format_number</tt>.
+    #
+    # @since 0.2.0
+    module NumberFormattingHelper
+      private
+      # Format the given number, according to the options
+      #
+      # It accepts a number (<tt>Numeric</tt>) or a string representation.
+      #
+      # If an integer is given, no precision is applied.
+      # For the rest of the numbers, it will format as a float representation.
+      # This is the case of: <tt>Float</tt>, <tt>BigDecimal</tt>,
+      # <tt>Complex</tt>, <tt>Rational</tt>.
+      #
+      # If the argument cannot be coerced into a number, it will raise a
+      # <tt>TypeError</tt>.
+      #
+      # @param number [Numeric,String] the number to be formatted
+      #
+      # @return [String] formatted number
+      #
+      # @raise [TypeError] if number can't be formatted
+      #
+      # @since 0.2.0
+      #
+      # @example
+      #   require 'hanami/helpers/number_formatting_helper'
+      #
+      #   class Checkout
+      #     include Hanami::Helpers::NumberFormattingHelper
+      #
+      #     def total
+      #       format_number 1999.99
+      #     end
+      #
+      #     def euros
+      #       format_number 1256.95, delimiter: '.', separator: ','
+      #     end
+      #
+      #     def visitors_count
+      #       format_number '1000'
+      #     end
+      #   end
+      #
+      #   view = Checkout.new
+      #
+      #   view.total
+      #     # => "1,999.99"
+      #
+      #   view.euros
+      #     # => "1.256,95"
+      #
+      #   view.visitors_count
+      #     # => "1,000"
+      def format_number(number, options = {})
+        Formatter.new(number, options).format
+      end
+
+      # Formatter
+      #
+      # @since 0.2.0
+      # @api private
+      class Formatter
+        # Regex to delimitate integer part of a number
+        #
+        # @return [Regexp] the delimitation regex
+        #
+        # @since 0.2.0
+        # @api private
+        #
+        # @see Hanami::Helpers::NumberFormatter::Formatter#delimitate
+        DELIMITATION_REGEX = /(\d)(?=(\d{3})+$)/
+
+        # Regex to guess if the number is a integer
+        #
+        # @return [Regexp] the guessing regex
+        #
+        # @since 0.2.0
+        # @api private
+        #
+        # @see Hanami::Helpers::NumberFormatter::Formatter#to_number
+        INTEGER_REGEXP     = /\A[\d]+\z/
+
+        # Default separator
+        #
+        # @return [String] default separator
+        #
+        # @since 0.2.0
+        # @api private
+        DEFAULT_SEPARATOR  = '.'.freeze
+
+        # Default delimiter
+        #
+        # @return [String] default delimiter
+        #
+        # @since 0.2.0
+        # @api private
+        DEFAULT_DELIMITER  = ','.freeze
+
+        # Default precision
+        #
+        # @return [String] default precision
+        #
+        # @since 0.2.0
+        # @api private
+        DEFAULT_PRECISION  = 2
+
+        # Initialize a new formatter
+        #
+        # @param number [Numeric,String] the number to format
+        # @param options [Hash] options for number formatting
+        # @option options [String] :delimiter hundred delimiter
+        # @option options [String] :separator fractional part delimiter
+        # @option options [Integer] :precision rounding precision
+        #
+        # @since 0.2.0
+        # @api private
+        #
+        # @see Hanami::Helpers::NumberFormatter::Formatter::DEFAULT_DELIMITER
+        # @see Hanami::Helpers::NumberFormatter::Formatter::DEFAULT_SEPARATOR
+        # @see Hanami::Helpers::NumberFormatter::Formatter::DEFAULT_PRECISION
+        def initialize(number, options)
+          @number = number
+          @delimiter = options.fetch(:delimiter, DEFAULT_DELIMITER)
+          @separator = options.fetch(:separator, DEFAULT_SEPARATOR)
+          @precision = options.fetch(:precision, DEFAULT_PRECISION)
+        end
+
+        # Format number according to the specified options
+        #
+        # @return [String] formatted number
+        #
+        # @raise [TypeError] if number can't be formatted
+        #
+        # @since 0.2.0
+        # @api private
+        def format
+          parts.join(@separator)
+        end
+
+        private
+
+        # Return integer and fractional parts
+        #
+        # @return [Array] parts
+        #
+        # @since 0.2.0
+        # @api private
+        def parts
+          integer_part, fractional_part = to_str.split(DEFAULT_SEPARATOR)
+          [delimitate(integer_part), fractional_part].compact
+        end
+
+        # Delimitate the given part
+        #
+        # @return [String] delimitated string
+        #
+        # @since 0.2.0
+        # @api private
+        def delimitate(part)
+          part.gsub(DELIMITATION_REGEX) { |digit| "#{digit}#{@delimiter}" }
+        end
+
+        # String coercion
+        #
+        # @return [String] coerced number
+        #
+        # @raise [TypeError] if number can't be formatted
+        #
+        # @since 0.2.0
+        # @api private
+        def to_str
+          to_number.to_s
+        end
+
+        # Numeric coercion
+        #
+        # @return [Numeric] coerced number
+        #
+        # @raise [TypeError] if number can't be formatted
+        #
+        # @since 0.2.0
+        # @api private
+        def to_number
+          case @number
+          when NilClass
+            raise TypeError
+          when ->(n) { n.to_s.match(INTEGER_REGEXP) }
+            Utils::Kernel.Integer(@number)
+          else
+            Utils::Kernel.Float(rounded_number)
+          end
+        end
+
+        # Round number in case we need to return a <tt>Float</tt> representation.
+        # If <tt>@number</tt> doesn't respond to <tt>#round</tt> return the number as it is.
+        #
+        # @return [Float,Complex,Rational,BigDecimal] rounded number, if applicable
+        #
+        # @since 0.2.0
+        # @api private
+        def rounded_number
+          if @number.respond_to?(:round)
+            @number.round(@precision)
+          else
+            @number
+          end
+        end
+      end
+    end
+  end
+end