semantic_date_time_tags 0.1.13 → 0.2.0

data/lib/semantic_date_time_tags.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require "i18n"
 require "semantic_date_time_tags/railtie" if defined?(Rails)
 require "semantic_date_time_tags/engine"
 require "semantic_date_time_tags/version"
 
-I18n.load_path += Dir.glob(File.join( File.dirname(__FILE__), 'config', 'locales', '*.yml' ))
+I18n.load_path += Dir.glob(File.join(File.dirname(__FILE__), "config", "locales", "*.yml"))

data/lib/semantic_date_time_tags/engine.rb

@@ -1,8 +1,10 @@
-require 'rails/engine'
+# frozen_string_literal: true
+
+require "rails/engine"
 
 module SemanticDateTimeTags
   module Rails
     class Engine < ::Rails::Engine
     end
   end
-end
+end

data/lib/semantic_date_time_tags/format_parser.rb

@@ -1,5 +1,7 @@
 # encoding: utf-8
-require 'action_view'
+# frozen_string_literal: true
+
+require "action_view"
 
 module SemanticDateTimeTags
   class FormatParser < Struct.new(:format, :str)
@@ -8,44 +10,48 @@ module SemanticDateTimeTags
     def to_html
       processed_str = str
       (
-        formatting_components.flatten.inject('') do |res, comp|
+        formatting_components.flatten.inject("") do |res, comp|
           regexp = Regexp.new(get_regexp_for_component(comp))
           if match = processed_str.match(regexp)
             res += get_tag_for_match(match[0], comp)
             processed_str = processed_str[match[0].length..-1]
           end
           res
-        end + processed_str
+        end + get_tag_for_str(processed_str)
       ).html_safe
     end
 
-    private # =============================================================
+    private
+      def formatting_components
+        format.scan(/(%-?[[:word:]]|.+?(?=%))/)
+      end
 
-    def formatting_components
-      format.scan(/(%-?[[:word:]]|.+?(?=%))/)
-    end
+      def get_tag_for_match(match, comp)
+        content_tag :span, match, class: get_classes_for_component(comp)
+      end
 
-    def get_tag_for_match(match, comp)
-      content_tag :span, match, class: get_classes_for_component(comp)
-    end
+      def get_tag_for_str(str)
+        return "" unless str.present?
+        content_tag :span, str, class: "str"
+      end
 
-    def get_regexp_for_component(comp)
-      case comp
-      when /%-?[[:word:]]/ then '([[:word:]]+)'
-      else "(#{comp})"
+      def get_regexp_for_component(comp)
+        case comp
+        when /%-?[[:word:]]/ then "([[:word:]]+)"
+        else "(#{comp})"
+        end
       end
-    end
 
-    def get_classes_for_component(comp)
-      case comp
-      when /%-?[YCy]/ then ['year', comp[/[[:word:]]/]]
-      when /%-?[mBbh]/ then ['month', comp[/[[:word:]]/]]
-      when /%-?[aAdej]/ then ['day', comp[/[[:word:]]/]]
-      when /%-?[HKIl]/ then ['hours', comp[/[[:word:]]/]]
-      when /%-?[M]/ then ['minutes', comp[/[[:word:]]/]]
-      when /%-?[pP]/ then ['ampm', comp[/[[:word:]]/]]
-      when /\W+/ then ['sep']
+      def get_classes_for_component(comp)
+        case comp
+        when /%-?[YCy]/ then ["year", comp[/[[:word:]]/]]
+        when /%-?[mBbh]/ then ["month", comp[/[[:word:]]/]]
+        when /%-?[aAdej]/ then ["day", comp[/[[:word:]]/]]
+        when /%-?[HKIl]/ then ["hours", comp[/[[:word:]]/]]
+        when /%-?[M]/ then ["minutes", comp[/[[:word:]]/]]
+        when /%-?[pP]/ then ["ampm", comp[/[[:word:]]/]]
+        when /\W+/ then ["sep"]
+        end
       end
-    end
   end
 end

data/lib/semantic_date_time_tags/railtie.rb

@@ -1,5 +1,7 @@
-require 'semantic_date_time_tags/view_helpers'
-require 'rails/railtie'
+# frozen_string_literal: true
+
+require "semantic_date_time_tags/view_helpers"
+require "rails/railtie"
 
 module SemanticDateTimeTags
   class Railtie < Rails::Railtie
@@ -7,4 +9,4 @@ module SemanticDateTimeTags
       ActionView::Base.send :include, ViewHelpers
     end
   end
-end
+end

data/lib/semantic_date_time_tags/tag.rb

@@ -1,5 +1,7 @@
-require 'action_view'
-require 'i18n'
+# frozen_string_literal: true
+
+require "action_view"
+require "i18n"
 
 module SemanticDateTimeTags
   class Tag
@@ -10,24 +12,18 @@ module SemanticDateTimeTags
     attr_accessor :options
     attr_accessor :output_buffer
 
-    # =====================================================================
-
     def initialize(obj, options = {})
       @obj = obj
-      @options = options.tap { |opts| opts.delete(:scope) }
+      @options = options.except(*%i(scope))
     end
 
-    # ---------------------------------------------------------------------
-
     def to_html
       raise NotImplementedError
     end
 
-    # ---------------------------------------------------------------------
-
     def dom_classes
       [
-        'semantic',
+        "semantic",
         locale_class,
         am_pm_class,
         type_class,
@@ -47,39 +43,39 @@ module SemanticDateTimeTags
 
     def current_date_class
       return unless [::Date, ::DateTime].any? { |c| obj.instance_of? c }
-      'current_date' if obj.today?
+      "current_date" if obj.today?
     end
 
     def current_year_class
       return unless [::Date, ::DateTime].any? { |c| obj.instance_of? c }
-      'current_year' if obj.year == ::Date.today.year
+      "current_year" if obj.year == ::Date.today.year
     end
 
     def whole_hour_class
       return unless [::Time, ::DateTime].any? { |c| obj.instance_of? c }
-      'whole_hour' unless obj.min > 0
+      "whole_hour" unless obj.min > 0
     end
 
     def whole_minute_class
       return unless [::Time, ::DateTime].any? { |c| obj.instance_of? c }
-      'whole_minute' unless obj.sec > 0
+      "whole_minute" unless obj.sec > 0
     end
 
     def noon_class
       return unless [::Time, ::DateTime].any? { |c| obj.instance_of? c }
-      'noon' if obj == obj.noon
+      "noon" if obj == obj.noon
     end
 
     def midnight_class
       return unless [::Time, ::DateTime].any? { |c| obj.instance_of? c }
-      'midnight' if obj == obj.midnight
+      "midnight" if obj == obj.midnight
     end
 
     def am_pm_class
       return unless [::Time, ::DateTime].any? { |c| obj.instance_of? c }
       case
-      when (0..11).cover?(obj.hour) then 'am'
-      else 'pm'
+      when (0..11).cover?(obj.hour) then "am"
+      else "pm"
       end
     end
 
@@ -87,54 +83,49 @@ module SemanticDateTimeTags
       I18n.locale.to_s
     end
 
-    # ---------------------------------------------------------------------
-
     def dom_data
-      { in_words: in_words, format: format.to_s }
-    end
-
-    private # =============================================================
-
-    def scope
-      raise NotImplementedError
-    end
-
-    def format_string
-      I18n.t(scope)[format]
+      options.fetch(:data, {})
+        .merge(in_words: in_words, format: format.to_s)
     end
 
-    def format
-      options.fetch :format, :full
-    end
-
-    # ---------------------------------------------------------------------
+    private
+      def scope
+        raise NotImplementedError
+      end
 
-    def localized_obj
-      I18n.l obj, format: format
-    end
+      def format_string
+        case format
+        when Symbol then I18n.t(scope)[format]
+        else format
+        end
+      end
 
-    # ---------------------------------------------------------------------
+      def format
+        options.fetch :format, :full
+      end
 
-    def tag_name
-      options.fetch :tag_name, :time
-    end
+      def localized_obj
+        I18n.l obj, format: format
+      end
 
-    # ---------------------------------------------------------------------
+      def tag_name
+        options.fetch :tag_name, :time
+      end
 
-    def in_words
-      [noon_in_words, midnight_in_words].reject(&:blank?).join(' ')
-    end
+      def in_words
+        [noon_in_words, midnight_in_words].reject(&:blank?).join(" ")
+      end
 
-    def noon_in_words
-      return unless [::Time, ::DateTime].any? { |c| obj.instance_of? c }
-      return unless obj == obj.noon
-      I18n.t :noon, scope: %i(time in_words)
-    end
+      def noon_in_words
+        return unless [::Time, ::DateTime].any? { |c| obj.instance_of? c }
+        return unless obj == obj.noon
+        I18n.t :noon, scope: %i(time in_words)
+      end
 
-    def midnight_in_words
-      return unless [::Time, ::DateTime].any? { |c| obj.instance_of? c }
-      return unless obj == obj.midnight
-      I18n.t :midnight, scope: %i(time in_words)
-    end
+      def midnight_in_words
+        return unless [::Time, ::DateTime].any? { |c| obj.instance_of? c }
+        return unless obj == obj.midnight
+        I18n.t :midnight, scope: %i(time in_words)
+      end
   end
 end

data/lib/semantic_date_time_tags/tag/date.rb

@@ -1,15 +1,18 @@
-require_relative '../format_parser'
+# frozen_string_literal: true
+
+require_relative "../format_parser"
 
 module SemanticDateTimeTags
   class Tag
     class Date < Tag
       def initialize(obj, options = {})
-        raise 'object must be Date or DateTime' unless [::Date, ::DateTime].any? { |c| obj.instance_of? c }
+        raise "object must be Date or DateTime" unless [::Date, ::DateTime].any? { |c| obj.instance_of? c }
+
+        options = options.except(*%i(separator))
+
         super(obj, options)
       end
 
-      # ---------------------------------------------------------------------
-
       def to_html
         if tag_name == :time
           datetime = obj.acts_like?(:time) ? obj.xmlschema : obj.iso8601
@@ -21,14 +24,13 @@ module SemanticDateTimeTags
 
         value = SemanticDateTimeTags::FormatParser.new(format_string, localized_obj).to_html.html_safe
 
-        content_tag(tag_name, options) { value }.html_safe
+        content_tag(tag_name, options.except(*%i(format))) { value }.html_safe
       end
 
-      private # =============================================================
-
-      def scope
-        'date.formats'
-      end
+      private
+        def scope
+          "date.formats"
+        end
     end
   end
 end

data/lib/semantic_date_time_tags/tag/date_range.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SemanticDateTimeTags
   class Tag
     class DateRange < Tag
@@ -9,10 +11,9 @@ module SemanticDateTimeTags
         @date_from = date_from
         @date_to = date_to
         @options = options
+        @separator = options.delete(:separator) || " – "
       end
 
-      # ---------------------------------------------------------------------
-
       def spans_years?
         return false if date_to.nil?
         date_from.year != date_to.year
@@ -45,43 +46,39 @@ module SemanticDateTimeTags
           (date_from.to_datetime.hour >= 12 && date_to.to_datetime.hour >= 12)
       end
 
-      # ---------------------------------------------------------------------
-
       def dom_classes
         res = []
-        res << 'date_range'
-        res << 'same_year' unless spans_years?
-        res << 'current_year' if both_in_current_year?
-        res << 'same_month' unless spans_months?
-        res << 'more_than_a_week' unless within_a_week?
-        res << 'same_day' if same_day?
-        res << 'same_time' if same_time?
-        res << 'same_meridian' if same_meridian?
+        res << "date_range"
+        res << "same_year" unless spans_years?
+        res << "current_year" if both_in_current_year?
+        res << "same_month" unless spans_months?
+        res << "more_than_a_week" unless within_a_week?
+        res << "same_day" if same_day?
+        res << "same_time" if same_time?
+        res << "same_meridian" if same_meridian?
         res
       end
 
-      # ---------------------------------------------------------------------
+      def dom_data
+        options.fetch(:data, {})
+      end
 
       def to_html
+        from_options = options.merge(class: "from").except(:data, :time_data).merge(data: options.fetch(:time_data, {}))
         from = case date_from
-               when ::DateTime then SemanticDateTimeTags::Tag::DateTime.new(date_from, options.merge(class: 'from')).to_html
-               when ::Date then SemanticDateTimeTags::Tag::Date.new(date_from.to_date, options.merge(class: 'from')).to_html
+               when ::DateTime then SemanticDateTimeTags::Tag::DateTime.new(date_from, from_options).to_html
+               when ::Date then SemanticDateTimeTags::Tag::Date.new(date_from.to_date, from_options).to_html
         end
 
-        sep = content_tag(:span, separator, class: 'date_range_separator')
+        sep = content_tag(:span, @separator, class: "date_range_separator")
 
+        to_options = options.merge(class: "to").except(:data, :time_data).merge(data: options.fetch(:time_data, {}))
         to = case date_to
-             when ::DateTime then SemanticDateTimeTags::Tag::DateTime.new(date_to, options.merge(class: 'to')).to_html
-             when ::Date then SemanticDateTimeTags::Tag::Date.new(date_to.to_date, options.merge(class: 'to')).to_html
+             when ::DateTime then SemanticDateTimeTags::Tag::DateTime.new(date_to, to_options).to_html
+             when ::Date then SemanticDateTimeTags::Tag::Date.new(date_to.to_date, to_options).to_html
         end
 
-        content_tag(:span, class: dom_classes) { [from, sep, to].join.html_safe }.html_safe
-      end
-
-      private # =============================================================
-
-      def separator
-        options.fetch(:separator, ' – ')
+        content_tag(:span, class: dom_classes, data: dom_data) { [from, sep, to].join.html_safe }.html_safe
       end
     end
   end

data/lib/semantic_date_time_tags/tag/date_time.rb

@@ -1,15 +1,18 @@
-require_relative '../format_parser'
+# frozen_string_literal: true
+
+require_relative "../format_parser"
 
 module SemanticDateTimeTags
   class Tag
     class DateTime < Tag
       def initialize(obj, options = {})
-        raise 'object must be DateTime' unless obj.instance_of?(::DateTime)
+        raise "object must be DateTime" unless obj.instance_of?(::DateTime)
+
+        options = options.except(*%i(separator))
+
         super(obj, options)
       end
 
-      # ---------------------------------------------------------------------
-
       def to_html
         if tag_name == :time
           datetime = obj.acts_like?(:time) ? obj.xmlschema : obj.iso8601
@@ -21,19 +24,21 @@ module SemanticDateTimeTags
 
         value = SemanticDateTimeTags::FormatParser.new(format_string, localized_obj).to_html.html_safe
 
-        time_tag(obj, options) { value }.html_safe
+        time_tag(obj, options.except(*%i(format))) { value }.html_safe
       end
 
-      private # =============================================================
-
-      def scope
-        'date_time.formats'
-      end
+      private
+        def scope
+          "date_time.formats"
+        end
 
-      def localized_obj
-        format_string = I18n.t(format, scope: scope, locale: I18n.locale)
-        I18n.l(obj, format: format_string)
-      end
+        def localized_obj
+          format_string = case format
+                          when Symbol then I18n.t(format, scope: scope, locale: I18n.locale)
+                          else format
+          end
+          I18n.l(obj, format: format_string)
+        end
     end
   end
 end