Feature vs Request Specs in Ruby on Rails

It is generally easy to determine the quality of code, and it has nothing to do with Rails or Ruby.

1. All functions should be between less than 8 lines.
2. No function should have more than two levels of indent.
3. Names should be communicative and explicit.
   3a. Variables in short scopes should have short names. 3b. Variables in long scopes should have long names. 3c. Functions in long scopes should have short names. 3d. Functions in short scopes should have long names.
4. The code should read like well written prose and have very few comments.
5. As you read the code you should not have to look up the definitions of the variables and functions being called. They should be obvious.
6. Function calls should have 3 or fewer arguments, with a preference for fewer.
7. Unit test coverage should be close to 100%, and the programmer should know the coverage number.
8. Unit tests should be short, easy to read, and easy to understand. You should be able to understand the program by reading the tests.
9. The tests should execute very quickly. Long running tests are a symptom of carelessness.

Look for signs of carelessness like commented out code, meaningless comments, needlessly shortened names, long functions, long argument lists, etc.

Ask yourself whether or not the code looks like the programmer cared.

If you want some Rails specific stuff -- look to see if there are business rules in the active objects. This is a symptom of careless design.

That article is pretty much classic. Yes, you should stick to the "fat models, skinny controllers, stupid views" architecture as long as the models make sense as objects (and they almost always do).

In your case, I'm not really sure what the output "model" should look like, but let's say it's a gallery. So you can create a model like this:

class Gallery # no "< ActiveRecord" if don't work with database

  attr_accessor :zip_file_path, :xml, :images

  def initialize(params ={})
    @zip_file_path = params[:zip_file_path]
    @xml = nil
    @images = []
    @output = nil # model: html code, path to file...
  end

  def generate_model
    unzip_file! # populates @xml and @images
    transform_xml! # creates model into @output
    @output
  end

  def unzip_file!
    ...
  end

  def transform_xml!
    ...
  end

end

It's just a rough design, you might want to make it more function-oriented (@xml, @images = unzip_file(@zip_file_path) ) etc.

Controller will then act just as a mediator between model and views/user:

class GalleriesController < ApplicationController
  def new()
    # display upload form for zip_file
  end

 def create()
   # check input here, or leave it to model validations

  @output = Gallery.new(params).generate_model
 end

end