Class: Squared::Workspace::Series

Inherits:
Object
  • Object
show all
Extended by:
Forwardable
Includes:
Rake::DSL
Defined in:
lib/squared/workspace/series.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(workspace, exclude: []) ⇒ Series

Returns a new instance of Series.



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
# File 'lib/squared/workspace/series.rb', line 74

def initialize(workspace, exclude: [])
  @workspace = workspace
  @sync = []
  @multiple = []
  @parallel = []
  @chain = {}
  @exclude = exclude.freeze
  @session = {
    group: {},
    parent: {},
    id: []
  }
  @data = {}
  (TASK_BASE + TASK_KEYS).each { |key| @data[key] = [] }
end

Instance Attribute Details

#multiple ⇒ Object (readonly)

Returns the value of attribute multiple.



69
70
71
 
# File 'lib/squared/workspace/series.rb', line 69

def multiple
  @multiple
end

#parallel ⇒ Object (readonly)

Returns the value of attribute parallel.



69
70
71
 
# File 'lib/squared/workspace/series.rb', line 69

def parallel
  @parallel
end

#sync ⇒ Object (readonly)

Returns the value of attribute sync.



69
70
71
 
# File 'lib/squared/workspace/series.rb', line 69

def sync
  @sync
end

Class Method Details

.add(task, obj) ⇒ Object 



20
21
22
23
 
# File 'lib/squared/workspace/series.rb', line 20

def add(task, obj)
  key_set task
  (TASK_EXTEND[task] ||= []) << obj
end

.alias(ref, obj) ⇒ Object 



38
39
40
41
42
43
44
 
# File 'lib/squared/workspace/series.rb', line 38

def alias(ref, obj)
  if obj.is_a?(Hash)
    obj.each { |key, val| (TASK_ALIAS[key] ||= {})[ref] = val }
  else
    TASK_ALIAS[obj]&.delete(ref)
  end
end

.base_set(obj) ⇒ Object 



50
51
52
53
54
55
56
57
 
# File 'lib/squared/workspace/series.rb', line 50

def base_set(obj)
  TASK_BASE.clear
           .concat((if TASK_KEYS.empty?
                      obj.tasks
                    else
                      obj.tasks.reject { |val| TASK_KEYS.include?(val) }
                    end).freeze)
end

.batch(*args, obj) ⇒ Object 



25
26
27
28
29
30
31
32
33
34
35
36
 
# File 'lib/squared/workspace/series.rb', line 25

def batch(*args, obj)
  if obj.is_a?(Hash)
    obj.each do |key, val|
      key_set key
      data = TASK_BATCH[key] ||= {}
      args.each { |ref| (data[ref] ||= []).concat(val) }
    end
  elsif (data = TASK_BATCH[obj])
    args.each { |ref| data.delete(ref) }
    TASK_KEYS.delete(obj) if data.empty?
  end
end

.rename(key, task) ⇒ Object 



46
47
48
 
# File 'lib/squared/workspace/series.rb', line 46

def rename(key, task)
  TASK_NAME[key.to_sym] = task.to_sym
end

Instance Method Details

#alias_get(key) ⇒ Object 



171
172
173
 
# File 'lib/squared/workspace/series.rb', line 171

def alias_get(key)
  TASK_ALIAS[key]
end

#base?(key) ⇒ Boolean

Returns:

  • (Boolean) 


184
185
186
 
# File 'lib/squared/workspace/series.rb', line 184

def base?(key)
  TASK_BASE.include?(key)
end

#batch?(obj, key) ⇒ Boolean

Returns:

  • (Boolean) 


205
206
207
208
209
 
# File 'lib/squared/workspace/series.rb', line 205

def batch?(obj, key)
  return false unless (data = batch_get(key))

  data.keys.any? { |ref| obj.ref?(ref) }
end

#batch_get(key) ⇒ Object 



167
168
169
 
# File 'lib/squared/workspace/series.rb', line 167

def batch_get(key)
  TASK_BATCH[key]
end

#build(parallel: [], pattern: []) ⇒ Object 



113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
 
# File 'lib/squared/workspace/series.rb', line 113

def build(parallel: [], pattern: [], **)
  subcheck = ->(val) { (ns = task_namespace(val)) && parallel.include?(ns) }
  @data.merge!(@session[:parent]) if @session[:id].uniq.size > 1
  @data.merge!(@session[:group])
  @data.each do |key, items|
    next if exclude?(key, true) || @workspace.task_exclude?(t = name_get(key))

    key = task_name t
    val = format_desc(key, out: true)
    if items.size > 1
      @multiple << key
      if parallel.include?(t) || pattern.any? { |pat| t.match?(pat) } || subcheck.call(t)
        task_desc("#{val} (thread)", name: key)
        multitask key => items
        @parallel << key

        s = task_join(key, 'sync')
        task_desc("#{val} (sync)", name: s)
        task s => items
        @sync << s
        next
      end
    end

    task_desc(val, name: key)
    task key => items
  end
  @multiple.concat(sync)
end

#chain(key, level, sync: []) ⇒ Object 



143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
 
# File 'lib/squared/workspace/series.rb', line 143

def chain(key, level, sync: [])
  return if level.empty?

  index = 0
  prereqs = level.map do |tasks|
    task_join(key, index += 1).tap do |subkey|
      if sync.include?(tasks) || (tasks.size == 1 && (sync << tasks))
        task subkey => tasks
      else
        multitask subkey => tasks
      end
    end
  end
  @chain[key] = level.freeze
  parallel << key

  format_desc key, level.map(&:size).join('-')
  task key => prereqs
end

#chain?(val) ⇒ Boolean

Returns:

  • (Boolean) 


211
212
213
214
215
216
217
218
219
220
221
222
 
# File 'lib/squared/workspace/series.rb', line 211

def chain?(val)
  @chain.each_value do |tasks|
    tasks.flatten(1).each do |task|
      next unless Rake::Task[task].already_invoked

      if val == task || Rake::Task[task].prerequisites.any? { |pr| pr == val && Rake::Task[val].already_invoked }
        return true
      end
    end
  end
  false
end

#exclude?(key, empty = false) ⇒ Boolean

Returns:

  • (Boolean) 


236
237
238
 
# File 'lib/squared/workspace/series.rb', line 236

def exclude?(key, empty = false)
  @exclude.include?(key) || (empty && @data[key].empty?)
end

#extend?(obj, key) ⇒ Boolean

Returns:

  • (Boolean) 


188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
 
# File 'lib/squared/workspace/series.rb', line 188

def extend?(obj, key)
  return false unless (items = TASK_EXTEND[key]) && !(items = items.select { |kind| obj.is_a?(kind) }).empty?

  meth = :"#{key}?"
  ret = false
  items.each do |kind|
    if kind.instance_methods.include?(meth)
      out = obj.__send__(meth)
      return true if out == 1
      return out if obj.ref?(kind.ref)
    elsif obj.ref?(kind.ref)
      ret = true
    end
  end
  ret
end

#multiple?(val = nil) ⇒ Boolean

Returns:

  • (Boolean) 


224
225
226
 
# File 'lib/squared/workspace/series.rb', line 224

def multiple?(val = nil)
  already_invoked?(multiple, val)
end

#name_get(key) ⇒ Object 



163
164
165
 
# File 'lib/squared/workspace/series.rb', line 163

def name_get(key)
  (TASK_NAME[key] || key).to_s
end

#parallel?(val = nil) ⇒ Boolean

Returns:

  • (Boolean) 


232
233
234
 
# File 'lib/squared/workspace/series.rb', line 232

def parallel?(val = nil)
  already_invoked?(parallel, val)
end

#populate(proj) ⇒ Object 



90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
# File 'lib/squared/workspace/series.rb', line 90

def populate(proj, **)
  group, parent, id = @session.values
  ws = proj.workspace
  @data.each do |key, items|
    next if exclude?(key) || (tasks = ws.task_resolve(proj, key)).empty?

    if (g = proj.group)
      id << g
      (group[:"#{key}:#{g}"] ||= []).concat(tasks)
    else
      items.concat(tasks)
    end
    if tasks.size > 1 && batch?(proj, key) && !ws.task_exclude?(key, proj)
      ws.task_desc(t = ws.task_join(proj.name, key))
      task t => tasks
    end
    next unless (b = ws.find_base(proj)) && (n = b.ref.to_s) != g

    id << n
    (parent[:"#{key}:#{n}"] ||= []).concat(tasks)
  end
end

#some?(key) ⇒ Boolean

Returns:

  • (Boolean) 


175
176
177
178
179
180
181
182
 
# File 'lib/squared/workspace/series.rb', line 175

def some?(key)
  return @data.key?(key) && !@data[key].empty? unless (batch = batch_get(key))

  batch.each_value do |items|
    return true if items.all? { |val| some?(val) || alias_get(val)&.any? { |_, alt| some?(alt) } }
  end
  false
end

#sync?(val = nil) ⇒ Boolean

Returns:

  • (Boolean) 


228
229
230
 
# File 'lib/squared/workspace/series.rb', line 228

def sync?(val = nil)
  already_invoked?(sync, val)
end