rggen-core 0.20.0 → 0.21.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
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: []