eldarscrolls 0.7.0

data/features/support/common.rb

@@ -0,0 +1,51 @@
+module CommonHelpers
+  def get_command_output
+    strip_color_codes(File.read(@stdout)).chomp
+  end
+
+  def strip_color_codes(text)
+    text.gsub(/\e\[\d+m/, '')
+  end
+
+  def in_tmp_folder(&block)
+    FileUtils.chdir(@tmp_root, &block)
+  end
+
+  def in_project_folder(&block)
+    project_folder = @active_project_folder || @tmp_root
+    FileUtils.chdir(project_folder, &block)
+  end
+
+  def in_home_folder(&block)
+    FileUtils.chdir(@home_path, &block)
+  end
+
+  def force_local_lib_override(project_name = @project_name)
+    rakefile = File.read(File.join(project_name, 'Rakefile'))
+    File.open(File.join(project_name, 'Rakefile'), "w+") do |f|
+      f << "$:.unshift('#{@lib_path}')\n"
+      f << rakefile
+    end
+  end
+
+  def setup_active_project_folder project_name
+    @active_project_folder = File.join(@tmp_root, project_name)
+    @project_name = project_name
+  end
+
+  # capture both [stdout, stderr] as well as stdin
+  def capture_stdios(input = nil, &block)
+    require 'stringio'
+    org_stdin, $stdin = $stdin, StringIO.new(input) if input
+    org_stdout, $stdout = $stdout, StringIO.new
+    org_stderr, $stderr = $stdout, StringIO.new
+    yield
+    return [$stdout.string, $stderr.string]
+  ensure
+    $stderr = org_stderr
+    $stdout = org_stdout
+    $stdin = org_stdin
+  end
+end
+  
+World(CommonHelpers)

data/features/support/env.rb

@@ -0,0 +1,18 @@
+$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../../lib'))
+require 'bundler/setup'
+require 'eldarscrolls'
+
+path = ENV['PATH']
+
+Before do
+  @tmp_root      = File.dirname(__FILE__) + "/../../tmp"
+  @active_project_folder = @tmp_root
+  @home_path     = File.expand_path(File.join(@tmp_root, "home"))
+  @lib_path      = File.expand_path(File.dirname(__FILE__) + "/../../lib")
+  @fixtures_path = File.expand_path(File.dirname(__FILE__) + "/../../fixtures")
+  FileUtils.rm_rf   @tmp_root
+  FileUtils.mkdir_p @home_path
+  ENV['HOME'] = @home_path
+  fixture_bin_path = File.expand_path('../../../fixtures/bin', __FILE__)
+  ENV['PATH'] = fixture_bin_path + ":" + path
+end

data/lib/eldarscrolls.rb

@@ -0,0 +1,10 @@
+require 'eldarscrolls/scrolls'
+require 'eldarscrolls/scroll'
+require 'eldarscrolls/config'
+require 'eldarscrolls/template'
+
+Dir[File.dirname(__FILE__) + '/../scrolls/*.rb'].each do |path|
+  key = File.basename(path, '.rb')
+  scroll = EldarScrolls::Scroll.generate(key, File.open(path))
+  EldarScrolls::Scrolls.add(scroll)
+end

data/lib/eldarscrolls/command.rb

@@ -0,0 +1,85 @@
+require 'eldarscrolls'
+require 'thor'
+
+module EldarScrolls
+  class Command < Thor
+    include Thor::Actions
+    desc "new APP_NAME", "create a new Rails app"
+    method_option :scrolls, :type => :array, :aliases => "-s", :desc => "List scrolls, e.g. -s resque rails_basics jquery"
+    method_option :template, :type => :boolean, :aliases => "-t", :desc => "Only display template that would be used"
+    def new(name)
+      if options[:scrolls]
+        run_template(name, options[:scrolls], options[:template])
+      else
+        @scrolls = []
+
+        while scroll = ask("#{print_scrolls}#{bold}Which scroll would you like to add? #{clear}#{yellow}(blank to finish)#{clear}")
+          if scroll == ''
+            run_template(name, @scrolls)
+            break
+          elsif EldarScrolls::Scrolls.list.include?(scroll)
+            @scrolls << scroll
+            puts
+            puts "> #{green}Added '#{scroll}' to template.#{clear}"
+          else
+            puts
+            puts "> #{red}Invalid scroll, please try again.#{clear}"
+          end
+        end
+      end
+    end
+
+    desc "list [CATEGORY]", "list available scrolls (optionally by category)"
+    def list(category = nil)
+      if category
+        scrolls = EldarScrolls::Scrolls.for(category).map{|r| EldarScrolls::Scroll.from_mongo(r) }
+      else
+        scrolls = EldarScrolls::Scrolls.list_classes
+      end
+
+      scrolls.each do |scroll|
+        puts scroll.key.ljust(15) + "# #{scroll.description}"
+      end
+    end
+
+    no_tasks do
+      def cyan; "\033[36m" end
+      def clear; "\033[0m" end
+      def bold; "\033[1m" end
+      def red; "\033[31m" end
+      def green; "\033[32m" end
+      def yellow; "\033[33m" end
+
+      def print_scrolls
+        puts
+        puts
+        puts
+        if @scrolls && @scrolls.any?
+          puts "#{green}#{bold}Your Scrolls:#{clear} " + @scrolls.join(", ")
+          puts
+        end
+        puts "#{bold}#{cyan}Available Scrolls:#{clear} " + EldarScrolls::Scrolls.list.join(', ')
+        puts
+      end
+
+      def run_template(name, scrolls, display_only = false)
+        puts
+        puts
+        puts "#{bold}Generating and Running Template..."
+        puts
+        file = Tempfile.new('template')        
+        template = EldarScrolls::Template.new(scrolls)
+        file.write template.compile
+        file.close
+        if display_only
+          puts "Template stored to #{file.path}"
+          puts File.read(file.path)
+        else
+          system "rails new #{name} -m #{file.path} #{template.args.join(' ')}"
+        end
+      ensure
+        file.unlink
+      end
+    end
+  end
+end

data/lib/eldarscrolls/config.rb

@@ -0,0 +1,86 @@
+require 'active_support/ordered_hash'
+
+module EldarScrolls
+  class Config
+    attr_reader :questions
+
+    def initialize(schema)
+      @questions = ActiveSupport::OrderedHash.new
+      schema.each do |hash| 
+        key = hash.keys.first
+        details = hash.values.first
+
+        kind = details['type']
+        raise ArgumentError, "Unrecognized question type, must be one of #{QUESTION_TYPES.keys.join(', ')}" unless QUESTION_TYPES.keys.include?(kind)
+        @questions[key] = QUESTION_TYPES[kind].new(details)
+      end
+    end
+
+    def compile(values = {})
+      result = []
+      result << "config = #{values.inspect}"
+      @questions.each_pair do |key, question|
+        result << "config['#{key}'] = #{question.compile} unless config.key?('#{key}')"
+      end
+      result.join("\n")
+    end
+
+    class Prompt
+      attr_reader :prompt, :details
+      def initialize(details)
+        @details = details
+        @prompt = details['prompt']
+      end
+
+      def compile
+        "#{question} if #{conditions}"
+      end
+
+      def question
+        "ask_wizard(#{prompt.inspect})"
+      end
+
+      def conditions
+        [config_conditions, scroll_conditions].join(' && ')
+      end
+
+      def config_conditions
+        if details['if']
+          "config['#{details['if']}']"
+        elsif details['unless']
+          "!config['#{details['unless']}']"
+        else
+          'true'
+        end
+      end
+
+      def scroll_conditions
+        if details['if_scroll']
+          "scroll?('#{details['if_scroll']}')"
+        elsif details['unless_scroll']
+          "!scroll?('#{details['unless_scroll']}')"
+        else
+          'true'
+        end
+      end
+    end
+
+    class TrueFalse < Prompt
+      def question 
+        "yes_wizard?(#{prompt.inspect})"
+      end
+    end
+
+    class MultipleChoice < Prompt
+      def question
+        "multiple_choice(#{prompt.inspect}, #{@details['choices'].inspect})"
+      end 
+    end
+
+    QUESTION_TYPES = {
+      'boolean' => TrueFalse,
+      'string' => Prompt,
+      'multiple_choice' => MultipleChoice
+    }
+  end
+end

data/lib/eldarscrolls/scroll.rb

@@ -0,0 +1,106 @@
+require 'eldarscrolls/config'
+
+require 'active_support/inflector'
+require 'yaml'
+require 'erb'
+
+module EldarScrolls
+  class Scroll
+    extend Comparable
+    
+    def self.<=>(another)
+      return -1 if another.run_after.include?(self.key) || self.run_before.include?(another.key)
+      return 1 if another.run_before.include?(self.key) || self.run_after.include?(another.key)
+      self.key <=> another.key
+    end
+
+    ATTRIBUTES = %w(key args category name description template config exclusive tags run_before run_after requires website)
+    DEFAULT_ATTRIBUTES = {
+      :category => 'other',
+      :args => [],
+      :tags => [],
+      :run_after => [],
+      :run_before => [],
+      :requires => []
+    }
+
+    def self.generate(key, template_or_file, attributes = {})
+      if template_or_file.respond_to?(:read)
+        file = template_or_file.read
+        parts = file.split(/^__END__$/)
+        raise ArgumentError, "The scroll file must have YAML matter after an __END__" unless parts.size == 2
+        template = parts.first.strip
+        attributes = YAML.load(parts.last).inject({}) do |h,(k,v)|
+          h[k.to_sym] = v
+          h
+        end.merge!(attributes)
+      else
+        template = template_or_file
+      end
+ 
+      scroll_class = Class.new(EldarScrolls::Scroll) 
+      scroll_class.attributes = attributes
+      scroll_class.template = template
+      scroll_class.key = key
+
+      scroll_class
+    end
+
+    ATTRIBUTES.each do |setter|
+      class_eval <<-RUBY
+        def self.#{setter}
+          attributes[:#{setter}]
+        end
+
+        def self.#{setter}=(val)
+          attributes[:#{setter}] = val
+        end
+
+        def #{setter}
+          self.class.#{setter}
+        end
+      RUBY
+    end
+
+    # The attributes hash containing any set values for
+    def self.attributes
+      @attributes ||= DEFAULT_ATTRIBUTES.dup
+    end
+
+    def self.attributes=(hash)
+      attributes.merge! hash
+    end
+
+    def self.config
+      return nil unless attributes[:config]
+      EldarScrolls::Config.new(attributes[:config])
+    end
+
+    def attributes
+      self.class.attributes
+    end
+
+    def self.compile
+      "# >#{"[ #{name} ]".center(75,'-')}<\n\n# #{description}\nsay_scroll '#{name}'\n\n#{template}\n"
+    end
+    def compile; self.class.compile end
+
+    def self.to_mongo(value)
+      case value
+        when Class
+          value.key
+        when String
+          value
+      end
+    end
+
+    def self.from_mongo(key)
+      return key if key.respond_to?(:superclass) && key.superclass == EldarScrolls::Scroll
+      EldarScrolls::Scrolls[key]
+    end
+
+    def self.get_binding
+      binding
+    end
+  end
+end

data/lib/eldarscrolls/scrolls.rb

@@ -0,0 +1,38 @@
+module EldarScrolls
+  module Scrolls
+    @@categories = {}
+    @@list = {}
+    
+    def self.add(scroll)
+      EldarScrolls::Scrolls.const_set ActiveSupport::Inflector.camelize(scroll.key), scroll
+      @@list[scroll.key] = scroll
+      (@@categories[scroll.category.to_s] ||= []) << scroll.key
+      @@categories[scroll.category.to_s].uniq!
+      scroll
+    end
+
+    def self.[](key)
+      @@list[key.to_s]
+    end
+
+    def self.list
+      @@list.keys.sort
+    end
+
+    def self.list_classes
+      @@list.values.sort_by{|c| c.key}
+    end
+
+    def self.categories
+      @@categories.keys.sort
+    end
+
+    def self.for(category)
+      (@@categories[category.to_s] || []).sort
+    end
+
+    def self.remove_from_category(category, scroll)
+      (@@categories[category.to_s] ||= []).delete(scroll.key)
+    end
+  end
+end

data/lib/eldarscrolls/template.rb

@@ -0,0 +1,67 @@
+module EldarScrolls
+  class Template
+    attr_reader :scrolls, :unknown_scroll_names
+
+    def initialize(scrolls)
+      @unknown_scroll_names = []
+      @scrolls = scrolls.inject([]) do |list, name|
+        scroll = EldarScrolls::Scroll.from_mongo(name)
+        if scroll
+          list << scroll
+        else
+          @unknown_scroll_names << name
+          $stderr.puts "Unknown scroll '#{name}'. Skipping."
+        end
+        list
+      end
+    end
+
+    def self.template_root
+      File.dirname(__FILE__) + '/../../templates'
+    end
+
+    def self.render(template_name, binding = nil)
+      erb = ERB.new(File.open(template_root + '/' + template_name + '.erb').read)
+      erb.result(binding)
+    end
+    def render(template_name, binding = nil); self.class.render(template_name, binding) end
+
+
+    def resolve_scrolls
+      @resolve_scrolls ||= scrolls_with_dependencies.sort
+    end
+
+    def scroll_classes
+      @scroll_classes ||= scrolls.map { |name| EldarScrolls::Scroll.from_mongo(name) }
+    end
+
+    def scrolls_with_dependencies
+      @scrolls_with_dependencies ||= scroll_classes
+      
+      added_more = false
+      for scroll in scroll_classes
+        scroll.requires.each do |requirement|
+          requirement = EldarScrolls::Scroll.from_mongo(requirement)
+          count = @scrolls_with_dependencies.size
+          (@scrolls_with_dependencies << requirement).uniq!
+          unless @scrolls_with_dependencies.size == count
+            added_more = true
+          end
+        end
+      end
+
+      added_more ? scrolls_with_dependencies : @scrolls_with_dependencies
+    end
+
+    def compile
+      render 'layout', binding
+    end
+
+    def args
+      scrolls.map(&:args).uniq
+    end
+
+    def custom_code?; false end
+    def custom_code; nil end
+  end
+end