rango 0.0.4 → 0.0.6

data/vendor/simple-templater/Rakefile

@@ -0,0 +1,61 @@
+#!/usr/bin/env rake1.9
+# encoding: utf-8
+
+# http://support.runcoderun.com/faqs/builds/how-do-i-run-rake-with-trace-enabled
+Rake.application.options.trace = true
+
+task :setup => ["submodules:init"]
+
+namespace :submodules do
+  desc "Init submodules"
+  task :init do
+    sh "git submodule init"
+  end
+
+  desc "Update submodules"
+  task :update do
+    Dir["vendor/*"].each do |path|
+      if File.directory?(path) && File.directory?(File.join(path, ".git"))
+        Dir.chdir(path) do
+          puts "=> #{path}"
+          puts %x[git reset --hard]
+          puts %x[git fetch]
+          puts %x[git reset origin/master --hard]
+          puts
+        end
+      end
+    end
+  end
+end
+
+task :gem do
+  sh "gem build simple-templater.gemspec"
+end
+
+desc "Release new version of simple-templater"
+task release: ["release:tag", "release:gemcutter"]
+
+namespace :release do
+  desc "Create Git tag"
+  task :tag do
+    require_relative "lib/simple-templater"
+    puts "Creating new git tag #{SimpleTemplater::VERSION} and pushing it online ..."
+    sh "git tag -a -m 'Version #{SimpleTemplater::VERSION}' #{SimpleTemplater::VERSION}"
+    sh "git push --tags"
+    puts "Tag #{SimpleTemplater::VERSION} was created and pushed to GitHub."
+  end
+
+  desc "Push gem to Gemcutter"
+  task :gemcutter => :gem do
+    puts "Pushing to Gemcutter ..."
+    sh "gem push #{Dir["*.gem"].last}"
+  end
+end
+
+desc "Run specs"
+task :default => :setup do
+  rubylib = (ENV["RUBYLIB"] || String.new).split(":")
+  libdirs = Dir["vendor/*/lib"]
+  ENV["RUBYLIB"] = (libdirs + rubylib).join(":")
+  exec "./script/spec --options spec/spec.opts spec"
+end

data/vendor/simple-templater/TODO.txt

@@ -0,0 +1,15 @@
+=== Version 0.2 ===
+- javascripts/{javascript}.js for collections (instead of %javascript%)
+- hooks: description
+- better CLI interface, so project can just run SimpleTemplater::CLI.exec(scope, ARGV)
+- improve project generator (see my other projects)
+- better syntax for simple-templater.scope
+
+=== Version 0.3 ===
+- bin/simple-templater
+- Logger from Rango (-> RubyExts)
+
+=== Version 0.4 ===
+- 100% specs coverage & refactoring
+- YARD Code Documentation
+- discoverers: Rip, plain (for classic unix systems, so it will just look for generators in /usr/share or wherevers)

data/vendor/simple-templater/bin/simple-templater

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby1.9
+# encoding: utf-8
+
+# --list (scope): list all generators available for given scope or just list all generators
+# -i | --interactive run IRB with loaded simple templater
+# --scopes: list all available scopes
+# --help
+
+# simple-templater [scope] [generator] [options] [arguments]
+# simple-templater rango project my_blog --orm=datamapper
+
+base   = File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__
+libdir = File.expand_path(File.join(File.dirname(base), "..", "lib"))
+
+vendor = File.join(File.dirname(__FILE__), "..", "vendor")
+if File.directory?(vendor)
+  Dir["#{vendor}/*"].each do |path|
+    if File.directory?(path) && Dir["#{path}/*"].empty?
+      warn "Dependency #{File.basename(path)} in vendor seems to be empty. Run git submodule init && git submodule update to checkout it."
+    elsif File.directory?(path) && File.directory?(File.join(path, "lib"))
+      $:.unshift(File.join(path, "lib"))
+    end
+  end
+end
+
+# because of system installation, there is bin/../lib, but not bin/../lib/rango
+if File.directory?(File.join(libdir, "simple-templater"))
+  # NOTE: don't test if libdir is already in $:, just put it there,
+  # otherwise you might get errors because of you are loading bad simple-templater
+  $:.unshift(libdir)
+end
+
+require "simple-templater"
+
+# === Helpers === #
+# TODO: Generators.each { |generator| puts generator.help }
+def usage
+<<-HELP
+=== Usage ===
+rango create project mycoolproject    Generate new site
+rango create app mycoolapp            Generate new application
+HELP
+end
+
+begin
+  ARGV.shift # create
+  generator_name = ARGV.shift
+  templater = SimpleTemplater.new(:simple_templater)
+  # This enables you to create custom generators for Rango
+  load "simple-templater.scope" # neccesary if we run rango locally and not from RubyGems
+  templater.discover!
+  generator_set = templater.find(generator_name)
+  if generator_set.nil?
+    abort "Generator #{generator_name} doesn't exist. Available generators are: #{templater.generators.map { |set| set.name }.inspect}"
+  else
+    begin
+      generator_set.run(ARGV)
+    rescue SimpleTemplater::TargetAlreadyExist => exception
+      abort exception.message
+    rescue Interrupt
+      exit
+    rescue Exception => exception
+      abort "Exception #{exception.inspect} occured during running generator #{generator_set.inspect}\n#{exception.backtrace.join("\n")}"
+    end
+  end
+end

data/vendor/simple-templater/deps.rip

@@ -0,0 +1,7 @@
+#!/usr/bin/env rip install
+
+# Syntax:
+# repository [tag or commit to install]
+git://github.com/botanicus/cli.git
+git://github.com/botanicus/rubyexts.git
+git://github.com/genki/erubis.git

data/vendor/simple-templater/lib/simple-templater.rb

@@ -0,0 +1,97 @@
+#!/usr/bin/env ruby -Ivendor/rubyexts/lib:vendor/erubis/lib:vendor/abstract/lib:vendor/cli/lib
+# encoding: utf-8
+
+require "rubyexts"
+require "simple-templater/discoverer"
+require "simple-templater/generator_set"
+
+class SimpleTemplater
+  VERSION ||= "0.0.1"
+  GeneratorNotFound ||= Class.new(StandardError)
+  TargetAlreadyExist ||= Class.new(StandardError)
+
+  def self.logger
+    @@logger ||= begin
+      require "logger"
+      Logger.new(STDOUT)
+    end
+  end
+
+  def self.logger=(logger)
+    @@logger = logger
+  end
+
+  def self.scopes
+    @scopes ||= Hash.new
+  end
+
+  # scope => generator
+  # rango: GeneratorSet.new(:project, *paths)
+  def self.generators
+    @generators ||= Hash.new
+  end
+
+  # Adds a block of code specific for a certain scope of generators, where the scope would
+  # probably be the name of the program running the generator.
+  #
+  # === Parameters
+  # scope<String>:: The name of the scope
+  # block<&Proc>:: A block of code to execute provided the scope is correct
+  def self.scope(scope, &block)
+    self.scopes[scope] ||= Array.new
+    self.scopes[scope] << block
+  end
+
+  def self.register(scope, name, *paths)
+    self.generators[scope] ||= Array.new
+    self.generators[scope].push(GeneratorSet.new(name, *paths))
+  end
+
+  # Searches installed gems for simple-templater.scope files and loads all code blocks in them that match
+  # the given scope.
+  #
+  # === Parameters
+  # scope<String>:: The name of the scope to search for
+  def self.discover!(scope)
+    klass = Discoverer.detect
+    discoverer = klass.new(scope)
+    discoverer.run
+  end
+
+  attr_reader :scope, :generators
+  def initialize(scope, logger = nil)
+    @scope      = scope
+    @generators = Hash.new
+  end
+
+  def logger
+    @logger ||= standard_logger
+  end
+
+  def discover!
+    SimpleTemplater.discover!(self.scope)
+  end
+
+  def generators
+    SimpleTemplater.generators[self.scope] || Hash.new
+  end
+
+  # templater.register(:project, path)
+  def register(name, path)
+    SimpleTemplater.register(self.scope, name, path)
+  end
+
+  def find(name)
+    self.generators.find do |generator|
+      generator.name == name.to_sym
+    end
+  end
+end
+
+# run console if executed directly
+if $0 == __FILE__
+  require "irb"
+  require "irb/completion"
+  include SimpleTemplater
+  IRB.start(__FILE__)
+end

data/vendor/simple-templater/lib/simple-templater/argv_parsing.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+class SimpleTemplater
+  module ArgvParsingMixin
+    def parse!
+      self.inject(Hash.new) do |options, argument|
+        case argument
+        when /^--no-([^=]+)$/ # --no-git-repository
+          options[$1.gsub("-", "_").to_sym] = false
+        when /^--([^=]+)$/    # --git-repository
+          options[$1.gsub("-", "_").to_sym] = true
+        when /^--([^=]+)=([^,]+)$/ # --controller=post
+          key, value = $1, $2
+          options[key.gsub("-", "_").to_sym] = value.dup
+        when /^--([^=]+)=(.+)$/    # --controllers=posts,comments
+          key, value = $1, $2
+          options[key.gsub("-", "_").to_sym] = value.split(",")
+        else
+          raise "Parsing failed on: #{argument}"
+        end
+        options
+      end
+    end
+  end
+end
+
+ARGV.extend(SimpleTemplater::ArgvParsingMixin)

data/vendor/simple-templater/lib/simple-templater/builder.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+
+require "erubis"
+require "fileutils"
+require "tempfile"
+require "find"
+require "simple-templater/helpers"
+
+module FileUtils
+  def self.cp_f(source, target)
+    sh "cp -f '#{source}' '#{target}'"
+    # self.rm target
+    # self.cp source, target
+  end
+end
+
+# @since 0.0.3
+# @example
+#   SimpleTemplater::Builder.create("my_generator_dir", user: "botanicus", constant: -> { |argv| argv.first.camel_case })
+class SimpleTemplater
+  class Builder
+    def self.create(*args)
+      templater = self.new(*args)
+      SimpleTemplater.logger.debug("Context: #{templater.context.inspect}")
+      templater.create
+    end
+
+    attr_accessor :context
+    def initialize(content_dir, context = Hash.new)
+      @content_dir, @context = content_dir, context
+    end
+
+    def create
+      Find.find(@content_dir) do |template|
+        file = self.expand_path(template)
+        next if template == @content_dir
+        proceed(template, file)
+      end
+    end
+
+    protected
+    # %name%_controller.rb => application_controller.rb
+    def expand_path(file)
+      self.location(file).sub(/\.rbt$/, "")
+    end
+
+    def location(file)
+      file.sub(%r[^#{Regexp::quote(@content_dir)}/?], "")
+    end
+
+    # TODO: %a%/%b% etc, now it can handle just one %var%
+    def proceed(template, file)
+      # OK, this is a bit tricky, but it works
+      # == TEMPLATE ==   | == CONTEXT ==             | == OUTPUT ==
+      # config/%user%.rb | {user: "botanicus"}       | config/botanicus.rb
+      # %model%.rb       | {models: ["tag", "post"]} | tag.rb, post.rb
+      if template.match(/%(\w+)%/)
+        singular, plural = $1.to_sym, "#{$1}s".to_sym # TODO: use inflector
+        if self.context.has_key?(singular)
+          target = file.sub(/%(\w+)%/, self.context[singular])
+          proceed_file(template, target)
+        elsif self.context.has_key?(plural)
+          variables = self.context[plural] || Array.new
+          variables.each do |variable|
+            target = file.sub(/%(\w+)%/, variable)
+            proceed_file(template, target, {singular => variable})
+          end
+        else
+          raise "Context #{self.context.inspect} doesn't have key #{singular} or #{plural}"
+        end
+      else
+        proceed_file(template, file)
+      end
+    end
+
+    def proceed_file(template, file, local_context = Hash.new)
+      SimpleTemplater.logger.debug("Local context: #{local_context.inspect}") unless local_context.empty?
+      FileUtils.mkdir_p(File.dirname(file))
+
+      if File.directory?(template)
+        FileUtils.rm_rf(file) # directory include its content
+        FileUtils.mkdir(file)
+      end
+
+      if template.end_with?(".rbt")
+        if File.exist?(file)
+          SimpleTemplater.logger.debug("[RETEMPLATE] #{file} (from #{template})")
+        else
+          SimpleTemplater.logger.debug("[TEMPLATE] #{file} (from #{template})")
+        end
+        File.open(file, "w") do |file|
+          eruby = Erubis::Eruby.new(File.read(template))
+          context = Erubis::Context.new(@context.merge(local_context))
+          context.extend(SimpleTemplater::Helpers)
+          begin
+            output = eruby.evaluate(context)
+          rescue Exception => exception
+            SimpleTemplater.logger.error("Exception occured in template #{template}: #{exception.message}")
+          end
+          file.print(output)
+        end
+      else # just copy
+        if File.directory?(file)
+          # do nothing
+          # it shouldn't get here never, we have File.directory? above
+        elsif File.file?(file)
+          SimpleTemplater.logger.debug("[RECOPY] #{file} (from #{template})")
+          FileUtils.cp_f(template, file)
+        else
+          SimpleTemplater.logger.debug("[COPY] #{file} (from #{template})")
+          FileUtils.cp(template, file)
+        end
+      end
+
+      copy_permissions template, file
+    end
+
+    def copy_permissions(template, file) # TODO: reimplement, this is crap
+      File.chmod(0755, file) if File.executable?(template)
+    end
+  end
+
+  class FlatBuilder < Builder
+    attr_reader :source, :target
+    def initialize(source, target, context = Hash.new)
+      @source, @target, @context = source, target, context
+      @content_dir = File.expand_path(File.join(source, ".."))
+    end
+
+    def create
+      proceed(self.source, self.target)
+    end
+  end
+end

data/vendor/simple-templater/lib/simple-templater/discoverer.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+class SimpleTemplater
+  class Discoverer
+    def self.detect
+      # TODO: coming in version 0.2
+      require "simple-templater/discoverers/gems"
+      SimpleTemplater::RubyGems
+    end
+
+    attr_reader :scope
+    def initialize(scope)
+      @scope = scope
+    end
+
+    def run
+      raise NotImplementedError
+    end
+  end
+end

data/vendor/simple-templater/lib/simple-templater/discoverers/gems.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+# Mostly stolen from Templater http://github.com/jnicklas/templater
+
+# This provides a hook system which programs that use Templater can use to discover generators
+# installed through gems. This requires two separate things, the Templater-using progrma will
+# have to call the #discover! method giving a scope, like this:
+#
+#     Templater::Discovery.discover!("name-of-scope")
+#
+# Where "name-of-scope" should be a string that uniquely identifies your program. Any gem wishing
+# to then add a generator, that is automatically picked up, will then need to add a simple-templater.scope
+# file at the root of the project (don't forget to add it to the gem's manifest of files).
+#
+#     - lib /
+#     - spec /
+#     - Rakefile
+#     - simple-templater.scope
+#
+# This file should look something like this:
+#
+#     SimpleTemplater.scope(:rango) do
+#       root = File.dirname(__FILE__)
+#       Dir["#{root}/stubs/*"].each do |stub_dir|
+#         if File.directory?(stub_dir)
+#           SimpleTemplater.register(:rango, stub_dir)
+#         end
+#       end
+#     end
+#
+# Multiple scopes can be added to the same simple-templater.scope file for use with different generator
+# programs.
+
+class SimpleTemplater
+  class RubyGems < Discoverer
+    # Searches installed gems for simple-templater.scope files and loads all code blocks in them that match
+    # the given scope.
+    #
+    # === Parameters
+    # scope<String>:: The name of the scope to search for
+    def run
+      generator_files.each { |file| load file }
+      if SimpleTemplater.scopes[self.scope]
+        SimpleTemplater.scopes[self.scope].each do |block|
+          begin
+            block.call
+          rescue Exception => exception
+            warn "[Scope #{self.scope}] Exception #{exception.class}: #{exception} occured in scope file #{block.inspect}\n#{exception.backtrace.join("\n")}"
+          end
+        end
+      end
+    end
+
+    def find_latest_gem_paths
+      require "rubygems" unless defined?(Gem)
+      # Minigems provides a simpler (and much faster) method for finding the
+      # latest gems.
+      if Gem.respond_to?(:latest_gem_paths)
+        Gem.latest_gem_paths
+      else
+        gems = Gem.cache.inject(Hash.new) do |latest_gems, cache|
+          name, gem = cache
+          currently_latest = latest_gems[gem.name]
+          latest_gems[gem.name] = gem if currently_latest.nil? or gem.version > currently_latest.version
+          latest_gems
+        end
+        gems.values.map { |gem| gem.full_gem_path }
+      end
+    end
+
+    def generator_files
+      find_latest_gem_paths.inject(Array.new) do |files, gem_path|
+        path = ::File.join(gem_path, "simple-templater.scope")
+        files << path if ::File.file?(path)
+        files
+      end
+    end
+  end
+end