d13n 0.5.2

data/lib/d13n/cli/commands/scaffold.rb

@@ -0,0 +1,345 @@
+require 'fileutils'
+require 'erb'
+require 'd13n/version'
+module D13n::Cli
+  class Scaffold < Command
+    def self.command; "scaffold"; end
+
+    attr_accessor :application, :project, :ruby_version, :application_base
+
+    def initialize(args)
+      @bare = false
+      @application = nil
+      @ruby_version = '2.3.3'
+      super(args)
+    end
+
+    def run
+      check_options
+      generate_scaffold
+    end
+
+    def check_options
+      if @application.nil?
+        puts 'application name required'
+        exit 1
+      elsif @project.nil?
+        puts 'project name required'
+        exit 1
+      end
+    end
+
+    def generate_scaffold
+      @template_home = File.join(File.expand_path(File.dirname(__FILE__)), '..', '..', '..', '..', 'templates')
+
+      unless @bare
+        puts "Setting up application [#{application_base}] directories..."
+        Dir.mkdir(@application) unless File.directory?(@application)
+        Dir.chdir(@application)
+      end
+
+      @current_home = Dir.pwd
+
+      unless @bare
+        application_scaffold
+      end
+
+      rake_scaffold
+
+      migration_scaffold
+
+      gem_scaffold
+
+      makefile_scaffold
+
+      application_yml_scaffold
+
+      docker_scaffold
+
+      docker_script_scaffold
+
+      jekinsfile_scaffold
+
+      ruby_version_scaffold
+
+      spec_scaffold
+        
+    end
+
+    private
+
+    def application_base
+     @application_base = @application.split('_').map {|w| w.capitalize}.join
+    end
+
+    def application_const
+      @application_const ||= "#{application_base}::Service"
+    end
+
+    def template_erb(src, dst, src_sub_path=nil, dst_sub_path=nil)
+      src_file = if src_sub_path.nil?
+        File.join(@template_home,src)
+      else
+        File.join(@template_home, src_sub_path, src)
+      end
+      dst_file = if dst_sub_path.nil?
+        File.join(@current_home,dst)
+      else
+        File.join(@current_home, dst_sub_path, dst)
+      end
+      File.open(src_file) do |tfh|
+        erb = ERB.new(tfh.read)
+        File.open(dst_file, 'w') do |ofh|
+          ofh.print erb.result(binding)
+        end
+      end
+    end
+
+    def application_scaffold
+      puts "Generating application[#{application_base}] lib folder ..."
+      Dir.mkdir('lib')
+      application_source_path = File.join("lib","#{application}")
+      Dir.mkdir(application_source_path)
+
+      puts "Generating #{application_base} namespace file ..." 
+      template_erb('application.rb.template', "#{application}.rb", 'lib', 'lib')
+
+      puts "Generating #{application_base} service file ..."
+      template_erb('service.rb.template','service.rb','lib',application_source_path)
+      template_erb('version.rb.template','version.rb','lib',application_source_path)
+
+      application_api
+
+      application_rack
+
+      application_readme
+
+      application_guard
+    end
+
+    def application_api
+      puts "Generating application[#{application_base}] api folder ..."
+      api_root = File.join('lib',application,'api')
+      Dir.mkdir(api_root)
+
+      application_source_path = File.join("lib","#{application}")
+      template_erb('api.rb.template','api.rb','lib', application_source_path)
+
+      api_template_root = File.join('lib', 'api')
+      puts api_template_root
+      puts "Generating #{application_base} api files ..."
+      template_erb('service.rb.template','service.rb',api_template_root, api_root)
+      template_erb('support.rb.template','support.rb',api_template_root, api_root)
+      template_erb('version.rb.template','version.rb',api_template_root, api_root) 
+    end
+
+    def application_rack
+      puts "Generating application[#{application_base}] rack file ..."
+      template_erb('config.ru.template','config.ru')
+    end
+
+    def application_readme
+      puts "Generating application[#{application_base}] README.md file ..."
+      template_erb('README.md.template','README.md')
+    end
+
+    def application_guard
+      puts "Generating application[#{application_base}] README.md file ..."
+      template_erb('Guardfile.template','Guardfile')
+    end
+
+    def migration_scaffold
+      puts "Generating database migration folders ..."
+      @migration_root = 'db'
+      Dir.mkdir(@migration_root) unless File.directory?(@migration_root)
+
+      @migration_sub_dir = ['migrations', 'seeds']
+      @migration_sub_dir.each do |dir|
+        root_dir = "#{@migration_root}/#{dir}"
+        Dir.mkdir(root_dir) unless File.directory?(root_dir)
+      end
+
+      puts "Generating Rake migration file ..."
+
+      File.open(File.join(@template_home, @rake_task_root, 'migration.rake.template')) do |tfh|
+        erb = ERB.new(tfh.read)
+        File.open(File.join(@current_home, @rake_task_root, "migration.rake"), 'w') do |ofh|
+          ofh.print erb.result(binding)
+        end
+      end
+    end
+
+    def gem_scaffold
+      puts "Generating Gemfile ..."
+
+      File.open(File.join(@template_home, 'Gemfile.template')) do |tfh|
+        erb = ERB.new(tfh.read)
+        File.open(File.join(@current_home, "Gemfile"), 'w') do |ofh|
+          ofh.print erb.result(binding)
+        end
+      end
+    end
+    
+    def makefile_scaffold
+      puts "Generating Makefile ..."
+      File.open(File.join(@template_home, 'Makefile.template')) do |tfh|
+        erb = ERB.new(tfh.read)
+        File.open(File.join(@current_home, "Makefile"), 'w') do |ofh|
+          ofh.print erb.result(binding)
+        end
+      end
+    end
+
+    def application_yml_scaffold
+      puts "Generating #{application}.yml ..."
+      File.open(File.join(@template_home, 'application.yml.template')) do |tfh|
+        erb = ERB.new(tfh.read)
+        File.open(File.join(@current_home, "#{application}.yml"), 'w') do |ofh|
+          ofh.print erb.result(binding)
+        end
+      end
+    end
+
+    def docker_scaffold
+      puts "Generating docker folder ..."
+      @docker_root = 'docker'
+      Dir.mkdir(@docker_root) unless File.directory?(@docker_root)
+
+      @docker_development_files = ['docker-compose.yml','Dockerfile.cache','Dockerfile']
+      @docker_release_files = ['docker-compose.yml', 'Dockerfile']
+
+      docker_stage(@docker_root, 'development', @docker_development_files)
+      docker_stage(@docker_root, 'release', @docker_release_files)
+    end
+
+    def docker_stage(root, stage, files)
+      puts "Generating docker #{stage} folder ..."
+      root_dir = "#{root}/#{stage}"
+      Dir.mkdir(root_dir) unless File.directory?(root_dir)
+
+      puts "Generating #{stage} docker files ..."
+      stage_dir = "#{root}/#{stage}"
+      files.each do |file|
+        File.open(File.join(@template_home, "docker", "#{file}.#{stage}")) do |tfh|
+          erb = ERB.new(tfh.read)
+          File.open(File.join(@current_home, stage_dir, file), 'w') do |ofh|
+            ofh.print erb.result(binding)
+          end
+        end
+      end
+    end
+
+    def docker_script_scaffold
+      @docker_script_root = 'scripts'
+      Dir.mkdir(@docker_script_root) unless File.directory?(@docker_script_root)
+
+      puts "Generating docker scripts ..."
+      File.open(File.join(@template_home, "#{@docker_script_root}/", "test.sh.template")) do |tfh|
+        erb = ERB.new(tfh.read)
+        File.open(File.join(@current_home, "#{@docker_script_root}/", "test.sh"), 'w') do |ofh|
+          ofh.print erb.result(binding)
+        end
+
+        FileUtils.chmod 0755,File.join(@current_home, "#{@docker_script_root}/", "test.sh")
+      end
+    end
+
+    def jekinsfile_scaffold
+      puts "Generating Jekinsfile ..."
+
+      File.open(File.join(@template_home, "Jenkinsfile.template")) do |tfh|
+        erb = ERB.new(tfh.read)
+        File.open(File.join(@current_home, "Jenkinsfile"), 'w') do |ofh|
+          ofh.print erb.result(binding)
+        end
+      end
+    end
+
+    def ruby_version_scaffold
+      puts "Generating Ruby Version file ..."
+
+      File.open(File.join(@template_home, ".ruby-version.template")) do |tfh|
+        erb = ERB.new(tfh.read)
+        File.open(File.join(@current_home, ".ruby-version"), 'w') do |ofh|
+          ofh.print erb.result(binding)
+        end
+      end
+    end
+
+    def spec_scaffold
+      puts "Generating RSpec configuraion file ..."
+
+      File.open(File.join(@template_home, ".rspec.template")) do |tfh|
+        erb = ERB.new(tfh.read)
+        File.open(File.join(@current_home, ".rspec"), 'w') do |ofh|
+          ofh.print erb.result(binding)
+        end
+      end
+
+      puts "Generating Spec folders ..."
+
+      @spec_root = 'spec'
+
+      Dir.mkdir(@spec_root) unless File.directory?(@spec_root)
+
+      ['unit', 'functional', 'factories'].each do |folder|
+        spec_sub_dir = File.join(@spec_root, folder)
+        Dir.mkdir(spec_sub_dir) unless File.directory?(spec_sub_dir)
+      end
+
+      puts "Generating Rspec Helper file ..."
+
+      File.open(File.join(@template_home, "spec", "spec_helper.rb.template")) do |tfh|
+        erb = ERB.new(tfh.read)
+        File.open(File.join(@current_home, "spec", "spec_helper.rb"), 'w') do |ofh|
+          ofh.print erb.result(binding)
+        end
+      end
+
+      puts 'Generating Rspec rake task file ...'
+
+      File.open(File.join(@template_home, @rake_task_root, "spec.rake.template")) do |tfh|
+        erb = ERB.new(tfh.read)
+        File.open(File.join(@current_home, @rake_task_root, "spec.rake"), 'w') do |ofh|
+          ofh.print erb.result(binding)
+        end
+      end
+    end
+
+    def rake_scaffold
+      puts "Generating Rake file ..."
+
+      File.open(File.join(@template_home, "Rakefile.template")) do |tfh|
+        erb = ERB.new(tfh.read)
+        File.open(File.join(@current_home, "Rakefile"), 'w') do |ofh|
+          ofh.print erb.result(binding)
+        end
+      end
+
+      puts "Generating Rake Task folder ..."
+
+      @rake_task_root = 'tasks'
+
+      Dir.mkdir(@rake_task_root) unless File.directory?(@rake_task_root)
+    end
+
+    def options
+      OptionParser.new %Q{Usage: #{$0} #{self.class.command} [OPTIONS] ["description"] }, 40 do |opts|
+        opts.separator ''
+        opts.separator 'Specific options:'
+
+        opts.on('-a APP', '--app','Specify an application to scaffold') do |app|
+          @application = app.downcase
+        end
+
+        opts.on('-p PROJECT', '--project','Specify project of application to scaffold') do |project|
+          @project = project.downcase
+        end
+
+        opts.on('-b', '--bare', 'Scaffold a bare folder') do |bare|
+          @bare = true
+        end
+      end
+    end
+  end
+end

data/lib/d13n/configuration/default_source.rb

@@ -0,0 +1,200 @@
+require 'forwardable'
+
+module D13n::Configuration
+  def self.value_of(key)
+    Proc.new {
+      D13n.config[key]
+    }
+  end
+
+  class Boolean
+    def self.===(o)
+      TrueClass === o or FalseClass === o
+    end
+  end
+
+  class DefaultSource
+    attr_reader :defaults, :alias
+
+    extend Forwardable
+    def_delegators :@defaults, :has_key?, :each, :merge, :delete, :keys, :[], :to_hash
+
+  
+    def initialize
+      frozen_default
+      @defaults = default_values
+      @alias = default_alias
+    end
+
+    def frozen_default
+      D13n::Configuration::DEFAULTS.freeze
+    end
+
+    def default_values
+      result = {}
+      D13n::Configuration::DEFAULTS.each do |key, value|
+        result[key] = value[:default]
+      end
+      result
+    end
+
+    def default_alias
+      result = {}
+      D13n::Configuration::DEFAULTS.each do |key,value|
+        result[key] = (value[:alias] || key).to_s
+      end
+      result
+    end
+
+    def self.defaults
+      D13n::Configuration::DEFAULTS
+    end
+
+    def self.defaults=(default_config)
+      D13n::Configuration::DEFAULTS.merge!(default_config)
+    end
+
+    def self.config_search_paths
+      Proc.new {
+        paths = [
+            File.join("config", "#{D13n.app_name}.yml"),
+            File.join("#{D13n.app_name}.yml")
+        ]
+
+        if D13n.service.instance.root
+          paths << File.join(D13n.service.instance.root, "config", "#{D13n.app_name}.yml")
+          paths << File.join(D13n.service.instance.root, "#{D13n.app_name}.yml")
+        end
+
+        if ENV["HOME"]
+          paths << File.join(ENV["HOME"], ".#{D13n.app_name}", "#{D13n.app_name}.yml")
+          paths << File.join(ENV["HOME"], "#{D13n.app_name}.yml")
+        end
+        paths
+      }
+    end
+
+    def self.config_path
+      Proc.new {
+        found_path = D13n.config[:config_search_paths].detect do |file|
+          File.expand_path(file) if File.exist? file
+        end
+        found_path || ""
+      }
+    end
+
+    def self.transform_for(key)
+      default_settings = D13n::Configuration::DEFAULTS[key]
+      default_settings[:transform] if default_settings
+    end
+
+    def self.convert_to_list(value)
+      case value
+      when String
+        value.split(/\s*,\s*/)
+      when Array
+        value
+      else
+        raise ArgumentError.new("Config value '#{value}' couldn't be turned into a list.")
+      end
+    end
+  end
+
+  DEFAULTS = {
+      :app_name => {
+        :default => Proc.new{"#{D13n.app_name}"},
+        :public => true,
+        :type => String,
+        :allowed_from_server => false,
+        :description => 'Define Application Name'
+      },
+      :port => {
+          :default => 3000,
+          :public => true,
+          :type => Integer,
+          :description => 'Define service port'
+      },
+      :host => {
+          :default => '0.0.0.0',
+          :public => true,
+          :type => String,
+          :description => 'Define service host'
+      },
+    #
+    # Log config
+    #
+      :log_level => {
+          :default => 'info',
+          :public => true,
+          :type => String,
+          :description => 'Sets the level of detail of log messages. Possible log levels, in increasing verbosity, are: <code>error</code>, <code>warn</code>, <code>info</code> or <code>debug</code>.'
+      },
+      :log_file_path => {
+          :default => 'stdout',
+          :public => true,
+          :type => String,
+          :description => 'Defines a path to the log file, excluding the filename.'
+      },
+      :log_file_name => {
+          :default => Proc.new{"#{D13n.app_name}.log"},
+          :public => true,
+          :type => String,
+          :description => 'Defines a name for the log file.'
+      },
+      #
+      # YAML file Config
+      #
+      :config_path => {
+          :default => DefaultSource.config_path,
+          :public => true,
+          :type => String,
+          :description => 'Path to <b>application.yml</b>. If undefined, the agent checks the following directories (in order): <b>config/application.yml</b>, <b>application.yml</b>, <b>$HOME/.d13n/application.yml</b> and <b>$HOME/application.yml</b>.'
+      },
+      :config_search_paths => {
+          :default => DefaultSource.config_search_paths,
+          :public => false,
+          :type => Array,
+          :allowed_from_server => false,
+          :description => "An array of candidate locations for the service\'s configuration file."
+        },
+      :'metric.channel.type' => {
+          :default => 'logger',
+          :public => true,
+          :type => String,
+          :allowed_from_server => true,
+          :description => 'Metric Channel Type.'
+      },
+      :'metric.app.http.in.apdex_t' => {
+        :default => 300,
+        :public => true,
+        :type => Integer,
+        :allowed_from_server => true,
+        :description => 'Metric HTTP IN Apdex Config Value.'
+      },
+      :'metric.app.http.in.tracable' => {
+        :default => true,
+        :public => true,
+        :type => D13n::Configuration::Boolean,
+        :description => 'Metric HTTP IN trace enable switch'
+      },
+      :'metric.app.http.in.sinatra.enable' => {
+      :default => true,
+      :public => true,
+      :type => D13n::Configuration::Boolean,
+      :description => 'enable http in trace for sinatra'
+      },
+      :'metric.app.http.in.sinatra.auto_middleware.enable' => {
+        :default => true,
+       :public => true,
+       :type => D13n::Configuration::Boolean,
+       :description => 'enable sinatra auto load middleware'
+      },
+      :'metric.app.http.out.tracable' => {
+        :default => true,
+        :public => true,
+        :type => D13n::Configuration::Boolean,
+        :allowed_from_server => true,
+        :description => "Metric HTTP OUT trace enable switch"
+      }
+   }
+end

data/lib/d13n/configuration/dotted_hash.rb

@@ -0,0 +1,39 @@
+module D13n::Configuration
+  class DottedHash < ::Hash
+    def initialize(hash, keep_nesting=false)
+      self.merge!(hash) if keep_nesting
+
+      self.merge!(dot_flattened(hash))
+      DottedHash.symbolize(self)
+    end
+
+    def inspect
+      "#<#{self.class.name}:#{object_id} #{super}>"
+    end
+
+    def to_hash
+      {}.replace(self)
+    end
+
+    def self.symbolize(hash)
+      hash.keys.each do |key|
+        hash[key.to_sym] = hash.delete(key)
+      end
+    end
+
+    protected
+    # turns {'a' => {'b' => 'c'}} into {'a.b' => 'c'}
+    def dot_flattened(nested_hash, names=[], result={})
+      nested_hash.each do |key, val|
+        next if val == nil
+        if val.respond_to?(:has_key?)
+          dot_flattened(val, names + [key], result)
+        else
+          result[(names + [key]).join('.')] = val
+        end
+      end
+      result
+    end
+
+  end
+end

data/lib/d13n/configuration/environment_source.rb

@@ -0,0 +1,89 @@
+module D13n::Configuration
+  class EnvironmentSource < DottedHash
+    SUPPORTED_PREFIXES = Proc.new {/^#{D13n.app_name}_/i}
+    SPECIAL_CASE_KEYS  = [
+          "#{D13n.app_prefix}_LOG"  # read by set_log_file
+        ]
+
+    attr_accessor :type_map
+
+    def initialize
+      set_log_file
+      set_config_file
+
+      @type_map = {}
+
+      DEFAULTS.each do |config_setting, value|
+        self.type_map[config_setting] = value[:type]
+      end
+
+      set_values_from_app_environment_variables
+    end
+
+    def set_log_file
+      env_log = "#{D13n.app_prefix}_LOG"
+      if ENV[env_log]
+        if ENV[env_log].upcase == 'STDOUT'
+          self[:log_file_path] = self[:log_file_name] = 'STDOUT'
+        else
+          self[:log_file_path] = File.dirname(ENV[env_log])
+          self[:log_file_name] = File.basename(ENV[env_log])
+        end
+      end
+    end
+
+    def set_config_file
+      env_config = "#{D13n.app_prefix}_CONFIG"
+      self[:config_path] = ENV[env_config] if ENV[env_config]
+    end
+
+    def set_values_from_app_environment_variables
+      app_env_var_keys = collect_app_environment_variable_keys
+
+      app_env_var_keys.each do |key|
+        next if SPECIAL_CASE_KEYS.include?(key.upcase)
+        set_value_from_app_environment_variable(key)
+      end
+    end
+
+    def set_value_from_app_environment_variable(key)
+      config_key = convert_environment_key_to_config_key(key)
+      set_key_by_type(config_key, key)
+    end
+
+    def set_key_by_type(config_key, environment_key)
+      value = ENV[environment_key]
+      type = self.type_map[config_key]
+
+      if type == String
+        self[config_key] = value
+      elsif type == Integer
+        self[config_key] = value.to_i
+      elsif type == Float
+        self[config_key] = value.to_f
+      elsif type == Symbol
+        self[config_key] = value.to_sym
+      elsif type == Array
+        self[config_key] = value.split(/\s*,\s*/)
+      elsif type == D13n::Configuration::Boolean
+        if value =~ /false|off|no/i
+          self[config_key] = false
+        elsif value != nil
+          self[config_key] = true
+        end
+      else
+        D13n.logger.info("#{environment_key} does not have a corresponding configuration setting (#{config_key} does not exist).")
+        self[config_key] = value
+      end
+    end
+
+    def convert_environment_key_to_config_key(key)
+      stripped_key = key.gsub(SUPPORTED_PREFIXES.call, '').downcase.to_sym
+    end
+
+
+    def collect_app_environment_variable_keys
+      ENV.keys.select { |key| key.match(SUPPORTED_PREFIXES.call) }
+    end
+  end
+end