foreman_discovery 1.0.0.rc1

data/test/foreman_app/app/helpers/images_helper.rb

@@ -0,0 +1,11 @@
+module ImagesHelper
+  def image_field f
+    return unless @compute_resource.capabilities.include?(:image)
+    images = @compute_resource.available_images
+    if images.any?
+      return select_f(f, :uuid, images.to_a.sort! { |a, b| a.name.downcase <=> b.name.downcase }, :id, :name, {}, :label => _('Image'))
+    else
+      text_f f, :uuid, :label => _("Image ID"), :help_inline => _("Image ID as provided by the compute resource, e.g. ami-..")
+    end
+  end
+end

data/test/foreman_app/app/helpers/layout_helper.rb

@@ -0,0 +1,214 @@
+module LayoutHelper
+  def title(page_title, page_header = nil)
+    content_for(:title, page_title.to_s)
+    @page_header       = page_header || @content_for_title || page_title.to_s
+  end
+
+  def title_actions *elements
+    content_for(:title_actions) { elements.join(" ").html_safe }
+  end
+
+  def button_group *elements
+      content_tag(:div,:class=>"btn-group") { elements.join(" ").html_safe }
+  end
+
+  def search_bar *elements
+    content_for(:search_bar) { elements.join(" ").html_safe }
+  end
+
+  def stylesheet(*args)
+    content_for(:head) { stylesheet_link_tag(*args) }
+  end
+
+  def javascript(*args)
+    content_for(:head) { javascript_include_tag(*args) }
+  end
+
+  def text_f(f, attr, options = {})
+    field(f, attr, options) do
+      f.text_field attr, options
+    end
+  end
+
+  def line_count (f, attr)
+    rows = f.object.try(attr).to_s.lines.count rescue 1
+    rows == 0 ? 1 : rows
+  end
+
+  def textarea_f(f, attr, options = {})
+    field(f, attr, options) do
+      options[:rows] = line_count(f, attr) if options[:rows] == :auto
+      f.text_area attr, options
+    end
+  end
+
+  def password_f(f, attr, options = {})
+    field(f, attr, options) do
+      f.password_field attr, options
+    end
+  end
+
+  def checkbox_f(f, attr, options = {}, checked_value="1", unchecked_value="0")
+    text = options.delete(:help_text)
+    inline = options.delete(:help_inline)
+    field(f, attr, options) do
+      label_tag('', :class=>'checkbox') do
+        help_inline = inline.blank? ? '' : content_tag(:span, inline, :class => "help-inline")
+        f.check_box(attr, options, checked_value, unchecked_value) + " #{text} " + help_inline.html_safe
+      end
+    end
+  end
+
+
+  def multiple_checkboxes(f, attr, klass, associations, options = {}, html_options={})
+    if associations.count > 5
+      associated_obj = klass.send(ActiveModel::Naming.plural(associations.first))
+      selected_ids = associated_obj.select("#{associations.first.class.table_name}.id").map(&:id)
+      multiple_selects(f, attr, associations, selected_ids, options, html_options)
+    else
+      field(f, attr, options) do
+        authorized_edit_habtm klass, associations, options[:prefix]
+      end
+    end
+  end
+
+  # add hidden field for options[:disabled]
+  def multiple_selects(f, attr, associations, selected_ids, options={}, html_options={})
+    field(f, attr,options) do
+      attr_ids = (attr.to_s.singularize+"_ids").to_sym
+      hidden_fields = f.hidden_field(attr_ids, :multiple => true, :value => '', :id=>'')
+      options[:disabled] ||=[]
+      options[:disabled].each do |disabled_value|
+        hidden_fields += f.hidden_field(attr_ids, :multiple => true, :value => disabled_value, :id=>'' )
+      end
+      hidden_fields + f.collection_select(attr_ids, associations.all.sort_by { |a| a.to_s },
+                                          :id, :to_s ,options.merge(:selected => selected_ids),
+                                          html_options.merge(:multiple => true))
+    end
+  end
+
+  def radio_button_f(f, attr, options = {})
+    text = options.delete(:text)
+    value = options.delete(:value)
+    label_tag('', :class=>"radio inline") do
+      f.radio_button(attr, value, options) + " #{text} "
+    end
+  end
+
+  def select_f(f, attr, array, id, method, select_options = {}, html_options = {})
+    field(f, attr, html_options) do
+      f.collection_select attr, array, id, method, select_options, html_options
+    end
+  end
+
+  def selectable_f(f, attr, array, select_options = {}, html_options = {})
+    field(f, attr, html_options) do
+      f.select attr, array, select_options, html_options
+    end
+  end
+
+  def file_field_f(f, attr, options = {})
+    field(f, attr, options) do
+      f.file_field attr, options
+    end
+  end
+
+  def field(f, attr, options = {})
+    fluid = options[:fluid]
+    error = f.object.errors[attr] if f && f.object.respond_to?(:errors)
+    inline = options.delete(:help_inline)
+    inline = error.to_sentence.html_safe unless error.empty?
+    help_inline = inline.blank? ? '' : content_tag(:span, inline, :class => "help-inline")
+    help_block  = content_tag(:span, options.delete(:help_block), :class => "help-block")
+    content_tag :div, :class => "control-group #{fluid ? "row-fluid" : ""} #{error.empty? ? "" : 'error'}" do
+      label = options.delete(:label) || (f.object.class.respond_to?(:gettext_translation_for_attribute_name) &&
+                                           s_(f.object.class.gettext_translation_for_attribute_name attr))
+      label_tag(attr, label, :class=>"control-label").html_safe +
+        content_tag(:div, :class => "controls") do
+          yield.html_safe + help_inline.html_safe + help_block.html_safe
+        end.html_safe
+    end
+  end
+
+  def submit_or_cancel f, overwrite = false, args = { }
+    args[:cancel_path] ||= eval "#{controller_name}_path"
+    content_tag(:div, :class => "form-actions") do
+      text    = overwrite ? _("Overwrite") : _("Submit")
+      options = overwrite ? {:class => "btn btn-danger"} : {:class => "btn btn-primary"}
+      link_to(_("Cancel"), args[:cancel_path], :class => "btn") + " " +
+      f.submit(text, options)
+    end
+  end
+
+  def base_errors_for obj
+    unless obj.errors[:base].blank?
+      content_tag(:div, :class => "alert alert-message alert-block alert-error base in fade") do
+        ("<a class='close' href='#' data-dismiss='alert'>&times;</a><h4>" + _("Unable to save") + "</h4> " + obj.errors[:base].map {|e| "<li>#{e}</li>"}.join).html_safe
+      end
+    end
+  end
+
+  def popover title, msg, options = {}
+    link_to icon_text("info-sign"), {}, {:remote => true, :rel => "popover", :data => {"content" => msg, "original-title" => title} }.merge(options)
+  end
+
+   def will_paginate(collection = nil, options = {})
+    options.merge!(:class=>"span7  pagination")
+    options[:renderer] ||= "WillPaginate::ActionView::BootstrapLinkRenderer"
+    options[:inner_window] ||= 2
+    options[:outer_window] ||= 0
+    super collection, options
+  end
+
+  def page_entries_info(collection, options = {})
+    html = super(collection, options)
+    html += options[:more].html_safe if options[:more]
+    content_tag(
+      :div,content_tag(
+          :ul, content_tag(
+              :li, link_to(html, "#")
+          ), :style=>"float: left;"
+      ), :class => "span4 pagination")
+  end
+
+  def form_for(record_or_name_or_array, *args, &proc)
+    if args.last.is_a?(Hash)
+      args.last[:html] = {:class=>"form-horizontal well"}.merge(args.last[:html]||{})
+    else
+      args << {:html=>{:class=>"form-horizontal well"}}
+    end
+    super record_or_name_or_array, *args, &proc
+  end
+
+  def icons i
+    content_tag :i, :class=>"icon-#{i}" do
+      yield
+    end
+  end
+
+  def icon_text(i, text="", opts = {})
+    (content_tag(:i,"", :class=>"icon-#{i} #{opts[:class]}") + " " + text).html_safe
+  end
+
+  def alert opts = {}
+    opts[:close] ||= true
+    opts[:header] ||= _("Warning!")
+    opts[:text] ||= _("Alert")
+    content_tag :div, :class => "alert #{opts[:class]}" do
+      result = "".html_safe
+      result += alert_close if opts[:close]
+      result += alert_header(opts[:header])
+      result += opts[:text].html_safe
+      result
+    end
+  end
+
+  def alert_header text
+  "<h4 class='alert-heading'>#{text}</h4>".html_safe
+  end
+
+  def alert_close
+    "<a class='close' href='#' data-dismiss='alert'>&times;</a>".html_safe
+  end
+
+end

data/test/foreman_app/app/helpers/lookup_keys_helper.rb

@@ -0,0 +1,108 @@
+module LookupKeysHelper
+
+  def remove_child_link(name, f, opts = {})
+    opts[:class] = [opts[:class], "remove_nested_fields"].compact.join(" ")
+    f.hidden_field(opts[:method]||:_destroy) + link_to_function(name, "remove_child_node(this);" , opts)
+  end
+
+  def add_child_link(name, association, opts = {})
+    opts[:class] = [opts[:class], "add_nested_fields btn btn-success"].compact.join(" ")
+    opts[:"data-association"] = association
+    link_to_function(name.to_s, "add_child_node(this);" , opts)
+  end
+
+  def new_child_fields_template(form_builder, association, options = { })
+    options[:object]             ||= form_builder.object.class.reflect_on_association(association).klass.new
+    options[:partial]            ||= association.to_s.singularize
+    options[:form_builder_local] ||= :f
+    options[:form_builder_attrs] ||= {}
+
+    content_tag(:div, :class => "#{association}_fields_template", :style => "display: none;") do
+        form_builder.fields_for(association, options[:object], :child_index => "new_#{association}") do |f|
+        render(:partial => options[:partial], :locals => { options[:form_builder_local] => f }.merge(options[:form_builder_attrs]))
+      end
+    end
+  end
+
+  def show_puppet_class f
+    # In case of a new smart-var inside a puppetclass (REST nesting only), or a class parameter:
+    # Show the parent puppetclass as a context, but permit no change.
+    if params["puppetclass_id"]
+      select_f f, :puppetclass_id, [Puppetclass.find(params["puppetclass_id"])], :id, :to_label, {}, {:label => _("Puppet class"), :disabled => true}
+    elsif f.object.is_param && f.object.param_class
+      field(f, :puppetclass_id, :label => _('Puppet Class')) do
+        content_tag(:input, nil, :value => f.object.param_class, :type => 'text', :disabled => true)
+      end
+    else # new smart-var with no particular context
+         # Give a select for choosing the parent puppetclass
+      select_f(f, :puppetclass_id, Puppetclass.all, :id, :to_label, { :include_blank => _('None') }, {:label => _("Puppet class")})
+    end unless @puppetclass # nested smart-vars form in a tab of puppetclass/_form: no edition allowed, and the puppetclass is already visible as a context
+  end
+
+  def param_type_selector f
+    selectable_f f, :key_type, options_for_select(LookupKey::KEY_TYPES, f.object.key_type),{},
+               { :disabled => (f.object.is_param && !f.object.override), :class => "medium",
+                 :help_inline => popover("?",_("<dl>" +
+               "<dt>String</dt> <dd>Everything is taken as a string.</dd>" +
+               "<dt>Boolean</dt> <dd>Common representation of boolean values are accepted.</dd>" +
+               "<dt>Integer</dt> <dd>Integer numbers only, can be negative.</dd>" +
+               "<dt>Real</dt> <dd>Accept any numerical input.</dd>" +
+               "<dt>Array</dt> <dd>A valid JSON or YAML input, that must evaluate to an array.</dd>" +
+               "<dt>Hash</dt> <dd>A valid JSON or YAML input, that must evaluate to an object/map/dict/hash.</dd>" +
+               "<dt>YAML</dt> <dd>Any valid YAML input.</dd>" +
+               "<dt>JSON</dt> <dd>Any valid JSON input.</dd>" +
+               "</dl>"), :title => _("How values are validated")).html_safe}
+  end
+
+  def validator_type_selector f
+     selectable_f f, :validator_type, options_for_select(LookupKey::VALIDATOR_TYPES, f.object.validator_type),{:include_blank => _("None")},
+                { :disabled => (f.object.is_param && !f.object.override), :class => "medium",
+                  :onchange => 'validatorTypeSelected(this)',
+                  :help_inline => popover("?",_("<dl>" +
+                "<dt>List</dt> <dd>A list of the allowed values, specified in the Validator rule field.</dd>" +
+                "<dt>Regexp</dt> <dd>Validates the input with the regular expression in the Validator rule field.</dd>" +
+                "</dl>"), :title => _("Validation types")).html_safe}
+  end
+
+  def used_matcher host, key
+    infos = { :used_matcher => nil }
+    key.value_for host, :obs_matcher_block => Proc.new { |h| infos = h }, :skip_fqdn => true
+    origin = infos[:used_matcher] || '(default value)'
+    origin.gsub(/=.*$/,'')
+  end
+
+  def overridable_lookup_keys klass, host
+    klass.class_params.override.where(:environment_classes => {:environment_id => host.environment_id}) + klass.lookup_keys
+  end
+
+  def key_with_diagnostic host, key
+     errors = Set.new
+     value = key.value_for host, :skip_fqdn => true
+     original_value = key.value_before_type_cast value
+     new_value = key.value_for host
+
+     diagnostic_class = []
+     diagnostic_helper = popover(_("Additional info"), _("<b>Description:</b> %{key}<br><b>Type:</b> %{type}<br> <b>Matcher:</b> %{matcher}") % { :desc => key.description, :key => key.key_type, :matcher => used_matcher(host, key)})
+     if new_value.blank? && !new_value.is_a?(FalseClass)
+       if key.required
+         diagnostic_class << 'error'
+         diagnostic_helper = popover(_('No value error'), _("Required parameter without value.<br/><b>Please override!</b> <br><br><b>Description:</b>: %s") % key.description)
+       else
+         diagnostic_class << 'warning'
+         diagnostic_helper = popover(_('No value warning'), _("Optional parameter without value.<br/><i>Won\'t be given to Puppet.</i> <br><br><b>Description:</b> %s") % key.description)
+       end
+     end
+     if errors.size > 0
+       diagnostic_class.delete 'warning'
+       diagnostic_class << 'error'
+       diagnostic_helper = popover(_('Fact error'), _('One or more unknown facts were encountered during evaluation:') + '<ul>' + errors.sort.map {|v| "<li>#{v}</li>" }.join + '</ul>')
+     end
+     content_tag :div, :class => ['control-group', 'condensed'] + diagnostic_class do
+      row_count = original_value.to_s.lines.count rescue 1
+      text_area_tag("value_#{key.key}", original_value, :rows => row_count == 0 ? 1 : row_count,
+                    :class => ['span5'], :'data-property' => 'value', :disabled => true) +
+      content_tag(:span, :class => "help-inline") { diagnostic_helper }
+     end
+  end
+
+end

data/test/foreman_app/app/helpers/media_helper.rb

@@ -0,0 +1,2 @@
+module MediaHelper
+end

data/test/foreman_app/app/helpers/medium_helper.rb

@@ -0,0 +1,2 @@
+module MediumHelper
+end

data/test/foreman_app/app/helpers/model_helper.rb

@@ -0,0 +1,2 @@
+module ModelHelper
+end

data/test/foreman_app/app/helpers/models_helper.rb

@@ -0,0 +1,2 @@
+module ModelsHelper
+end

data/test/foreman_app/app/helpers/notices_helper.rb

@@ -0,0 +1,3 @@
+module NoticesHelper
+
+end

data/test/foreman_app/app/helpers/operatingsystems_helper.rb

@@ -0,0 +1,40 @@
+module OperatingsystemsHelper
+  include CommonParametersHelper
+
+  def icon record, opts = {}
+    return "" if record.blank? or record.name.blank?
+    family = case record.name
+    when /fedora/i
+      "Fedora"
+    when /ubuntu/i
+      "Ubuntu"
+    when /solaris|sunos/i
+      "Solaris"
+    when /darwin/i
+      "Darwin"
+    when /centos/i
+      "Centos"
+    when /scientific/i
+      "Scientific"
+    when /archlinux/i
+      "Archlinux"
+    when /SLC/i
+      "SLC"
+    else
+      return "" if record.family.blank?
+      record.family
+    end
+
+    image_tag(family+".png", opts) + " "
+  end
+
+  def os_name record, opts = {}
+    "#{icon(record, opts)} #{record}".html_safe
+  end
+
+  def os_habtm_family type, obj
+    result = type.where(:os_family => obj.family)
+    result.empty? ? type : result
+  end
+
+end

data/test/foreman_app/app/helpers/organization_helper.rb

@@ -0,0 +1,2 @@
+module OrganizationHelper
+end

data/test/foreman_app/app/helpers/ptables_helper.rb

@@ -0,0 +1,2 @@
+module PtablesHelper
+end

data/test/foreman_app/app/helpers/puppetclasses_and_environments_helper.rb

@@ -0,0 +1,39 @@
+module PuppetclassesAndEnvironmentsHelper
+  def class_update_text pcs, env
+    if pcs.empty?
+      _("Empty environment")
+    elsif pcs == ["_destroy_"]
+      _("Deleted environment")
+    elsif pcs.delete "_destroy_"
+      _("Deleted environment %{env} and %{pcs}") % { :env => env, :pcs => pcs.to_sentence }
+    else
+      pretty_print(pcs.is_a?(Hash) ? pcs.keys : pcs)
+    end
+  end
+
+  def import_proxy_select hash
+    select_action_button( _('Import'),
+      SmartProxy.puppet_proxies.map do |proxy|
+        display_link_if_authorized(_("Import from %s") % proxy.name, hash.merge(:proxy => proxy), :class=>'btn')
+      end.flatten
+    )
+  end
+
+  private
+  def pretty_print classes
+    hash = { }
+    classes.each do |klass|
+      if (mod = klass.gsub(/::.*/, ""))
+        hash[mod] ||= []
+        hash[mod] << klass
+      else
+        next
+      end
+    end
+    hash.keys.sort.map do |key|
+      link_to_function key, { :rel => "popover", "data-content" => hash[key].sort.join('<br>').html_safe, "data-original-title" => key }
+    end.to_sentence.html_safe
+
+  end
+
+end