roger 1.1.3 → 1.2.1

data/lib/roger/cli/test.rb

@@ -1,16 +1,17 @@
 module Roger
+  # The test command and all it's children
   class Cli::Test < Thor
     def self.exit_on_failure?
       true
     end
 
-    default_task :all    
+    default_task :all
 
     desc "all", "Run all tests defined in Mockupfile. (this is the default action)"
     def all
-      unless Cli::Base.project.test.run!
-        raise Thor::Error, "Test failed"
-      end
+      # If we use fail here the test breaks; no idea why
+      # rubocop:disable Style/SignalException:
+      raise(Thor::Error, "Test failed") unless Cli::Base.project.test.run!
     end
   end
-end
+end

data/lib/roger/extractor.rb

@@ -1,84 +1,84 @@
-require 'hpricot'
-require File.dirname(__FILE__) + '/resolver'
+require "hpricot"
+require File.dirname(__FILE__) + "/resolver"
 
 module Roger
-  
-  # @deprecated Don't use the extractor anymore, use release.use(:mockup, options) processor and release.use(:url_relativizer, options) processor
+  # @deprecated Don't use the extractor anymore, use release.use(:mockup, options) processor and
+  # release.use(:url_relativizer, options) processor
   class Extractor
-    
     attr_reader :project, :target_path
-    
-    
+
     # @param [Project] project Project object
     # @param [String,Pathname] target_path Path to extract to
     # @param [Hash] options Options hash
-    
+
     # @option options [Array] :url_attributes The element attributes to parse and relativize
     # @option options [Array] :url_relativize Wether or not we should relativize
     # @option options [Array] :env ENV variable to pass to template renderer.
-    def initialize(project, target_path, options={})
+    def initialize(project, target_path, options = {})
       @project = project
       @target_path = Pathname.new(target_path)
       @resolver = Resolver.new(self.target_path)
-      
-      
+
       @options = {
-        :url_attributes => %w{src href action},
-        :url_relativize => true,
-        :env => {}
+        url_attributes: %w(src href action),
+        url_relativize: true,
+        env: {}
       }
-      
+
       @options.update(options) if options
-      
+
       @options[:env].update("MOCKUP_PROJECT" => project)
     end
-    
+
     def run!
       target_path = self.target_path
-      source_path = self.project.html_path
-      
-      
+      source_path = project.html_path
+
       filter = "**/*.html"
-      raise ArgumentError, "Target #{target_path} already exists, please choose a new directory to extract into" if target_path.exist?
-      
+      fail(
+        ArgumentError,
+        "Target #{target_path} already exists, please choose a new directory to extract into"
+      ) if target_path.exist?
+
       mkdir_p(target_path)
       target_path = target_path.realpath
-      
+
       # Copy source to target first, we'll overwrite the templates later on.
       cp_r(source_path.children, target_path)
-      
+
       Dir.chdir(source_path) do
         Dir.glob(filter).each do |file_path|
           self.run_on_file!(file_path, @options[:env])
         end
-      end           
+      end
     end
-    
+
     def run_on_file!(file_path, env = {})
-      source = self.extract_source_from_file(file_path, env)
-      File.open(target_path + file_path,"w"){|f| f.write(source) }
+      source = extract_source_from_file(file_path, env)
+      File.open(target_path + file_path, "w") { |f| f.write(source) }
     end
-    
+
     # Runs the extractor on a single file and return processed source.
     def extract_source_from_file(file_path, env = {})
-      source = Roger::Template.open(file_path, :partials_path => self.project.partial_path, :layouts_path => self.project.layouts_path).render(env.dup)
+      source = Roger::Template.open(
+        file_path,
+        partials_path: project.partial_path,
+        layouts_path: project.layouts_path
+      ).render(env.dup)
+
+      source = relativize_urls(source, file_path) if @options[:url_relativize]
 
-      if @options[:url_relativize]
-        source = relativize_urls(source, file_path)
-      end
-      
       source
     end
-    
-    
+
     protected
-    
+
     def relativize_urls(source, file_path)
       doc = Hpricot(source)
       @options[:url_attributes].each do |attribute|
-        (doc/"*[@#{attribute}]").each do |tag|
+        (doc / "*[@#{attribute}]").each do |tag|
           converted_url = @resolver.url_to_relative_url(tag[attribute], file_path)
-              
+
           case converted_url
           when String
             tag[attribute] = converted_url
@@ -87,9 +87,8 @@ module Roger
           end
         end
       end
-      
-      doc.to_original_html      
+
+      doc.to_original_html
     end
-            
   end
-end
+end

data/lib/roger/generators.rb

@@ -1,35 +1,43 @@
-require 'thor'
-require 'thor/group'
+require "thor"
+require "thor/group"
 
 module Roger
+  # Generators namespace
   module Generators
-
+    # Base Generator class
     class Base < Cli::Command
     end
 
-    def self.register(name, sub = nil)
-      # Hack to not break old tasks
-      if name.kind_of?(Class)
-        sub = name
-        name = sub.to_s.sub(/Generator$/, "").sub(/^.*Generators::/,"").downcase
-      else
-        raise ArgumentError, "Name must be a symbol" unless name.kind_of?(Symbol)
-      end
-
-      name = name.to_s
+    def self.register(name, klass = nil)
+      name, klass = generator_name(name, klass)
 
-      raise ArgumentError, "Another generator has already claimed the name #{name.inspect}" if Cli::Generate.tasks.has_key?(name)
+      fail(
+        ArgumentError,
+        "Generator name '#{name.inspect}' already in use"
+      ) if Cli::Generate.tasks.key?(name)
 
-      usage = "#{name} #{sub.arguments.map{ |arg| arg.banner }.join(" ")}"
-      long_desc =  sub.desc || "Run #{name} generator"
+      usage = "#{name} #{klass.arguments.map(&:banner).join(' ')}"
+      long_desc =  klass.desc || "Run #{name} generator"
 
-      Cli::Generate.register sub, name, usage, long_desc
-      Cli::Generate.tasks[name].options = sub.class_options if sub.class_options
+      Cli::Generate.register klass, name, usage, long_desc
+      Cli::Generate.tasks[name].options = klass.class_options if klass.class_options
     end
 
+    def self.generator_name(name, klass)
+      # Hack to not break old tasks
+
+      if name.is_a?(Class)
+        klass = name
+        name = klass.to_s.sub(/Generator$/, "").sub(/^.*Generators::/, "").downcase
+      else
+        fail ArgumentError, "Name must be a symbol" unless name.is_a?(Symbol)
+      end
+
+      [name.to_s, klass]
+    end
   end
 end
 
 # Default generators
 require File.dirname(__FILE__) + "/generators/new"
-require File.dirname(__FILE__) + "/generators/generator"
+require File.dirname(__FILE__) + "/generators/generator"

data/lib/roger/generators/generator.rb

@@ -1,23 +1,20 @@
+# The generator generator!
 class Roger::Generators::GeneratorGenerator < Roger::Generators::Base
-  
   include Thor::Actions
-  
+
   desc "Create your own generator for roger"
-  argument :name, :type => :string, :required => true, :desc => "Name of the new generator"
-  argument :path, :type => :string, :required => true, :desc => "Path to generate the new generator"
-  # class_option :template, :type => :string, :aliases => ["-t"], :desc => "Template to use, can be a path or a git repository remote, uses built in minimal as default"
-  
+  argument :name, type: :string, required: true, desc: "Name of the new generator"
+  argument :path, type: :string, required: true, desc: "Path to generate the new generator"
+
   def self.source_root
     File.dirname(__FILE__)
   end
 
   def create_lib_file
     destination = "#{path}/#{name}_generator.rb"
-    template('templates/generator.tt', destination)
+    template("templates/generator.tt", destination)
     say "Add `require #{destination}` to your mockup file and run mockup generate #{name}."
   end
-
-  
 end
 
-Roger::Generators.register Roger::Generators::GeneratorGenerator
+Roger::Generators.register Roger::Generators::GeneratorGenerator

data/lib/roger/generators/new.rb

@@ -1,67 +1,82 @@
-require 'shellwords'
+require "shellwords"
 
+# Generator to create a new HTML mockup based on an existing skeleton
 class Roger::Generators::NewGenerator < Thor::Group
-  
   include Thor::Actions
-  
+
   desc "Create a new HTML mockup based on an existing skeleton"
-  argument :path, :type => :string, :required => true, :desc => "Path to generate mockup into"
-  class_option :template, :type => :string, :aliases => ["-t"], :desc => "Template to use, can be a path or a git repository remote, uses built in minimal as default"
-  
+
+  argument :path, type: :string, required: true, desc: "Path to generate mockup into"
+
+  class_option(
+    :template,
+    type: :string,
+    aliases: ["-t"],
+    desc: "Template to use, can be a path or a git remote, uses built in minimal as default"
+  )
+
   attr_reader :source_paths
-  
-  def setup_variables    
+
+  def setup_variables
     self.destination_root = path
-    
+
     @source_paths = []
-    
+
     # Stuff to rm -rf later
     @cleanup = []
   end
-  
+
   def validate_path_is_empty
-    if File.directory?(self.destination_root)
-      say "Directory #{self.destination_root} already exists, please only use this to create new mockups"
-      exit(1)
-    end
+    return unless File.directory?(destination_root)
+
+    say "Directory #{destination_root} already exists, please only use this to create new mockups"
+    exit(1)
   end
-  
+
   def validate_template_path
-    if options[:template]
-      template = options[:template]
-    else
-      template = File.dirname(__FILE__) + "/../../../examples/default_template"
-    end
-    
+    template = options[:template] || File.dirname(__FILE__) + "/../../../examples/default_template"
+
     if File.exist?(template)
       say "Taking template from #{template}"
       @source_paths << template
     else
-      # Hack to create temp directory
-      t = Tempfile.new("htmlmockup-generate-new")
-      tmp_dir = Pathname.new(t.path)
-      t.close
-      t.unlink
-      
-      if run("git clone --depth=1 #{Shellwords.escape(template)} #{tmp_dir}")
-        say "Cloned template from #{template}"
-        run("rm -rf #{tmp_dir + ".git"}")
-        @source_paths << tmp_dir.to_s
-        @cleanup << tmp_dir.to_s
-      else
-        say "Template path #{template} doesn't seem to be a git remote or a local path"
-        exit(1)
-      end
+      say "Getting template from git remote #{template}"
+      @source_paths << git_clone_template(template)
     end
-  rescue Exception => e
+  rescue StandardError => e
     puts e
     puts e.backtrace.join("\n")
   end
-  
+
   def create_mockup
     directory(".", ".")
   end
-  
+
+  protected
+
+  def git_clone_template(template)
+    tmp_dir = temp_directory
+
+    if run("git clone --depth=1 #{Shellwords.escape(template)} #{tmp_dir}")
+      say "Cloned template from #{template}"
+      run("rm -rf #{tmp_dir + '.git'}")
+      @cleanup << tmp_dir.to_s
+    else
+      say "Template path #{template} doesn't seem to be a git remote or a local path"
+      exit(1)
+    end
+
+    tmp_dir
+  end
+
+  def temp_directory
+    # Hack to create temp directory
+    t = Tempfile.new("htmlmockup-generate-new")
+    tmp_dir = Pathname.new(t.path)
+    t.close
+    t.unlink
+    tmp_dir
+  end
 end
 
-Roger::Generators.register Roger::Generators::NewGenerator
+Roger::Generators.register Roger::Generators::NewGenerator

data/lib/roger/generators/templates/generator.tt

@@ -1,13 +1,13 @@
+# The <%= name.capitalize %> generator
 class <%= name.capitalize %>Generator < Roger::Generators::Base
-  
   include Thor::Actions
-  
+
   desc "<%= name.capitalize %> generator helps you doing ... and ..."
-  argument :path, :type => :string, :required => true, :desc => "Path to generate the new generator"
-  
+  argument :path, type: :string, required: true, desc: "Path to generate the new generator"
+
   def create_stuff
     # your stuff
   end
 end
 
-Roger::Generators.register <%= name.capitalize %>Generator
+Roger::Generators.register <%= name.capitalize %>Generator

data/lib/roger/helpers/get_callable.rb

@@ -1,28 +1,29 @@
 module Roger
   module Helpers
+    # Helper to include the get_callbable method
     module GetCallable
-      # Makes callable into a object that responds to call. 
+      # Makes callable into a object that responds to call.
       #
-      # @param [#call, Symbol, Class] callable If callable already responds to #call will just return callable, a Symbol will be searched for in the scope parameter, a class will be instantiated (and checked if it will respond to #call)
+      # @param [#call, Symbol, Class] callable If callable already responds to #call will
+      #   just return callable, a Symbol will be searched for in the scope parameter, a class
+      #   will be instantiated (and checked if it will respond to #call)
       # @param [Hash] map, Mapping to match symbol to a callable
       def get_callable(callable, map)
         return callable if callable.respond_to?(:call)
-      
-        if callable.kind_of?(Symbol) && map.has_key?(callable)
-          callable = map[callable]
-        end
-      
-        if callable.kind_of?(Class)
-          callable = callable.new
-        end
-      
+
+        callable = map[callable] if callable.is_a?(Symbol) && map.key?(callable)
+
+        callable = callable.new if callable.is_a?(Class)
+
         if callable.respond_to?(:call)
           callable
         else
-          raise ArgumentError, "Could not resolve #{callable.inspect}. Callable must be an object that responds to #call or a symbol that resolve to such an object or a class with a #call instance method."
+          error_message = "Could not resolve #{callable.inspect}. Callable must"
+          error_message << "be an object that responds to #call or a symbol that resolve"
+          error_message << "to such an object or a class with a #call instance method."
+          fail ArgumentError, error_message
         end
-      
       end
     end
   end
-end
+end

data/lib/roger/helpers/logging.rb

@@ -1,30 +1,52 @@
 module Roger
   module Helpers
+    # Helper module for logging
     module Logging
+      GRAY = "\e[37m"
+      RED  = "\e[31m"
+
       # Write out a log message
       def log(part, msg, verbose = false, &block)
-        if !verbose || verbose && self.project.options[:verbose]
-          self.project.shell.say "\033[37m#{part.class.to_s}\033[0m" + " : " + msg.to_s, nil, true
-        end
-        if block_given?
-          begin
-            self.project.shell.padding = self.project.shell.padding + 1
-            yield
-          ensure
-            self.project.shell.padding = self.project.shell.padding - 1
-          end
+        shell = project.shell
+
+        if !verbose || verbose && project.options[:verbose]
+          shell.say(
+            shell.set_color(part_string(part), GRAY) +
+            " : " +
+            msg
+          )
         end
+
+        log_block_indent(&block) if block_given?
       end
 
       def debug(part, msg, &block)
-        self.log(part, msg, true, &block)
+        log(part, msg, true, &block)
       end
 
       # Write out a warning message
       def warn(part, msg)
-        self.project.shell.say "\033[37m#{part.class.to_s}\033[0m" + " : " + "\033[31m#{msg.to_s}\033[0m", nil, true
+        shell = project.shell
+
+        shell.say(
+          shell.set_color(part_string(part), GRAY) +
+          " : " +
+          shell.set_color(msg, RED)
+        )
       end
 
+      protected
+
+      def part_string(part)
+        part.is_a?(String) ? part : part.class.to_s
+      end
+
+      def log_block_indent(&_block)
+        project.shell.padding = project.shell.padding + 1
+        yield
+      ensure
+        project.shell.padding = project.shell.padding - 1
+      end
     end
   end
-end
+end