rggen-core 0.20.0 → 0.21.0

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: d9079e5f068e752e9f083fd64c97dda8cdc9f47f2e4ce3c6f1d0568f4950caa3
4
- data.tar.gz: e60e14aa24f9f7b003391f0d87d773a35adbdf99c794016cdd803fc8025df8de
3
+ metadata.gz: 135125b25bc30e8eb74fa97644c356afd817cda2a84a810a401efbcde7d2a647
4
+ data.tar.gz: c4cb605aaa49801ff0f70458148f1349a220de2c41b6f7ed614e98466e425668
5
5
  SHA512:
6
- metadata.gz: 7f2b3f56089899d459e62bd6873166a467eec667d559690ad26a17558a72b4e399744d156c9a092181067a1313c82615db12a63469e8b7d9145678adfed2c830
7
- data.tar.gz: a5cf836ea12ba57a905d925f29406f76155ce3e389d4678f76adee6da8bec9f5964c3f973f2803019c4aa8756f7223abf1de958f2ceb6b6fd97024d663c02327
6
+ metadata.gz: 122340fafae09f08a604c54b3f21e8428a0d03af5ef81b37f4211f881a99186c2f0a45e50cad9367406a75f784041eabc0ef87ebf692946a2dfbec5221135e8f
7
+ data.tar.gz: fb87835adc54ec4416f5811126ff65355ada76e05cc46d89eedbe87e2899fd16665d26caf66e41a9919a074824f51ef97fd6dee9abc2aa959b42d83b9c4dd35c
@@ -38,6 +38,7 @@ require_relative 'core/base/feature_layer_extension'
38
38
 
39
39
  require_relative 'core/input_base/input_value'
40
40
  require_relative 'core/input_base/input_data'
41
+ require_relative 'core/input_base/input_value_extractor'
41
42
  require_relative 'core/input_base/loader'
42
43
  require_relative 'core/input_base/json_loader'
43
44
  require_relative 'core/input_base/yaml_loader'
@@ -87,6 +88,7 @@ require_relative 'core/output_base/feature_factory'
87
88
 
88
89
  require_relative 'core/builder/component_entry'
89
90
  require_relative 'core/builder/component_registry'
91
+ require_relative 'core/builder/loader_registry'
90
92
  require_relative 'core/builder/input_component_registry'
91
93
  require_relative 'core/builder/output_component_registry'
92
94
  require_relative 'core/builder/simple_feature_entry'
@@ -20,16 +20,14 @@ module RgGen
20
20
  component_registry(:output, name, body)
21
21
  end
22
22
 
23
- def register_loader(component, loader)
24
- @component_registries[:input][component].register_loader(loader)
25
- end
26
-
27
- def register_loaders(component, loaders)
28
- @component_registries[:input][component].register_loaders(loaders)
29
- end
30
-
31
- def define_loader(component, &body)
32
- @component_registries[:input][component].define_loader(&body)
23
+ [
24
+ :register_loader, :register_loaders,
25
+ :define_value_extractor, :ignore_value, :ignore_values
26
+ ].each do |method_name|
27
+ define_method(method_name) do |component, *args, &block|
28
+ @component_registries[:input][component]
29
+ .__send__(__method__, *args, &block)
30
+ end
33
31
  end
34
32
 
35
33
  def add_feature_registry(name, target_layer, registry)
@@ -6,29 +6,62 @@ module RgGen
6
6
  class InputComponentRegistry < ComponentRegistry
7
7
  def initialize(name, builder)
8
8
  super
9
- @loaders = []
9
+ @loader_registries = {}
10
10
  end
11
11
 
12
- attr_setter :base_loader
12
+ def register_loader(loader_type, loader)
13
+ loader_registry(loader_type).register_loader(loader)
14
+ end
15
+
16
+ def register_loaders(loader_type, loaders)
17
+ loader_registry(loader_type).register_loaders(loaders)
18
+ end
13
19
 
14
- def register_loader(loader)
15
- @loaders << loader
20
+ def define_value_extractor(loader_type, layers_or_value, value = nil, &body)
21
+ layers, value =
22
+ if value
23
+ [layers_or_value, value]
24
+ else
25
+ [nil, layers_or_value]
26
+ end
27
+ loader_registry(loader_type).define_value_extractor(layers, value, &body)
16
28
  end
17
29
 
18
- def register_loaders(loaders)
19
- @loaders.concat(Array(loaders))
30
+ def ignore_value(loader_type, layers_or_value, value = nil)
31
+ layers, value =
32
+ if value
33
+ [layers_or_value, value]
34
+ else
35
+ [nil, layers_or_value]
36
+ end
37
+ loader_registry(loader_type).ignore_value(layers, value)
20
38
  end
21
39
 
22
- def define_loader(&body)
23
- loader = Class.new(@base_loader, &body)
24
- register_loader(loader)
40
+ def ignore_values(loader_type, layers_or_values, values = nil)
41
+ layers, values =
42
+ if values
43
+ [layers_or_values, values]
44
+ else
45
+ [nil, layers_or_values]
46
+ end
47
+ loader_registry(loader_type).ignore_values(layers, values)
25
48
  end
26
49
 
27
50
  def build_factory
28
51
  factory = super
29
- factory.loaders(@loaders)
52
+ factory.loaders(build_loaders)
30
53
  factory
31
54
  end
55
+
56
+ private
57
+
58
+ def loader_registry(loader_type)
59
+ @loader_registries[loader_type] ||= LoaderRegistry.new
60
+ end
61
+
62
+ def build_loaders
63
+ @loader_registries.values.flat_map(&:create_loaders)
64
+ end
32
65
  end
33
66
  end
34
67
  end
@@ -0,0 +1,48 @@
1
+ # frozen_string_literal: true
2
+
3
+ module RgGen
4
+ module Core
5
+ module Builder
6
+ class LoaderRegistry
7
+ def initialize
8
+ @loaders = []
9
+ @extractors = []
10
+ @ignore_values = {}
11
+ end
12
+
13
+ def register_loader(loader)
14
+ register_loaders([loader])
15
+ end
16
+
17
+ def register_loaders(loaders)
18
+ @loaders.concat(Array(loaders))
19
+ end
20
+
21
+ def define_value_extractor(layers, value, &body)
22
+ @extractors <<
23
+ create_extractor(layers, value, &body)
24
+ end
25
+
26
+ def ignore_value(layers, value)
27
+ ignore_values(layers, [value])
28
+ end
29
+
30
+ def ignore_values(layers, values)
31
+ [layers].flatten.each do |layer|
32
+ (@ignore_values[layer] ||= []).concat(Array(values))
33
+ end
34
+ end
35
+
36
+ def create_loaders
37
+ @loaders.map { |loader| loader.new(@extractors, @ignore_values) }
38
+ end
39
+
40
+ private
41
+
42
+ def create_extractor(layers, value, &body)
43
+ Class.new(Core::InputBase::InputValueExtractor, &body).new(layers, value)
44
+ end
45
+ end
46
+ end
47
+ end
48
+ end
@@ -10,8 +10,9 @@ module RgGen
10
10
  feature Feature, FeatureFactory
11
11
  end
12
12
 
13
- base_loader Loader
14
- register_loaders [RubyLoader, JSONLoader, YAMLLoader]
13
+ register_loader :ruby, RubyLoader
14
+ register_loader :yaml, YAMLLoader
15
+ register_loader :json, JSONLoader
15
16
  end
16
17
  end
17
18
  end
@@ -4,8 +4,10 @@ module RgGen
4
4
  module Core
5
5
  module Configuration
6
6
  module HashLoader
7
- def format(read_data, file)
8
- input_data.values(Hash(read_data), file)
7
+ private
8
+
9
+ def format_layer_data(read_data, _layer, file)
10
+ Hash(read_data)
9
11
  rescue TypeError => e
10
12
  raise Core::LoadError.new(e.message, file)
11
13
  end
@@ -0,0 +1,34 @@
1
+ # frozen_string_literal: true
2
+
3
+ module RgGen
4
+ module Core
5
+ module InputBase
6
+ class InputValueExtractor
7
+ def initialize(target_layers, target_value)
8
+ @target_layers = Array(target_layers)
9
+ @target_value = target_value
10
+ end
11
+
12
+ class << self
13
+ attr_reader :extractor
14
+
15
+ private
16
+
17
+ def extract(&body)
18
+ @extractor = body
19
+ end
20
+ end
21
+
22
+ def target_value?(layer, value)
23
+ value == @target_value &&
24
+ (@target_layers.empty? || @target_layers.include?(layer))
25
+ end
26
+
27
+ def extract(input_data)
28
+ body = self.class.extractor
29
+ instance_exec(input_data, &body)
30
+ end
31
+ end
32
+ end
33
+ end
34
+ end
@@ -4,39 +4,83 @@ module RgGen
4
4
  module Core
5
5
  module InputBase
6
6
  class Loader
7
- class << self
8
- def support_types(types)
9
- @support_types = types.map(&:to_sym)
10
- end
11
-
12
- def support?(file)
13
- file_ext = File.ext(file).to_sym
14
- @support_types.any? { |type| type.casecmp?(file_ext) }
15
- end
7
+ def self.support_types(types = nil)
8
+ types && (@support_types ||= []).concat(types.map(&:to_sym))
9
+ @support_types
10
+ end
16
11
 
17
- def load_file(file, input_data, valid_value_list)
18
- new(input_data, valid_value_list).load_file(file)
19
- end
12
+ def initialize(extractors, ignore_values)
13
+ @extractors = extractors
14
+ @ignore_values = ignore_values
20
15
  end
21
16
 
22
- def initialize(input_data, valid_value_lists)
23
- @input_data = input_data
24
- @valid_value_lists = valid_value_lists
17
+ def support?(file)
18
+ ext = File.ext(file).to_sym
19
+ types = self.class.support_types
20
+ types&.any? { |type| type.casecmp?(ext) } || false
25
21
  end
26
22
 
27
- def load_file(file)
23
+ def load_file(file, input_data, valid_value_lists)
28
24
  File.readable?(file) ||
29
25
  (raise Core::LoadError.new('cannot load such file', file))
30
- format(read_file(file), file)
26
+ @input_data = input_data
27
+ @valid_value_lists = valid_value_lists
28
+ format(read_file(file), input_data, input_data.layer, file)
31
29
  end
32
30
 
33
31
  private
34
32
 
35
- def format(_read_data, _file)
33
+ attr_reader :input_data
34
+
35
+ def format(read_data, input_data, layer, file)
36
+ layer_data =
37
+ format_layer_data(read_data, layer, file) ||
38
+ format_layer_data_by_extractors(read_data, layer)
39
+ layer_data &&
40
+ input_data.values(filter_layer_data(layer_data, layer), file)
41
+ format_sub_layer(read_data, input_data, layer, file)
36
42
  end
37
43
 
38
- attr_reader :input_data
39
- attr_reader :valid_value_lists
44
+ def format_sub_layer(read_data, input_data, layer, file)
45
+ format_sub_layer_data(read_data, layer, file)
46
+ &.flat_map { |sub_layer, data_array| [sub_layer].product(data_array) }
47
+ &.each do |(sub_layer, data)|
48
+ format(data, input_data.child(sub_layer), sub_layer, file)
49
+ end
50
+ end
51
+
52
+ def format_layer_data(_read_data, _layer, _file)
53
+ end
54
+
55
+ def format_layer_data_by_extractors(read_data, layer)
56
+ layer_data = {}
57
+ valid_values(layer).each do |value|
58
+ @extractors
59
+ .select { |extractor| extractor.target_value?(layer, value) }
60
+ .each do |extractor|
61
+ extract_value(read_data, extractor, layer_data, value)
62
+ end
63
+ end
64
+ layer_data.empty? ? nil : layer_data
65
+ end
66
+
67
+ def extract_value(read_data, extractor, layer_data, value)
68
+ data = extractor.extract(read_data)
69
+ data && (layer_data[value] = data)
70
+ end
71
+
72
+ def filter_layer_data(layer_data, layer)
73
+ layer_data
74
+ .select { |key, _| valid_values(layer).include?(key) }
75
+ end
76
+
77
+ def format_sub_layer_data(_read_data, _layer, _file)
78
+ end
79
+
80
+ def valid_values(layer)
81
+ @valid_value_lists[layer]
82
+ .reject { |value| @ignore_values[layer]&.include?(value) }
83
+ end
40
84
  end
41
85
  end
42
86
  end
@@ -12,8 +12,9 @@ module RgGen
12
12
  feature Feature, FeatureFactory if layer != :root
13
13
  end
14
14
 
15
- base_loader Loader
16
- register_loaders [RubyLoader, JSONLoader, YAMLLoader]
15
+ register_loader :ruby, RubyLoader
16
+ register_loader :yaml, YAMLLoader
17
+ register_loader :json, JSONLoader
17
18
  end
18
19
  end
19
20
  end
@@ -4,36 +4,77 @@ module RgGen
4
4
  module Core
5
5
  module RegisterMap
6
6
  module HashLoader
7
- def format(read_data, file)
8
- format_data(:root, root, read_data, file)
9
- rescue TypeError => e
10
- raise Core::LoadError.new(e.message, file)
11
- end
12
-
13
7
  private
14
8
 
15
- LAYER_MAP = {
9
+ SUB_LAYER_KEYS = {
10
+ root: [:register_block, :register_blocks],
11
+ register_block: [:register_file, :register_files, :register, :registers],
12
+ register_file: [:register_file, :register_files, :register, :registers],
13
+ register: [:bit_field, :bit_fields]
14
+ }.freeze
15
+
16
+ SUB_LAYER_KEY_MAP = {
16
17
  root: { register_blocks: :register_block },
17
18
  register_block: { register_files: :register_file, registers: :register },
18
19
  register_file: { register_files: :register_file, registers: :register },
19
20
  register: { bit_fields: :bit_field }
20
21
  }.freeze
21
22
 
22
- def format_data(layer, input_data, read_data, file)
23
- read_data = Hash(read_data)
24
- input_data.values(read_data, file)
25
- format_next_layer_data(layer, input_data, read_data, file)
23
+ def format_layer_data(read_data, layer, file)
24
+ if read_data.is_a?(Array)
25
+ format_array_layer_data(read_data, layer, file)
26
+ else
27
+ fomrat_hash_layer_data(read_data, layer, file)
28
+ end
29
+ end
30
+
31
+ def format_array_layer_data(read_data, layer, file)
32
+ read_data.each_with_object({}) do |data, layer_data|
33
+ layer_data.merge!(fomrat_hash_layer_data(data, layer, file))
34
+ end
35
+ end
36
+
37
+ def fomrat_hash_layer_data(read_data, layer, file)
38
+ convert_to_hash(read_data, file)
39
+ .reject { |key, _| SUB_LAYER_KEYS[layer]&.include?(key) }
26
40
  end
27
41
 
28
- def format_next_layer_data(layer, input_data, read_data, file)
29
- LAYER_MAP[layer]&.each do |key, next_layer|
30
- Array(read_data[key]).each do |data|
31
- format_data(
32
- next_layer, input_data.child(next_layer), data, file
33
- )
42
+ def format_sub_layer_data(read_data, layer, file)
43
+ if read_data.is_a?(Array)
44
+ format_array_sub_layer_data(read_data, layer, file)
45
+ else
46
+ format_hash_sub_layer_data(read_data, layer, file)
47
+ end
48
+ end
49
+
50
+ def format_array_sub_layer_data(read_data, layer, file)
51
+ read_data.each_with_object({}) do |data, sub_layer_data|
52
+ format_hash_sub_layer_data(data, layer, file, sub_layer_data)
53
+ end
54
+ end
55
+
56
+ def format_hash_sub_layer_data(read_data, layer, file, sub_layer_data = {})
57
+ convert_to_hash(read_data, file)
58
+ .select { |key, _| SUB_LAYER_KEYS[layer]&.include?(key) }
59
+ .each do |key, value|
60
+ merge_sub_layer_data(sub_layer_data, layer, key, value)
34
61
  end
62
+ sub_layer_data
63
+ end
64
+
65
+ def merge_sub_layer_data(sub_layer_data, layer, key, value)
66
+ if SUB_LAYER_KEY_MAP[layer].key?(key)
67
+ (sub_layer_data[SUB_LAYER_KEY_MAP[layer][key]] ||= []).concat(value)
68
+ else
69
+ (sub_layer_data[key] ||= []) << value
35
70
  end
36
71
  end
72
+
73
+ def convert_to_hash(read_data, file)
74
+ Hash(read_data)
75
+ rescue TypeError => e
76
+ raise Core::LoadError.new(e.message, file)
77
+ end
37
78
  end
38
79
  end
39
80
  end
@@ -3,7 +3,7 @@
3
3
  module RgGen
4
4
  module Core
5
5
  MAJOR = 0
6
- MINOR = 20
6
+ MINOR = 21
7
7
  PATCH = 0
8
8
  VERSION = "#{MAJOR}.#{MINOR}.#{PATCH}"
9
9
  end
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: rggen-core
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.20.0
4
+ version: 0.21.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - Taichi Ishitani
8
8
  autorequire:
9
9
  bindir: exe
10
10
  cert_chain: []
11
- date: 2020-07-06 00:00:00.000000000 Z
11
+ date: 2020-07-22 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: docile
@@ -96,6 +96,7 @@ files:
96
96
  - lib/rggen/core/builder/input_component_registry.rb
97
97
  - lib/rggen/core/builder/layer.rb
98
98
  - lib/rggen/core/builder/list_feature_entry.rb
99
+ - lib/rggen/core/builder/loader_registry.rb
99
100
  - lib/rggen/core/builder/output_component_registry.rb
100
101
  - lib/rggen/core/builder/plugins.rb
101
102
  - lib/rggen/core/builder/simple_feature_entry.rb
@@ -124,6 +125,7 @@ files:
124
125
  - lib/rggen/core/input_base/input_data.rb
125
126
  - lib/rggen/core/input_base/input_matcher.rb
126
127
  - lib/rggen/core/input_base/input_value.rb
128
+ - lib/rggen/core/input_base/input_value_extractor.rb
127
129
  - lib/rggen/core/input_base/json_loader.rb
128
130
  - lib/rggen/core/input_base/loader.rb
129
131
  - lib/rggen/core/input_base/property.rb
@@ -187,5 +189,5 @@ requirements: []
187
189
  rubygems_version: 3.1.2
188
190
  signing_key:
189
191
  specification_version: 4
190
- summary: rggen-core-0.20.0
192
+ summary: rggen-core-0.21.0
191
193
  test_files: []