ngi 0.2.3 → 0.3.0

data/lib/ngi/delegate.rb

@@ -3,20 +3,15 @@
 # github.com/joshbeam/angular_init
 # MIT License
 
-# CURRENT_DIR is defined in angualr_init.rb
-
-# require CURRENT_DIR+'/generator'
-# require CURRENT_DIR+'/configure'
-
-require_relative 'generator'
-require_relative 'configure'
-
 # Generator and Configure are "wrapped" in this class
 # that "delegates" (hence the name "Delegate")
 # the flow of control to either the Generator class
 # or the Configure class, based on the argument passed
 # in (which is handled by bin/ngi)
 class Delegate
+  require_relative 'generator'
+  require_relative 'configure'
+
   Generator = ::Generator
   Configure = ::Configure
 end

data/lib/ngi/generator.rb

@@ -7,7 +7,20 @@ require_relative 'utils/utils'
 
 # This class generates templates (hence the name "Generator")
 class Generator
-  Utils = ::Utils
+  # STDIN is separated into a class so that
+  # it can be extracted and tested
+  class AcceptInput
+    def self.str(type)
+      case type
+      when :condensed
+        $stdin.gets.gsub(WHITESPACE, EMPTY)
+      when :comma_delimited_to_array
+        $stdin.gets.split(',').map(&:strip).reject(&:empty?)
+      when :downcased
+        $stdin.gets.strip.downcase
+      end
+    end
+  end
 
   # Here we just implement
   # the virtual class Utils::AskLoop
@@ -15,7 +28,7 @@ class Generator
     def self.ask(args)
       print "\n#{args[:prompt]}"
 
-      answer = $stdin.gets.strip.downcase
+      answer = AcceptInput.str(:downcased)
 
       loop do
         break if args[:check] == answer
@@ -29,29 +42,41 @@ class Generator
 
   WHITESPACE = /\s*/
   EMPTY = ''
-  CURRENT_DIR = File.dirname(__FILE__)
+  Utils::CurrentDir.dir = File.dirname(__FILE__)
 
   ################################
 
   # SET UP ALL THE CONFIG OPTIONS
   # Generator.new (the initialization function) is called in self.run
 
-  def initialize(args)
-    @type, @config = args[:type], args[:config]['global']
+  # An extraction of the template file/directory for
+  # the generator... This way it can be separated, redefined,
+  # and tested.
+  class TemplateDir
+    attr_reader :dir
 
-    component = @config['components'].find { |t| t['name'] == @type }
+    def initialize(component)
+      @dir = "#{Utils::CurrentDir.dir}/templates/"
+      @dir << "#{component['type']}/#{component['language']}"
+      @dir << "/#{component['using']}/#{component['template']}"
+    end
 
-    # basically just rebuilding the object so we can use it here
-    @component = {
-      of_type: component['type'],
-      language: @config['language'][component['type']],
-      using: component['using'], template: component['template']
-    }
+    def read
+      f = File.open(@dir)
+      content = f.read
+      f.close
 
-    template_dir = "#{CURRENT_DIR}/../templates/"
-    template_dir << "#{@component[:of_type]}/#{@component[:language]}/#{@component[:using]}/#{@component[:template]}"
+      content
+    end
+  end
+
+  def initialize(args)
+    @type, @config = args[:type], args[:config]
 
-    @template_file = IO.read(template_dir)
+    @component = args[:component]
+    @component['language'] = @config['language'][@component['type']]
+
+    @template_file = TemplateDir.new(@component).read
 
     yield(self) if block_given?
   end
@@ -61,30 +86,30 @@ class Generator
   def new_file_name
     print '[?] New file name: '
 
-    @new_file = $stdin.gets.gsub(WHITESPACE, EMPTY)
+    @new_file = AcceptInput.str(:condensed)
   end
 
   def module_name
     print '[?] Module name: '
 
-    @module_name = $stdin.gets.gsub(WHITESPACE, EMPTY)
+    @module_name = AcceptInput.str(:condensed)
   end
 
   def name
     print "[?] #{@type.capitalize} name: "
 
-    @name = $stdin.gets.gsub(WHITESPACE, EMPTY)
+    @name = AcceptInput.str(:condensed)
   end
 
   def inject
-    # REVIEW: use symbols instead of strings?
     special = %w(routes controller).include?(@type)
     auto_injections = [
       { for_type: 'routes', service: '$routeProvider' },
       { for_type: 'controller', service: '$scope' }
     ]
 
-    injection = special ? auto_injections.select { |inj| inj[:for_type] == @type }[0][:service] : nil
+    for_type = -> (inj) { inj[:for_type] == @type }
+    injection = special ? auto_injections.find(&for_type)[:service] : nil
 
     auto_injection_statement = special ? " (already injected #{injection})" : ''
 
@@ -93,42 +118,41 @@ class Generator
     # accepts a comma-delimited list
     # EXAMPLE: testService, testService2
     # => [testService,testService2]
-    @dependencies = $stdin.gets.split(',').map(&:strip).reject(&:empty?)
-
-    # automatically inject $scope into a controller
-    # FIXME: don't use index accessors (numbers are confusing)
-    @dependencies << auto_injections[1][:service] if @type == 'controller' && !@dependencies.include?(auto_injections[1][:service])
+    @dependencies = AcceptInput.str(:comma_delimited_to_array)
 
-    # automatically insert $routeProvider into a routes config
-    @dependencies << auto_injections[0][:service] if @type == 'routes' && !@dependencies.include?(auto_injections[0][:service])
+    @dependencies << injection unless injection.nil?
   end
 
   def replace
-    # inject may or may not have run... if it wasn't run, then @dependencies was never set
-    # for example, for html templates, we don't run the inject function
-    # @dependencies = @dependencies || []
+    # inject may or may not have run...
+    # if it wasn't run, then @dependencies was never set
     @dependencies ||= []
     has_dependencies = @dependencies.size > 0
 
-    # Use 'config' as the type, since 'routes' is really an alias for a specific type of 'config'.
     # TODO: map aliases from config file
     @type = 'config' if @type == 'routes'
 
     # Regex replacements to generate the template
+    cdv = lambda do |s, (dep, i)|
+      s + dep.to_s + (i == @dependencies.size - 1 ? '' : ', ')
+    end
+
+    array_string = has_dependencies ? @dependencies.to_s.gsub(/"/, '\'') : '[]'
+
+    if has_dependencies == true
+      cdv_string = @dependencies.each_with_index.inject('', &cdv)
+    else
+      cdv_string = ''
+    end
+
+    cdv_regex = /\{\{inject\s\|\scomma_delimited_variables\}\}/
+
     @template_file =  @template_file
                       .gsub(/\{\{type\}\}/, @type)
                       .gsub(/\{\{name\}\}/, @name || '')
-                      .gsub(/\{\{module\}\}/, "#{@module_name}")
-                      .gsub(
-                        /\{\{inject\s\|\sarray_string\}\}/,
-                        has_dependencies ?
-                        @dependencies.to_s.gsub(/"/, '\'') : '[]'
-                      )
-                      .gsub(
-                        /\{\{inject\s\|\scomma_delimited_variables\}\}/,
-                        has_dependencies ?
-                        @dependencies.each_with_index.inject('') { |str, (dep, i)| str += dep.to_s + (i == @dependencies.size - 1 ? '' : ', ') } : ''
-                      )
+                      .gsub(/\{\{module\}\}/, @module_name)
+                      .gsub(/\{\{inject\s\|\sarray_string\}\}/, array_string)
+                      .gsub(cdv_regex, cdv_string)
   end
 
   def tag
@@ -143,7 +167,9 @@ class Generator
   def write
     # create the new file
     def overwrite?
-      AskLoop.ask(check: 'y', prompt: 'File exists already, overwrite it? (y/n) ')
+      AskLoop.ask(
+        check: 'y', prompt: 'File exists already, overwrite it? (y/n) '
+      )
     end
 
     overwrite? if File.exist?(@new_file)
@@ -154,8 +180,11 @@ class Generator
     end
   end
 
-  # Use this function to be able to say AngularInit::Delegate::Generator.run() inside the executable file
-  # This function simply goes through all of the methods in order to interactively
+  # Use this function to be able to say
+  # Ngi::Delegate::Generator.run() inside
+  # the executable file.
+  # This function simply goes through all of the
+  # methods in order to interactively
   # prompt the user to generate a new template
   def self.run(args)
     Generator.new(args) do |g|
@@ -165,7 +194,6 @@ class Generator
       g.module_name unless args[:type] == 'module'
 
       # 'run', 'config', and 'routes' don't have custom names in AngularJS
-      # REVIEW: use symbols instead of strings?
       g.name unless %w(run config routes index).include? args[:type]
 
       g.inject unless ['index'].include? args[:type]

data/lib/ngi/parser.rb

@@ -0,0 +1,97 @@
+
+require_relative 'utils/utils'
+require_relative 'delegate'
+require_relative 'version'
+
+# This class is just a wrapper for the main process
+# of ngi
+class Parser
+  CURRENT_DIR = File.dirname(__FILE__)
+
+  COMPONENTS_FILE = "#{CURRENT_DIR}/../config/config.components.yml"
+  COMPONENTS_HASH = Delegate::Configure
+                    .new(COMPONENTS_FILE)
+                    .to_ruby(from: 'yaml')
+  COMPONENTS = COMPONENTS_HASH.collect { |c| c['name'] }
+
+  CONFIG_FILE = "#{CURRENT_DIR}/../config/config.yml"
+  CONFIG_HASH = Delegate::Configure.new(CONFIG_FILE).to_ruby(from: 'yaml')
+
+  CONFIGURABLE_FILE = "#{CURRENT_DIR}/../config/config.configurable.yml"
+  CONFIGURABLE = Delegate::Configure
+                 .new(CONFIGURABLE_FILE).to_ruby(from: 'yaml')
+
+  LANGUAGES_FILE = "#{CURRENT_DIR}/../config/config.languages.yml"
+  LANGUAGES_HASH = Delegate::Configure.new(LANGUAGES_FILE).to_ruby(from: 'yaml')
+
+  # Abstraction to choose the component (custom or default)
+  class ComponentChooser
+    attr_reader :component
+
+    def initialize(args)
+      chosen_type = -> (c) { c['name'] == args[:type] }
+      @component = args[:components_hash].find(&chosen_type)
+
+      return unless args[:config_hash].key? 'templates'
+
+      custom = args[:config_hash]['templates'].find(&chosen_type)
+      language = args[:config_hash]['language'].collect { |_, v| v }
+
+      return if custom.nil?
+
+      template = custom['templates']
+                 .find { |t| language.include? t['language'] }
+
+      return if template.nil?
+
+      template = template['template']
+      # Rebuild the object to be used by Delegate::Generator
+      custom = {
+        'type' => custom['type'], 'using' => 'user',
+        'template' => template, 'name' => custom['name']
+      }
+
+      @component = custom
+    end
+  end
+
+  def self.parse(args)
+    p = Utils::CommandParser.new do |parser|
+      components = Utils::UserInput.new(valid_inputs: COMPONENTS)
+
+      parser.name, parser.version = 'ngi', Ngi::VERSION
+      parser.banner << "\n(<command> can be one of the following)"
+
+      parser.on(components.valid_inputs, 'Create a new component') do |type|
+        component = ComponentChooser
+                    .new(
+                      type: type,
+                      components_hash: COMPONENTS_HASH,
+                      config_hash: CONFIG_HASH
+                    )
+                    .component
+
+        Delegate::Generator.run(
+          type: type,
+          config: CONFIG_HASH,
+          component: component
+        )
+      end
+
+      parser.on(['-o', '--options'], 'Configure ngi') do
+        Delegate::Configure.run(
+          write: true,
+          to: 'yaml',
+          destination: CONFIG_FILE,
+          languages: LANGUAGES_HASH,
+          config: CONFIG_HASH,
+          components: COMPONENTS,
+          components_hash: COMPONENTS_HASH,
+          configurable: CONFIGURABLE
+        )
+      end
+    end
+
+    p.parse(args)
+  end
+end

data/lib/ngi/utils/command_parser.rb

@@ -3,99 +3,114 @@
 # github.com/joshbeam/angular_init
 # MIT License
 
-# Similar to Ruby's OptionParser
-# However, this is customized for angular_init
-class CommandParser
-  attr_reader :args
-  attr_accessor :banner, :version, :separator, :name
-
-  def initialize
-    # TODO: to "Usage #{file_name}", etc.
-    @name = '<CLI>'
-    @banner = "Usage: #{@name} <command>"
-    @version = '0.0.0'
-    @separator = '===================='
-    @listeners = []
-
-    # automatically register some listeners
-    register_help
-    register_version
-
-    # be able to pass in a block for setup
-    yield(self) if block_given?
-  end
+# Utilities
+module Utils
+  # Similar to Ruby's OptionParser
+  # However, this is customized for angular_init
+  class CommandParser
+    attr_reader :args
+    attr_accessor :banner, :version, :separator, :name
+
+    # Create an abstraction of puts
+    # so that we can test it
+    class Output
+      def initialize(str)
+        @str = str
+      end
 
-  def name=(name)
-    # need to also replace the name in the banner
-    @banner = @banner.gsub(@name, name)
+      def to_s
+        puts @str
+      end
+    end
 
-    @name = name
-  end
+    def initialize
+      # TODO: to "Usage #{file_name}", etc.
+      @name = '<CLI>'
+      @banner = "Usage: #{@name} <command>"
+      @version = '0.0.0'
+      @separator = '===================='
+      @listeners = []
 
-  # register the listeners
-  def on(options, description = '', &block)
-    listener = {}
+      # automatically register some listeners
+      register_help
+      register_version
 
-    # be able to pass in a single argument, or an array of arguments
-    options = *options unless options.is_a? Array
+      # be able to pass in a block for setup
+      yield(self) if block_given?
+    end
+
+    def name=(name)
+      # need to also replace the name in the banner
+      @banner = @banner.gsub(@name, name)
 
-    listener[:options] = options.map do |opt|
-      opt.strip.split(' ')
+      @name = name
     end
 
-    listener[:block] = block
-    listener[:description] = description
+    # register the listeners
+    def on(options, description = '', &block)
+      listener = {}
 
-    @listeners << listener
-  end
+      # be able to pass in a single argument, or an array of arguments
+      options = *options unless options.is_a? Array
 
-  def parse(args)
-    # puts @listeners
-    matched_listener = {
-      options: nil,
-      block: nil
-    }
-
-    @listeners.each do |listener|
-      listener[:options].each do |opt_arr|
-        if opt_arr == args
-          matched_listener[:options] = opt_arr
-          matched_listener[:block] = listener[:block]
-          break
-        end
+      listener[:options] = options.map do |opt|
+        opt.strip.split(' ')
       end
+
+      listener[:block] = block
+      listener[:description] = description
+
+      @listeners << listener
     end
 
-    if !matched_listener[:options].nil?
-      # matched_listener[:options] should always be an array
-      # when we call, we can each member of that array to be
-      # passed separately
-      matched_listener[:block].call(*matched_listener[:options])
-    else
-      # if there was no match, show the help menu
-      parse(['-h'])
+    def parse(args)
+      # puts @listeners
+      matched_listener = {
+        options: nil,
+        block: nil
+      }
+
+      @listeners.each do |listener|
+        listener[:options].each do |opt_arr|
+          if opt_arr == args
+            matched_listener[:options] = opt_arr
+            matched_listener[:block] = listener[:block]
+            break
+          end
+        end
+      end
+
+      if !matched_listener[:options].nil?
+        # matched_listener[:options] should always be an array
+        # when we call, we can each member of that array to be
+        # passed separately
+        matched_listener[:block].call(*matched_listener[:options])
+      else
+        # if there was no match, show the help menu
+        parse(['-h'])
+      end
     end
-  end
 
-  def register_help
-    # automaticaly register this listener
-    on(['-h', '--help'], 'Show the help menu') do
-      puts @separator
-      puts @banner
+    def register_help
+      # automaticaly register this listener
+      on(['-h', '--help'], 'Show the help menu') do
+        Output.new(@separator).to_s
+        Output.new(@banner).to_s
 
-      @listeners.each_with_index do |listener, i|
-        desc = "\n" << "(#{i + 1}) #{listener[:description]}: "
-        desc << "#{listener[:options].join(', ')}"
-        puts desc
+        @listeners.each_with_index do |listener, i|
+          desc = "\n" << "(#{i + 1}) #{listener[:description]}: "
+          desc << "#{listener[:options].join(', ')}"
+          Output.new(desc).to_s
+        end
+        Output.new(@separator).to_s
       end
-      puts @separator
     end
-  end
 
-  def register_version
-    # automaticaly register this listener
-    on(['-v', '--version'], 'Show the version') do
-      puts "#{@name} #{@version}"
+    def register_version
+      # automaticaly register this listener
+      on(['-v', '--version'], 'Show the version') do
+        Output.new("#{@name} #{@version}").to_s
+      end
     end
   end
 end