embulk 0.7.2 → 0.7.3

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.
@@ -38,83 +38,81 @@ module Embulk
38
38
  raise NotImplementedError, "InputPlugin#run must be implemented"
39
39
  end
40
40
 
41
- if Embulk.java?
42
- def self.new_java
43
- JavaAdapter.new(self)
44
- end
41
+ def self.new_java
42
+ JavaAdapter.new(self)
43
+ end
45
44
 
46
- class JavaAdapter
47
- include Java::InputPlugin
45
+ class JavaAdapter
46
+ include Java::InputPlugin
48
47
 
49
- def initialize(ruby_class)
50
- @ruby_class = ruby_class
51
- end
48
+ def initialize(ruby_class)
49
+ @ruby_class = ruby_class
50
+ end
52
51
 
53
- def transaction(java_config, java_control)
54
- config = DataSource.from_java(java_config)
55
- config_diff_hash = @ruby_class.transaction(config) do |task_source_hash,columns,task_count|
56
- java_task_source = DataSource.from_ruby_hash(task_source_hash).to_java
57
- java_schema = Schema.new(columns).to_java
58
- java_task_reports = java_control.run(java_task_source, java_schema, task_count)
59
- java_task_reports.map {|java_task_report|
60
- DataSource.from_java(java_task_report)
61
- }
62
- end
63
- # TODO check return type of #transaction
64
- return DataSource.from_ruby_hash(config_diff_hash).to_java
52
+ def transaction(java_config, java_control)
53
+ config = DataSource.from_java(java_config)
54
+ config_diff_hash = @ruby_class.transaction(config) do |task_source_hash,columns,task_count|
55
+ java_task_source = DataSource.from_ruby_hash(task_source_hash).to_java
56
+ java_schema = Schema.new(columns).to_java
57
+ java_task_reports = java_control.run(java_task_source, java_schema, task_count)
58
+ java_task_reports.map {|java_task_report|
59
+ DataSource.from_java(java_task_report)
60
+ }
65
61
  end
62
+ # TODO check return type of #transaction
63
+ return DataSource.from_ruby_hash(config_diff_hash).to_java
64
+ end
66
65
 
67
- def resume(java_task_source, java_schema, task_count, java_control)
68
- task_source = DataSource.from_java(java_task_source)
69
- schema = Schema.from_java(java_schema)
70
- config_diff_hash = @ruby_class.resume(task_source, schema, task_count) do |task_source_hash,columns,task_count|
71
- java_task_source = DataSource.from_ruby_hash(task_source_hash).to_java
72
- java_schema = Schema.new(columns).to_java
73
- java_task_reports = java_control.run(java_task_source, java_schema, task_count)
74
- java_task_reports.map {|java_task_report|
75
- DataSource.from_java(java_task_report)
76
- }
77
- end
78
- # TODO check return type of #resume
79
- return DataSource.from_ruby_hash(config_diff_hash).to_java
66
+ def resume(java_task_source, java_schema, task_count, java_control)
67
+ task_source = DataSource.from_java(java_task_source)
68
+ schema = Schema.from_java(java_schema)
69
+ config_diff_hash = @ruby_class.resume(task_source, schema, task_count) do |task_source_hash,columns,task_count|
70
+ java_task_source = DataSource.from_ruby_hash(task_source_hash).to_java
71
+ java_schema = Schema.new(columns).to_java
72
+ java_task_reports = java_control.run(java_task_source, java_schema, task_count)
73
+ java_task_reports.map {|java_task_report|
74
+ DataSource.from_java(java_task_report)
75
+ }
80
76
  end
77
+ # TODO check return type of #resume
78
+ return DataSource.from_ruby_hash(config_diff_hash).to_java
79
+ end
81
80
 
82
- def cleanup(java_task_source, java_schema, task_count, java_task_reports)
83
- task_source = DataSource.from_java(java_task_source)
84
- schema = Schema.from_java(java_schema)
85
- task_reports = java_task_reports.map {|c| DataSource.from_java(c) }
86
- @ruby_class.cleanup(task_source, schema, task_count, task_reports)
87
- return nil
88
- end
81
+ def cleanup(java_task_source, java_schema, task_count, java_task_reports)
82
+ task_source = DataSource.from_java(java_task_source)
83
+ schema = Schema.from_java(java_schema)
84
+ task_reports = java_task_reports.map {|c| DataSource.from_java(c) }
85
+ @ruby_class.cleanup(task_source, schema, task_count, task_reports)
86
+ return nil
87
+ end
89
88
 
90
- def guess(java_config)
91
- config = DataSource.from_java(java_config)
92
- config_diff_hash = @ruby_class.guess(config)
93
- return DataSource.from_ruby_hash(config_diff_hash).to_java
94
- end
89
+ def guess(java_config)
90
+ config = DataSource.from_java(java_config)
91
+ config_diff_hash = @ruby_class.guess(config)
92
+ return DataSource.from_ruby_hash(config_diff_hash).to_java
93
+ end
95
94
 
96
- def run(java_task_source, java_schema, processor_index, java_output)
97
- task_source = DataSource.from_java(java_task_source)
98
- schema = Schema.from_java(java_schema)
99
- page_builder = PageBuilder.new(schema, java_output)
100
- begin
101
- task_report_hash = @ruby_class.new(task_source, schema, processor_index, page_builder).run
102
- return DataSource.from_ruby_hash(task_report_hash).to_java
103
- ensure
104
- page_builder.close
105
- end
95
+ def run(java_task_source, java_schema, processor_index, java_output)
96
+ task_source = DataSource.from_java(java_task_source)
97
+ schema = Schema.from_java(java_schema)
98
+ page_builder = PageBuilder.new(schema, java_output)
99
+ begin
100
+ task_report_hash = @ruby_class.new(task_source, schema, processor_index, page_builder).run
101
+ return DataSource.from_ruby_hash(task_report_hash).to_java
102
+ ensure
103
+ page_builder.close
106
104
  end
107
105
  end
106
+ end
108
107
 
109
- def self.from_java(java_class)
110
- JavaPlugin.ruby_adapter_class(java_class, InputPlugin, RubyAdapter)
111
- end
108
+ def self.from_java(java_class)
109
+ JavaPlugin.ruby_adapter_class(java_class, InputPlugin, RubyAdapter)
110
+ end
112
111
 
113
- module RubyAdapter
114
- module ClassMethods
115
- end
116
- # TODO
112
+ module RubyAdapter
113
+ module ClassMethods
117
114
  end
115
+ # TODO
118
116
  end
119
117
  end
120
118
 
@@ -47,103 +47,101 @@ module Embulk
47
47
  {}
48
48
  end
49
49
 
50
- if Embulk.java?
51
- def self.new_java
52
- JavaAdapter.new(self)
53
- end
50
+ def self.new_java
51
+ JavaAdapter.new(self)
52
+ end
54
53
 
55
- class JavaAdapter
56
- include Java::OutputPlugin
54
+ class JavaAdapter
55
+ include Java::OutputPlugin
57
56
 
58
- def initialize(ruby_class)
59
- @ruby_class = ruby_class
60
- end
57
+ def initialize(ruby_class)
58
+ @ruby_class = ruby_class
59
+ end
61
60
 
62
- def transaction(java_config, java_schema, task_count, java_control)
63
- config = DataSource.from_java(java_config)
64
- schema = Schema.from_java(java_schema)
65
- config_diff_hash = @ruby_class.transaction(config, schema, task_count) do |task_source_hash|
66
- java_task_source = DataSource.from_ruby_hash(task_source_hash).to_java
67
- java_task_reports = java_control.run(java_task_source)
68
- java_task_reports.map {|java_task_report|
69
- DataSource.from_java(java_task_report)
70
- }
71
- end
72
- # TODO check return type of #transaction
73
- return DataSource.from_ruby_hash(config_diff_hash).to_java
61
+ def transaction(java_config, java_schema, task_count, java_control)
62
+ config = DataSource.from_java(java_config)
63
+ schema = Schema.from_java(java_schema)
64
+ config_diff_hash = @ruby_class.transaction(config, schema, task_count) do |task_source_hash|
65
+ java_task_source = DataSource.from_ruby_hash(task_source_hash).to_java
66
+ java_task_reports = java_control.run(java_task_source)
67
+ java_task_reports.map {|java_task_report|
68
+ DataSource.from_java(java_task_report)
69
+ }
74
70
  end
71
+ # TODO check return type of #transaction
72
+ return DataSource.from_ruby_hash(config_diff_hash).to_java
73
+ end
75
74
 
76
- def resume(java_task_source, java_schema, task_count, java_control)
77
- task_source = DataSource.from_java(java_task_source)
78
- schema = Schema.from_java(java_schema)
79
- config_diff_hash = @ruby_class.resume(task_source, schema, task_count) do |task_source_hash,columns,task_count|
80
- java_task_source = DataSource.from_ruby_hash(task_source_hash).to_java
81
- java_task_reports = java_control.run(java_task_source)
82
- java_task_reports.map {|java_task_report|
83
- DataSource.from_java(java_task_report)
84
- }
85
- end
86
- # TODO check return type of #resume
87
- return DataSource.from_ruby_hash(config_diff_hash).to_java
75
+ def resume(java_task_source, java_schema, task_count, java_control)
76
+ task_source = DataSource.from_java(java_task_source)
77
+ schema = Schema.from_java(java_schema)
78
+ config_diff_hash = @ruby_class.resume(task_source, schema, task_count) do |task_source_hash,columns,task_count|
79
+ java_task_source = DataSource.from_ruby_hash(task_source_hash).to_java
80
+ java_task_reports = java_control.run(java_task_source)
81
+ java_task_reports.map {|java_task_report|
82
+ DataSource.from_java(java_task_report)
83
+ }
88
84
  end
85
+ # TODO check return type of #resume
86
+ return DataSource.from_ruby_hash(config_diff_hash).to_java
87
+ end
89
88
 
90
- def cleanup(java_task_source, java_schema, task_count, java_task_reports)
91
- task_source = DataSource.from_java(java_task_source)
92
- schema = Schema.from_java(java_schema)
93
- task_reports = java_task_reports.map {|c| DataSource.from_java(c) }
94
- @ruby_class.cleanup(task_source, schema, task_count, task_reports)
95
- return nil
96
- end
89
+ def cleanup(java_task_source, java_schema, task_count, java_task_reports)
90
+ task_source = DataSource.from_java(java_task_source)
91
+ schema = Schema.from_java(java_schema)
92
+ task_reports = java_task_reports.map {|c| DataSource.from_java(c) }
93
+ @ruby_class.cleanup(task_source, schema, task_count, task_reports)
94
+ return nil
95
+ end
97
96
 
98
- def open(java_task_source, java_schema, processor_index)
99
- task_source = DataSource.from_java(java_task_source)
100
- schema = Schema.from_java(java_schema)
101
- ruby_object = @ruby_class.new(task_source, schema, processor_index)
102
- return OutputAdapter.new(ruby_object, schema)
103
- end
97
+ def open(java_task_source, java_schema, processor_index)
98
+ task_source = DataSource.from_java(java_task_source)
99
+ schema = Schema.from_java(java_schema)
100
+ ruby_object = @ruby_class.new(task_source, schema, processor_index)
101
+ return OutputAdapter.new(ruby_object, schema)
102
+ end
104
103
 
105
- class OutputAdapter
106
- include Java::TransactionalPageOutput
104
+ class OutputAdapter
105
+ include Java::TransactionalPageOutput
107
106
 
108
- def initialize(ruby_object, schema)
109
- @ruby_object = ruby_object
110
- @schema = schema
111
- end
107
+ def initialize(ruby_object, schema)
108
+ @ruby_object = ruby_object
109
+ @schema = schema
110
+ end
112
111
 
113
- def add(java_page)
114
- # TODO reuse page reader
115
- @ruby_object.add Page.new(java_page, @schema)
116
- end
112
+ def add(java_page)
113
+ # TODO reuse page reader
114
+ @ruby_object.add Page.new(java_page, @schema)
115
+ end
117
116
 
118
- def finish
119
- @ruby_object.finish
120
- end
117
+ def finish
118
+ @ruby_object.finish
119
+ end
121
120
 
122
- def close
123
- @ruby_object.close
124
- end
121
+ def close
122
+ @ruby_object.close
123
+ end
125
124
 
126
- def abort
127
- @ruby_object.abort
128
- end
125
+ def abort
126
+ @ruby_object.abort
127
+ end
129
128
 
130
- def commit
131
- task_report_hash = @ruby_object.commit
132
- return DataSource.from_ruby_hash(task_report_hash).to_java
133
- end
129
+ def commit
130
+ task_report_hash = @ruby_object.commit
131
+ return DataSource.from_ruby_hash(task_report_hash).to_java
134
132
  end
135
133
  end
134
+ end
136
135
 
137
- def self.from_java(java_class)
138
- JavaPlugin.ruby_adapter_class(java_class, OutputPlugin, RubyAdapter)
139
- end
136
+ def self.from_java(java_class)
137
+ JavaPlugin.ruby_adapter_class(java_class, OutputPlugin, RubyAdapter)
138
+ end
140
139
 
141
- module RubyAdapter
142
- module ClassMethods
143
- # TODO transaction, resume, cleanup
144
- end
145
- # TODO add, finish, close, abort, commit
140
+ module RubyAdapter
141
+ module ClassMethods
142
+ # TODO transaction, resume, cleanup
146
143
  end
144
+ # TODO add, finish, close, abort, commit
147
145
  end
148
146
  end
149
147
 
@@ -26,52 +26,50 @@ module Embulk
26
26
  raise NotImplementedError, "ParserPlugin#run(file_input) must be implemented"
27
27
  end
28
28
 
29
- if Embulk.java?
30
- def self.new_java
31
- JavaAdapter.new(self)
32
- end
29
+ def self.new_java
30
+ JavaAdapter.new(self)
31
+ end
33
32
 
34
- class JavaAdapter
35
- include Java::ParserPlugin
33
+ class JavaAdapter
34
+ include Java::ParserPlugin
36
35
 
37
- def initialize(ruby_class)
38
- @ruby_class = ruby_class
39
- end
36
+ def initialize(ruby_class)
37
+ @ruby_class = ruby_class
38
+ end
40
39
 
41
- def transaction(java_config, java_control)
42
- config = DataSource.from_java(java_config)
43
- @ruby_class.transaction(config) do |task_source_hash,columns|
44
- java_task_source = DataSource.from_ruby_hash(task_source_hash).to_java
45
- java_schema = Schema.new(columns).to_java
46
- java_control.run(java_task_source, java_schema)
47
- end
48
- nil
40
+ def transaction(java_config, java_control)
41
+ config = DataSource.from_java(java_config)
42
+ @ruby_class.transaction(config) do |task_source_hash,columns|
43
+ java_task_source = DataSource.from_ruby_hash(task_source_hash).to_java
44
+ java_schema = Schema.new(columns).to_java
45
+ java_control.run(java_task_source, java_schema)
49
46
  end
47
+ nil
48
+ end
50
49
 
51
- def run(java_task_source, java_schema, java_file_input, java_output)
52
- task_source = DataSource.from_java(java_task_source)
53
- schema = Schema.from_java(java_schema)
54
- file_input = FileInput.new(java_file_input)
55
- page_builder = PageBuilder.new(schema, java_output)
56
- begin
57
- @ruby_class.new(task_source, schema, page_builder).run(file_input)
58
- nil
59
- ensure
60
- page_builder.close
61
- # FileInput is closed by FileInputRunner
62
- end
50
+ def run(java_task_source, java_schema, java_file_input, java_output)
51
+ task_source = DataSource.from_java(java_task_source)
52
+ schema = Schema.from_java(java_schema)
53
+ file_input = FileInput.new(java_file_input)
54
+ page_builder = PageBuilder.new(schema, java_output)
55
+ begin
56
+ @ruby_class.new(task_source, schema, page_builder).run(file_input)
57
+ nil
58
+ ensure
59
+ page_builder.close
60
+ # FileInput is closed by FileInputRunner
63
61
  end
64
62
  end
63
+ end
65
64
 
66
- def self.from_java(java_class)
67
- JavaPlugin.ruby_adapter_class(java_class, ParserPlugin, RubyAdapter)
68
- end
65
+ def self.from_java(java_class)
66
+ JavaPlugin.ruby_adapter_class(java_class, ParserPlugin, RubyAdapter)
67
+ end
69
68
 
70
- module RubyAdapter
71
- module ClassMethods
72
- end
73
- # TODO
69
+ module RubyAdapter
70
+ module ClassMethods
74
71
  end
72
+ # TODO
75
73
  end
76
74
  end
77
75
 
data/lib/embulk/plugin.rb CHANGED
@@ -14,8 +14,8 @@ module Embulk
14
14
  require 'embulk/encoder_plugin'
15
15
  require 'embulk/guess_plugin'
16
16
  require 'embulk/executor_plugin'
17
- require 'embulk/java_plugin' if Embulk.java?
18
- require 'embulk/exec' if Embulk.java?
17
+ require 'embulk/java_plugin'
18
+ require 'embulk/exec'
19
19
 
20
20
  class PluginManager
21
21
  def initialize
data/lib/embulk/schema.rb CHANGED
@@ -88,15 +88,13 @@ module Embulk
88
88
  @record_writer.call(page_builder, record)
89
89
  end
90
90
 
91
- if Embulk.java?
92
- def self.from_java(java_schema)
93
- new java_schema.getColumns.map {|column| Column.from_java(column) }
94
- end
91
+ def self.from_java(java_schema)
92
+ new java_schema.getColumns.map {|column| Column.from_java(column) }
93
+ end
95
94
 
96
- def to_java
97
- columns = self.map {|column| column.to_java }
98
- Java::Schema.new(columns)
99
- end
95
+ def to_java
96
+ columns = self.map {|column| column.to_java }
97
+ Java::Schema.new(columns)
100
98
  end
101
99
  end
102
100
 
@@ -1,3 +1,3 @@
1
1
  module Embulk
2
- VERSION = '0.7.2'
2
+ VERSION = '0.7.3'
3
3
  end