Allow file uploads with attribute

spec/attribute_spec.cr

@@ -19,6 +19,11 @@ describe "Avram::Attribute" do
       empty_array = Avram::Attribute.new(name: :empty_array, param: nil, value: [] of String, param_key: "test_form")
       empty_array.value.should_not be_nil
     end
+
+    it "returns nil for empty uploads" do
+      empty_upload = Avram::Attribute.new(name: :empty_upload, param: nil, value: UploadedFile.new(""), param_key: "test_form")
+      empty_upload.value.should be_nil
+    end
   end
 
   describe "#original_value" do
@@ -31,6 +36,11 @@ describe "Avram::Attribute" do
       empty_array = Avram::Attribute.new(name: :empty_array, param: nil, value: [] of String, param_key: "test_form")
       empty_array.original_value.should_not be_nil
     end
+
+    it "returns nil for empty uploads" do
+      empty_upload = Avram::Attribute.new(name: :empty_upload, param: nil, value: UploadedFile.new(""), param_key: "test_form")
+      empty_upload.original_value.should be_nil
+    end
   end
 
   it "can reset errors" do

spec/define_attribute_spec.cr

@@ -5,6 +5,8 @@ private class Operation < Post::SaveOperation
   attribute terms_of_service : Bool
   attribute best_kind_of_bear : String = "black bear"
   attribute default_is_false : Bool = false
+  attribute thumb : UploadedFile
+
   before_save prepare
 
   def prepare
@@ -25,6 +27,7 @@ describe "attribute in operations" do
 
   it "generates a list of attributes" do
     operation.attributes.map(&.name).should eq [
+      :thumb,
       :default_is_false,
       :best_kind_of_bear,
       :terms_of_service,
@@ -107,6 +110,41 @@ describe "attribute in operations" do
   end
 end
 
+describe "file_attribute in operation" do
+  it "is a PermittedAttribute" do
+    operation.thumb.should be_a(Avram::PermittedAttribute(Avram::Uploadable?))
+    operation.thumb.name.should eq(:thumb)
+    operation.thumb.param_key.should eq("post")
+  end
+
+  it "is included in the list of attributes" do
+    operation.attributes.map(&.name).should contain(:thumb)
+  end
+
+  it "gracefully handles invalid params" do
+    operation = operation({"thumb" => "not a file"})
+    operation.thumb.value.should be_nil
+    operation.thumb.errors.first.should eq "is invalid"
+  end
+
+  it "includes file attribute errors when calling SaveOperation#valid?" do
+    operation = operation({"thumb" => "not a file"})
+    operation.setup_required_database_columns
+    operation.valid?.should be_false
+  end
+
+  it "can still save to the database" do
+    params = {"thumb" => UploadedFile.new("thumb.png")}
+    operation = upload_operation(params)
+    operation.setup_required_database_columns
+    operation.save.should eq true
+  end
+end
+
 private def operation(attrs = {} of String => String)
   Operation.new(Avram::Params.new(attrs))
 end
+
+private def upload_operation(attrs = {} of String => Avram::Uploadable)
+  Operation.new(UploadParams.new(attrs))
+end

spec/nested_save_operation_spec.cr

@@ -47,6 +47,14 @@ private class NestedParams
   def get(key)
     raise "Not implemented"
   end
+
+  def nested_file?(key)
+    raise "Not implemented"
+  end
+
+  def nested_file(key)
+    raise "Not implemented"
+  end
 end
 
 describe "Avram::SaveOperation with nested operation" do

spec/support/upload_params.cr

@@ -0,0 +1,16 @@
+class UploadParams < Avram::Params
+  include Avram::Paramable
+
+  @uploads : Hash(String, UploadedFile) = {} of String => UploadedFile
+
+  def initialize(@uploads)
+  end
+
+  def nested_file?(key) : Hash(String, UploadedFile)
+    @uploads
+  end
+
+  def nested_file(key) : Hash(String, UploadedFile)
+    @uploads
+  end
+end

spec/support/uploaded_file.cr

@@ -0,0 +1,9 @@
+class UploadedFile
+  include Avram::Uploadable
+
+  def initialize(filename : String)
+    @name = "part.name"
+    @tempfile = File.tempfile(@name) { |file| File.write(file.path, "tmp") }
+    @metadata = HTTP::FormData::FileMetadata.new(filename)
+  end
+end

src/avram/attribute.cr

@@ -5,7 +5,12 @@ class Avram::Attribute(T)
   getter :param_key
   @errors = [] of String
 
-  def initialize(@name : Symbol, @param : String?, @value : T, @param_key : String)
+  def initialize(
+    @name : Symbol,
+    @param : Avram::Uploadable | String?,
+    @value : T,
+    @param_key : String
+  )
     @original_value = @value
   end
 
@@ -55,7 +60,7 @@ class Avram::Attribute(T)
   end
 
   private def ensure_no_blank(value : T)
-    if value.is_a?(String) && value.blank?
+    if value.is_a?(Avram::Uploadable | String) && value.blank?
       nil
     else
       value

src/avram/define_attribute.cr

@@ -49,15 +49,23 @@ module Avram::DefineAttribute
 
     {% ATTRIBUTES << type_declaration %}
 
-    {% type = type_declaration.type %}
-    {% name = type_declaration.var %}
     {%
-      default_value = if type_declaration.value.is_a?(Nop)
+      target_type = type_declaration.type
+
+      includers = Avram::Uploadable.includers
+      includers.each { |includer| includers += includer.all_subclasses }
+      is_uploadable = includers.includes?(target_type.resolve)
+
+      type = is_uploadable ? Avram::Uploadable : target_type
+      name = type_declaration.var
+
+      default_value = if type_declaration.value.is_a?(Nop) || is_uploadable
                         nil
                       else
                         type_declaration.value
                       end
     %}
+
     @_{{ name }} : Avram::Attribute({{ type }}?)?
 
     ensure_base_attributes_method_is_present
@@ -84,17 +92,36 @@ module Avram::DefineAttribute
     end
 
     private def {{ name }}_param
-      params.nested(self.class.param_key)["{{ name }}"]?
+      {% if is_uploadable %}
+        if file = params.nested_file?(self.class.param_key)
+          file["{{ name }}"]?
+        end
+      {% else %}
+        params.nested(self.class.param_key)["{{ name }}"]?
+      {% end %}
     end
 
     private def {{ name }}_param_given?
-      params.nested(self.class.param_key).has_key?("{{ name }}")
+      {% if is_uploadable %}
+        file = params.nested_file?(self.class.param_key)
+        file && file.has_key?("{{ name }}")
+      {% else %}
+        params.nested(self.class.param_key).has_key?("{{ name }}")
+      {% end %}
     end
 
     def set_{{ name }}_from_param(attribute : Avram::Attribute)
       parse_result = {{ type }}::Lucky.parse({{ name }}_param)
       if parse_result.is_a? Avram::Type::SuccessfulCast
-        attribute.value = parse_result.value
+        {% if is_uploadable %}
+          attribute.value = if parse_result.value.class == {{ target_type }}
+                              parse_result.value
+                            else
+                              {{ target_type }}.new(parse_result.value)
+                            end
+        {% else %}
+          attribute.value = parse_result.value
+        {% end %}
       else
         attribute.add_error "is invalid"
       end

src/avram/params.cr

@@ -30,4 +30,12 @@ class Avram::Params
   def get(key)
     @hash[key]
   end
+
+  def nested_file?(key) : Hash(String, String)
+    @hash
+  end
+
+  def nested_file(key) : Hash(String, String)
+    @hash
+  end
 end

src/avram/uploadable.cr

@@ -0,0 +1,54 @@
+# Include this module in classes that represent an uploaded file from a form
+module Avram::Uploadable
+  getter name : String
+  getter tempfile : File
+  getter metadata : HTTP::FormData::FileMetadata
+
+  macro included
+    # :nodoc:
+    def initialize(file : Avram::Uploadable)
+      @name = file.name
+      @tempfile = file.tempfile
+      @metadata = file.metadata
+    end
+  end
+
+  # Returns the path of the File as a String
+  #
+  # ```
+  # uploaded_file_object.path # => String
+  # ```
+  def path : String
+    @tempfile.path
+  end
+
+  # Returns the original file name as a String
+  #
+  # ```
+  # uploaded_file_object.filename # => String
+  # ```
+  def filename : String
+    metadata.filename.to_s
+  end
+
+  # If no file was selected in the form's file input, this will return `true`
+  #
+  # ```
+  # uploaded_file_object.blank? # => Bool
+  # ```
+  def blank? : Bool
+    filename.blank?
+  end
+
+  module Lucky
+    include Avram::Type
+
+    def parse(value : Avram::Uploadable)
+      SuccessfulCast(Avram::Uploadable).new(value)
+    end
+
+    def parse(value : String?)
+      FailedCast.new
+    end
+  end
+end