rango 0.1.pre → 0.1.0

data/vendor/simple-templater/Rakefile

@@ -1,61 +0,0 @@
-#!/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

@@ -1,15 +0,0 @@
-=== 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

@@ -1,66 +0,0 @@
-#!/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

@@ -1,7 +0,0 @@
-#!/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

@@ -1,97 +0,0 @@
-#!/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

@@ -1,27 +0,0 @@
-# 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

@@ -1,134 +0,0 @@
-# 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

@@ -1,20 +0,0 @@
-# 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

@@ -1,79 +0,0 @@
-# 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