tenon 1.1.8 → 2.0.0

data/app/form_builders/tenon/form_builder.rb

@@ -5,7 +5,7 @@ module Tenon
     alias_method :super_label, :label
 
     def tenon_content(method_name)
-      @template.render 'tenon/tenon_content/builder',
+      @template.render 'tenon/tenon_content/tenon_content',
         f: self,
         field: method_name
     end
@@ -13,47 +13,210 @@ module Tenon
     def asset(method_name, opts = {})
       defaults = {
         label: nil,
+        wrapper_class: 'panel',
         # Remove button triggers cocoon's remove child event?
         remove_association: false
       }
       opts = defaults.merge(opts)
-
       @template.render 'tenon/fields/asset',
         f: self,
         label_tag: label(method_name, opts[:label]),
-        field: method_name,
+        method_name: method_name,
         proxy_attachment: object.send(method_name),
         opts: opts
     end
 
     def rich_text(method_name, opts = {})
       defaults = {
-        placeholder: '--',
+        placeholder: '--'
       }
       opts = defaults.merge(opts)
 
       @template.render 'tenon/fields/rich_text',
         f: self,
-        field: method_name,
+        method_name: method_name,
         label_tag: label(method_name, opts[:label]),
         opts: opts
     end
     alias_method :me_text, :rich_text
 
     alias_method :super_text_field, :text_field
-    def text_field(method_name, options = {})
-      content = build_content(:text_field_content, method_name, options)
+    def text_field(method_name, opts = {})
+      defaults = {
+        placeholder: '--'
+      }
+      opts = defaults.merge(opts)
+
+      @template.render 'tenon/fields/text_field',
+        f: self,
+        method_name: method_name,
+        opts: opts
     end
 
-    def text_field_content(method_name, options = {}, language = nil, language_title = nil)
-      label = label(method_name, options[:label], language, language_title)
-      explanation = explanation(options[:explanation])
-      label + explanation + super_text_field(get_method(method_name, language), options)
+    def title_text_field(method_name, opts = {})
+      defaults = {
+        placeholder: '--'
+      }
+      opts = defaults.merge(opts)
+
+      @template.render 'tenon/fields/title_text_field',
+        f: self,
+        method_name: method_name,
+        opts: opts
+    end
+
+    alias_method :super_email_field, :email_field
+    def email_field(method_name, opts = {})
+      defaults = {
+        placeholder: '--'
+      }
+      opts = defaults.merge(opts)
+
+      @template.render 'tenon/fields/email_field',
+        f: self,
+        method_name: method_name,
+        opts: opts
+    end
+
+    alias_method :super_password_field, :password_field
+    def password_field(method_name, opts = {})
+      defaults = {
+        placeholder: '--'
+      }
+      opts = defaults.merge(opts)
+
+      @template.render 'tenon/fields/password_field',
+        f: self,
+        method_name: method_name,
+        opts: opts
+    end
+
+    alias_method :super_number_field, :number_field
+    def number_field(method_name, opts = {})
+      defaults = {
+        placeholder: '--'
+      }
+      opts = defaults.merge(opts)
+
+      @template.render 'tenon/fields/number_field',
+        f: self,
+        method_name: method_name,
+        opts: opts
+    end
+
+    alias_method :super_phone_field, :phone_field
+    def phone_field(method_name, opts = {})
+      defaults = {
+        placeholder: '--'
+      }
+      opts = defaults.merge(opts)
+
+      @template.render 'tenon/fields/phone_field',
+        f: self,
+        method_name: method_name,
+        opts: opts
+    end
+
+    alias_method :super_url_field, :url_field
+    def url_field(method_name, opts = {})
+      defaults = {
+        placeholder: '--'
+      }
+      opts = defaults.merge(opts)
+
+      @template.render 'tenon/fields/url_field',
+        f: self,
+        method_name: method_name,
+        opts: opts
+    end
+
+    alias_method :super_color_field, :color_field
+    def color_field(method_name, opts = {})
+      defaults = {
+        placeholder: '--'
+      }
+      opts = defaults.merge(opts)
+
+      @template.render 'tenon/fields/color_field',
+        f: self,
+        method_name: method_name,
+        opts: opts
     end
 
     alias_method :super_text_area, :text_area
-    def text_area(method_name, options = {})
-      content = build_content(:text_area_content, method_name, options)
+    def text_area(method_name, opts = {})
+      @template.render 'tenon/fields/text_area',
+        f: self,
+        method_name: method_name,
+        opts: opts
+    end
+
+    alias_method :super_select, :select
+    def select(method_name, choices, opts = {}, html_opts = {})
+      @template.render 'tenon/fields/select',
+        f: self,
+        method_name: method_name,
+        choices: choices,
+        opts: opts,
+        html_opts: html_opts
+    end
+
+    alias_method :super_check_box, :check_box
+    def check_box(method_name, opts = {})
+      @template.render 'tenon/fields/check_box',
+        f: self,
+        method_name: method_name,
+        opts: opts
+    end
+
+    def inline_check_box(method_name, opts = {})
+      @template.render 'tenon/fields/inline_check_box',
+        f: self,
+        method_name: method_name,
+        opts: opts
+    end
+
+    alias_method :super_radio_button, :radio_button
+    def radio_button(method_name, value, opts = {})
+      @template.render 'tenon/fields/radio_button',
+        f: self,
+        method_name: method_name,
+        value: value,
+        opts: opts
+    end
+
+    def inline_radio_button(method_name, value, opts = {})
+      @template.render 'tenon/fields/inline_radio_button',
+      f: self,
+      method_name: method_name,
+      value: value,
+      opts: opts
+    end
+
+    alias_method :super_collection_select, :collection_select
+    def collection_select(method_name, collection, value_method, text_method, opts = {}, html_opts = {})
+      @template.render 'tenon/fields/collection_select',
+        f: self,
+        method_name: method_name,
+        collection: collection,
+        value_method: value_method,
+        text_method: text_method,
+        opts: opts,
+        html_opts: html_opts
+    end
+
+    def date_picker(method_name, opts = {})
+      @template.render 'tenon/fields/date_picker',
+        f: self,
+        method_name: method_name,
+        opts: opts
+    end
+
+    def date_time_picker(method_name, opts = {})
+      @template.render 'tenon/fields/date_time_picker',
+        f: self,
+        method_name: method_name,
+        opts: opts
     end
 
     def text_area_content(method_name, options = {}, language = nil, language_title = nil)
@@ -91,22 +254,29 @@ module Tenon
       end
     end
 
-    private
-
-    def label(method_name, label, language = nil, language_title = nil)
+    def label(method_name, label, required = false, inline = false, language = nil, language_title = nil)
       if label == false
         ''.html_safe
       else
         label ||= method_name.to_s.titleize
         label = language_title ? label + " (#{language_title.to_s.titleize})" : label
-        super(get_method(method_name, language), label.html_safe)
+        label_class = ['input-block__label']
+        label_class = ['input-block__label--inline'] if inline
+        if required
+          label += content_tag(:span, 'Required', class: 'input-block__required-msg')
+        end
+        super(get_method(method_name, language), label.html_safe, class: label_class.join(' '))
       end
     end
 
+    private
+
     def build_content(generator, method_name, options)
       content = send(generator, method_name, options)
-      content = internationalize_content(generator, method_name, content, options) if Tenon::I18nLookup.new(@object.class).fields.include? method_name.to_s
-      content
+      if Tenon::I18nLookup.new(@object.class).fields.include? method_name.to_s
+        content = internationalize_content(generator, method_name, content, options)
+      end
+      content_tag(:div, content, class: 'form-field')
     end
 
     def internationalize_content(generator, method_name, content, options = {})

data/app/helpers/tenon/active_link_to_helper.rb

@@ -0,0 +1,9 @@
+module Tenon
+  module ActiveLinkToHelper
+    def active_link_to(name = nil, options = {}, html_options = nil, &block)
+      options[:class] = '' unless options[:class].present?
+      options[:class] += ' --is-active' if name == request.original_fullpath
+      link_to(name, options, html_options, &block)
+    end
+  end
+end

data/app/helpers/tenon/application_helper.rb

@@ -1,15 +1,7 @@
 module Tenon
   module ApplicationHelper
-    def flash_messages
-      messages = []
-      %w(notice alert warning error).each do |msg|
-        unless flash[msg.to_sym].blank?
-          content = content_tag(:p, flash[msg.to_sym])
-          content += link_to fa_icon('times'), '#', id: 'flash-dismiss'
-          messages << content_tag(:div, content, class: "flash flash-#{msg}")
-        end
-      end
-      messages.join('').html_safe
+    def thisicon(icon)
+      content_tag(:i, icon, class: 'material-icon')
     end
 
     def menu_item(title, link, options = {})
@@ -21,11 +13,6 @@ module Tenon
       link_to(title, link, class: klass)
     end
 
-    # now uses http://github.com/mdeering/gravatar_image_tag
-    def gravatar_for(object)
-      gravatar_image_tag(object.email)
-    end
-
     def table_row(*args)
       html = '<tr>'
       args.each_with_index do |cell, i|
@@ -79,12 +66,6 @@ module Tenon
       false
     end
 
-    def current_translations
-      I18n.backend.send(:init_translations) unless I18n.backend.initialized?
-      @translations ||= I18n.backend.send(:translations)
-      @translations[I18n.locale].with_indifferent_access
-    end
-
     private
 
     def h5bp_opening_tag(ie_versions = 6..8)
@@ -97,7 +78,7 @@ module Tenon
       ie_versions.each do |version|
         next if version == max
 
-        klass = ie_versions.select { |e| e > version }.map { |e| "ie-lt#{e}" }.join(' ')
+        klass = ie_versions.select{ |e| e > version }.map{ |e| "ie-lt#{e}" }.join(' ')
 
         htmls << if_ie("<html lang='#{I18n.locale}' dir='ltr' class='noscript #{klass}'>", version: version)
       end
@@ -139,7 +120,7 @@ module Tenon
       end
     end
 
-      # humanizing various things
+    # humanizing various things
     def human(object)
       if object.is_a?(Date)
         object.strftime('%B %d, %Y')

data/app/helpers/tenon/asset_helper.rb

@@ -56,8 +56,8 @@ module Tenon
       def default_options
         {
           'data-modal-remote' => true,
-          'data-modal-title' => t('tenon.assets.edit_asset')
+          'data-modal-title' => 'Edit Asset'
         }
       end
-    end
+  end
 end

data/app/helpers/tenon/back_to_index_path_helper.rb

@@ -0,0 +1,13 @@
+module Tenon
+  # Generate a back button that includes the previous query if there was one
+  module BackToIndexPathHelper
+    def back_to_index_path(obj)
+      path = polymorphic_path(obj.class)
+      if cookies["last-query-#{path}.json"].present?
+        query = JSON.parse(cookies["last-query-#{path}.json"])
+        path = polymorphic_path(obj.class, query)
+      end
+      path
+    end
+  end
+end

data/app/helpers/tenon/breadcrumbs_helper.rb

@@ -0,0 +1,33 @@
+module Tenon
+  module BreadcrumbsHelper
+    def breadcrumb_links
+      links = []
+      if controller_name != 'index'
+        path = polymorphic_path(controller_name)
+        links << make_link(controller_name.titleize, path)
+
+        if %w( new edit ).include?(action_name)
+          links << make_link(member_title, member_path)
+        end
+      end
+      links
+    end
+
+    private
+
+    def make_link(title, path)
+      {
+        title: title,
+        path: path
+      }
+    end
+
+    def member_path
+      request.path
+    end
+
+    def member_title
+      action_name.titleize
+    end
+  end
+end

data/app/helpers/tenon/flash_helper.rb

@@ -0,0 +1,14 @@
+module Tenon
+  module FlashHelper
+    def flash_messages
+      messages = []
+      %w(notice alert warning error).each do |msg|
+        unless flash[msg.to_sym].blank?
+          content = content_tag(:div, flash[msg.to_sym], class: 'flash__message')
+          messages << content_tag(:div, content, class: "flash flash--#{msg}")
+        end
+      end
+      messages.join('').html_safe
+    end
+  end
+end

data/app/helpers/tenon/icon_helper.rb

@@ -0,0 +1,7 @@
+module Tenon
+  module IconHelper
+    def i(icon, opts = {})
+      content_tag(:i, icon, class: "material-icon #{opts[:class] if opts[:class].present?}")
+    end
+  end
+end

data/app/helpers/tenon/input_block_helper.rb

@@ -0,0 +1,25 @@
+module Tenon
+  module InputBlockHelper
+    def input_block(label, opts = {}, &blk)
+      content_tag :div, class: 'input-block' do
+        block_label_tag(label) +
+        content_tag(:div, capture(&blk), class: 'input-block__inline-group' ) +
+        block_explanation(opts[:explanation])
+      end
+    end
+
+    private
+
+    def block_label_tag(text)
+      content_tag(:label, text, class: 'input-block__label')
+    end
+
+    def block_explanation(text)
+      if text.present?
+        return content_tag(:div, text, class: 'input-block__explanation')
+      else
+        return ''
+      end
+    end
+  end
+end

data/app/helpers/tenon/item_version_helper.rb

@@ -5,36 +5,48 @@ module Tenon
 
       default_opts = {
         builder: Tenon::FormBuilder,
-        data: data
+        data: data,
+        validate: true
       }
 
       form_for(obj, default_opts.merge(opts), &blk)
     end
 
-    def save_draft_button(obj)
+    def save_draft_link(obj)
       path = new_item_version_path(item_type: class_for(obj), item_id: obj.id)
-      css_class = 'btn btn-primary btn-block draft'
+      css_class = 'draft'
       data = {
         'modal-remote' => true,
         'modal-handler' => 'Tenon.features.NewItemVersionHandler',
-        'modal-title' => t('tenon.item_versions.save_draft')
+        'modal-title' => 'Save Draft'
       }
-      link_to t('tenon.item_versions.save_draft'), path, class: css_class, data: data
+      link_to path, class: css_class, data: data do
+        content_tag(:i, 'cloud_queue', class: 'material-icon') +
+        'Save Draft'
+      end
     end
 
     def clear_draft_link
       path = url_for(version: nil)
-      link_to t('tenon.item_versions.load_active_version'), path, class: 'delete-link'
+      link_to 'Load Active Version', path, class: 'delete-link'
     end
 
     def load_draft_link(obj)
       path = item_versions_path(item_type: obj.class.to_s, item_id: obj.id)
       data = {
         'modal-remote' => true,
-        'modal-title' => t('tenon.item_versions.load_draft'),
+        'modal-title' => 'Load Draft',
         'modal-handler' => 'Tenon.features.ItemVersionIndexHandler'
       }
-      link_to t('tenon.item_versions.load_draft'), path, class: 'delete-link', data: data
+      link_to 'Load Draft', path, class: 'delete-link', data: data
+    end
+
+    def item_version_active_path(obj)
+      if obj.persisted?
+        polymorphic_path [:edit, obj]
+      else
+        new_polymorphic_path obj.class
+      end
     end
 
     private
@@ -52,7 +64,8 @@ module Tenon
         'item-type' => class_for(obj),
         'item-id' => obj.id,
         'autosave' => !params[:version],
-        'version-create-path' => item_versions_path
+        'version-create-path' => item_versions_path,
+        'protect-changes' => true
       }
 
       if opts[:data]

data/app/helpers/tenon/nav_helper.rb

@@ -1,34 +1,38 @@
 module Tenon
   module NavHelper
-    def nav_item(text, path_object, icon_class, link_opts = {})
-      path = path(path_object)
-      content = link(text, path, icon_class, link_opts)
-      content_tag(:li, content)
+    def nav_item(text, path, icon, link_opts = {}, &blk)
+      content = link(text, path, icon, link_opts)
+      content += subnav(&blk) if block_given?
+      content_tag(:li, content, class: "main-nav__item #{active_class(path, link_opts[:active])}")
     end
 
     private
 
-    def path(path_object)
-      if path_object.is_a?(Class)
-        path_object
-      else
-        path_object
-      end
+    def subnav(&blk)
+      icons = content_tag(:i, 'keyboard_arrow_down', class: 'main-nav__open-icon')
+      icons += content_tag(:i, 'keyboard_arrow_up', class: 'main-nav__close-icon')
+      content = link_to(icons, '#', class: 'main-nav__link-toggle')
+      content += content_tag(:ul, capture(&blk), class: 'main-nav__sub-nav')
+      content
     end
 
-    def link(text, path, icon_class, opts = {})
-      content = content_tag(:i, '', class: "fa fa-#{icon_class} fa-fw fa-2x")
-      content += text
-      opts[:class] ||= ''
+    def link(text, path, icon, opts = {})
+      content = content_tag(:i, icon, class: 'material-icon')
+      content += content_tag(:span, text)
+      opts[:class] ||= 'main-nav__link action-icon'
+      opts[:class] += ' main-nav__link--sub' if opts[:sub]
       opts[:title] ||= text
-      opts[:class] += " #{active_class(path, opts[:active])}"
       link_to(content, path, opts)
     end
 
     def active_class(path, active)
       path = url_for(path).split('/')[0..2].join('/')[1..-1]
-      tenon_path = tenon.root_path.gsub(/^\//,'') + controller_name
-      'active' if active || path == tenon_path
+      tenon_path = tenon.root_path.gsub(%r{^\/}, '') + controller_name
+      if active || path == tenon_path
+        'main-nav__item--active main-nav__item--open'
+      else
+        ''
+      end
     end
   end
 end

data/app/helpers/tenon/piece_helper.rb

@@ -29,7 +29,7 @@ module Tenon
         sizes = breakpoints[:full]
 
         # calculate the image size at :full breakpoint based on the piece width
-        image_size = (piece.sizes[piece_size(piece).to_sym] / 12 * content_size(sizes, piece)).to_i
+        image_size = (piece.size.to_f / 12.0 * content_size(sizes, piece)).to_i
 
         # round up to nearest 200
         image_size = image_size.round(-2)
@@ -45,7 +45,7 @@ module Tenon
       # item_type-specific tenon_content width not defined.
       def generate_sizes(piece, breakpoints)
         breakpoints.map do |name, sizes|
-          "(min-width: #{sizes[:browser]}px) #{(piece.sizes[piece_size(piece).to_sym] / 12 * 100 * content_size(sizes, piece) / sizes[:browser]).to_i}vw"
+          "(min-width: #{sizes[:browser]}px) #{(piece.size.to_f / 12.0 * 100 * content_size(sizes, piece) / sizes[:browser]).to_i}vw"
         end.join(', ')
       end
 
@@ -60,11 +60,6 @@ module Tenon
         end.join(', ')
       end
 
-      # Handle 'twelve' pieces that have size set to '' in the db
-      def piece_size(piece)
-        piece_size = piece.size == '' ? 'twelve' : piece.size
-      end
-
       def computed_style(piece, style)
         computed_style = "#{piece.image.style_prefix}_#{style}"
       end

data/app/helpers/tenon/platform_hints_helper.rb

@@ -1,9 +1,7 @@
 module Tenon
   module PlatformHintsHelper
-
-  def platform_hints(color)
-    render 'tenon/shared/platform_hints', color: color
-  end
-
+    def platform_hints(color)
+      render 'tenon/shared/platform_hints', color: color
+    end
   end
 end

data/app/helpers/tenon/styleguide_helper.rb

@@ -0,0 +1,15 @@
+module Tenon
+  module StyleguideHelper
+    def color_spans(arr, join = ', ')
+      arr.map{|c| color_span(c)}.join(join).html_safe
+    end
+
+    def color_span(color)
+      content_tag(:span, color, class: "color-#{color}")
+    end
+
+    def expandable_toggle
+      link_to i('keyboard_arrow_down'), '#', class: 'expand'
+    end
+  end
+end

data/app/helpers/tenon/tenon_content_helper.rb

@@ -5,15 +5,15 @@ module Tenon
         'data-association-insertion-node' => "##{field}-tenon-content",
         'data-association-insertion-method' => 'append',
         'data-searchable-title' => title.downcase,
-        :partial => 'tenon/tenon_content/row',
-        :render_options => {
+        partial: 'tenon/tenon_content/row',
+        render_options: {
           locals: {
             row_partial: "tenon/tenon_content/row_types/form/#{row_type.to_s.underscore}",
             field: field,
             title: title
           }
         },
-        :wrap_object => proc do |row|
+        wrap_object: proc do |row|
           row.set_row_type(row_type)
           row.decorate
         end
@@ -22,8 +22,13 @@ module Tenon
     end
 
     def row_link_content(title, row_type)
-      link = image_tag("tenon/tenon-content/#{row_type}.png", id: row_type, data: { :'row-type' => row_type })
-      link += content_tag(:p, "#{title}")
+      content = image_tag(
+        "tenon/tenon-content/#{row_type}.png",
+        class: 'tn-tc-library__image',
+        id: row_type,
+        data: { :'row-type' => row_type }
+      )
+      content + content_tag(:p, title, class: 'tn-tc-library__title')
     end
 
     def tenon_content_sizes
@@ -32,7 +37,7 @@ module Tenon
         links << link_to(name.to_s.titleize, '#', class: 'btn btn-white', data: { size: size_for_breakpoint(widths[:default]) })
       end
       last = Tenon.config.breakpoints.front_end.values.last
-      links << link_to(t('tenon.common.mobile'), '#', class: 'btn btn-white', data: { size: 320, mobile: true })
+      links << link_to('Mobile', '#', class: 'btn btn-white', data: { size: 320, mobile: true })
       links.join('').html_safe
     end