Class: RokuBuilder::ConfigParser

Inherits:
Object
  • Object
show all
Defined in:
lib/roku_builder/config_parser.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options:, config:) ⇒ ConfigParser

Returns a new instance of ConfigParser.



14
15
16
17
18
19
20
 
# File 'lib/roku_builder/config_parser.rb', line 14

def initialize(options:, config:)
  @logger = Logger.instance
  @options = options
  @config = config
  @parsed = {init_params: {}}
  parse_config
end

Instance Attribute Details

#parsed ⇒ Object (readonly)

Returns the value of attribute parsed.



7
8
9
 
# File 'lib/roku_builder/config_parser.rb', line 7

def parsed
  @parsed
end

Class Method Details

.parse(options:, config:) ⇒ Object 



9
10
11
12
 
# File 'lib/roku_builder/config_parser.rb', line 9

def self.parse(options:, config:)
  parser = new(options: options, config: config)
  parser.parsed
end

Instance Method Details

#check_for_working ⇒ Object 



173
174
175
 
# File 'lib/roku_builder/config_parser.rb', line 173

def check_for_working
  @parsed[:project][:stage_method] = :working if @options[:working]
end

#convert_to_source_files ⇒ Object 



165
166
167
168
169
170
171
 
# File 'lib/roku_builder/config_parser.rb', line 165

def convert_to_source_files
  unless @parsed[:project][:source_files]
    @parsed[:project][:source_files] = @parsed[:project][:files] + @parsed[:project][:folders]
    @parsed[:project].delete(:files)
    @parsed[:project].delete(:folders)
  end
end

#current_project ⇒ Object 



68
69
70
71
72
73
 
# File 'lib/roku_builder/config_parser.rb', line 68

def current_project
  @config[:projects].each_pair do |key,value|
    return key if is_current_project?(project_config: value)
  end
  nil
end

#file_defined?(type) ⇒ Boolean

Returns:

  • (Boolean) 


111
112
113
 
# File 'lib/roku_builder/config_parser.rb', line 111

def file_defined?(type)
  user_file(type).end_with?(".zip") or user_file(type).end_with?(".pkg") or user_file(type).end_with?(".jpg")
end

#get_global_key_config ⇒ Object

Raises:



196
197
198
199
200
201
202
203
 
# File 'lib/roku_builder/config_parser.rb', line 196

def get_global_key_config
  raise ParseError, "No Keys Configured" unless @config[:keys]
  raise ParseError, "Unknown Key: #{@parsed[:key]}" unless @config[:keys][@parsed[:key].to_sym]
  @parsed[:key] = @config[:keys][@parsed[:key].to_sym].dup
  if @config[:keys][:key_dir]  and !@parsed[:key][:keyed_pkg].start_with?("./")
    @parsed[:key][:keyed_pkg] = File.join(@config[:keys][:key_dir], @parsed[:key][:keyed_pkg])
  end
end

#get_repo_path(project_config:) ⇒ Object 



83
84
85
86
87
88
89
 
# File 'lib/roku_builder/config_parser.rb', line 83

def get_repo_path(project_config:)
  if @config[:projects][:project_dir] and !Pathname.new(project_config[:directory]).absolute?
    Pathname.new(File.join(@config[:projects][:project_dir], project_config[:directory])).realdirpath
  else
    Pathname.new(project_config[:directory]).realdirpath
  end
end

#get_root_dir ⇒ Object 



215
216
217
218
219
220
 
# File 'lib/roku_builder/config_parser.rb', line 215

def get_root_dir
  root_dir = @parsed[:project][:directory] if @parsed[:project]
  root_dir = @options[:in] if @options[:in]
  root_dir = Pathname.pwd.to_s if @options[:current]
  root_dir
end

#is_current_project?(project_config:) ⇒ Boolean

Returns:

  • (Boolean) 


75
76
77
78
79
80
81
 
# File 'lib/roku_builder/config_parser.rb', line 75

def is_current_project?(project_config:)
  return false unless project_config.is_a?(Hash)
  repo_path = get_repo_path(project_config: project_config)
  Pathname.pwd.descend do |path_parent|
    return true if path_parent == repo_path
  end
end

#parse_config ⇒ Object 



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
# File 'lib/roku_builder/config_parser.rb', line 22

def parse_config
  process_in_argument
  setup_devices
  setup_api_keys
  setup_project
  setup_in_out_file
  setup_project_config
  setup_stage_config
  setup_key_config
  setup_root_dir
  setup_build_dir
  setup_input_mappings
  setup_console_log
  setup_deeplinks
end

#process_in_argument ⇒ Object 



38
39
40
 
# File 'lib/roku_builder/config_parser.rb', line 38

def process_in_argument
  @options[:in] = File.expand_path(@options[:in]) if @options[:in]
end

#project_required ⇒ Object 



63
64
65
66
 
# File 'lib/roku_builder/config_parser.rb', line 63

def project_required
  non_project_source = ([:current, :in] & @options.keys).count > 0
  @options.has_source? and not non_project_source
end

#set_default_outfile ⇒ Object 



124
125
126
127
128
129
130
131
 
# File 'lib/roku_builder/config_parser.rb', line 124

def set_default_outfile
  unless @parsed[:out][:folder]
    @parsed[:out][:folder] = Dir.tmpdir
  end
  if @config[:default_file]
    @parsed[:out][:default_file] = @config[:default_file]
  end
end

#set_project_directory ⇒ Object 



156
157
158
159
160
161
162
163
 
# File 'lib/roku_builder/config_parser.rb', line 156

def set_project_directory
  if @config[:projects][:project_dir]  and !Pathname.new(@parsed[:project][:directory]).absolute?
    @parsed[:project][:directory] = File.join(@config[:projects][:project_dir], @parsed[:project][:directory])
  end
  unless Dir.exist?(@parsed[:project][:directory])
    raise ParseError, "Missing project directory: #{@parsed[:project][:directory]}"
  end
end

#setup_api_keys ⇒ Object 



47
48
49
 
# File 'lib/roku_builder/config_parser.rb', line 47

def setup_api_keys
  @parsed[:api_keys] = @config[:api_keys]
end

#setup_build_dir ⇒ Object 



222
223
224
225
226
227
228
229
 
# File 'lib/roku_builder/config_parser.rb', line 222

def setup_build_dir
  if @options[:build_dir].nil? and @parsed[:project] and not @parsed[:project][:build_dir].nil?
    @options[:build_dir] = File.expand_path(@parsed[:project][:build_dir], @parsed[:root_dir])
  end
  unless @options[:build_dir].nil?
    @parsed[:build_dir] = File.expand_path(@options[:build_dir], @parsed[:root_dir])
  end
end

#setup_console_log ⇒ Object 



235
236
237
 
# File 'lib/roku_builder/config_parser.rb', line 235

def setup_console_log
  @parsed[:console_log] = @config[:console_log]
end

#setup_deeplinks ⇒ Object 



239
240
241
 
# File 'lib/roku_builder/config_parser.rb', line 239

def setup_deeplinks
  @parsed[:deeplinks] = @config[:deeplinks]
end

#setup_devices ⇒ Object 



42
43
44
45
 
# File 'lib/roku_builder/config_parser.rb', line 42

def setup_devices
  @parsed[:device_default] = @config[:devices][:default]
  @parsed[:devices] = @config[:devices].select{|key, value| :default != key}
end

#setup_file_and_folder(type) ⇒ Object 



115
116
117
118
119
120
121
122
 
# File 'lib/roku_builder/config_parser.rb', line 115

def setup_file_and_folder(type)
  @parsed[type][:folder], @parsed[type][:file] = Pathname.new(user_file(type)).split.map{|p| p.to_s}
  if @parsed[type][:folder] == "." and not user_file(type).start_with?(".")
    @parsed[type][:folder] = nil
  else
    @parsed[type][:folder] = File.expand_path(@parsed[type][:folder])
  end
end

#setup_in_out_file ⇒ Object 



91
92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/roku_builder/config_parser.rb', line 91

def setup_in_out_file
  [:in, :out].each do |type|
    @parsed[type] = {file: nil, folder: nil}
    if user_file(type)
      if file_defined?(type)
        setup_file_and_folder(type)
      elsif user_file(type)
        @parsed[type][:folder] = File.expand_path(user_file(type))
      end
    end
  end
  set_default_outfile
end

#setup_input_mappings ⇒ Object 



231
232
233
 
# File 'lib/roku_builder/config_parser.rb', line 231

def setup_input_mappings
  @parsed[:input_mappings] = @config[:input_mappings]
end

#setup_key_config ⇒ Object 



186
187
188
189
190
191
192
193
194
 
# File 'lib/roku_builder/config_parser.rb', line 186

def setup_key_config
  if @options.keyed_command?
    if @parsed[:stage]
      @parsed[:key] = @parsed[:stage][:key]
      get_global_key_config if @parsed[:key].class == String
      test_key_file
    end
  end
end

#setup_project ⇒ Object 



51
52
53
54
55
56
57
58
59
60
61
 
# File 'lib/roku_builder/config_parser.rb', line 51

def setup_project
  if project_required and not @options[:project]
    project = current_project
    if project
      @options[:project] = project
    elsif @config[:projects][:default]
      @options[:project] = @config[:projects][:default]
    end
    raise ArgumentError, "A project is required for that command" unless @options[:project]
  end
end

#setup_project_config ⇒ Object 



133
134
135
136
137
138
139
140
141
142
143
 
# File 'lib/roku_builder/config_parser.rb', line 133

def setup_project_config
  if @options[:current]
    stub_project_config_for_current
  elsif  project_required
    @parsed[:project] = @config[:projects][@options[:project].to_sym].dup
    raise ParseError, "Unknown Project: #{@options[:project]}" unless @parsed[:project]
    set_project_directory
    convert_to_source_files
    check_for_working
  end
end

#setup_root_dir ⇒ Object 



211
212
213
 
# File 'lib/roku_builder/config_parser.rb', line 211

def setup_root_dir
  @parsed[:root_dir] = get_root_dir
end

#setup_stage_config ⇒ Object 



177
178
179
180
181
182
183
184
 
# File 'lib/roku_builder/config_parser.rb', line 177

def setup_stage_config
  if project_required
    stage = @options[:stage].to_sym if @options[:stage]
    stage ||= @parsed[:project][:stages].keys[0].to_sym
    raise ParseError, "Unknown Stage: #{stage}" unless @parsed[:project][:stages][stage]
    @parsed[:stage] = @parsed[:project][:stages][stage]
  end
end

#stub_project_config_for_current ⇒ Object

Raises:



145
146
147
148
149
150
151
152
153
154
 
# File 'lib/roku_builder/config_parser.rb', line 145

def stub_project_config_for_current
  pwd =  Pathname.pwd.to_s
  manifest = File.join(pwd, "manifest")
  raise ParseError, "Missing Manifest: #{manifest}" unless File.exist?(manifest)
  @parsed[:project] = {
    directory: pwd,
    source_files: nil,
    stage_method: :current
  }
end

#test_key_file ⇒ Object 



205
206
207
208
209
 
# File 'lib/roku_builder/config_parser.rb', line 205

def test_key_file
  if @parsed[:key] and not File.exist?(@parsed[:key][:keyed_pkg])
    raise ParseError, "Bad key file: #{@parsed[:key][:keyed_pkg]}"
  end
end

#user_file(type) ⇒ Object 



105
106
107
108
109
 
# File 'lib/roku_builder/config_parser.rb', line 105

def user_file(type)
  file = @options[type]
  file ||= @config[type]
  file
end