codger 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in codger.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Jacob Williams
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,63 @@
+# codger
+
+Goals:
+
+* Provide a simple way to define and run project skeletons and other code generators.
+* Help integrate later changes to the generators into a project.
+
+## Creating Skeletons
+
+Put the skeleton in a git repo. Before testing it, make sure to at least `git add` the files. Then:
+
+    codger skeleton path/to/your-repo-name --test
+
+Now, to generate code inside the current working directory, do
+
+    codger gen your-repo-name
+
+Here's how the skeleton repo will be used:
+
+1. If there is a script named `generate.rb` in the root directory, it will be run.
+2. Files ending in `.erb` will be [interpolated](http://ruby-doc.org/stdlib-1.9.3/libdoc/erb/rdoc/ERB.html) and written to the target directory.
+3. Other files will be copied directly to the target directory. (Exceptions: README, README.md, README.markdown)
+
+### Parameters
+
+In the templates or generate.rb, use the method `param :parameter_name` to request values to configure the skeleton. The first time a particular parameter is requested, the user will be prompted for a value.
+
+The first time a prompt is given, the skeleton repo's README will be printed (if it exists).
+
+### Helpers
+
+* In a template, you can use `<%- rename "relative_path" -%>` to override the output file name.
+* Use `copy "path1", "path2"` to copy files "path1" and "path2" (relative the skeleton repo's root directory) into the target directory directly. Use `copy "path1" => "newpath1"` to override the destination path in the target directory.
+* Use `interpolate "path1", "path2"` to interpolate ERB files "path1" and "path2" into the target directory. As with `copy` you can use a hash to override the destination paths.
+* Use `ignore "path1", "path2"` to prevent automatic copying or interpolation of files.
+
+## Using Skeletons
+
+Register a skeleton:
+
+    codger skeleton git://example.com/boilerplate.git
+
+Run it in a new folder:
+
+    codger create boilerplate monumental-endeavor
+
+Or run it in the current working directory:
+
+    codger gen boilerplate
+
+In either case the parameters used will be recorded in a file named `.codger`, so that later, after the project or the skeleton have changed, you can use
+
+    codger diff
+
+to compare the current state of your project with the output of the current version of the skeleton. The command used for diffing can be changed:
+
+    codger config diff "diff -ur %SOURCE %DEST"
+
+## TODO
+
+* Better documentation; examples
+* I'm hopeful that more useful diffing can be done through git integration, but I haven't worked on it much yet.
+* Code generators shouldn't be restricted to whatever dependencies happen to be pulled in by codger.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/codger

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'codger'
+Codger::CLI.start

data/codger.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "codger/version"
+
+Gem::Specification.new do |s|
+  s.name        = "codger"
+  s.version     = Codger::VERSION
+  s.authors     = ["Jacob Williams"]
+  s.email       = ["jacobaw@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Manages invocation of code generators.}
+  s.description = %q{Manages invocation of code generators.}
+
+  s.rubyforge_project = "codger"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+  s.add_runtime_dependency 'activesupport', '~> 3.2.1'
+  s.add_runtime_dependency 'deep_merge', '~> 1.0.0'
+  s.add_runtime_dependency 'git', '~> 1.2.5'
+  s.add_runtime_dependency 'thor', '~> 0.14.6'
+end

data/lib/codger/cli.rb

@@ -0,0 +1,100 @@
+require 'fileutils'
+require 'git'
+require 'thor'
+require 'tmpdir'
+require 'yaml'
+
+module Codger
+  class CLI < Thor
+    desc 'config [NAME [VALUE]]', 'lists, shows, or alters configuration'
+    def config(name = nil, value = nil)
+      if name
+        if value
+          Manager.default.global_settings[:config][name] = value
+          Manager.default.save_globals
+        else
+          puts Manager.default.settings[:config][name]
+        end
+      else
+        puts YAML.dump(Manager.default.settings[:config]).lines.drop(1).join
+      end
+    end
+
+    desc 'available', 'lists registered code generators'
+    def available
+      Manager.default.settings[:generators].each do |name, info|
+        puts "#{name}\t#{info.inspect}"
+      end
+    end
+
+    desc 'skeleton LOCATION', 'register a git repository as a code generator, creating a clone from the given location'
+    method_option :name, desc: 'Name you wish to refer to the skeleton by.'
+    method_option :test, desc: 'Prevent cloning or pulling of the repository. Location should be a path on the file system.'
+    def skeleton(location)
+      info = {}
+      if options[:test]
+        location = File.expand_path(location)
+        info[:test] = true
+      end
+      info[:git] = location
+      Manager.default.register options[:name], info
+    end
+
+    desc 'create NAME PATH', 'run the named generator in a new folder at the given path'
+    def create(name, path)
+      FileUtils.mkdir path
+      Git.init File.expand_path(path)
+      manager = Manager.new(File.join(path, '.codger'))
+      generator = manager.generator(manager.settings[:generators][name])
+      generator.run path, project_name: path.split('/').last
+      manager.record_run generator
+    end
+
+    desc 'gen NAME', 'run the named generator'
+    def gen(name)
+      generator = Manager.default.generator(Manager.default.settings[:generators][name])
+      generator.run(Dir.pwd)
+      Manager.default.record_run(generator)
+    end
+
+    desc 'history', 'show the actions recorded for this directory'
+    def history
+      Manager.default.settings[:runs].each do |info|
+        puts "#{info[:generator]} [#{info[:tags].join(' ')}]"
+        puts Generator.format_params(info[:params])
+        puts
+      end
+    end
+
+    desc 'diff [TAGS...]', 'run part or all of the history in a temp directory and display a diff'
+    def diff(*tags)
+      Dir.mktmpdir do |dir|
+        Manager.default.settings[:runs].each do |info|
+          if tags.empty? or (tags & info[:tags]).any?
+            generator = Manager.default.generator(info[:generator])
+            generator.run dir, info[:params]
+          end
+        end
+        system Manager.default.diff_command(dir, Dir.pwd)
+      end
+    end
+
+    desc 'repeat [TAGS...]', 're-run part or all of the history'
+    def repeat(*tags)
+      Manager.default.settings[:runs].each do |info|
+        if tags.empty? or (tags & info[:tags]).any?
+          puts "Running #{info[:generator]} [#{info[:tags].join(' ')}]"
+          puts Generator.format_params(info[:params])
+          puts
+          generator = Manager.default.generator(info[:generator])
+          generator.run Dir.pwd, info[:params]
+        end
+      end
+    end
+
+    desc 'unregister NAME', 'unregister a code generator and delete its clone'
+    def unregister(name)
+      Manager.default.unregister name
+    end
+  end
+end

data/lib/codger/generator.rb

@@ -0,0 +1,84 @@
+require 'yaml'
+
+module Codger
+  # A code generator. The #run method is called to perform code generation;
+  # the parameters used (which may have been specified interactively during #run)
+  # can be determined afterwards using #params.
+  #
+  # Subclasses must implement:
+  # * a #generate method which will perform the code generation
+  # * a #help method which returns help text
+  #
+  # Methods for use by subclasses:
+  # * #dest_path
+  # * #ensure_folder
+  # * #param
+  # * #tags
+  class Generator
+    class << self
+      # Given a params map, print one param per line, indented.
+      def format_params(params)
+        YAML.dump(params).lines.drop(1).map do |line|
+          "\t#{line}"
+        end.join
+      end
+    end
+
+    # The map of parameters used during the last call to #run.
+    attr_reader :params
+    # The output directory used during the last call to #run.
+    attr_reader :target
+
+    # Perform code generation in the given directory. Any parameters
+    # already known (e.g., if we're repeating a previous run) can be
+    # specified; any other parameters needed will be determined interactively.
+    def run(target, params = {})
+      @showed_help = false
+      @target = target
+      @params = params.with_indifferent_access
+
+      generate
+    end
+
+    # Given a path relative to the output directory root, returns the full path.
+    def dest_path(path)
+      File.join(target, path)
+    end
+
+    # Given a path relative to the output directory root, creates a folder
+    # at that location if one does not yet exist.
+    def ensure_folder(path)
+      FileUtils.mkdir_p(File.join(target, File.dirname(path)))
+    end
+
+    # Returns the value from the params map for the given name. If there
+    # is none, asks the user for a value. #help is called the first time
+    # the user is asked for a value.
+    # The parameter will also be saved in an instance variable of the same name.
+    def param(name)
+      until params[name]
+        unless @showed_help
+          puts help
+          puts
+          @showed_help = true
+        end
+        print "Specify #{name}: "
+        value = STDIN.gets.chomp
+        params[name] = value unless value.empty?
+      end
+      instance_variable_set("@#{name}", params[name])
+      params[name]
+    end
+
+    # Sets (with parameters) or returns (without parameters) tags for
+    # this generator. The tags will be associated to recorded runs.
+    # (This may be useless, we'll see.)
+    def tags(*tags)
+      if tags == []
+        @tags || []
+      else
+        @tags = tags.flatten
+      end
+    end
+  end
+end

data/lib/codger/manager.rb

@@ -0,0 +1,134 @@
+require 'fileutils'
+require 'git'
+require 'yaml'
+
+module Codger
+  # Responsible for:
+  # * Reading, writing, and to some degree interpreting configuration files.
+  # * Looking up code generators from their identifiers.
+  class Manager
+    class << self
+      # Return an instance using any settings in the .codger
+      # file (if one exists) of the working directory.
+      def default
+        @config ||= Manager.new(File.join(Dir.pwd, '.codger'))
+      end
+    end
+
+    # The global settings map (i.e. from ~/.codger/codger.yaml)
+    attr_reader :global_settings
+    # The project settings map (i.e. from .codger)
+    attr_reader :project_settings
+
+    # Create an instance with project-level settings stored at the specified path
+    # (does not need to exist yet, and will not be created unless necessary).
+    def initialize(path)
+      @project_path = path
+      @project_settings = {
+        runs: []
+      }.with_indifferent_access
+      if File.exists?(@project_path)
+        @project_settings.merge! YAML.load(File.read(@project_path))
+      end
+
+      @global_settings = {
+        config: {
+          diff: 'diff -ur %SOURCE %DEST'
+        },
+        clones: {},
+        generators: {}
+      }.with_indifferent_access
+      if File.exists?(globals_path)
+        @global_settings.merge! YAML.load(File.read(globals_path))
+      end
+    end
+
+    # Creates a Generator, currently always a Skeleton.
+    # info should contain :git, the path/URI of the repository.
+    # Unless it contains :test, the repository will be cloned to #clones_base
+    # (if it has not been already).
+    def generator(info)
+      if location = info[:git]
+        if info[:test]
+          clone = location
+        elsif !(clone = settings[:clones][location] and File.exists?(clone))
+          FileUtils.mkdir_p clones_base
+          next_id = Dir.entries(clones_base).map(&:to_i).max + 1
+          clone = File.join(clones_base, next_id.to_s)
+          Git.clone location, clone
+          @global_settings[:clones][location] = clone
+          save_globals
+        end
+        Skeleton.new clone, info
+      end
+    end
+
+    # Load a generator for the given attributes and register it
+    # in the global configuration under the given name, or its default
+    # name if name is nil.
+    def register(name, info)
+      gen = generator(info)
+      @global_settings[:generators][name || gen.name] = gen.info
+      save_globals
+    end
+
+    # Given a generator name, removes it from the config, and delete its
+    # local clone if one exists.
+    def unregister(name)
+      info = @global_settings[:generators].delete name # TODO graciously handle it not existing
+      clone = @global_settings[:clones].delete info[:git]
+      if clone and clone.start_with? clones_base # sanity check before rm_rf
+        FileUtils.rm_rf clone
+      end
+      save_globals
+    end
+
+    # Saves the tags, identifier, and params from the last run of the given generator instance
+    # in the project settings file.
+    def record_run(generator)
+      @project_settings[:runs] << {
+        tags: [generator.name] + generator.tags,
+        generator: generator.info,
+        params: generator.params
+      }.with_indifferent_access
+      save_project
+    end
+
+    # Save #project_settings.
+    def save_project
+      File.write @project_path, @project_settings.to_yaml
+    end
+
+    # Save #global_settings.
+    def save_globals
+      FileUtils.mkdir_p codger_home
+      File.write globals_path, @global_settings.to_yaml
+    end
+
+    # Return the folder where global settings and other resources can be saved.
+    # By default ~/.codger but this can be overridden using 'codger_home' in #project_settings.
+    def codger_home
+      @project_settings[:codger_home] || File.join(Dir.home, '.codger')
+    end
+
+    # Return the file where global settings should be saved - 'codger.yaml' in #codger_home.
+    def globals_path
+      File.join(codger_home, 'codger.yaml')
+    end
+
+    # Return the folder where skeleton clones can be saved - 'clones' in #codger_home.
+    def clones_base
+      File.join(codger_home, 'clones')
+    end
+
+    # Return a merged map of #global_settings and #project_settings.
+    def settings
+      @global_settings.deep_merge @project_settings
+    end
+
+    # Return the command to use for diffing two folders.
+    def diff_command(source, dest)
+      settings[:config][:diff].gsub('%SOURCE', source).gsub('%DEST', dest)
+    end
+  end
+end

data/lib/codger/skeleton.rb

@@ -0,0 +1,137 @@
+require 'erb'
+require 'fileutils'
+require 'git'
+
+module Codger
+  # A generator that produces code by using a git repository as a template.
+  #
+  # By default:
+  # * README, README.md, README.markdown will be ignored, except to
+  #   be printed as documentation if user input is required for the
+  #   value of a param
+  # * generate.rb (if it exists) will be executed in the context of
+  #   the Skeleton instance
+  # * Files ending in .erb will be interpolated in the context of
+  #   the Skeleton instance
+  # * All other files will be copied directly
+  #
+  # Methods for use in generate.rb and templates:
+  # * #src_path
+  # * #copy
+  # * #interpolate
+  # * #ignore
+  # * #rename
+  class Skeleton < Generator
+    # Returns a (non-unique) name for the generator. For
+    # skeletons this is based on the last segment of the origin
+    # URI or of the clone's path.
+    attr_reader :name
+    # Returns the attributes used in creating this instance.
+    attr_reader :info
+
+    # Create an instance reading from the git repository at the specified
+    # path. Options for info:
+    # git:: Canonical source for the repo; required.
+    # test:: Unless truthy, an attempt will be made to perform a 'pull' for the repository.
+    def initialize(repo, info)
+      @info = info
+      @git = Git.open(repo)
+      # https://github.com/schacon/ruby-git/issues/32
+      @git.lib.send(:command, 'pull') unless info[:test] # TODO needs to be OK if this fails
+      @name = info[:git].split('/').last.sub(/\.git\z/,'')
+    end
+
+    # Perform code generation using the process outlined in the class documentation.
+    def generate
+      @to_copy = @git.ls_files.keys - ['README', 'README.md', 'README.markdown', 'generate.rb']
+
+      code_path = src_path('generate.rb')
+      if File.exists?(code_path)
+        eval(File.read(code_path), binding, code_path)
+      end
+
+      interpolate(@to_copy.select {|path| path =~ /\.erb\z/})
+      copy @to_copy
+    end
+
+    # Return the full path to the given file in the repo.
+    def src_path(path)
+      File.join(@git.dir.to_s, path)
+    end
+
+    # For each path or array of paths, copy the
+    # corresponding files directly from the repository to
+    # the target directory.
+    # Alternatively, a hash of paths may be given, in which
+    # keys specify the name in the source repository and
+    # values specify the desired name in the target directory.
+    def copy(*paths)
+      paths = paths.flatten
+      mappings = {}
+      paths.each do |path|
+        if path.is_a? Hash
+          mappings.merge! path
+        else
+          mappings[path] = path
+        end
+      end
+
+      mappings.each do |src, dest|
+        ensure_folder dest
+        FileUtils.cp src_path(src), dest_path(dest)
+        @to_copy.delete src
+      end
+    end
+
+    # For each path or array of paths, interpolate (in the
+    # context of this object) the corresponding files and
+    # write the output to the target directory, stripping
+    # .erb from the filename.
+    # Alternatively, a hash of paths may be given, in which
+    # keys specify the name in the source repository and
+    # values specify the desired name in the target directory.
+    #
+    # Note that calls to #rename may override the destination path.
+    def interpolate(*paths)
+      paths = paths.flatten
+      mappings = {}
+      paths.each do |path|
+        if path.is_a? Hash
+          mappings.merge! path
+        else
+          mappings[path] = path.sub(/\.erb\z/, '')
+        end
+      end
+
+      mappings.each do |src, dest|
+        @current_template_src = src
+        @current_template_dest = dest
+        template = ERB.new(File.read(src_path(src)), nil, '-')
+        ensure_folder @current_template_dest
+        result = template.result(binding)
+        File.write dest_path(@current_template_dest), result
+        @to_copy.delete src
+      end
+    end
+
+    # Should only be called from within a file being interpolated.
+    # The output path will be changed to dest, which should be
+    # relative to the template's folder.
+    def rename(dest)
+      @current_template_dest = File.join(File.dirname(@current_template_src), dest)
+    end
+
+    # For each path or array of paths, disable implicit copying.
+    def ignore(*paths)
+      @to_copy -= paths.flatten
+    end
+
+    # Returns the text of the README, README.md or README.markdown file, if any.
+    def help
+      path = Dir[src_path('README')].first || Dir[src_path('README.md')].first || Dir[src_path('README.markdown')].first
+      if path
+        File.read path
+      end
+    end
+  end
+end

data/lib/codger/version.rb

@@ -0,0 +1,3 @@
+module Codger
+  VERSION = "0.0.1"
+end

data/lib/codger.rb

@@ -0,0 +1,8 @@
+require 'active_support/core_ext'
+require 'deep_merge/rails_compat'
+
+require 'codger/cli'
+require 'codger/generator'
+require 'codger/manager'
+require 'codger/skeleton'
+require 'codger/version'

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: codger
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jacob Williams
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70337635384820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *70337635384820
+- !ruby/object:Gem::Dependency
+  name: deep_merge
+  requirement: &70337635384160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70337635384160
+- !ruby/object:Gem::Dependency
+  name: git
+  requirement: &70337635383500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.5
+  type: :runtime
+  prerelease: false
+  version_requirements: *70337635383500
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: &70337635382820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.14.6
+  type: :runtime
+  prerelease: false
+  version_requirements: *70337635382820
+description: Manages invocation of code generators.
+email:
+- jacobaw@gmail.com
+executables:
+- codger
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/codger
+- codger.gemspec
+- lib/codger.rb
+- lib/codger/cli.rb
+- lib/codger/generator.rb
+- lib/codger/manager.rb
+- lib/codger/skeleton.rb
+- lib/codger/version.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: codger
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Manages invocation of code generators.
+test_files: []