ngi 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5a59338ccc566495d2d77474f11a156be3eb2f94
-  data.tar.gz: 7981be7a346fb035357d197964f8e798612414cb
+  metadata.gz: bbad7c67486f004d161fbd0edbe47ec93bf3ffb3
+  data.tar.gz: ae9b49af3939e3805550532f6d5347d85218bb77
 SHA512:
-  metadata.gz: ae746334de0c717fb963b9af9bd41757bed32be13a7e4e5a50676141ea55c1de45d6e1da4bb506eeef3d173cc5d30f3bf7dac900304a1181a1cb87bebddf4ed6
-  data.tar.gz: bf02f0b2d863130e0f7c2e790f1af3348c0d1f47a1bf85ba28b28e86ff7d8e037ee5dfc0ba4889b0506cc2e8ebc9d0bec64baa790ab67a8f1a82b24fbc400d81
+  metadata.gz: 017f5aa9bb956fb047eec65b14fde636a8e29c0a17a0feef887d22c5dfe5c8bbd49a8928c2244fb057b6d53ff460c183abc6731f204d7ebc6961efb418ebb486
+  data.tar.gz: 1772205977bb7e65530f2e735b4de58f92246ba1e376251d4023e41f2147ea64b77fee18227f11838d93670cfb148caa5a3997b080dc1090357d572a7c0ea44d

data/Rakefile

@@ -1,2 +1,8 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
+# require 'rake/testtask'
+# require 'memfs'
 
+# Rake::TestTask.new do |t|
+#   t.libs << 'test'
+#   t.test_files = FileList['test/test*.rb']
+# end

data/bin/ngi

@@ -5,36 +5,6 @@
 # github.com/joshbeam/angular_init
 # MIT License
 
-# Ngi is the main module (src/ruby/angular_init.rb)
 require_relative '../lib/ngi'
-require_relative '../lib/ngi/utils/utils'
 
-# This class is just a wrapper for the main process
-# of ngi
-class Parser
-  CURRENT_DIR = File.dirname(__FILE__)
-  def self.parse(args)
-    p = Utils::CommandParser.new do |parser|
-      config_file = "#{CURRENT_DIR}/../lib/config/angular_init.config.json"
-      config = Ngi::Delegate::Configure.new(config_file).from_json
-      components = config['global']['components'].collect { |t| t['name'] }
-      types = Ngi::UserInput.new(valid_inputs: components)
-
-      parser.name = 'ngi'
-      parser.version = Ngi::VERSION
-      parser.banner << "\n(<command> can be one of the following)"
-
-      parser.on(types.valid_inputs, 'Create a new component') do |command|
-        Ngi::Delegate::Generator.run(type: command, config: config)
-      end
-
-      parser.on(['-o', '--options'], 'Configure ngi') do
-        Ngi::Delegate::Configure.run(write: true, file_path: config_file)
-      end
-    end
-
-    p.parse(args)
-  end
-end
-
-Parser.parse(ARGV)
+Ngi::Parser.parse(ARGV)

data/lib/config/backup/config.components.aliases.yml

@@ -0,0 +1,3 @@
+aliases:
+  config:
+    - routes

data/lib/config/backup/config.components.yml

@@ -0,0 +1,55 @@
+- 
+  name: "directive"
+  type: "script"
+  using: "default"
+  template: "basic.js"
+- 
+  name: "controller"
+  type: "script"
+  using: "default"
+  template: "basic.js"
+- 
+  name: "factory"
+  type: "script"
+  using: "default"
+  template: "basic.js"
+- 
+  name: "service"
+  type: "script"
+  using: "default"
+  template: "basic.js"
+- 
+  name: "config"
+  type: "script"
+  using: "default"
+  template: "config.js"
+- 
+  name: "run"
+  type: "script"
+  using: "default"
+  template: "config.js"
+- 
+  name: "routes"
+  type: "script"
+  using: "default"
+  template: "config.js"
+- 
+  name: "filter"
+  type: "script"
+  using: "default"
+  template: "basic.js"
+- 
+  name: "module"
+  type: "script"
+  using: "default"
+  template: "module.js"
+- 
+  name: "constant"
+  type: "script"
+  using: "default"
+  template: "constant.js"
+- 
+  name: "index"
+  type: "markup"
+  using: "default"
+  template: "index.html"

data/lib/config/backup/config.configurable.yml

@@ -0,0 +1 @@
+- language

data/lib/config/backup/config.languages.yml

@@ -0,0 +1,5 @@
+script:
+  - coffee
+  - es5
+markup:
+  - html

data/lib/config/backup/config.yml

@@ -0,0 +1,3 @@
+language:
+  script: es5
+  markup: html

data/lib/config/backup/template-skeleton.js

@@ -0,0 +1,93 @@
+/*
+  Hello!
+
+  Use this file to create your own template to use with ngi.
+
+  Erase this tutorial when finished with your template.
+
+  Then, do the following in your terminal:
+
+  $ ngi -o
+  $ [?] Option: template
+  $ <file path>
+  $ [?] Language: 
+
+  Example (basic.js)
+  ==================
+
+  ;(function(app) {
+
+  'use strict';
+
+  app.{{type}}('{{name}}',{{name}});
+
+  {{name}}.$inject = {{inject | array_string}};
+
+  function {{name}}({{inject | comma_delimited_variables}}) {
+    {% if directive %}
+    var d = {
+      restrict: 'A',
+      link: link
+    };
+
+    return d;
+
+    function link(scope, element, attrs) {
+
+    }
+    {% endif directive %}
+    {% if filter %}
+    return function(input) {
+      return;
+    }
+    {% endif filter %}
+  }
+
+  })(angular.module('{{module}}'));
+
+  Syntax
+  ======
+
+  Use normal JavaScript or CoffeeScript syntax.
+
+  (1) Placeholders
+
+      Use the following *placeholders* in your template:
+
+        {{type}}
+          The type of component (directive, controller, etc. Type ngi -h to see the available components)
+
+        {{name}}
+          [?] <component> name: <user input>
+          The user will inject the name of the component here (e.g. MyAwesomeController)
+
+        {{inject | array_string}}
+          [?] Inject: <user input>
+          This will turn the user's input for the injectable components into an array
+
+          For example:
+          [?] Inject: someService, anotherService
+          => ['someService', 'anotherService']
+
+        {{inject | comma_delimited_variables}}
+          [?] Inject: <user input>
+          This will turn the user's input for the injectable components into a
+          comma-delimited string of arguments
+
+          For example:
+          [?] Inject: someService, anotherService
+          => 'someService', 'anotherService'
+
+  (2) Tags
+      
+      Tags allow you to use the same template for multiple types of components.
+      For example, the above example template for "basic.js" allows you
+      to use the same template for multiple components, including controllers,
+      directives, and filters.
+
+      Use the following *tags* in your template:
+
+        {% if <component> %}
+          // conditional code here
+        {% endif <component> %}
+*/

data/lib/config/config.components.aliases.yml

@@ -0,0 +1,3 @@
+aliases:
+  config:
+    - routes

data/lib/config/config.components.yml

@@ -0,0 +1,55 @@
+- 
+  name: "directive"
+  type: "script"
+  using: "default"
+  template: "basic.js"
+- 
+  name: "controller"
+  type: "script"
+  using: "default"
+  template: "basic.js"
+- 
+  name: "factory"
+  type: "script"
+  using: "default"
+  template: "basic.js"
+- 
+  name: "service"
+  type: "script"
+  using: "default"
+  template: "basic.js"
+- 
+  name: "config"
+  type: "script"
+  using: "default"
+  template: "config.js"
+- 
+  name: "run"
+  type: "script"
+  using: "default"
+  template: "config.js"
+- 
+  name: "routes"
+  type: "script"
+  using: "default"
+  template: "config.js"
+- 
+  name: "filter"
+  type: "script"
+  using: "default"
+  template: "basic.js"
+- 
+  name: "module"
+  type: "script"
+  using: "default"
+  template: "module.js"
+- 
+  name: "constant"
+  type: "script"
+  using: "default"
+  template: "constant.js"
+- 
+  name: "index"
+  type: "markup"
+  using: "default"
+  template: "index.html"

data/lib/config/config.configurable.yml

@@ -0,0 +1,2 @@
+- language
+- templates

data/lib/config/config.languages.yml

@@ -0,0 +1,5 @@
+script:
+  - coffee
+  - es5
+markup:
+  - html

data/lib/config/config.yml

@@ -0,0 +1,4 @@
+---
+language:
+  script: es5
+  markup: html

data/lib/ngi.rb

@@ -3,17 +3,14 @@
 # github.com/joshbeam/angular_init
 # MIT License
 
-CURRENT_DIR = File.dirname(__FILE__)
-
-require_relative 'ngi/delegate'
-require_relative 'ngi/utils/utils'
-require_relative 'ngi/version'
-
 # This module wraps the basic classes
 # of the tool ngi (in other words, this
 # module simply provides namespace)
 module Ngi
+  require_relative 'ngi/delegate'
+  require_relative 'ngi/parser'
+
   # REVIEW: Is this the best way to do it?
   Delegate = ::Delegate
-  UserInput = ::Utils::UserInput
+  Parser = ::Parser
 end

data/lib/ngi/configure.rb

@@ -3,19 +3,30 @@
 # github.com/joshbeam/angular_init
 # MIT License
 
-# CURRENT_DIR is defined in angualr_init.rb
+# TODO: Method to clean out unused custom template files
 
-require_relative '../dep/json'
 require_relative 'utils/utils'
+require 'fileutils'
+require 'yaml'
 
 # Run the user through an interactive
 # session of configuring ngi
 class Configure
   attr_accessor :file, :location
 
-  Utils = ::Utils
-  JSArray = Utils::JSArray
-  JSHash = Utils::JSHash
+  JSer = Utils::JSer
+  Utils::CurrentDir.dir = File.dirname(__FILE__)
+
+  # STDIN is separated into a class so that
+  # it can be extracted and tested
+  class AcceptInput
+    def self.str(type)
+      case type
+      when :stripped
+        $stdin.gets.strip
+      end
+    end
+  end
 
   # Here, we implement the virtual class "Utils::AskLoop"
   # (see src/ruby/utils/utils.rb)
@@ -24,35 +35,179 @@ class Configure
   class AskLoop < Utils::AskLoop
     def self.ask(args)
       puts "\nChoose from: #{args[:valid]}"
-      answer = $stdin.gets.strip
+      answer = AcceptInput.str(:stripped)
 
       loop do
         break if args[:check].include?(answer)
         puts "Choose from: #{args[:valid]}\n(or press ctrl+c to exit)"
-        answer = $stdin.gets.strip
+        answer = AcceptInput.str(:stripped)
       end
       answer
     end
   end
 
+  # An extraction of the template file/directory for
+  # the generator... This way it can be separated, redefined,
+  # and tested.
+  class TemplateDir
+    attr_reader :d
+
+    def initialize(component, language, template)
+      @d = "#{Utils::CurrentDir.dir}/templates/"
+      @d << "#{component['type']}/#{language}"
+      @d << "/user/#{template}"
+    end
+
+    def read
+      f = File.open(@d)
+      content = f.read
+      f.close
+
+      content
+    end
+  end
+
   # Holds all the configure functions for the properties
   # that are configurable
   class Configurable
     def self.language(config)
-      v = JSArray.new(config.lang_types).to_str
+      v = JSer.new(config.lang_types).to_str
       type = AskLoop.ask(check: config.lang_types, valid: v)
-
-      curr_lang = config.global['language'][type]
+      curr_lang = config.config['language'][type]
       lang_opts = config.languages[type].reject { |l| l if curr_lang == l }
 
-      v = JSArray.new(lang_opts).to_str
+      v = JSer.new(lang_opts).to_str
       language = AskLoop.ask(check: lang_opts, valid: v)
 
-      answer = config.global['language']
+      answer = config.config['language']
       answer[type] = language
 
       answer
     end
+
+    def self.create_template_file(args)
+      component = args[:component]
+      language = args[:language]
+      template = args[:template]
+
+      template_dir = TemplateDir.new(component, language, template).d
+
+      destination = File.dirname(template_dir)
+
+      # Create the directory "user" unless it already exists
+      FileUtils.mkdir_p(destination) unless File.directory?(destination)
+
+      # The actual custom file
+      custom_file = template
+
+      # Copy the custom file into the new or existing "user" directory
+      if File.exist? custom_file
+        # TODO: Add a 'safety net' by checking if the user
+        # has already added the custom template before
+        # so that they don't overwrite it
+        FileUtils.cp(custom_file, destination)
+      else
+        puts "Cannot find custom template file: '#{custom_file}'
+Check to make sure the custom template file exists,
+and that you're in the correct directory of the custom template."
+
+        exit
+      end
+    end
+
+    def self.templates(config)
+      v_c = JSer.new(config.components).to_str
+      component = AskLoop.ask(check: config.components, valid: v_c)
+      chosen_component = -> (c) { c['name'] == component }
+
+      print '[?] Use the following template file: '
+      file_name = AcceptInput.str(:stripped)
+
+      print '[?] What language is this template for?'
+      type = config.components_hash.find(&chosen_component)['type']
+      v_l = JSer.new(config.languages[type]).to_str
+      language = AskLoop.ask(check: config.languages[type], valid: v_l)
+      chosen_language = -> (t) { t['language'] == language }
+
+      # Our answer will be an empty array first,
+      # because Tempaltes: might not exist the
+      # config.yml file
+      answer = []
+
+      # Set the answer to Templates: from the config.yml
+      # file if it exists
+      answer = config.config['templates'] if config.config.key? 'templates'
+
+      # Then we want to see if the component already exists in
+      # the config file
+      exists = false
+      existing_component = answer.find(&chosen_component)
+      exists = true if !existing_component == false
+
+      if file_name != 'default'
+        if exists == true
+          # Remove the current existing component (it's already saved above)
+          answer = answer
+                   .reject(&chosen_component)
+
+          # Remove the existing template object
+          existing_component['templates'] = existing_component['templates']
+                                            .reject(&chosen_language)
+
+          # Put in the updated template object
+          existing_component['templates'] << {
+            'language' => language,
+            'template' => file_name
+          }
+
+          # Push the existing component back into the templates array
+          answer << existing_component
+
+        elsif exists == false
+
+          # If it isn't already there,
+          # go ahead and add it to the templates array
+          answer << {
+            'name' => component,
+            'type' => type,
+            'templates' => [
+              {
+                'language' => language,
+                'template' => file_name
+              }
+            ]
+          }
+        end
+
+        create_template_file(
+          config: config.config,
+          component: answer.last,
+          language: language,
+          template: file_name
+        )
+      else
+        # If default is chosen as the template,
+        # then delete the template from the templates
+        # array for that component
+        answer
+          .find(&chosen_component)['templates']
+          .delete_if(&chosen_language)
+
+        # If the templates array of the component
+        # is empty, then delete the entire component
+        # from the answer
+        answer
+          .delete_if(&chosen_component) if answer
+                                           .find(&chosen_component)['templates']
+                                           .size == 0
+      end
+
+      if answer.size == 0
+        nil
+      else
+        answer
+      end
+    end
   end
 
   # Make Questioner accesible as in: Configure::Questioner.run()
@@ -62,44 +217,38 @@ class Configure
   # options (like language to use, templates, etc.)
   class Questioner
     attr_accessor :file
-    attr_reader :configurable_properties,
-                :languages, :global,
-                :configurable, :lang_types
-
-    def initialize(file)
-      @file = file
-
-      @global = @file['global']
-      # TODO: extend array with this inject function?
-
-      # The options for languages to use
-      @languages = @global['languages']
-
+    attr_reader :configurable,
+                :languages,
+                :config,
+                :components,
+                :components_hash,
+                :lang_types
+
+    def initialize(args)
+      @languages = args[:languages]
       language_types = @languages.select do |type, languages|
         type if languages.size > 1
       end
-      # For example, ['script','markup']
       @lang_types = language_types.collect { |type, _| type }.flatten
-
-      # The properties in key => value format
-      # of the properties the user can configure
-      @configurable = @global['configurable']
-
-      # An array of the properties that the user is allowed to configure,
-      # according to src/config/angular_init.config.json
-      @configurable_properties = @configurable.collect { |_k, v| v }
+      @components_hash = args[:components_hash]
+      @components = args[:components]
+      @config = args[:config]
+      @configurable = args[:configurable]
 
       yield(self) if block_given?
     end
 
     def choose_configurable_property
-      @configurable_properties.each_with_index do |p, i|
-        puts "#{i + 1}) #{p.capitalize}: #{JSHash.new(@global[p]).to_str}"
+      puts "Current settings\n================"
+      @configurable.each_with_index do |p, i|
+        json_string = 'Currently using default settings'
+        json_string = JSer.new(@config[p]).to_str if @config.key? p
+        puts "#{i + 1}) #{p.capitalize}: #{json_string}"
       end
 
-      valid = JSArray.new(@configurable_properties).to_str
+      valid = JSer.new(@configurable).to_str
       # return
-      AskLoop.ask(check: @configurable_properties, valid: valid)
+      AskLoop.ask(check: @configurable, valid: valid)
     end
 
     # This method delegates to the appropriate
@@ -109,8 +258,10 @@ class Configure
     # from_json config object from config/angular_init.config.json
     def configure_property(property)
       case property
-      when @configurable['language']
+      when 'language'
         return Configurable.language(self)
+      when 'templates'
+        return Configurable.templates(self)
       end
     end
 
@@ -130,11 +281,14 @@ class Configure
         # Hash from_json object that came from
         # config/angular_init.config.json
         # and is inside of this instance of Questioner
-        q.file['global'][property] = result
+        q.config[property] = result
+
+        # delete any properties that are nil
+        q.config.delete_if { |_, v| v.nil? }
 
         # This just tells the user that we were
         # successful
-        result_string_hash = JSHash.new(result).to_str
+        result_string_hash = JSer.new(result).to_str rescue 'null'
         puts "#{property.capitalize} set to: #{result_string_hash}"
       end
 
@@ -142,42 +296,57 @@ class Configure
       # (For example, Configure might write this
       # new hash as a JSON file to
       # config/angular_init.config.json)
-      questioner.file
+      questioner.config
     end
   end
 
   # The only thing we do here is load the JSON config file basically
   # as just a string in JSON format.
   # It will be converted to a Ruby hash in from_json below
-  def initialize(location)
-    @location = location
-    @file = IO.read(@location)
+  def initialize(location = nil)
+    unless location.nil?
+      @location = location
+      f = File.open(@location, 'r')
+      @file = f.read
+      f.close
+    end
 
     yield(self) if block_given?
   end
 
   # Convert the file to a Ruby hash
-  def from_json
-    JSON.parse(@file)
+  # def from_json
+  #   JSON.parse(@file)
+  # end
+
+  # Convert the file to a Ruby hash
+  # Usage: Configure.new('file/path').to_ruby(from: 'yaml')
+  def to_ruby(args)
+    case args[:from]
+    when 'json'
+      JSON.parse(@file)
+    when 'yaml'
+      YAML.load(@file)
+    end
   end
 
-  # Generate a "prettified" JSON version of our
-  # newly updated Ruby hash with the user's options
-  def to_json
-    if @file.is_a? Hash
+  # Convert the file from a Ruby hash
+  # into whatever language is specified
+  # Usage: <Configure instance>.from_ruby(to: 'yaml')
+  def from_ruby(args)
+    case args[:to]
+    when 'json'
       JSON.pretty_generate(@file)
-    else
-      @file
+    when 'yaml'
+      @file.to_yaml
     end
   end
 
   # Here we actually write the new JSON config file
   # to config/angular_init.config.json
-  def write
-    new_file = to_json
-
-    File.open(@location, 'w') do |f|
-      f.write(new_file)
+  def write(args)
+    File.open(args[:destination], 'w') do |f|
+      f.write(args[:file])
       f.close
     end
   end
@@ -190,23 +359,15 @@ class Configure
   # to actually write the file in JSON format
   # to config/angular_init.config.json
   def self.run(args)
-    Configure.new(args[:file_path]) do |c|
-      # Get the JSON file as a Ruby Hash
-      json_file = c.from_json
-
-      # Pass it off to Questioner so that
-      # we can interact with the user and
-      # have the user configure the Hash.
-      # Then, we set the Configure file
-      # to the output of however the user
-      # configured it with Questioner
-      c.file = Configure::Questioner.run(json_file)
-
-      # We'll write the hash to
-      # config/angular_init.config.json.
-      # Configure#write converts the Hash
-      # to JSON and then uses File.write
-      c.write if args[:write] == true
+    Configure.new do |c|
+      c.file = Configure::Questioner.run(args)
+
+      if args[:write] == true
+        c.write(
+          destination: args[:destination],
+          file: c.from_ruby(to: args[:to])
+        )
+      end
     end
   end
 end