nutella_framework 0.3.1 → 0.4.0

data/lib/{core/commands → commands}/template.rb

@@ -1,9 +1,9 @@
-require 'core/template_command'
+require 'commands/meta/template_command'
 
 module Nutella
 
   class Template < TemplateCommand
-    @description = 'Helps create and validate templates'
+    @description = 'Creates and validates nutella components templates'
 
     def run(args=nil)
 
@@ -30,9 +30,9 @@ module Nutella
     private
 
     def display_help
-      console.info 'You need to specify a sub command.'
-      console.info 'create <template_name>    creates a template skeleton in the folder with the same name'
-      console.info 'validate  <temple_dir>    validates a template that already exists'
+      console.warn 'You need to specify a sub command.'
+      console.warn 'create <template_name>    creates a template skeleton in the folder with the same name'
+      console.warn 'validate  <temple_dir>    validates a template that already exists'
     end
 
 
@@ -45,73 +45,93 @@ module Nutella
     end
 
 
-    def create_template_sub_command( name_d )
-      ver_d = '0.1.0'
-      type_d = 'bot'
+    def create_template_sub_command( template_name )
+      @default_version = '0.1.0'
+      @default_type = 'bot'
+      # Get template parameters from command line
+      name = prompt_and_read_name template_name
+      version = prompt_and_read_version
+      type = prompt_and_read_type
+      description = prompt_and_read_description type
+      repo = prompt_and_read_repo
+      # Build JSON
+      json = build_nutella_json( name, version, type, description, repo )
+      # Show confirmation and read
+      prompt_and_read_confirm json
+
+    end
 
-      # Name
+
+    def prompt_and_read_name(template_name)
       puts 'What is the name of your template?'
-      print "(#{name_d}) "
-      c = $stdin.gets.chomp!
-      name = c.empty? ? name_d : c
-      # Version
-      puts 'What is the version of your template?'
-      print "(#{ver_d}) "
+      print "(#{template_name}) "
       c = $stdin.gets.chomp!
-      version = c.empty? ? ver_d : c
-      # Type
-      puts 'Are you creating a template for a "bot" or "interface"?'
-      print "(#{type_d}) "
+      c.empty? ? template_name : c
+    end
+
+    def prompt_and_read_version
+      prompt_and_read 'What is the version of your template?', @default_version
+    end
+
+    def prompt_and_read_type
+      prompt_and_read 'Are you creating a template for a "bot" or "interface"?', @default_type
+    end
+
+    def prompt_and_read( prompt, default )
+      puts prompt
+      print "(#{default}) "
       c = $stdin.gets.chomp!
-      type = c.empty? ? type_d : c
-      # Description
+      c.empty? ? default : c
+    end
+
+    def prompt_and_read_description(type)
       puts "Do you want to provide a short description for your #{type} template?"
       print '(optional, hit enter if no description) '
-      description = $stdin.gets.chomp!
-      # Repo
+      $stdin.gets.chomp!
+    end
+
+    def prompt_and_read_repo
       puts 'Do you want to provide a git repository for your template?'
       print '(optional, hit enter if no repo) '
-      repo = $stdin.gets.chomp!
+      $stdin.gets.chomp!
+    end
 
-      # Build JSON and show confirmation
+    def prompt_and_read_confirm(json)
       puts 'Looks good?'
-      json = build_nutella_json( name, version, type, description, repo )
       puts JSON.pretty_generate json
       print '(yes/no) '
-
-      # If user confirms, create template
       confirm = $stdin.gets.chomp!
       if confirm=='yes'
-        create_template_files json
+        create_template json
       else
         console.warn 'Template creation aborted'
       end
-
     end
 
-
-    def create_template_files( json )
+    def create_template( json )
       # First validate the JSON
       unless validate_nutella_file_json json
         console.error 'Something was wrong with your nutella.json file. Template creation aborted'
         return
       end
-      # Assemble destination directory
+      # Check that the template directory doesn't already exist
       template_dir = File.join( Dir.pwd, json['name'] )
-      # Check that the directory doesn't exist already
-      if File.directory?(template_dir)
+      if File.directory? template_dir
         console.error("The directory #{template_dir} already exists! Can't create template #{json[:name]}")
         return
       end
+      # Create template directory and files
+      create_template_files(json, template_dir)
+    end
+
+    def create_template_files(json, template_dir)
       # Create directory
       Dir.mkdir template_dir
       # Create nutella.json file
       File.open("#{template_dir}/nutella.json", 'w') { |f| f.write(JSON.pretty_generate json) }
       # Add bot/interface specific files
-      bot_specific_file = nil
-      bot_specific_file = File.join( Nutella.config['nutella_home'], 'data/startup' ) if json['type']=='bot'
-      bot_specific_file = File.join( Nutella.config['nutella_home'], 'data/index.html' ) if json['type']=='interface'
-      FileUtils.copy( bot_specific_file, template_dir )
+      FileUtils.copy(File.join(Nutella::NUTELLA_HOME, 'data/startup'), template_dir) if json['type']=='bot'
+      FileUtils.copy(File.join(Nutella::NUTELLA_HOME, 'data/index.html'), template_dir) if json['type']=='interface'
       console.success "Template #{json['name']} created successfully!"
     end
 

data/lib/config/current_app_utils.rb

@@ -0,0 +1,51 @@
+require 'json'
+
+module Nutella
+
+  # This module contains a series of utilities methods to handle the nutella
+  # application contained in the directory we are at this moment
+  module CurrentAppUtils
+    
+    # Checks that the current directory is actually a nutella application
+    # @return [Boolean] true if the current directory is a nutella application, false otherwise
+    def CurrentAppUtils.exist?
+      cur_app_dir = Dir.pwd
+      nutella_json_file = "#{cur_app_dir}/nutella.json"
+      # Check that there is a nutella.json file in the main directory of the application
+      if File.exist? nutella_json_file
+        conf = JSON.parse( IO.read(nutella_json_file) )
+        if conf['nutella_version'].nil?
+          return false
+        end
+      else
+        return false
+      end
+      true
+    end
+
+    # Builds a PersistedHash of the application nutella.json file and returns it.
+    # This method is used to ease access to the app nutella.json file.
+    # @return [PersistedHash] the PersistedHash of the app nutella.json file
+    def CurrentAppUtils.config
+      cur_app_dir = Dir.pwd
+      nutella_json_file = "#{cur_app_dir}/nutella.json"
+      if File.exist? nutella_json_file
+        return PersistedHash.new(nutella_json_file)
+      else
+        raise 'The current directory is not a nutella app: impossible to read nutella.json file'
+      end
+    end
+    
+  end
+
+
+  # Calling this method (Nutella.current_app) simply returns
+  # a reference to the CurrentAppUtils module
+  def Nutella.current_app
+    CurrentAppUtils
+  end
+  
+end
+
+
+

data/lib/config/persisted_hash.rb

@@ -4,12 +4,12 @@ require 'fileutils'
 module Nutella
 
   # This class behaves *similarly* to a regular Hash but it persists every operation
-  # to the json file passed in the constructor. Not all Hash operations are supported
+  # to the file passed in the constructor. Not all Hash operations are supported
   # and we added some of our own.
   class PersistedHash
 
     def initialize(file)
-      @config_file=file
+      @file=file
     end
 
     def []( key )
@@ -69,7 +69,7 @@ module Nutella
     # there is currently no value associated with the specified key.
     # @return [Boolean] false if the key already exists, true if the
     # <key, value> pair was added successfully
-    def add?(key, val)
+    def add_key_value?(key, val)
       hash = load_hash
       return false if hash.key? key
       hash[key] = val
@@ -81,37 +81,39 @@ module Nutella
     # there is currently a value associated with the specified key.
     # @return [Boolean] false if there is no value associated with
     # the specified key, true otherwise
-    def delete?( key )
+    def delete_key_value?( key )
       hash = load_hash
       return false if hash.delete(key).nil?
       store_hash hash
       true
     end
 
+
+    # Removes the file the hash is persisted to
+    def remove_file
+      File.delete(@file) if File.exist?(@file)
+    end
+
     private
 
     def store_hash(hash)
-      dirname = File.dirname(@config_file)
+      dirname = File.dirname(@file)
       FileUtils.mkdir_p(dirname) unless File.directory?(dirname)
-      File.open(@config_file, 'w+') do |f|
+      File.open(@file, 'w+') do |f|
         f.write(JSON.pretty_generate(hash))
       end
-      File.chmod(0777, @config_file)
+      File.chmod(0777, @file)
     end
 
     def load_hash
       begin
-        return JSON.parse IO.read @config_file
+        return JSON.parse IO.read @file
       rescue
         # File doesn't exist, return new empty Hash
         Hash.new
       end
     end
 
-    def remove_file
-      File.delete(@config_file) if File.exist?(@config_file)
-    end
-
   end
 
 end

data/lib/config/runlist.rb

@@ -1,32 +1,132 @@
 require 'config/persisted_hash'
 
 module Nutella
-  
-  class RunListHash < PersistedHash
 
-    # Returns the +run_id+ names for a certain project
-    # If no project is specified, +run_id+s for all projects are returned
-    # @param [String] project_name the name of the project we want to find run names for
-    # @return [Array<String>] list of +run_id+s associated to the specified project
-    def runs_by_project( project_name=nil )
-      (project_name == nil) ? keys : keys.select { |run| run.start_with?(project_name) }
+  # Manages the list of nutella applications and runs handled by the framework.
+  # The list has a structure similar this one:
+  # {
+  #   "app_a": {
+  #     "runs": [ "default", "run_1", "run_2" ],
+  #     "path": "/path/to/app/a/files/"
+  #   },
+  #   "app_b": {
+  #     "runs": [ "run_1", "run_3" ],
+  #     "path": "/path/to/app/b/files/"
+  #   }
+  # }
+  class RunListHash
+
+    def initialize( file )
+      @ph = PersistedHash.new file
+    end
+
+
+    # Returns all the +run_id+s for ALL applications
+    #
+    # @return [Array<String>] list of +run_id+s associated to the specified app_id
+    def all_runs
+      @ph.to_h
+    end
+
+
+    # Returns all the +run_id+s for a certain application
+    #
+    # @param [String] app_id the id of the application we want to find run_ids for
+    # @return [Array<String>] list of +run_id+s associated to the specified app_id
+    def runs_for_app( app_id )
+      # If there is no app, then return false and do nothing
+      return [] if @ph[app_id].nil?
+      runs = @ph[app_id]['runs']
+      runs.nil? ? [] : runs
+    end
+
+
+    # Adds a run_id to the runlist
+    #
+    # @param [String] app_id the app_id the run_id belongs to
+    # @param [String] run_id the run_id we are trying to add to the runs list
+    # @param [String] path_to_app_files the path to the application files
+    # @return [Boolean] true if the run_id is added to the list (i.e. there is no other
+    #   run_id with for the same app_id)
+    def add?( app_id, run_id, path_to_app_files )
+      # If no run_id is specified, we are adding the "default" run
+      run_id = 'default' if run_id.nil?
+      # Check if we are adding the first run for a certain application
+      if @ph.add_key_value?(app_id, Hash.new)
+        t = @ph[app_id]
+        # Add path and initialize runs
+        t['path'] = path_to_app_files
+        t['runs'] = [run_id]
+      else
+        t = @ph[app_id]
+        # Check a run with this name doesn't already exist
+        return false if t['runs'].include? run_id
+        # Add the run_id to list of runs
+        t['runs'].push(run_id)
+      end
+      @ph[app_id] = t
+      true
     end
 
-    # Extracts the +run_id+ from the run name (specified at command line)
-    # @param [String] run_name
-    # @return [String] the +run_id+ which is either the +project_name+ (if no +run_name+
-    # was specified) or the concatenation of +project_name+ and +run_name+
-    def extract_run_id( run_name )
-      run_name.to_s.empty? ? Nutella.current_project.config['name'] : "#{Nutella.current_project.config['name']}_#{run_name}"
+
+    # Remove a run_id from the list
+    #
+    # @param [String] app_id the app_id the run_id belongs to
+    # @param [String] run_id the run_if we are trying to remove from the runs list
+    # @return [Boolean] true if the run_id is removed from the list (i.e. a run_id with that name exists
+    #   and is successfully removed)
+    def delete?( app_id, run_id )
+      # If there is no app, then return false and do nothing
+      return false if @ph[app_id].nil?
+      t = @ph[app_id]
+      result = t['runs'].delete run_id
+      if t['runs'].empty?
+        # If run_id was the last run for this app, remove the app as well
+        @ph.delete_key_value? app_id
+      else
+        # otherwise write the hash back
+        @ph[app_id] = t
+      end
+      result.nil? ? false : true
+    end
+
+
+    # Returns true if the runs list is empty
+    # @return [Boolean] true if the list is empty, false otherwise
+    def empty?
+      @ph.empty?
+    end
+
+
+    # Removes the runs list file
+    def remove_file
+      @ph.remove_file
+    end
+
+
+    # This method checks that the list reflects the actual
+    # state of the system. It does so by checking that there is
+    # still a tmux session with the run name. If that's not the case,
+    # it removes the missing runs from the list.
+    def clean_list
+      all_runs.each do |app, _|
+        runs_for_app(app).each do |run|
+          unless Tmux.session_exist? Tmux.session_name(app, run)
+            delete? app, run
+          end
+        end
+      end
     end
-    
 
   end
 
+
   # Calling this method (Nutella.runlist) simply returns and instance of
   # RunListHash linked to file runlist.json in the nutella home directory
   def Nutella.runlist
-    RunListHash.new( "#{ENV['HOME']}/.nutella/runlist.json" )
+    rl = RunListHash.new( "#{ENV['HOME']}/.nutella/runlist.json" )
+    rl.clean_list
+    rl
   end
   
 end

data/lib/{cli → core}/nutella_cli.rb

@@ -40,7 +40,7 @@ module Nutella
     # Print nutella logo
     def self.print_nutella_logo
       console.info(NUTELLA_LOGO)
-      nutella_version = File.open("#{Nutella.config['nutella_home']}VERSION", 'rb').read
+      nutella_version = File.open("#{Nutella::NUTELLA_HOME}VERSION", 'rb').read
       console.info("Welcome to nutella version #{nutella_version}! For a complete lists of available commands type 'nutella help'\n")
       # If nutella is not ready to be used (i.e. nobody has invoked the "nutella checkup" command yet),
       # append warning/reminder message

data/lib/core/nutella_core.rb

@@ -1,8 +1,8 @@
 # Require all commands by iterating through all the files
 # in the commands directory
-Dir["#{File.dirname(__FILE__)}/commands/*.rb"].each do |file|
+Dir["#{File.dirname(__FILE__)}/../commands/*.rb"].each do |file|
   # noinspection RubyResolve
-  require "core/commands/#{File.basename(file, File.extname(file))}"
+  require "commands/#{File.basename(file, File.extname(file))}"
 end
 
 module Nutella
@@ -29,14 +29,10 @@ module Nutella
     end
     
     # This method initializes the nutella configuration file (config.json) with:
-    # - nutella_home: the directory nutella is installed in
-    # - tmp_dir: temporary directory used when installing remote templates
     # - config_dir: directory where the configuration files are stored in
     # - broker_dir: directory where the local broker is installed in
     # - main_interface_port: the port used to serve interfaces
     def Nutella.init
-      Nutella.config['nutella_home'] = NUTELLA_HOME
-      Nutella.config['tmp_dir'] = "#{NUTELLA_HOME}.tmp/"
       Nutella.config['config_dir'] = "#{ENV['HOME']}/.nutella/"
       Nutella.config['broker_dir'] = "#{Nutella.config['config_dir']}broker/"
       Nutella.config['main_interface_port'] = 57880

data/lib/nutella_framework.rb

@@ -1,15 +1,17 @@
 # Import all the modules
 require 'logging/nutella_logging'
 require 'core/nutella_core'
+require 'core/nutella_cli'
 require 'config/config'
 require 'config/runlist'
-require 'config/current_project'
-require 'cli/nutella_cli'
+require 'config/current_app_utils'
 
 module Nutella
-  # Initialize nutella home
+
+  # Initialize nutella home and temporary folder
   home_dir = File.dirname(__FILE__)
   NUTELLA_HOME = home_dir[0..-4]
+  NUTELLA_TMP = "#{NUTELLA_HOME}.tmp/"
 
   # If the nutella configuration file (config.json) is empty (or doesn't exist) we're going to initialize it
   # with nutella constants and defaults