stevenson 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a01532f19f37e0bbd43a680127d4471c9988edae
-  data.tar.gz: 0c6ccedfe334238758c7c9e1146fb93e85212350
+  metadata.gz: d4bbb1c5387f8971d634dbab92d275947b481e6a
+  data.tar.gz: 8944fee22ba3f747259246c6512c9b13860a6b2f
 SHA512:
-  metadata.gz: 774610b2e82f5e08bb134b231b664084f91e52b48ef4e2ecadd05f5fc71caf02da37610edfc3745cc9b719dd8ff3ff2fb3bfedd9281d741213fd03563f5cf5d8
-  data.tar.gz: 4d0bdf722f9ff79cb00d9592cd9610976a0415efdc993e4b47f143260cd76439d8da7c337349f330916579cec6ff79d66e2087b1cb7ef875ddc90e3e8662d8b4
+  metadata.gz: a06819996cd37937b72e2d6e000336a867af6723402b41e353654c913a739b8cc9f87bad2e25a27cdb0d051e65e2593cbd87f1d14c38251d8d7c37f3b7734029
+  data.tar.gz: a91025832a88cf33489e40a6360c6ee78c6c1f91b70f392f88564966b6e9ad1fd6491df3ece4827b555a5257e6ad80b6a4b13384b7ff859d3b127008088300c4

data/.travis.yml

@@ -1,3 +1,5 @@
 language: ruby
+cache: bundler
+sudo: false
 rvm:
   - 2.1.2

data/assets/stevenson_dotfile.yml

@@ -0,0 +1,29 @@
+template_aliases:
+  hyde-base:
+    name: https://github.com/RootsRated/hyde.git
+    options:
+      subdirectory: base
+  templatedco-exmachina:
+    name: https://github.com/RootsRated/hyde.git
+    options:
+      subdirectory: exmachina
+  templatedco-horizons:
+    name: https://github.com/RootsRated/hyde.git
+    options:
+      subdirectory: horizons
+  templatedco-ion:
+    name: https://github.com/RootsRated/hyde.git
+    options:
+      subdirectory: ion
+  templatedco-linear:
+    name: https://github.com/RootsRated/hyde.git
+    options:
+      subdirectory: linear
+  templatedco-phaseshift:
+    name: https://github.com/RootsRated/hyde.git
+    options:
+      subdirectory: phaseshift
+  templatedco-solarize:
+    name: https://github.com/RootsRated/hyde.git
+    options:
+      subdirectory: solarize

data/lib/stevenson/application.rb

@@ -2,52 +2,57 @@ require 'thor'
 
 module Stevenson
   class Application < Thor
-    desc 'stevenson new PROJECT_NAME', 'generates a Jekyll at PROJECT_NAME'
+    desc 'new PROJECT_NAME CONFIG_PATH', 'generates a Jekyll at PROJECT_NAME with a config file at CONFIG_PATH'
 
+    method_option :template,
+                  aliases: '-t',
+                  default: 'hyde-base',
+                  desc: 'The template to use'
+
+    # Template Options
     method_option :branch,
                   aliases: '-b',
                   desc: 'The git branch you would like to use from your template'
-    method_option :jekyll,
-                  type: :boolean,
-                  aliases: '-j',
-                  desc: 'Jekyll compiles the output directory'
     method_option :subdirectory,
                   aliases: '-s',
                   desc: 'The subdirectory to use from the template, if any'
-    method_option :template,
-                  aliases: '-t',
-                  default: 'hyde-base',
-                  desc: 'The template repository to use'
+
+    # Data Options
+    method_option :data,
+                  aliases: "-d",
+                  desc: 'The path to related data yml files'
+
+    # Output Options
+    method_option :output,
+                  type: :array,
+                  aliases: "-o",
+                  desc: 'Array of output filters to be applied in order'
     method_option :zip,
                   type: :boolean,
                   aliases: "-z",
                   desc: 'Zip compresses the output directory'
 
-    def new(output_directory)
+    def new(output_directory, config_path)
       # Load the template using the template loader
-      template = Stevenson::TemplateLoader.load options[:template]
-
-      # If a branch is provided, switch to that branch
-      template.switch_branch options[:branch] if options[:branch]
-
-      # If a subdirectory is provided, switch to that directory
-      template.select_subdirectory options[:subdirectory] if options[:subdirectory]
+      template = Stevenson::Template.load(options[:template], options)
 
-      # Configure the template
-      configurator = Stevenson::Configurator::YAMLConfigurator.new template.path
-      configurator.configure
+      # Place yml files
+      template.place_config(config_path)
+      template.place_files(options[:data], '_data') if options[:data]
 
-      # If the jekyll flag is set, compile the template output
-      template.extend(Stevenson::OutputFilters::JekyllFilter) if options[:jekyll]
+      # Run output filters, in order, against the template
+      puts Stevenson::OutputFilter.generate!(template, options)
 
-      # If the zip flag is set, zip up the template output
-      template.extend(Stevenson::OutputFilters::ZipFilter) if options[:zip]
-
-      # Save the repo to the output directory
-      template.output output_directory
-
-    rescue Templates::InvalidTemplateException => e
+    rescue StandardError => e
       say e.message
+    ensure
+      template.close
+    end
+
+    desc 'generate_dotfile', 'Generates a Stevenson configuration dotfile'
+    def generate_dotfile
+      Dotfile.install
+      puts "Generated dotfile at #{Dotfile.path}"
     end
   end
 end

data/lib/stevenson/dotfile.rb

@@ -0,0 +1,26 @@
+require 'delegate'
+require 'hashie/mash'
+require 'yaml'
+
+module Stevenson
+  class Dotfile < SimpleDelegator
+
+    TEMPLATE_PATH = File.join(File.dirname(__FILE__), '..', '..', 'assets', 'stevenson_dotfile.yml')
+    DOTFILE_PATH = File.join(Dir.home, ".stevenson")
+
+    class << self
+      def install
+        FileUtils.copy TEMPLATE_PATH, DOTFILE_PATH
+      end
+
+      def path
+        DOTFILE_PATH
+      end
+    end
+
+    def initialize
+      dotfile_path = File.exist?(self.class.path) ? self.class.path : TEMPLATE_PATH
+      super Hashie::Mash.new YAML.load_file(dotfile_path)
+    end
+  end
+end

data/lib/stevenson/output_filter/generator.rb

@@ -0,0 +1,30 @@
+module Stevenson
+  module OutputFilter
+    class Generator
+      attr_reader :options
+
+      def initialize(options)
+        @options = options
+      end
+
+      def generate!(template)
+        filters.inject(template.local_directory) do |rendered, filter|
+          OutputFilter.filter_for(filter).new(rendered).output
+        end
+      end
+
+      private
+
+      def filters
+        @_filters ||= begin
+          filters = [:jekyll]
+          filters.concat options[:output] if options[:output]
+          filters << :zip if options[:zip]
+          filters.uniq
+        end
+      end
+
+    end
+
+  end
+end

data/lib/stevenson/output_filter.rb

@@ -0,0 +1,42 @@
+module Stevenson
+  module OutputFilter
+    autoload :Jekyll, 'stevenson/output_filters/jekyll'
+    autoload :Zip, 'stevenson/output_filters/zip'
+
+    autoload :Generator, 'stevenson/output_filter/generator'
+
+    class Base
+      attr_reader :directory
+
+      def self.included(filter)
+        filter.extend ClassMethods
+
+        Stevenson.output_filters[filter.filter_name] = filter
+      end
+
+      module ClassMethods
+        def filter_name
+          name.gsub(/^.*::/, '').downcase.to_sym
+        end
+      end
+
+      def initialize(directory)
+        @directory = directory
+      end
+
+      def output
+        raise NotImplementedError
+      end
+    end
+
+    def self.generate!(template, options)
+      Generator.new(options).generate!(template)
+    end
+
+    def self.filter_for(type)
+      Stevenson.output_filters[type] || const_get(type.to_s.capitalize)
+    rescue NameError => e
+      raise NameError.new "Type '#{type}' is not a valid output type.", e
+    end
+  end
+end

data/lib/stevenson/output_filters/jekyll.rb

@@ -1,21 +1,14 @@
 module Stevenson
-  module OutputFilters
-    module JekyllFilter
-      def output(directory)
+  module OutputFilter
+    class Jekyll < Base
+
+      def output
         # Jekyll Build the Directory
-        Dir.chdir(path) do
+        Dir.chdir(directory) do
           `jekyll b`
         end
 
-        # Replace the repository with the compiled directory
-        Dir.mktmpdir do |dir|
-          FileUtils.cp_r File.join(path, '_site', '.'), dir
-          FileUtils.rm_r path
-          FileUtils.cp_r dir, path
-        end
-
-        # Call the parent method
-        super directory
+        File.join(directory, '_site', '.')
       end
     end
   end

data/lib/stevenson/output_filters/zip.rb

@@ -1,15 +1,13 @@
 require 'zip'
 
 module Stevenson
-  module OutputFilters
-    module ZipFilter
-      def output(directory)
-        Dir.mktmpdir do |dir|
-          # Call the parent method
-          super dir
-  
+  module OutputFilter
+    class Zip < Base
+
+      def output
+        "#{directory}.zip".tap do |dir|
           # Zip up the output directory
-          write dir, directory
+          write directory, dir
         end
       end
 
@@ -22,24 +20,24 @@ module Stevenson
         entries = Dir.entries(@inputDir)
         entries.delete(".")
         entries.delete("..")
-        io = Zip::File.open(@outputFile, Zip::File::CREATE)
+        io = ::Zip::File.open(@outputFile, ::Zip::File::CREATE)
 
         writeEntries(entries, "", io)
         io.close()
       end
 
       def writeEntries(entries, path, io)
-        entries.each { |e|
-          zipFilePath = path == "" ? e : File.join(path, e)
+        entries.each do |entry|
+          zipFilePath = path == "" ? entry : File.join(path, entry)
           diskFilePath = File.join(@inputDir, zipFilePath)
           if File.directory?(diskFilePath)
             io.mkdir(zipFilePath)
-            subdir =Dir.entries(diskFilePath); subdir.delete("."); subdir.delete("..")
+            subdir = Dir.entries(diskFilePath); subdir.delete("."); subdir.delete("..")
             writeEntries(subdir, zipFilePath, io)
           else
-            io.get_output_stream(zipFilePath) { |f| f.puts(File.open(diskFilePath, "rb").read())}
+            io.get_output_stream(zipFilePath) { |f| f.puts(File.open(diskFilePath, "rb").read()) }
           end
-        }
+        end
       end
     end
   end

data/lib/stevenson/template/loader.rb

@@ -0,0 +1,36 @@
+module Stevenson
+  module Template
+    class Loader
+      attr_reader :template_name, :options
+
+      def initialize(template_name, options)
+        @template_name, @options = template_name, options
+      end
+
+      def template
+        return Template.load(matching_alias.name, matching_alias.options) if matching_alias?
+
+        template_klass.new template_name, options
+      end
+
+      def template_klass
+        case template_name
+        when /^.*\.git$/
+          Template::Git
+        else
+          Template::Local
+        end
+      end
+
+      private
+
+      def matching_alias
+        Stevenson.dotfile.template_aliases.fetch(template_name, nil)
+      end
+
+      def matching_alias?
+        !!matching_alias
+      end
+    end
+  end
+end

data/lib/stevenson/template.rb

@@ -0,0 +1,35 @@
+module Stevenson
+  module Template
+    autoload :Git, 'stevenson/templates/git'
+    autoload :Local, 'stevenson/templates/local'
+
+    autoload :Loader, 'stevenson/template/loader'
+
+    def self.load(template, options)
+      Loader.new(template, options).template
+    end
+
+    class Base
+      attr_reader :name, :options
+
+      def initialize(name, options = {})
+        @name, @options = name, options
+      end
+
+      def place_config(config_file)
+        place_files(config_file, 'config.yml')
+      end
+
+      def place_files(files, directory)
+        action = File.directory?(files) ? :cp_r : :cp
+        FileUtils.send(action, files, File.join(local_directory, directory))
+      end
+
+      def close
+        FileUtils.rm_rf local_directory if local_directory
+      end
+    end
+
+    class InvalidTemplateException < StandardError; end
+  end
+end

data/lib/stevenson/templates/git.rb

@@ -1,26 +1,25 @@
 require 'git'
-require 'stevenson/templates/base'
 
 module Stevenson
-  module Templates
-    class GitTemplate < Base
-      def initialize(template_url)
-        # Create a temporary directory to clone the repo at
-        Dir.mktmpdir do |dir|
-          # Clone the repo to a temporary directory for later use
-          Git.clone template_url, File.join(dir, 'repo')
+  module Template
+    class Git < Base
+      attr_reader :template_url, :options
 
-          # Call the super, thereby assigning the @path
-          super File.join(dir, 'repo')
-        end
-      rescue Git::GitExecuteError => e
-        # If the given URL is not valid, raise an exception and cleanup
-        raise InvalidTemplateException.new('Failed to clone the repository')
+      def initialize(template_url, options)
+        @template_url, @options = template_url, options
       end
 
-      def switch_branch(branch)
-        repo = Git::Base.open(path)
-        repo.checkout(branch)
+      def local_directory
+        @_local_directory ||= Dir.mktmpdir.tap do |dir|
+          # Clone the repo to a temporary directory for later use
+          ::Git.clone(template_url, dir).tap do |repo|
+            # Switch_branch if set
+            repo.checkout(options[:branch]) if options.has_key?(:branch)
+          end
+        end
+      rescue ::Git::GitExecuteError
+        # If the given repo URL is not valid, raise an exception
+        raise InvalidTemplateException.new('Failed to clone the repository')
       end
     end
   end

data/lib/stevenson/templates/local.rb

@@ -0,0 +1,21 @@
+module Stevenson
+  module Template
+    class Local < Base
+      attr_reader :template_path, :options
+
+      def initialize(template_path, options)
+        @template_path, @options = template_path, options
+      end
+
+      def local_directory
+        raise InvalidTemplateException.new('The given path is not a directory') unless File.directory?(template_path)
+
+        @_local_directory ||= Dir.mktmpdir.tap do |dir|
+          directories = [template_path, options[:subdirectory], '.'].compact
+
+          FileUtils.cp_r File.join(*directories), dir
+        end
+      end
+    end
+  end
+end

data/lib/stevenson/version.rb

@@ -1,3 +1,3 @@
 module Stevenson
-  VERSION = "1.0.1"
+  VERSION = "2.0.0"
 end

data/lib/stevenson.rb

@@ -1,14 +1,16 @@
-require 'stevenson/configurators/yaml_configurator'
-require 'stevenson/output_filters/jekyll'
-require 'stevenson/output_filters/zip'
-require 'stevenson/template_loader'
 require 'stevenson/version'
 
 module Stevenson
   autoload :Application, 'stevenson/application'
-  autoload :Input, 'stevenson/input'
+  autoload :Dotfile, 'stevenson/dotfile'
+  autoload :Template, 'stevenson/template'
+  autoload :OutputFilter, 'stevenson/output_filter'
 
-  def self.inputs
-    @_inputs ||= {}
+  def self.dotfile
+    @_dotfile ||= Dotfile.new
+  end
+
+  def self.output_filters
+    @_output_filters ||= {}
   end
 end

data/spec/lib/output_filter/generator_spec.rb

@@ -0,0 +1,37 @@
+describe Stevenson::OutputFilter::Generator do
+  let(:options) { Hash.new }
+  subject { described_class.new(options) }
+
+  describe "#generate!(template)" do
+    let(:template) { double(:template, local_directory: '/tmp/path/to/template') }
+    let(:jekyll_output) { double(:jekyll_output) }
+    let(:zip_output) { double(:zip_output) }
+    before do
+      allow_any_instance_of(Stevenson::OutputFilter::Jekyll).to receive(:output).and_return(jekyll_output)
+    end
+
+    it "should create a new filter for the jekyll filter's output" do
+      expect(Stevenson::OutputFilter::Jekyll).to receive(:new).with(template.local_directory).and_call_original
+      subject.generate!(template)
+    end
+
+    it "should return the filter's output result" do
+      expect(subject.generate!(template)).to eq jekyll_output
+    end
+
+    context "when more than one filter exists" do
+      let(:options) { { zip: true } }
+      let(:zip_filter) { double(:zip_filter, output: zip_output) }
+
+      it "should build subsequent filters with the previous' output" do
+        expect(Stevenson::OutputFilter::Zip).to receive(:new).with(jekyll_output).and_return(zip_filter)
+        subject.generate!(template)
+      end
+
+      it "should return the subsequent filter's output" do
+        allow(Stevenson::OutputFilter::Zip).to receive(:new).with(jekyll_output).and_return(zip_filter)
+        expect(subject.generate!(template)).to eq zip_output
+      end
+    end
+  end
+end

data/spec/lib/output_filter_spec.rb

@@ -0,0 +1,57 @@
+module Stevenson::OutputFilter
+  class Test < Base
+  end
+end
+
+describe Stevenson::OutputFilter do
+  let(:filter) { Stevenson::OutputFilter::Test }
+
+  describe ".generate!(template, options)" do
+    let(:template) { double(:template) }
+    let(:options) { Hash.new }
+    let(:output) { double(:output) }
+    let(:generator) { double(:generator, generate!: output) }
+    subject { described_class.generate!(template, options) }
+
+    it "should call Generator.new with options" do
+      expect(Stevenson::OutputFilter::Generator).to receive(:new).with(options).and_return(generator)
+      subject
+    end
+
+    it "should call generator's generate! with template" do
+      allow(Stevenson::OutputFilter::Generator).to receive(:new).and_return(generator)
+      expect(generator).to receive(:generate!).with(template)
+      subject
+    end
+
+    it "should return generate!er's output response" do
+      allow(Stevenson::OutputFilter::Generator).to receive(:new).and_return(generator)
+      expect(subject).to eq output
+    end
+  end
+
+  describe ".filter_for()" do
+    context "when the filter has been registered previously" do
+      it "should return the filter class from Stevenson.output_filters" do
+        expect(Stevenson::OutputFilter.filter_for(:test)).to eq(filter)
+      end
+    end
+
+    context "when the filter has not been registered previously" do
+      it "should return the filter class from Stevenson.output_filters" do
+        allow(Stevenson).to receive(:output_filters).and_return({})
+        expect(Stevenson::OutputFilter.filter_for(:test)).to eq(filter)
+      end
+    end
+
+    context "when the filter doesn't exist" do
+      it "should raise a NameError with a descriptive error message" do
+        expect { Stevenson::OutputFilter.filter_for(:bad_filter) }.to raise_error do |error|
+          expect(error).to be_a(NameError)
+          expect(error.message).to eq("Type 'bad_filter' is not a valid output type.")
+          expect(error.cause).to be_a(NameError)
+        end
+      end
+    end
+  end
+end

data/spec/lib/output_filters/jekyll_spec.rb

@@ -0,0 +1,23 @@
+describe Stevenson::OutputFilter::Jekyll do
+  let(:temporary_directory) { '/tmp/directory' }
+  let(:template) { double(:template, local_directory: temporary_directory) }
+  subject { described_class.new(template.local_directory) }
+
+  describe '#output' do
+    it "should change into the template's directory" do
+      expect(Dir).to receive(:chdir).with(temporary_directory)
+      subject.output
+    end
+
+    it "should build jekyll" do
+      allow(Dir).to receive(:chdir).with(temporary_directory).and_yield
+      expect(subject).to receive(:`).with("jekyll b")
+      subject.output
+    end
+
+    it 'outputs a jekyll compiled directory' do
+      allow(Dir).to receive(:chdir).with(temporary_directory)
+      expect(subject.output).to eq File.join(temporary_directory, '_site', '.')
+    end
+  end
+end

data/spec/lib/output_filters/zip_spec.rb

@@ -0,0 +1,19 @@
+describe Stevenson::OutputFilter::Zip do
+  let(:temporary_directory) { '/tmp/directory' }
+  let(:template) { double(:template, local_directory: temporary_directory) }
+  subject { described_class.new(template.local_directory) }
+
+  describe '#output' do
+    let(:output_zip) { "#{temporary_directory}.zip" }
+
+    it "should zip the files in temporary_directory to the zip" do
+      expect(subject).to receive(:write).with(temporary_directory, output_zip).and_return(true)
+      subject.output
+    end
+
+    it "should return the temporary_directory with '.zip' appended" do
+      allow(subject).to receive(:write).and_return(true)
+      expect(subject.output).to eq output_zip
+    end
+  end
+end

data/spec/lib/template/loader_spec.rb

@@ -0,0 +1,35 @@
+describe Stevenson::Template::Loader do
+  let(:template_name) { 'template' }
+  let(:options) { Hash.new }
+  subject { described_class.new(template_name, options) }
+
+  describe "#template" do
+    context "when 'template_name' matches an alias" do
+      let(:aliased_template) do
+        double(:aliased_template, name: 'template_path', options: {})
+      end
+      let(:dotfile) do
+        double(:dotfile, template_aliases: { template_name => aliased_template })
+      end
+
+      before { allow(Stevenson).to receive(:dotfile).and_return(dotfile) }
+
+      it "should call Loader on Template with the name" do
+        expect(Stevenson::Template).to receive(:load).with(aliased_template.name, aliased_template.options)
+        subject.template
+      end
+    end
+
+    context "when 'template' matches a git repo" do
+      let(:template_name) { 'http://www.github.com/Org/repo.git' }
+
+      it "should return a Git template" do
+        expect(subject.template).to be_a Stevenson::Template::Git
+      end
+    end
+
+    it "should return a Local template " do
+      expect(subject.template).to be_a Stevenson::Template::Local
+    end
+  end
+end