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) ⇒ Series

Returns a new instance of Series.



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

def initialize(workspace)
  @workspace = workspace
  @sync = []
  @multiple = []
  @parallel = []
  @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 



149
150
151
 
# File 'lib/squared/workspace/series.rb', line 149

def alias_get(key)
  TASK_ALIAS[key]
end

#base?(key) ⇒ Boolean

Returns:

  • (Boolean) 


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

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

#batch_get(key) ⇒ Object 



145
146
147
 
# File 'lib/squared/workspace/series.rb', line 145

def batch_get(key)
  TASK_BATCH[key]
end

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



111
112
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
 
# File 'lib/squared/workspace/series.rb', line 111

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 items.empty?

    key = task_name(t = name_get(key))
    val = format_desc(key, out: true)
    if items.size > 1
      @multiple << key
      if parallel.include?(t) || pattern.any? { |pat| t =~ pat } || subcheck.(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 += sync
end

#extend?(obj, key) ⇒ Boolean

Returns:

  • (Boolean) 


166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
 
# File 'lib/squared/workspace/series.rb', line 166

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

  meth = :"#{key}?"
  allref = obj.allref.to_a
  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 allref.include?(kind.ref)
      ret = true
    end
  end
  ret
end

#multiple?(val = nil) ⇒ Boolean

Returns:

  • (Boolean) 


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

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

#name_get(key) ⇒ Object 



141
142
143
 
# File 'lib/squared/workspace/series.rb', line 141

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

#parallel?(val = nil) ⇒ Boolean

Returns:

  • (Boolean) 


192
193
194
 
# File 'lib/squared/workspace/series.rb', line 192

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

#populate(proj) ⇒ Object 



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

def populate(proj)
  group, parent, id = @session.values
  ws = proj.workspace
  @data.each do |key, items|
    next if (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 && (data = batch_get(key)) && data.keys.any? { |ref| proj.ref?(ref) }
      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) 


153
154
155
156
157
158
159
160
 
# File 'lib/squared/workspace/series.rb', line 153

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) 


188
189
190
 
# File 'lib/squared/workspace/series.rb', line 188

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