1
module CrazyFun
2
  module Mappings
3
    class Tasks
4
      include FileCopyHack
5

6
      def task_name(dir, name)
7
        return name if name.to_s.start_with? "//"
8

9
        # Strip any leading ".", "./" or ".\\"
10
        # I am ashamed
11
        use = dir.gsub(/\\/, '/').sub(/^\./, '').sub(/^\//, '')
12

13
        "//#{use}:#{name}"
14
      end
15

16
      def output_name(dir, name, suffix)
17
        t = task_name(dir, name)
18
        result = "build/" + (t.slice(2 ... t.length)) + "." + suffix
19
        result.gsub(":", "/")
20
      end
21

22
      def add_dependencies(target, dir, all_deps)
23
        return if all_deps.nil?
24

25
        Array(all_deps).each do |dep|
26
          target.enhance(dep_type(dir, dep))
27
        end
28
      end
29

30
      def copy_resources(dir, to_copy, out_dir)
31
        to_copy.each do |res|
32
          if res.is_a? Symbol
33
            out = Rake::Task[task_name(dir, res)].out
34
          elsif Rake::Task.task_defined?(res)
35
            task = Rake::Task[res]
36
            out = task.out
37
            while out.nil? && task.prerequisites.size == 1 do
38
              task = Rake::Task[task.prerequisites[0]]
39
              out = task.out
40
            end
41
          elsif res.is_a? Hash
42
            # Copy the key to "out_dir + value"
43
            res.each do |from, to|
44
              possible_task = task_name(dir, from)
45
              if Rake::Task.task_defined?(possible_task) and Rake::Task[possible_task].out
46
                target = Rake::Task[possible_task].out
47

48
                if File.directory? target
49
                  dest = File.join(out_dir, to)
50
                  mkdir_p dest
51
                  cp_r target, dest
52
                else
53
                  dest = File.join(out_dir, to)
54
                  mkdir_p File.dirname(dest)
55
                  cp_r target, dest, remove_destination: true
56
                end
57
              else
58
                tdir = to.gsub(/\/.*?$/, "")
59
                mkdir_p "#{out_dir}/#{tdir}"
60
                src = find_file(File.join(dir, from))
61

62
                if File.directory? src
63
                  mkdir_p "#{out_dir}/#{to}"
64
                else
65
                  mkdir_p File.join(out_dir, File.dirname(to))
66
                end
67
                cp_r src, "#{out_dir}/#{to}"
68
              end
69
            end
70

71
            next
72
          else
73
            if File.exists? res
74
              out = res
75
            else
76
              out = File.join(dir, res)
77
              return copy_all(dir, to_copy, out_dir) unless File.exists?(out)
78
            end
79
          end
80

81
          if out.is_a? Array
82
            out.each { |o| cp_r o, out_dir }
83
          else
84
            cp_r out, out_dir
85
          end
86
        end
87
      end
88

89
      def zip(src, dest)
90
        out = SeleniumRake::Checks.path_for(File.expand_path(dest))
91
        Dir.chdir(src) {
92
          # TODO(jari): something very weird going on here on windows
93
          # the 2>&1 is needed for some reason
94
          ok = system(%{jar cMf "#{out}" * 2>&1})
95
          ok or raise "could not zip #{src} => #{dest}"
96
        }
97
      end
98

99
      private
100

101
      def find_file(file)
102
        puts "Copying #{file}" if $DEBUG
103

104
        if Rake::Task.task_defined?(file) && Rake::Task[file].out
105
          # Grab the "out" of the task represented by this symbol
106
          file = Rake::Task[file].out.to_s
107
        end
108

109
        if File.exist?(file)
110
          file
111
        elsif File.exist?("build/#{file}")
112
          "build/#{file}"
113
        else
114
          fl = FileList.new(file).existing!
115
          return fl unless fl.empty?
116

117
          fl = FileList.new("build/#{file}").existing!
118
          return fl unless fl.empty?
119

120
          puts "Unable to locate #{file}"
121
          exit -1
122
        end
123
      end
124

125
      def copy_string(dir, src, dest)
126
        if Rake::Task.task_defined? src
127
          from = Rake::Task[src].out
128
        else
129
          from = to_filelist(dir, src)
130
        end
131

132
        cp_r from, to_dir(dest), :remove_destination => true
133
      end
134

135
      def copy_symbol(dir, src, dest)
136
        from = Rake::Task[task_name(dir, src)].out
137

138
        if File.directory? from
139
          cp_r from, to_dir(dest)
140
        else
141
          mkdir_p File.dirname(dest)
142
          cp from, dest
143
        end
144
      end
145

146
      def copy_array(dir, src, dest)
147
        src.each do |item|
148
          if item.is_a? Hash
149
            copy_hash(dir, item, dest)
150
          elsif item.is_a? Array
151
            # TODO: Is this correct here? Shouldn't we do +copy_array+ (Luke - Sep 2019')
152
            raise StandardError, "Undetermined type: #{item.class}"
153
          elsif item.is_a? String
154
            copy_string(dir, item, dest)
155
          elsif item.is_a? Symbol
156
            copy_symbol(dir, item, dest)
157
          else
158
            raise StandardError, "Undetermined type: #{item.class}"
159
          end
160
        end
161
      end
162

163
      def copy_hash(dir, src, dest)
164
        src.each do |key, value|
165
          if key.is_a? Symbol
166
            copy_symbol dir, key, SeleniumRake::Checks.path_for(File.join(dest, value))
167
          else
168
            from, to = File.join(dir, key), File.join(dest, value)
169
            cp_r from, to
170
          end
171
        end
172
      end
173

174
      def copy_all(dir, srcs, dest)
175
        if srcs.is_a? Array
176
          copy_array(dir, srcs, dest)
177
        elsif srcs.is_a? String
178
          copy_string(dir, srcs, dest)
179
        elsif srcs.is_a? Hash
180
          copy_hash(dir, srcs, dest)
181
        elsif srcs.is_a? Symbol
182
          copy_symbol(dir, srcs, dest)
183
        else
184
          raise StandardError, "Undetermined type: #{srcs.class}"
185
        end
186
      end
187

188
      def to_dir(name)
189
        mkdir_p name unless File.exists?(name)
190
        name
191
      end
192

193
      def dep_type(dir, dep)
194
        if dep.is_a? String
195
          if dep.start_with?("//")
196
            return [dep]
197
          else
198
            return to_filelist(dir, dep)
199
          end
200
        end
201

202
        return [task_name(dir, dep)] if dep.is_a? Symbol
203

204
        if dep.is_a? Hash
205
          all_deps = []
206
          dep.each do |k, v|
207
            # We only care about the keys
208
            all_deps += dep_type(dir, k)
209
          end
210
          return all_deps
211
        end
212

213
        raise "Unmatched dependency type: #{dep.class}"
214
      end
215

216
      def to_filelist(dir, src)
217
        str = dir + "/" + src
218
        FileList[str].collect do |file|
219
          SeleniumRake::Checks.path_for(file)
220
        end
221
      end
222

223
      def halt_on_error?
224
        [nil, 'true'].include?(ENV['haltonerror']) &&
225
            [nil, 'true'].include?(ENV['haltonfailure'])
226
      end
227

228
      def halt_on_failure?
229
        halt_on_error?
230
      end
231
    end
232
  end
233
end
234

235