puppet_generator 0.5.4

data/lib/puppet_generator/models/importer.rb

@@ -0,0 +1,52 @@
+module PuppetGenerator
+  module Models
+    # model for import filter
+    class Importer < FeduxOrg::Stdlib::Models::BaseModel
+
+      include FeduxOrg::Stdlib::Models::FilesystemBasedModel
+      include FeduxOrg::Stdlib::Models::ClassBasedModel
+
+      extend Forwardable
+
+      #@!method convert
+      #   converts an object using the convert method of 
+      #   the stored filter
+      def_delegator :@importer, :read, :read
+      def_delegator :@importer, :reads_from?, :reads_from?
+
+      #create new instance of filter model
+      def initialize( name , importer )
+        super(name)
+
+        @importer = importer
+      end
+
+      class << self
+
+        def existing_source?(source)
+          return true if find( reads_from: source )
+
+          false
+        end
+
+        def valid_source?(source)
+          return true if find( reads_from: source, enabled: true )
+
+          false
+        end
+
+        private
+
+        def check_method
+          :read
+        end
+
+        def path
+          __FILE__
+        end
+
+      end
+
+    end
+  end
+end

data/lib/puppet_generator/models/logger.rb

@@ -0,0 +1,11 @@
+module PuppetGenerator
+  module Models
+    def self.logger
+      @logger ||= PuppetGenerator::Logger.new
+    end
+
+    def self.logger=(logger)
+      @logger = logger
+    end
+  end
+end

data/lib/puppet_generator/models/template.rb

@@ -0,0 +1,120 @@
+module PuppetGenerator
+  module Models
+    class Template < FeduxOrg::Stdlib::Models::BaseModel
+
+      include FeduxOrg::Stdlib::Models::FilesystemBasedModel
+
+      #create new instance of template model
+      def initialize( name , template_path, suitable_outputs=[], tags=[] )
+        super(name)
+
+        @template_path = template_path
+        @suitable_outputs = suitable_outputs
+        @tags = tags
+      end
+
+      #output path to template
+      def path
+        @template_path
+      end
+
+      #check if a template is suitable for 
+      #a given output
+      def is_suitable_for?(output)
+        @suitable_outputs.include? output
+      end
+
+      #check if a template is tagged 
+      def is_tagged_with?(asked_tags)
+        if asked_tags
+          return asked_tags.all? { |t| @tags.include? t }
+        else
+          return true
+        end
+      end
+
+      # render the template based on files
+      def render(items)
+
+        if @tags.include? :many_per_file
+          return [ Definition.new( nil , template.evaluate( items: items ) ) ]
+        elsif @tags.include? :one_per_file
+          return items.collect { |item| Definition.new( item.suggested_file_name, template.evaluate( item: item ) ) }
+        else
+          raise
+        end
+
+      rescue Exception => e
+        raise Exceptions::InvalidTemplate, "An invalid template \"#{@template_path}\" was used. Please check and correct the syntax and try again. The original error message was: #{e.message}."
+      end
+
+      private
+
+      def template
+        Erubis::Eruby.new( template_content )
+      rescue
+        raise Exceptions::InvalidTemplate, "An invalid template \"#{@template_path}\" was used. Please check and correct the syntax and try again."
+      end
+
+      def template_content
+        File.read( @template_path )
+      end
+
+      public
+
+      class << self
+
+        private
+
+        def suffix
+          '.pp.erb'
+        end
+
+        def path_to_instances
+          path = File.expand_path("../../../../#{model_name.downcase.pluralize}/puppet", __FILE__ )
+
+          File.join(path,'**', "*#{ suffix }")
+        end
+
+        def suffix
+          '.pp.erb'
+        end
+
+        def load_from_filesystem
+          files = Dir.glob( path_to_instances )
+
+          raise FeduxOrg::Stdlib::Models::Exceptions::NoImplementationsForModelFound, "You might need to store files at \"#{File.dirname(path_to_instances)}\" to make the library work." if files.blank?
+
+          files.each do |f| 
+            create( name( f ) , f, suitable_outputs_for_path( f ), create_tags( f ) )
+          end
+
+        end
+
+        def create_tags(path)
+          return case path 
+                 when %r[one_per_file]
+                   [ :one_per_file ]
+                 when %r[many_per_file]
+                   [ :many_per_file ]
+                 end
+        end
+
+        def suitable_outputs_for_path(path)
+          return case path 
+                 when %r[one_per_file]
+                   [ :directory, :dir, :stdout , :file ]
+                 when %r[many_per_file]
+                   [ :file , :stdout ]
+                 else
+                   [ :file , :stdout ]
+                 end
+        end
+
+        def path
+          __FILE__
+        end
+      end
+    end
+  end
+end

data/lib/puppet_generator/puppet_helper.rb

@@ -0,0 +1,19 @@
+module PuppetGenerator
+  module PuppetHelper
+    def puppet_class_name(string)
+      string.sub(/.pp$/, '' ).camelcase.downcase
+    end
+
+    def puppet_module_name(string)
+      string.sub(/.pp$/, '' ).camelcase.downcase
+    end
+
+    def puppet_module_path(string)
+      string.underscore
+    end
+
+    def puppet_manifest_path(string)
+      string.underscore + '.pp'
+    end
+  end
+end

data/lib/puppet_generator/puppet_objects/file.rb

@@ -0,0 +1,29 @@
+module PuppetGenerator
+  module PuppetObjects
+    class File
+
+      include PuppetHelper
+
+      attr_reader :path, :module_name, :class_name, :owner, :mode, :source, :type
+
+      def initialize(entry, module_name, class_name)
+        @path = entry[:name]
+        @module_name = module_name
+        @class_name = class_name
+
+        @owner = entry[:owner]
+        @mode = entry[:mode]
+        @type = entry.fetch( :type, 'file' )
+        @source = entry[:source]
+      end
+
+      def name
+        ::File.basename(path)
+      end
+
+      def suggested_file_name
+        puppet_manifest_path( name )
+      end
+    end
+  end
+end

data/lib/puppet_generator/puppet_objects/package.rb

@@ -0,0 +1,24 @@
+module PuppetGenerator
+  module PuppetObjects
+    class Package
+
+      include PuppetHelper
+
+      attr_reader :name, :provider, :version, :module_name, :class_name
+
+      def initialize(entry, module_name, class_name)
+        @name = entry[:name]
+        @module_name = module_name
+        @class_name = class_name
+
+        @version = entry.fetch( :version, 'installed' )
+        @provider = entry[:provider]
+      end
+
+      def suggested_file_name
+        puppet_manifest_path( name )
+      end
+
+    end
+  end
+end

data/lib/puppet_generator/puppet_objects/role.rb

@@ -0,0 +1,27 @@
+module PuppetGenerator
+  module PuppetObjects
+    class Role
+
+      include PuppetHelper
+
+      attr_reader :name, :path, :module_name, :class_name, :includes
+
+      def initialize(entry, module_name, class_name)
+        @path = entry[:name]
+        @module_name = entry.fetch(:module_name, module_name )
+        @class_name = entry.fetch(:class_name, class_name )
+
+        @includes = entry[:includes] || []
+      end
+
+      def suggested_file_name
+        puppet_manifest_path( path )
+      end
+      
+      def name
+        "#{module_name}::#{::File.basename( @path )}"
+      end
+
+    end
+  end
+end

data/lib/puppet_generator/puppet_objects/user.rb

@@ -0,0 +1,27 @@
+module PuppetGenerator
+  module PuppetObjects
+    class User
+
+      include PuppetHelper
+
+      attr_reader :name, :userid, :homedir, :groupid, :shell, :provider, :module_name, :class_name
+
+      def initialize(entry, module_name, class_name)
+        @name = entry[:name]
+        @module_name = module_name
+        @class_name = class_name
+
+        @userid = entry[:userid]
+        @groupid = entry[:groupid]
+        @shell = entry[:shell]
+        @homedir = entry[:homedir]
+        @provider = entry[:provider]
+      end
+
+      def suggested_file_name
+        puppet_manifest_path( name )
+      end
+
+    end
+  end
+end

data/lib/puppet_generator/setup/bare.rb

@@ -0,0 +1,25 @@
+module PuppetGenerator
+  module Setup
+    class Bare
+
+      def initialize(options)
+        @options = options
+
+        PuppetGenerator::Models.logger = PuppetGenerator.logger
+
+        Models::Template.init
+        Models::ImportFilter.init
+        Models::Action.init
+        Models::ErrorMessage.init
+        Models::Importer.init
+        Models::Exporter.init
+        Models::ExportFilter.init
+        Models::EntryConverter.init
+      end
+
+      def create_task
+        Task.new(@options)
+      end
+    end
+  end
+end

data/lib/puppet_generator/setup/default_actions.rb

@@ -0,0 +1,9 @@
+module PuppetGenerator
+  module Setup
+    module DefaultActions
+      def self.use
+        Models::Action.enable :null
+      end
+    end
+  end
+end

data/lib/puppet_generator/setup/default_entry_converter.rb

@@ -0,0 +1,8 @@
+module PuppetGenerator
+  module Setup
+    module EntryConverters
+      def self.use
+      end
+    end
+  end
+end

data/lib/puppet_generator/setup/default_error_messages.rb

@@ -0,0 +1,10 @@
+module PuppetGenerator
+  module Setup
+    module DefaultErrorMessages
+      def self.use
+        Models::ErrorMessage.all.each { |m| m.enable }
+      end
+    end
+  end
+end
+

data/lib/puppet_generator/setup/default_export_filter.rb

@@ -0,0 +1,9 @@
+module PuppetGenerator
+  module Setup
+    module DefaultExportFilter
+      def self.use
+        Models::ExportFilter.enable :null
+      end
+    end
+  end
+end

data/lib/puppet_generator/setup/default_exporter.rb

@@ -0,0 +1,11 @@
+module PuppetGenerator
+  module Setup
+    module DefaultExporter
+      def self.use
+        Models::Exporter.enable :file
+        Models::Exporter.enable :stdout
+        Models::Exporter.enable :directory
+      end
+    end
+  end
+end

data/lib/puppet_generator/setup/default_import_filter.rb

@@ -0,0 +1,10 @@
+module PuppetGenerator
+  module Setup
+    module DefaultImportFilter
+      def self.use
+        Models::ImportFilter.enable :null
+        Models::ImportFilter.enable :yaml
+      end
+    end
+  end
+end

data/lib/puppet_generator/setup/default_importer.rb

@@ -0,0 +1,10 @@
+module PuppetGenerator
+  module Setup
+    module DefaultImporter
+      def self.use
+        Models::Importer.enable :file
+        Models::Importer.enable :stdin
+      end
+    end
+  end
+end

data/lib/puppet_generator/setup/file.rb

@@ -0,0 +1,29 @@
+module PuppetGenerator
+  module Setup
+    class File < Bare
+
+      def initialize(options)
+        super
+      end
+
+      def setup_environment
+        DefaultErrorMessages.use
+        DefaultImportFilter.use
+        DefaultActions.use
+        DefaultImporter.use
+        DefaultExportFilter.use
+
+        Models::Action.enable :copy_files_to_module_directory
+        Models::Template.find_all(:file).collect { |t| t.enable }
+        Models::ExportFilter.enable :filesystem_attributes
+        Models::Importer.enable :directory
+      end
+
+      def create_task
+        Task.new(
+          HashWithIndifferentAccess.new( { command: :file } ).merge @options
+        )
+      end
+    end
+  end
+end

data/lib/puppet_generator/setup/module.rb

@@ -0,0 +1,22 @@
+module PuppetGenerator
+  module Setup
+    class Module < Bare
+
+
+      def initialize(options)
+        super
+      end
+
+      def setup_environment
+        DefaultErrorMessages.use
+      end
+
+      def create_task
+        Task.new(
+          HashWithIndifferentAccess.new( { command: :module } ).merge @options
+        )
+      end
+
+    end
+  end
+end

data/lib/puppet_generator/setup/package.rb

@@ -0,0 +1,27 @@
+module PuppetGenerator
+  module Setup
+    class Package < Bare
+
+
+      def initialize(options)
+        super
+      end
+
+      def setup_environment
+        DefaultErrorMessages.use
+        DefaultImportFilter.use
+        DefaultActions.use
+        DefaultImporter.use
+        DefaultExportFilter.use
+
+        Models::Template.find_all(:package).collect { |t| t.enable }
+      end
+
+      def create_task
+        Task.new(
+          HashWithIndifferentAccess.new( { command: :package } ).merge @options
+        )
+      end
+    end
+  end
+end

data/lib/puppet_generator/setup/role.rb

@@ -0,0 +1,28 @@
+module PuppetGenerator
+  module Setup
+    class Role < Bare
+
+      def initialize(options)
+        super
+      end
+
+      def setup_environment
+        DefaultErrorMessages.use
+        DefaultImportFilter.use
+        DefaultActions.use
+        DefaultImporter.use
+        DefaultExportFilter.use
+
+        Models::Template.find_all(:role).collect { |t| t.enable }
+        Models::Importer.enable :directory
+        Models::ExportFilter.enable :build_role_includes_for_directory
+      end
+
+      def create_task
+        Task.new(
+          HashWithIndifferentAccess.new( { command: :role } ).merge @options
+        )
+      end
+    end
+  end
+end

data/lib/puppet_generator/setup/user.rb

@@ -0,0 +1,27 @@
+module PuppetGenerator
+  module Setup
+    class User < Bare
+      def initialize(options)
+        super
+        @task = Task.new(options)
+      end
+
+      def setup_environment
+        DefaultErrorMessages.use
+        DefaultImportFilter.use
+        DefaultActions.use
+        DefaultImporter.use
+        DefaultExportFilter.use
+
+        Models::ImportFilter.enable :passwd
+        Models::Template.find_all(:user).collect { |t| t.enable }
+      end
+
+      def create_task
+        Task.new(
+          HashWithIndifferentAccess.new( { command: :user } ).merge @options
+        )
+      end
+    end
+  end
+end

data/lib/puppet_generator/task.rb

@@ -0,0 +1,39 @@
+module PuppetGenerator
+  class Task
+
+    include PuppetHelper
+
+    attr_reader :meta
+    attr_accessor :body
+
+    def initialize(options={})
+      @meta = {}
+      @body = nil
+
+      @meta[:source]        = options[:source] 
+      @meta[:destination]   = options[:destination]
+      @meta[:module]        = puppet_module_name( options[:module] )
+      @meta[:class]         = puppet_class_name( options[:class] )
+      @meta[:requested_import_filter] = options[:import_filter]
+      @meta[:requested_export_filter] = options[:export_filter]
+      @meta[:requested_actions]        = options[:action]
+      @meta[:logging_mode]             = log_level(options)
+      @meta[:command]       = options[:command] 
+      @meta[:template_tagged_with]       = options[:template_tagged_with].split(/:/).map(&:to_sym) if options[:template_tagged_with]
+      @meta[:debug]         = true if options[:debug]
+    end
+
+    private
+
+    def log_level(options)
+      if options[:silent]
+        return :silent
+      elsif options[:debug]
+        return :debug
+      else
+        return :info
+      end
+    end
+
+  end
+end

data/lib/puppet_generator/ui/commandline_parser_helper.rb

@@ -0,0 +1,31 @@
+module PuppetGenerator
+  module Ui
+    module CommandlineParserHelper
+
+      @runner_options = {}
+      @runner_options[:module] = { type: :string, default: 'mymodule', desc: 'the module prefix in puppet class name' }
+      @runner_options[:class] =  { type: :string, default: 'myclass', desc: 'the class suffix in puppet class name' }
+      @runner_options[:debug] =  { type: :boolean, default: false, desc: 'enable debug logging and debugging libraries' }
+      @runner_options[:silent] = { type: :boolean, default: false, desc: 'disable logging' }
+
+      @subcommand_options = {}
+      @subcommand_options[:source] =               { type: :string, default: 'input.txt', desc: 'enter the source which should be used to generate the puppet output' }
+      @subcommand_options[:import_filter] =        { type: :string, default: 'null', desc: 'make it possible to pipe structured data into command' }
+      @subcommand_options[:destination] =          { type: :string, default: 'dir:out.d', desc: 'where should the information be stored. Valid input is "file|dir:<dest>" or "stdout"' }
+      @subcommand_options[:action] =               { type: :array, default: [ :null ], desc: 'what action should be run after filtering the input: <action>( <action>)*' }
+      @subcommand_options[:template_tagged_with] = { type: :string, desc: 'use a template which is tagged with "<tag>(:<tag>)+"' }
+      @subcommand_options[:export_filter] =        { type: :array, default: [ :null ], desc: 'modify the data before exporting it (to add some more value to it): <filter>( <filter>)*' }
+
+      class << self
+        attr_reader :runner_options
+        attr_reader :subcommand_options
+      end
+
+      def self.pretty_subcommands(cmds)
+        cmds.keys.join(', ')
+      end
+
+
+    end
+  end
+end