ngi 0.2.1

data/lib/ngi/delegate.rb

@@ -0,0 +1,24 @@
+# angular_init (short-name: ngi)
+# Copyright 2015 Joshua Beam
+# 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
+	# Review: is this the best way to do it?
+	Generator = ::Generator
+	Configure = ::Configure
+end

data/lib/ngi/generator.rb

@@ -0,0 +1,199 @@
+# angular_init (short-name: ngi)
+# Copyright 2015 Joshua Beam
+# github.com/joshbeam/angular_init
+# MIT License
+
+require_relative "utils/utils"
+
+# This class generates templates (hence the name "Generator")
+class Generator
+	Utils = ::Utils
+
+	class AskLoop < Utils::AskLoop
+		def self.ask(args)
+			puts "\n"
+			print args[:prompt]
+
+			answer = $stdin.gets.strip.downcase
+
+			while true
+				if args[:check] == answer
+					break
+				else
+					puts "Exited!"
+					exit
+				end
+			end
+
+			answer
+		end
+	end
+
+	WHITESPACE = /\s*/
+	EMPTY = ""
+	CURRENT_DIR = File.dirname(__FILE__)
+
+	################################
+
+	# SET UP ALL THE CONFIG OPTIONS
+	# Generator.new (the initialization function) is called in self.run
+
+	def initialize(args)
+		@type = args[:type]
+		@config = args[:config]['global']
+
+		all_components = @config['components']
+		component = all_components.find{ |t| t['name'] == @type }
+
+		# 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']
+		}
+
+		template_dir = "#{CURRENT_DIR}/../templates/"
+		template_dir << "#{@component[:of_type]}/#{@component[:language]}/#{@component[:using]}/#{@component[:template]}"
+
+		@template_file = IO.read(template_dir)
+
+		if block_given?
+			yield(self)
+		end
+	end
+
+	###############################
+
+	def new_file_name
+		print "[?] New file name: "
+
+		@new_file = $stdin.gets.gsub(WHITESPACE,EMPTY)
+	end
+
+	def module_name
+		print "[?] Module name: "
+
+		@module_name = $stdin.gets.gsub(WHITESPACE,EMPTY)
+	end
+
+	def name
+		print "[?] #{@type.capitalize} name: "
+
+		@name = $stdin.gets.gsub(WHITESPACE,EMPTY)
+	end
+
+	def inject
+		# REVIEW: use symbols instead of strings?
+		special = ['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
+
+		auto_injection_statement = special ? " (already injected #{injection})" : ''
+
+		print "[?] Inject#{auto_injection_statement}: "
+
+		# accepts a comma-delimited list
+		# EXAMPLE: testService, testService2
+		# => [testService,testService2]
+		@dependencies = $stdin.gets.split(',').map { |dep| dep.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])
+
+		# automatically insert $routeProvider into a routes config
+		@dependencies << auto_injections[0][:service] if @type == 'routes' && !@dependencies.include?(auto_injections[0][:service])
+	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 || []
+		@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
+		@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 ? "" : ", ") }
+								: ""
+							)
+	end
+
+	def tag
+		# If Liquid-style tags are used in a template that can be used
+		# for multiple components, remove those parts that don't
+		# belong to the type of component user wants to generate
+		@template_file =	@template_file
+							.gsub(/\{\%\sif\s#{@type}\s\%\}(.*)\{\%\sendif\s#{@type}\s\%\}/m, '\1')
+							.gsub(/\s\{\%\sif\s.*\s\%\}.*\{\%\sendif\s.*\s\%\}/m, '')
+	end
+
+	def write
+		# create the new file
+		def overwrite?
+			AskLoop.ask(:check => "y", :prompt => "File exists already, overwrite it? (y/n) ")
+		end
+
+		if(File.exist?(@new_file))
+			overwrite?
+		end
+
+		File.open(@new_file,'w') do |file|
+			file.write(@template_file)
+			file.close
+		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
+	# prompt the user to generate a new template
+	def self.run(args)
+		Generator.new(args) do |g|
+			g.new_file_name
+
+			# we don't need to define the module if we're creating a module
+			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 ['run','config','routes','index'].include? args[:type]
+
+			g.inject unless ['index'].include? args[:type]
+
+			g.replace
+
+			g.tag
+
+			g.write
+		end
+
+		puts 'All done!'
+	end
+end

data/lib/ngi/utils/command_parser.rb

@@ -0,0 +1,104 @@
+# angular_init (short-name: ngi)
+# Copyright 2015 Joshua Beam
+# 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
+		if block_given?
+			yield(self)
+		end
+	end
+
+	def name=(name)
+		# need to also replace the name in the banner
+		@banner = @banner.gsub(@name,name)
+
+		@name = name
+	end
+
+	# register the listeners
+	def on(options,description="",&block)
+		listener = {}
+
+		# be able to pass in a single argument, or an array of arguments
+		options = *options unless options.is_a? Array
+
+		listener[:options] = options.map do |opt|
+			opt.strip.split(" ")
+		end
+
+		listener[:block] = block
+		listener[:description] = description
+
+		@listeners << listener
+	end
+
+	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
+
+		unless 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
+
+	def register_help
+		# automaticaly register this listener
+		on(["-h","--help"],"Show the help menu") do
+			puts @separator
+			puts @banner
+
+			@listeners.each_with_index do |listener,i|
+				puts "\n"
+				puts "(#{i+1}) #{listener[:description]}: #{listener[:options].join(', ')}"
+			end
+			puts @separator
+		end
+	end
+
+	def register_version
+		# automaticaly register this listener
+		on(["-v","--version"],"Show the version") do
+			puts "#{@name} #{@version}"
+		end
+	end
+end

data/lib/ngi/utils/jser.rb

@@ -0,0 +1,46 @@
+# angular_init (short-name: ngi)
+# Copyright 2015 Joshua Beam
+# github.com/joshbeam/angular_init
+# MIT License
+
+module JSer
+	# Since ngi is an AngularJS tool and the users
+	# are familiar with JavaScript, this class
+	# prints a string version of a Ruby hash or array
+	# as it would appear in normal JavaScript syntax
+	# For example:
+	# { "hello" => "world" }
+	# becomes:
+	# { 'hello': 'world' }
+	# and ["some","array"]
+	# becomes:
+	# ['some','array']
+	def to_str
+		self.to_s.gsub(/\"/,"'").gsub(/\=\>/,": ")
+	end
+
+	# A JSer class
+	# Usage:
+	#     JSHash.new({"hello" => "world"}).to_str
+	class JSHash < Hash
+		def initialize(hash)
+			super
+			hash.each do |key,val|
+				self[key] = val
+			end
+		end
+
+		include JSer
+	end
+
+	# Another JSer class
+	# Usage:
+	#     JSArray.new(["some","array"]).to_str
+	class JSArray < Array
+		def initialize(array)
+			super
+		end
+
+		include JSer
+	end
+end

data/lib/ngi/utils/utils.rb

@@ -0,0 +1,30 @@
+# angular_init (short-name: ngi)
+# Copyright 2015 Joshua Beam
+# github.com/joshbeam/angular_init
+# MIT License
+
+require_relative "command_parser"
+require_relative "jser"
+
+module Utils
+	CommandParser = ::CommandParser
+	JSArray = JSer::JSArray
+	JSHash = JSer::JSHash
+
+	class AskLoop; end
+
+	# This class is just a way to meaningfully
+	# collect an array of valid user inputs
+	# for use with OptionParser in bin/ngi
+	class UserInput
+		attr_reader :valid_inputs
+		
+		def initialize(args)
+			@valid_inputs = args[:valid_inputs]
+		end
+
+		def valid?(input)
+			@valid_inputs.include?(input)
+		end
+	end
+end

data/lib/ngi/version.rb

@@ -0,0 +1,3 @@
+module Ngi
+  VERSION = "0.2.1"
+end

data/lib/templates/markup/html/default/index.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html ng-app="{{module}}">
+<head>
+	<link href="" rel="stylesheet" type="text/css" />
+	<meta charset="utf-8">
+	<title></title>
+</head>
+<body>
+	<script src=""></script>
+</body>
+</html>

data/lib/templates/script/coffee/default/basic.js

@@ -0,0 +1,23 @@
+((app) ->
+
+  'use strict'
+  
+  {{name}}.$inject = {{inject | array_string}}
+  
+  app.{{type}} '{{name}}', {{name}}
+  
+  {{name}} = ({{inject | comma_delimited_variables}}) ->
+  	{% if directive %}
+    d = 
+      restrict: 'A'
+      link: link
+
+    link = (scope, element, attrs) ->
+
+    d
+    {% endif directive %}
+    {% if filter %}
+    (input) ->
+      input
+	{% endif filter %}
+) angular.module('{{module}}')