              final-note          (abc/note
                                   (build-note (:line-length metric-components) composition-key)
                                   (build-instrument (:author metric-components))
-                                  (build-lyrics current-source-file source-file)
+                                  (build-lyrics (:source-file metric-components))
                                   (build-tempo (:complexity metric-components)))]
 
         (recur
-         {:notes (conj (:notes measure) final-note) :source-file current-source-file :method-length current-method-length}
+         {:notes (conj (:notes measure) final-note) :method-length current-method-length}
          (next remaining-line-metrics)
-         (:source-file metric-components)
          (:method-length metric-components))))))
 
-(defn metrics-to-measure [metrics-in-measure composition-key source-file method-length]
- (let [measure               (build-measure metrics-in-measure composition-key source-file method-length)
+(defn metrics-to-measure [metrics-in-measure composition-key method-length]
+ (let [measure               (build-measure metrics-in-measure composition-key method-length)
        current-method-length (parser/find-longest-method-length-in metrics-in-measure)
        accompanying-chord    (n/pick-chord-for-method-length current-method-length composition-key (:method-length measure))]
    (abc/measure accompanying-chord (:notes measure))))


(defn- map-metrics [metrics composition-key]
  (let [metrics-in-measures (split-metrics-into-equal-measures metrics)
        mapped-notes         (map #(metrics-to-measure %1 composition-key "" 1) metrics-in-measures)]
    (apply str mapped-notes)))

(defn compose [metrics composition-key]

  (if (not (nil? indentation?))
    (midi/volume-boost)))

(defn build-lyrics [current-source-file]
  (abc/lyrics-for current-source-file))

(defn build-instrument [current-author]
  (midi/instrument-command-for current-author))

(defn build-measure [measure-lines-metrics composition-key method-length]
 (loop [measure {}
        remaining-line-metrics measure-lines-metrics
        current-method-length method-length]
     (if (not remaining-line-metrics)
       measure
