webgen 0.5.17 → 1.0.0.beta1

data/lib/webgen/cli/show_config_command.rb

@@ -0,0 +1,63 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/cli/utils'
+
+module Webgen
+  module CLI
+
+    # The CLI command for showing all available options.
+    class ShowConfigCommand < CmdParse::Command
+
+      def initialize # :nodoc:
+        super('config', false, false, true)
+        self.short_desc = 'Show available configuration options'
+        self.description = Utils.format_command_desc(<<DESC)
+Shows all available configuration options. The option name and default value as
+well as the currently used value are displayed.
+
+If the global verbosity option is set, option descriptions are additionally
+displayed.
+
+If an argument is given, only those options that have the argument in their name
+are displayed.
+
+Hint: A debug message will appear at the top of the output if this command is run
+in the context of a website, there are unknown configuration options in the
+configuration file and the log level is set to debug.
+DESC
+        self.options = CmdParse::OptionParserWrapper.new do |opts|
+          opts.separator "Options:"
+          opts.on("-m", "--modified",
+                  *Utils.format_option_desc("Show modified configuration options only")) do |v|
+            @modified = true
+          end
+        end
+        @modified = false
+        @unknown = true
+      end
+
+      def execute(args) # :nodoc:
+        config = commandparser.website.config
+        selector = args.first.to_s
+        config.options.select do |n, d|
+          n.include?(selector) && (!@modified || config[n] != d.default)
+        end.sort.each do |name, data|
+          format_config_option(name, data, config[name])
+        end
+      end
+
+      def format_config_option(name, data, cur_val)
+        print("#{Utils.light(Utils.blue(name))}: ")
+        if cur_val != data.default
+          puts(Utils.green(cur_val.to_s) + " (default: #{data.default})")
+        else
+          puts(cur_val.inspect)
+        end
+        puts(Utils.format(data.description, 78, 2, true).join("\n") + "\n\n") if commandparser.verbose
+      end
+      private :format_config_option
+
+    end
+
+  end
+end

data/lib/webgen/cli/show_dependencies_command.rb

@@ -0,0 +1,103 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/cli/utils'
+
+module Webgen
+  module CLI
+
+    # The CLI command for showing dependencies (tracked items) of paths.
+    class ShowDependenciesCommand < CmdParse::Command
+
+      def initialize # :nodoc:
+        super('deps', false, false, true)
+        self.short_desc = 'Show dependencies for all paths'
+        self.description = Utils.format_command_desc(<<DESC)
+Shows the dependencies (i.e. tracked items) for each path. This is only useful
+after webgen has generated the website at least once so that this information
+is available.
+
+If an argument is given, only those paths that have the argument in their name
+are displayed with their dependencies.
+
+Hint: The global verbosity option enables additional output.
+DESC
+      end
+
+      def execute(args) # :nodoc:
+        cache = commandparser.website.cache[:item_tracker_data]
+        if cache.nil?
+          puts "No data available, you need to generate the website first!"
+          return
+        end
+        arg = args.shift
+
+        data = cache[:node_dependencies]
+        data = data.select {|alcn, _| alcn.include?(arg) } if arg
+        data.sort.each do |alcn, deps|
+          deps = deps.sort {|a,b| a.first <=> b.first }.map do |uid|
+            method = "format_#{uid.first}"
+            if respond_to?(method, true)
+              send(method, alcn, uid, cache[:item_data][uid])
+            else
+              unknown_uid(uid)
+            end
+          end.compact
+
+          if deps.length > 0 || commandparser.verbose
+            puts("#{Utils.light(Utils.blue(alcn))}: ")
+            deps.each {|d| puts("  #{[d].flatten.join("\n    ")}")}
+          end
+        end
+      end
+
+      def unknown_uid(uid)
+        uid.first.to_s
+      end
+      private :unknown_uid
+
+      def format_node_meta_info(alcn, uid, data)
+        dep_alcn, key = *uid.last
+        return if alcn == dep_alcn && !commandparser.verbose
+
+        if key.nil?
+          "Any meta info from <#{dep_alcn}>"
+        else
+          "Meta info key '#{key}' from <#{dep_alcn}>"
+        end
+      end
+      private :format_node_meta_info
+
+      def format_node_content(alcn, uid, data)
+        dep_alcn = uid.last
+        return if alcn == dep_alcn && !commandparser.verbose
+
+        "Content from node <#{dep_alcn}>"
+      end
+      private :format_node_content
+
+      def format_file(alcn, uid, data)
+        "Content from file '#{uid.last}'"
+      end
+      private :format_file
+
+      def format_missing_node(alcn, uid, data)
+        path, lang = *uid.last
+
+        "Missing acn, alcn or dest path <#{path}>" << (lang.nil? ? '' : " in language '#{lang}'")
+      end
+      private :format_missing_node
+
+      def format_nodes(alcn, uid, data)
+        method, _, type = *uid.last
+
+        res = [(type == :content ? "Content" : "Meta info") + " from these nodes"]
+        res.first << " (result of #{[method].flatten.join('.')})" if commandparser.verbose
+        res.first << ":"
+        res += data.flatten
+      end
+      private :format_nodes
+
+    end
+
+  end
+end

data/lib/webgen/cli/show_extensions_command.rb

@@ -0,0 +1,74 @@
+# -*- encoding: utf-8 -*-
+
+require 'webgen/cli/utils'
+
+module Webgen
+  module CLI
+
+    # The CLI command for showing available extension.
+    class ShowExtensionsCommand < CmdParse::Command
+
+      def initialize # :nodoc:
+        super('extensions', false, false, true)
+        self.short_desc = 'Show available extensions'
+        self.description = Utils.format_command_desc(<<DESC)
+Shows all available extensions and additional information about them, e.g. a
+short summary of the functionality or the extension bundle it is defined in.
+
+If an argument is given, only those extensions that have the argument in their
+name are displayed.
+
+Hint: The global verbosity option enables additional output.
+DESC
+        self.options = CmdParse::OptionParserWrapper.new do |opts|
+          opts.separator "Options:"
+          opts.on("-b NAME", "--bundle NAME", String,
+                  *Utils.format_option_desc("Only show extensions of this bundle")) do |bundle|
+            @bundle = bundle
+          end
+        end
+        @bundle = nil
+      end
+
+      def execute(args) # :nodoc:
+        exts = {}
+        commandparser.website.ext.bundles.each do |bundle, info_file|
+          next if info_file.nil? || (@bundle && @bundle != bundle)
+          infos = YAML.load(File.read(info_file))
+          next unless infos['extensions']
+          infos['extensions'].each do |n, d|
+            d['bundle'] = bundle
+            d['author'] ||= infos['author']
+          end
+          exts.update(infos['extensions'])
+        end
+
+        selector = args.first.to_s
+        exts.select {|n, d| n.include?(selector)}.sort.each do |name, data|
+          format_extension_info(name, data, !selector.empty?)
+        end
+      end
+
+      def format_extension_info(name, data, has_selector)
+        author = (!data['author'] || data['author'].empty? ? 'unknown' : data['author'])
+
+        indentation = (has_selector ? 0 : name.count('.')*2)
+        puts(" "*indentation + Utils.light(Utils.blue(name)))
+        if commandparser.verbose
+          print(" "*(indentation + 2) + "Bundle:  ")
+          puts(Utils.format(data['bundle'], 78, indentation + 11, false))
+          print(" "*(indentation + 2) + "Author:  ")
+          puts(Utils.format(author, 78, indentation + 11, false))
+          print(" "*(indentation + 2) + "Summary: ")
+          puts(Utils.format(data['summary'], 78, indentation + 11, false))
+        else
+          puts(Utils.format(data['summary'], 78, indentation + 2, true).join("\n"))
+        end
+        puts
+      end
+      private :format_extension_info
+
+    end
+
+  end
+end

data/lib/webgen/cli/utils.rb

@@ -2,119 +2,92 @@
 
 require 'rbconfig'
 
-module Webgen::CLI
+module Webgen
 
-  # Provides methods for other CLI classes for formatting text in a consistent manner.
-  class Utils
+  module CLI
 
-    USE_ANSI_COLORS = Config::CONFIG['host_os'] !~ /mswin|mingw/
-    DEFAULT_WIDTH = if Config::CONFIG['host_os'] =~ /mswin|mingw/
-                      72
-                    else
-                      ((size = %x{stty size 2>/dev/null}).length > 0 && (size = size.split.last.to_i) > 0 ? size : 72) rescue 72
-                    end
+    # Provides methods for CLI classes for formatting text in a consistent manner.
+    module Utils
 
-    module Color
+      class << self; attr_accessor :use_colors; end
+      @use_colors = $stdout.tty? && RbConfig::CONFIG['host_os'] !~ /mswin|mingw/
 
-      @@colors = {:bold => [0, 1], :green => [0, 32], :lred => [1, 31], :reset => [0, 0]}
+      DEFAULT_WIDTH = 80
 
-      @@colors.each do |color, values|
-        module_eval <<-EOF
-        def Color.#{color.to_s}(text = nil)
-            "\e[#{values[0]};#{values[1]}m" + (text.nil? ? '' : text + self.reset)
-        end
-        EOF
-      end
+      module Color # :nodoc:
 
-    end
+        @@colors = {:bold => [1], :light => [1], :green => [32], :yellow => [33], :red => [31], :blue => [34], :reset => [0]}
 
+        @@colors.each do |color, values|
+          module_eval("def Color.#{color.to_s}(text = nil);" <<
+                      "'\e[#{values.join(';')}m' << (text.nil? ? '' : text + self.reset); end")
+        end
 
-    # Used for dynamically formatting the text (setting color, bold face, ...).
-    def self.method_missing(id, text = nil)
-      if USE_ANSI_COLORS && Color.respond_to?(id)
-        Color.send(id, text.to_s)
-      else
-        text.to_s
       end
-    end
 
-    # Return an array of lines which represents the text in +content+ formatted sothat no line is
-    # longer than +width+ characters. The +indent+ parameter specifies the amount of spaces
-    # prepended to each line. If +first_line_indented+ is +true+, then the first line is indented.
-    def self.format(content, indent = 0, first_line_indented = false, width = DEFAULT_WIDTH)
-      content = (content || '').dup
-      length = width - indent
-
-      paragraphs = content.split(/\n\n/)
-      if (0..1) === paragraphs.length
-        pattern = /^(.{0,#{length}})[ \n]/m
-        lines = []
-        while content.length > length
-          if content =~ pattern
-            str = $1
-            len = $&.length
-          else
-            str = content[0, length]
-            len = length
-          end
-          lines << (lines.empty? && !first_line_indented ? '' : ' '*indent) + str.gsub(/\n/, ' ')
-          content.slice!(0, len)
+
+      # Used for dynamically formatting the text (setting color, bold face, ...).
+      #
+      # The +id+ (method name) can be one of the following: bold, light, green, yellow, red, blue,
+      # reset.
+      def self.method_missing(id, text = nil)
+        if self.use_colors && Color.respond_to?(id)
+          Color.send(id, text)
+        else
+          text.to_s
         end
-        lines << (lines.empty? && !first_line_indented ? '' : ' '*indent) + content.gsub(/\n/, ' ') unless content.strip.empty?
-        lines
-      else
-        ((format(paragraphs.shift, indent, first_line_indented, width) << '') +
-         paragraphs.collect {|p| format(p, indent, true, width) << '' }).flatten[0..-2]
       end
-    end
 
-    # Return a headline with the given +text+ and amount of +indent+.
-    def self.headline(text, indent = 2)
-      ' '*indent + "#{bold(text)}"
-    end
-
-    # Return a section header with the given +text+ formatted in the given +color+ and indented
-    # according to +indent+. The whole text is also left justified to the column specified with
-    # +ljustlength+.
-    def self.section(text, ljustlength = 0, indent = 4, color = :green)
-      ' '*indent + "#{send(color, text)}".ljust(ljustlength - indent + send(color).length)
-    end
-
-    # Creates a listing of the key-value pairs of +hash+ under a section called +name+.
-    def self.hash_output(name, hash)
-      ljust = 20
-      puts section('Name', ljust) + "#{lred(name)}"
+      # Format the command description.
+      #
+      # Returns an array of Strings.
+      #
+      # See Utils.format for more information.
+      def self.format_command_desc(desc)
+        format(desc, 76)
+      end
 
-      hash.sort_by {|k,v| k.to_s }.each do |name, value|
-        next unless value.respond_to?(:to_str)
-        desc = format(value.to_str, ljust)
-        puts section(name.to_s.capitalize, ljust) + desc.shift
-        desc.each {|line| puts line}
+      # Format the option description.
+      #
+      # Returns an array of Strings.
+      #
+      # See Utils.format for more information.
+      def self.format_option_desc(desc)
+        format(desc, 48)
       end
-      puts
-    end
 
-    # Tries to match +name+ to a unique bundle name of the WebsiteManager +wm+. If this can not be
-    # done, it is checked whether +name+ is actually a valid bundle URL and if so, the URL source is
-    # added to the bundles of +wm+.
-    #
-    # Returns the correct bundle name or raises an error.
-    def self.match_bundle_name(wm, name)
-      matches = wm.bundles.keys.select {|k| k =~ /#{Regexp.escape(name)}/}
-      if matches.size > 1
-        raise ArgumentError.new("#{name} matches more than one bundle: #{matches.join(", ")}")
-      elsif matches.size == 0
-        begin
-          source = Webgen::Source::TarArchive.new(name)
-          wm.add_source(source, 'custom-URL-source')
-          name = 'custom-URL-source'
-        rescue
-          raise ArgumentError.new("#{name} is neither a valid bundle name nor a valid URL")
+      # Return an array of lines which represents the text in +content+ formatted so that no line is
+      # longer than +width+ characters.
+      #
+      # The +indent+ parameter specifies the amount of spaces prepended to each line. If
+      # +first_line_indented+ is +true+, then the first line is indented.
+      def self.format(content, width = DEFAULT_WIDTH, indent = 0, first_line_indented = false)
+        content = (content || '').dup
+        length = width - indent
+
+        paragraphs = content.split(/\n\n/)
+        if (0..1) === paragraphs.length
+          pattern = /^(.{0,#{length}})[ \n]/m
+          lines = []
+          while content.length > length
+            if content =~ pattern
+              str = $1
+              len = $&.length
+            else
+              str = content[0, length]
+              len = length
+            end
+            lines << (lines.empty? && !first_line_indented ? '' : ' '*indent) + str.gsub(/\n/, ' ')
+            content.slice!(0, len)
+          end
+          lines << (lines.empty? && !first_line_indented ? '' : ' '*indent) + content.gsub(/\n/, ' ') unless content.strip.empty?
+          lines
+        else
+          ((format(paragraphs.shift, width, indent, first_line_indented) << '') +
+           paragraphs.collect {|p| format(p, width, indent, true) << '' }).flatten[0..-2]
         end
-      else
-        name = matches.first
       end
-      name
+
     end
 
   end

data/lib/webgen/configuration.rb

@@ -1,149 +1,187 @@
 # -*- encoding: utf-8 -*-
 
+require 'yaml'
+require 'webgen/error'
+
 module Webgen
 
   # Stores the configuration for a webgen website.
   #
-  # Configuration options should be created like this:
+  # Configuration options can be created by using the define_option method:
+  #
+  #   config.define_option "my.new.option", 'default value', 'description'
+  #
+  # and later accessed or set using the accessor methods #[] and #[]=. A validation block can also
+  # be specified when defining an option. This validation block is called when a new value should be
+  # set and it should return the (possibly changed) value to be set:
   #
-  #   config.my.new.config 'value', :doc => 'some', :meta => 'info'
+  #   config.define_option "my.new.option", 'default value', 'description' do |val|
+  #     raise "Option must be a string" unless val.kind_of?(String)
+  #     val.upcase
+  #   end
   #
-  # and later accessed or set using the accessor methods #[] and #[]= or a configuration helper.
-  # These helpers are defined in the Helpers module and provide easier access to complex
-  # configuration options. Also see the {webgen
-  # manual}[http://webgen.rubyforge.org/documentation/manual.html#website-configfile] for
-  # information about the configuration helpers.
+  # **Note**: When a Configuration object is dumped (via Marshal), the option validator procs are
+  # not dumped and can therefore not be restored.
   class Configuration
 
-    # Helper class for providing an easy method to define configuration options.
-    class MethodChain
+    # Raised by the Webgen::Configuration class.
+    class Error < Webgen::Error; end
 
-      def initialize(config) #:nodoc:
-        @config = config
-        @name = ''
+    # Struct class for storing a configuration option.
+    Option = Struct.new(:default, :description, :validator) do
+      def dupped_default #:nodoc:
+        default.dup rescue default
       end
 
-      def method_missing(id, *args) #:nodoc:
-        @name += (@name.empty? ? '' : '.') + id.id2name.sub(/(!|=)$/,'')
-        if args.length > 0
-          value = args.shift
-          @config.data[@name] = value unless @config.data.has_key?(@name) # value is set only the first time
-          @config.meta_info[@name] ||= {}
-          @config.meta_info[@name].update(*args) if args.length > 0
-          nil
-        else
-          self
-        end
+      def ==(other) #:nodoc:
+        self.default == other.default
       end
 
-    end
-
-    # This module provides methods for setting more complex configuration options. It is mixed into
-    # Webgen::Configuration so that its methods can be used. Detailed information on the use of the
-    # methods can be found in the "User Manual" in the "Configuration File" section.
-    #
-    # All public methods defined in this module are available for direct use in the
-    # configuration file, e.g. the method named +default_meta_info+ can be used like this:
-    #
-    #   default_meta_info:
-    #     Webgen::SourceHandler::Page:
-    #       in_menu : true
-    #       :action : replace
-    #
-    # All methods have to take exactly one argument, a Hash.
-    #
-    # The special key <tt>:action</tt> should be used for specifying how the configuration option
-    # should be set:
-    #
-    # [replace]  Replace the configuration option with the new values.
-    # [modify]   Replace old values with new values and add missing ones (useful for hashes and
-    #            normally the default value)
-    module Helpers
-
-      # Set the default meta information for source handlers.
-      def default_meta_info(args)
-        args.each do |sh_name, mi|
-          raise ArgumentError, 'Invalid argument for configuration helper default_meta_info' unless mi.kind_of?(Hash)
-          action = mi.delete(:action) || 'modify'
-          mi_hash = (self['sourcehandler.default_meta_info'][complete_source_handler_name(sh_name)] ||= {})
-          case action
-          when 'replace' then mi_hash.replace(mi)
-          else mi_hash.update(mi)
-          end
-        end
+      def marshal_dump #:nodoc:
+        [self.default, self.description]
       end
 
-
-      # Set the path patterns used by source handlers.
-      def patterns(args)
-        args.each do |sh_name, data|
-          pattern_arr = (self['sourcehandler.patterns'][complete_source_handler_name(sh_name)] ||= [])
-          case data
-          when Array then pattern_arr.replace(data)
-          when Hash
-            (data['del'] || []).each {|pat| pattern_arr.delete(pat)}
-            (data['add'] || []).each {|pat| pattern_arr << pat}
-          else
-            raise ArgumentError, 'Invalid argument for configuration helper patterns'
-          end
-        end
+      def marshal_load(data) #:nodoc:
+        self.default = data[0]
+        self.description = data[1]
       end
 
+    end
 
-      # Set the default processing pipeline for a source handler.
-      def default_processing_pipeline(args)
-        args.each do |sh_name, pipeline|
-          raise ArgumentError, 'Invalid argument for configuration helper pipeline' unless pipeline.kind_of?(String)
-          mi_hash = (self['sourcehandler.default_meta_info'][complete_source_handler_name(sh_name)] ||= {})
-          ((mi_hash['blocks'] ||= {})['default'] ||= {})['pipeline'] = pipeline
-        end
-      end
 
+    # Contains all the defined configuration options.
+    attr_reader :options
 
-      # Complete +sh_name+ by checking if a source handler called
-      # <tt>Webgen::SourceHandler::SH_NAME</tt> exists.
-      def complete_source_handler_name(sh_name)
-        (Webgen::SourceHandler.constants.map {|c| c.to_s}.include?(sh_name) ? 'Webgen::SourceHandler::' + sh_name : sh_name)
-      end
-      private :complete_source_handler_name
+    # Create a new Configuration object.
+    def initialize
+      @options = {}
+      @values = {}
+    end
 
+    def initialize_copy(orig) #:nodoc:
+      super
+      @options = orig.options.dup
+      @values = {}
+      orig.instance_eval { @values }.each {|k,v| @values[k] = v.dup rescue v}
     end
 
+    def clone #:nodoc:
+      super
+      freeze if frozen?
+    end
 
-    include Helpers
+    def freeze #:nodoc:
+      super
+      @options.freeze
+      @values.each_value {|v| v.freeze}
+      @values.freeze
+      self
+    end
 
-    # The hash which stores the meta info for the configuration options.
-    attr_reader :meta_info
+    def ==(other) #:nodoc:
+      @options == other.options && @values == other.instance_variable_get(:@values)
+    end
 
-    # The configuration options hash.
-    attr_reader :data
+    # Define a new option +name+ with a default value of +default+ and the description.
+    #
+    # If a validation block is provided, it is called with the new value when one is set and should
+    # return a (possibly altered) value to be set.
+    def define_option(name, default, description, &validator)
+      if @options.has_key?(name)
+        raise ArgumentError, "Configuration option '#{name}' has already be defined"
+      else
+        @options[name] = Option.new
+        @options[name].default = default.freeze
+        @options[name].description = description.freeze
+        @options[name].validator = validator.freeze
+        @options[name].freeze
+      end
+    end
 
-    # Create a new Configuration object.
-    def initialize
-      @data = {}
-      @meta_info = {}
+    # Return +true+ if the given option exists.
+    def option?(name)
+      @options.has_key?(name)
     end
 
-    # Return the configuration option +name+.
+    # Return the value for the configuration option +name+.
     def [](name)
-      if @data.has_key?(name)
-        @data[name]
+      if @options.has_key?(name)
+        if frozen?
+          @values.has_key?(name) ? @values[name] : @options[name].dupped_default
+        else
+          @values[name] = @options[name].dupped_default unless @values.has_key?(name)
+          @values[name]
+        end
       else
-        raise ArgumentError, "No such configuration option: #{name}"
+        raise Error, "Configuration option '#{name}' does not exist"
       end
     end
 
-    # Set the configuration option +name+ to the provided +value+.
+    # Use +value+ as value for the configuration option +name+.
     def []=(name, value)
-      if @data.has_key?(name)
-        @data[name] = value
+      if @options.has_key?(name)
+        begin
+          @values[name] = (@options[name].validator ? @options[name].validator.call(value) : value)
+        rescue
+          raise Error, "Problem setting configuration option '#{name}': #{$!.message}", $!.backtrace
+        end
       else
-        raise ArgumentError, "No such configuration option: #{name}"
+        raise Error, "Configuration option '#{name}' does not exist"
       end
     end
 
-    def method_missing(id, *args) #:nodoc:
-      MethodChain.new(self).method_missing(id, *args)
+    # Set the configuration values from the Hash +values+.
+    #
+    # The hash can either contain full configuration option names or namespaced option names, ie. in
+    # YAML format:
+    #
+    #   my.option: value
+    #
+    #   website:
+    #     lang: en
+    #     url: my_url
+    #
+    # The above hash will set the option 'my.option' to +value+, 'website.lang' to +en+ and
+    # 'website.url' to +my_url+.
+    #
+    # Returns an array with all unknown configuration options.
+    def set_values(values)
+      unknown_options = []
+      process = proc do |name, value|
+        if @options.has_key?(name)
+          self[name] = value
+        elsif value.kind_of?(Hash)
+          value.each {|k,v| process.call("#{name}.#{k}", v)}
+        else
+          unknown_options << name
+        end
+      end
+      values.each(&process)
+      unknown_options
+    end
+
+    # Load the configuration values.
+    #
+    # If +filename+ is a String, it is treated as the name of the configuration file from which the
+    # values should be loaded. If +filename+ responds to \#read, it is treated as an IO object from
+    # which the values should be loaded.
+    #
+    # The configuration needs to be in YAML format. More specifically, it needs to contain a YAML
+    # hash which is further processed by #set_values.
+    #
+    # Returns an array with all unknown configuration options.
+    def load_from_file(filename)
+      data = if String === filename || filename.respond_to?(:read)
+               begin
+                 YAML::load(String === filename ? File.read(filename) : filename.read) || {}
+               rescue RuntimeError, ArgumentError, SyntaxError => e
+                 raise Error, "Problem parsing configuration data (it needs to contain a YAML hash): #{e.message}", e.backtrace
+               end
+             else
+               raise ArgumentError, "Need a String or IO object, not a #{filename.class}"
+             end
+      raise Error, 'Structure of configuration file is invalid, it has to be a Hash' unless data.kind_of?(Hash)
+      set_values(data)
     end
 
   end