file_templater 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d257cfba2b31bcafaee4785008f68e5d187401c2
+  data.tar.gz: c41333e40ac118c6abd00c45dd75ebd352ac7588
+SHA512:
+  metadata.gz: 70fd4f23174142d21e63fda267855c60501945b18167cdc79705f98859c11f19bf89a88d65797f82e032adb26ee458b1aa8bcbdefb7215526f55c4e3ba996697
+  data.tar.gz: 629360b5ef0856d50a4438d48734ab6657699acd0028292141f1bd6fc2b47e4f554828298e9cd930f019343423c81dfea6b4b67c2835af69c683467b06e5dcda

data/bin/template

@@ -0,0 +1,13 @@
+#! /usr/bin/env ruby
+
+# Include rel-path ../lib/ in the $LOAD_PATH if it's not there already.
+lib_directory = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+$LOAD_PATH.unshift(lib_directory) unless $LOAD_PATH.map { |directory| File.expand_path(directory) }.include?(lib_directory)
+
+require "file_templater"
+
+FileTemplater::FileActions.create_hub_if_necessary
+FileTemplater::FileActions.require_all_bindings
+
+handler = FileTemplater::OptionsHandler.new(ARGV)
+handler.process_actions

data/lib/file_templater/file_actions.rb

@@ -0,0 +1,132 @@
+module FileTemplater
+	class FileActions
+		class << self
+			def create_hub_if_necessary
+				HUBS.each do |k, v|
+					Dir.mkdir(v) unless Dir.exists?(v)
+				end
+			end
+
+			def add(path)
+				expanded = File.expand_path(path)
+				# Three cases of what we are adding can arise:
+				# file of the template being added
+				# directory of the template being added
+				# binding of the template being added
+				type = File.directory?(expanded) ? :directory : (expanded.end_with?(".rb") ? :binding : :file)
+				hub = (type == :binding ? :binding : :template)
+
+				if type == :file
+					# If the file we are adding is a single file,
+					# make a directory and put the file in it.
+					expanded_sans_extension = File.join(HUBS[hub], File.basename(expanded, ".*"))
+					FileUtils.mkdir(expanded_sans_extension)
+					FileUtils.copy_entry(expanded, File.join(expanded_sans_extension, File.basename(expanded)))
+				elsif type == :binding
+					# If we are adding a binding,
+					# we need to modify the code to work with our system.
+					output_file = File.open(File.join(HUBS[hub], File.basename(expanded)), "w")
+
+					output_file.print "module Bindings\n"
+					File.open(expanded, "r").each do |line|
+						if line.lstrip.start_with?("class ")
+							output_file.print(line + "def get_binding\nbinding\nend\n")
+						else
+							output_file.print line
+						end
+					end
+					output_file.print "end\n"
+
+					output_file.close
+
+					# We will save the original file just in case.
+					FileUtils.copy_entry(expanded, File.join(HUBS[:original], File.basename(expanded)))
+				else
+					FileUtils.copy_entry(expanded, File.join(HUBS[hub], File.basename(expanded)))
+				end
+			end
+
+			def remove(path)
+				removing_template = !path.end_with?(".rb")
+
+				unless removing_template
+					# Remove the associated binding.
+					begin
+						FileUtils.remove_file(File.join(HUBS[:binding], path))
+						FileUtils.remove_file(File.join(HUBS[:original], path))
+					rescue StandardError
+						# If we failed to remove one of these files, try to remove a template by the same name.
+						removing_template = true
+					end
+				end
+
+				# Remove the associated template.
+				FileUtils.remove_dir(File.join(HUBS[:template], path), true) if removing_template
+			end
+
+			def list
+				# In our list, we want to indicate if a template does not have a corresponding binding.
+				# As a result, we should list like so:
+				# Template    Binding
+				# example     example.rb
+				Terminal::Table.new do |t|
+					templates = list_templates.sort
+					bindings = list_bindings.sort
+
+					# table header
+					t.add_row ["Template", "Binding"]
+					t.add_separator
+
+					templates.each do |tm|
+						bind = tm + ".rb"
+						bind = nil unless bindings.include?(bind)
+						bindings.delete(bind) if bind
+
+						t.add_row [tm, bind]
+					end
+
+					bindings.each do |b|
+						t.add_row [nil, b]
+					end
+				end
+			end
+
+			def copy(path)
+				if File.exist?(path)
+					puts "A file of this name already exists.\nPlease remove it, or else this command will not work."
+					return
+				end
+
+				# This code is very similar to that of remove.
+				copying_template = !(path.end_with?(".rb") && File.exist?(File.join(HUBS[:binding], path)))
+
+				FileUtils.copy_entry(File.join(HUBS[copying_template ? :template : :original], path), path)
+			end
+
+			def combined_list
+				list_templates + list_bindings
+			end
+
+			def list_templates
+				unique_directory_list(HUBS[:template])
+			end
+
+			def list_bindings
+				unique_directory_list(HUBS[:binding])
+			end
+
+			# Requires all of the .rb files in HUBS[:binding].
+			def require_all_bindings
+				unique_directory_list(HUBS[:binding]).each do |f|
+					if f.end_with?(".rb")
+						require File.join(HUBS[:binding], f)
+					end
+				end
+			end
+
+			def unique_directory_list(path)
+				Dir.entries(path).reject { |d| d == "." || d == ".." }
+			end
+		end
+	end
+end

data/lib/file_templater/options_handler.rb

@@ -0,0 +1,103 @@
+module FileTemplater
+	class OptionsHandler
+		def initialize(argv)
+			@nomodify = false
+			@binding = nil
+
+			@actions = []
+
+			parser = OptionParser.new do |o|
+				o.banner = "Usage: template [options] [binding arguments]"
+
+				o.separator ""
+				o.separator "Specific options:"
+
+				o.on("-t", "--template TEMPLATE",
+					 "Load TEMPLATE to insert",
+					 "into the current directory") do |t|
+					@actions << [:template, t]
+				end
+
+				o.on("-b", "--binding BINDING",
+					 "Load BINDING as the binding",
+					 "for the loaded template") do |b|
+					@binding = b
+				end
+
+				o.on("-a", "--add THING", Array,
+					 "Add THING, a template or a binding,",
+					 "to the template or binding directory") do |t|
+					@actions << [:add, t]
+				end
+
+				o.on("-r", "--remove THING", Array,
+					 "Removes template or binding THING") do |tb|
+					@actions << [:remove, tb]
+				end
+
+				o.on("-l", "--list",
+					 "Lists the templates and bindings",
+					 "that are loaded") do
+					@actions << [:list]
+				end
+
+				o.on("-m", "--no-modify",
+					 "Prevents modifying the template source",
+					 "when loading") do
+					@nomodify = true
+				end
+
+				o.on("-c", "--copy TEMPLATE", Array,
+					 "Copies TEMPLATE and corresponding binding",
+					 "into current directory") do |tb|
+					@actions << [:copy, tb]
+				end
+
+				o.separator ""
+				o.separator "Common options:"
+
+				o.on_tail("-v", "--version", "Display the version") do
+					puts "File Templater (template) version " + VERSION
+					exit
+				end
+
+				o.on_tail("-h", "--help", "Show this message") do
+					puts o
+					exit
+				end
+			end
+
+			parser.parse!(argv)
+			@arguments = argv
+		end
+
+		def process_actions
+			@actions.each do |a|
+				command = a.first
+				arguments = a[1]
+
+				case command
+				when :template
+					# arguments is the template name,
+					# @arguments are the extraneous arguments
+					template = Template.new(arguments, @arguments, nomodify: @nomodify, bind: @binding)
+					template.load
+				when :add
+					arguments.each do |ar|
+						FileActions.add(ar)
+					end
+				when :remove
+					arguments.each do |ar|
+						FileActions.remove(ar)
+					end
+				when :list
+					puts FileActions.list
+				when :copy
+					arguments.each do |ar|
+						FileActions.copy(ar)
+					end
+				end
+			end
+		end
+	end
+end

data/lib/file_templater/template.rb

@@ -0,0 +1,61 @@
+module FileTemplater
+	class Template
+		# options can include:
+		# bind: which binding rather than the default to use
+		# nomodify: if the template ERB will be loaded or not
+		def initialize(template, arguments, options = {})
+			@nomodify = options[:nomodify]
+
+			@template = File.join(HUBS[:template], template)
+			binding_string = options[:bind] || template + ".rb"
+			using_binding = File.exist?(File.join(HUBS[:binding], binding_string))
+
+			if using_binding
+				binding_string = File.basename(binding_string, ".*")
+
+				# Convert binding_string to a class object.
+				binding_string = "Bindings::" + binding_string.split("_").map { |w| w.capitalize }.join
+				binding_class = Object.const_get(binding_string)
+				@bind = binding_class.new(*arguments)
+			end
+		end
+
+		def load(folder = @template)
+			FileActions.unique_directory_list(folder).each do |f|
+				# We need the whole path to f, but we will keep the short name.
+				short_name = f
+				f = File.join(folder, f)
+
+				if File.directory?(f)
+					self.load f
+				else
+					if !@nomodify && f.end_with?(".erb")
+						output_file = File.open(File.join(Dir.pwd, transform_file_name(short_name)), "w")
+
+						input_file = File.open(f, "r")
+						output_file.print(ERB.new(input_file.read, nil, "<>").result(@bind && @bind.get_binding))
+						input_file.close
+
+						output_file.close
+					else
+						FileUtils.copy_entry(f, File.join(Dir.pwd, transform_file_name(short_name)))
+					end
+				end
+			end
+		end
+
+		# Expands the variable-in-file-name notation.
+		# file is expected to be a short name
+		def transform_file_name(file)
+			if @bind
+				variables = file.scan(/{{([^}]*)}}/).flatten
+
+				variables.each do |v|
+					file.sub!("{{#{v}}}", @bind.get_binding.eval(v))
+				end
+			end
+
+			!@nomodify && file.end_with?(".erb") ? File.basename(file, ".*") : file
+		end
+	end
+end

data/lib/file_templater/variables.rb

@@ -0,0 +1,11 @@
+module FileTemplater
+	VERSION = "0.1.0"
+
+	# The hub is where we store our templates and bindings.
+	HUBS = {
+		:main => File.join(Dir.home, ".templater"),
+		:template => File.join(Dir.home, ".templater", "templates"),
+		:binding => File.join(Dir.home, ".templater", "bindings"),
+		:original => File.join(Dir.home, ".templater", "original")
+	}
+end

data/lib/file_templater.rb

@@ -0,0 +1,9 @@
+require "erb"
+require "fileutils"
+require "optparse"
+require "terminal-table"
+
+require "file_templater/variables"
+require "file_templater/template"
+require "file_templater/file_actions"
+require "file_templater/options_handler"

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: file_templater
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sam Craig
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+description: 
+email: sammidysam@gmail.com
+executables:
+- template
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/template
+- lib/file_templater.rb
+- lib/file_templater/file_actions.rb
+- lib/file_templater/options_handler.rb
+- lib/file_templater/template.rb
+- lib/file_templater/variables.rb
+homepage: https://github.com/Sammidysam/file_templater
+licenses:
+- gpl-3.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: A simple system to create files/file structures from ERB templates.
+test_files: []