Module: Cascading::Operations

Included in:
Aggregations, Assembly
Defined in:
lib/cascading/operations.rb

Overview

The Cascading::Operations module is deprecated. The original idea from long ago is that it would be useful to mixin operator wrappers to places other than Cascading::Assembly, but this is not true. Instead, put Eaches in Cascading::Assembly, Everies in Cascading::Aggregations, and any more generally useful utility code directly in the Cascading module (cascading/cascading.rb).

Further, the entire *args pattern should be deprecated as it leads to functions that can only be understood by reading their code. Instead, idiomatic Ruby (positional required params and a params hash for optional args) should be used. See Cascading::Assembly#set_value for an example.

Instance Method Summary collapse

Instance Method Details

#aggregator_function(args, aggregator_klass) ⇒ Object 



18
19
20
21
22
23
24
 
# File 'lib/cascading/operations.rb', line 18

def aggregator_function(args, aggregator_klass)
  options = args.extract_options!
  ignore = options[:ignore]

  parameters = [Cascading.fields(args), ignore].compact
  aggregator_klass.new(*parameters)
end

#coerce_to_java(v) ⇒ Object 



121
122
123
124
125
126
127
128
129
130
131
132
 
# File 'lib/cascading/operations.rb', line 121

def coerce_to_java(v)
  case v
    when Fixnum
      java.lang.Long.new(v)
    when Float
      java.lang.Double.new(v)
    when NilClass
      nil
    else
      java.lang.String.new(v.to_s)
  end
end

#date_formatter(fields, format, timezone = nil) ⇒ Object 



163
164
165
166
167
168
 
# File 'lib/cascading/operations.rb', line 163

def date_formatter(fields, format, timezone=nil)
  fields = fields(fields)
  timezone = Java::JavaUtil::TimeZone.get_time_zone(timezone) if timezone
  arguments = [fields, format, timezone].compact
  Java::CascadingOperationText::DateFormatter.new(*arguments)
end

#date_parser(field, format) ⇒ Object 



158
159
160
161
 
# File 'lib/cascading/operations.rb', line 158

def date_parser(field, format)
  fields = fields(field)
  Java::CascadingOperationText::DateParser.new(fields, format)
end

#expression_filter(*args) ⇒ Object 



134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
 
# File 'lib/cascading/operations.rb', line 134

def expression_filter(*args)
  options = args.extract_options!
  expression = (args[0] || options[:expression]).to_s
  parameters = options[:parameters]
  parameter_names = []
  parameter_types = []
  if parameters.is_a? ::Hash
    parameters.each do |name, type|
      parameter_names << name
      parameter_types << type
    end
    parameter_names = parameter_names.to_java(java.lang.String)
    parameter_types = parameter_types.to_java(java.lang.Class)

    arguments = [expression, parameter_names, parameter_types].compact
  elsif !parameters.nil?
    arguments = [expression, parameters.java_class].compact
  else
    arguments = [expression, java.lang.String.java_class].compact
  end

  Java::CascadingOperationExpression::ExpressionFilter.new(*arguments)
end

#expression_function(*args) ⇒ Object 



80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/cascading/operations.rb', line 80

def expression_function(*args)
  options = args.extract_options!

  fields = Cascading.fields(args)
  expression = options[:expression].to_s
  parameters = options[:parameters]
  parameter_names = []
  parameter_types = []
  if parameters.is_a? ::Hash
    parameters.each do |name, type|
      parameter_names << name
      parameter_types << type
    end
    parameter_names = parameter_names.to_java(java.lang.String)
    parameter_types = parameter_types.to_java(java.lang.Class)

    arguments = [fields, expression, parameter_names, parameter_types].compact
  elsif !parameters.nil?
    arguments = [fields, expression, parameters.java_class].compact
  else
    arguments = [fields, expression, java.lang.String.java_class].compact
  end

  Java::CascadingOperationExpression::ExpressionFunction.new(*arguments)
end

#field_joiner(*args) ⇒ Object 



192
193
194
195
196
197
198
199
 
# File 'lib/cascading/operations.rb', line 192

def field_joiner(*args)
  options = args.extract_options!
  delimiter = options[:delimiter] || ','
  fields = fields(options[:into])

  parameters = [fields, delimiter].compact
  Java::CascadingOperationText::FieldJoiner.new(*parameters)
end

#first_function(*args) ⇒ Object 



26
27
28
 
# File 'lib/cascading/operations.rb', line 26

def first_function(*args)
  aggregator_function(args, Java::CascadingOperationAggregator::First)
end

#identity ⇒ Object 



14
15
16
 
# File 'lib/cascading/operations.rb', line 14

def identity
  Java::CascadingOperation::Identity.new
end

#insert_function(*args) ⇒ Object 



106
107
108
109
110
111
112
113
 
# File 'lib/cascading/operations.rb', line 106

def insert_function(*args)
  options=args.extract_options!
  fields = Cascading.fields(args)
  values = options[:values]

  parameters = [fields, to_java_comparable_array(values)].compact
  Java::CascadingOperation::Insert.new(*parameters)
end

#last_function(*args) ⇒ Object 



38
39
40
 
# File 'lib/cascading/operations.rb', line 38

def last_function(*args)
  aggregator_function(args, Java::CascadingOperationAggregator::Last)
end

#max_function(*args) ⇒ Object 



34
35
36
 
# File 'lib/cascading/operations.rb', line 34

def max_function(*args)
  aggregator_function(args, Java::CascadingOperationAggregator::Max)
end

#min_function(*args) ⇒ Object 



30
31
32
 
# File 'lib/cascading/operations.rb', line 30

def min_function(*args)
  aggregator_function(args, Java::CascadingOperationAggregator::Min)
end

#regex_filter(*args) ⇒ Object 



170
171
172
173
174
175
176
177
178
 
# File 'lib/cascading/operations.rb', line 170

def regex_filter(*args)
  options = args.extract_options!

  pattern = args[0]
  remove_match = options[:remove_match]
  match_each_element = options[:match_each_element]
  parameters = [pattern.to_s, remove_match, match_each_element].compact
  Java::CascadingOperationRegex::RegexFilter.new(*parameters)
end

#regex_generator(*args) ⇒ Object 



71
72
73
74
75
76
77
78
 
# File 'lib/cascading/operations.rb', line 71

def regex_generator(*args)
  options = args.extract_options!

  fields = Cascading.fields(args)
  pattern = options[:pattern].to_s
  parameters = [fields, pattern].compact
  Java::CascadingOperationRegex::RegexGenerator.new(*parameters)
end

#regex_parser(*args) ⇒ Object 



42
43
44
45
46
47
48
49
50
51
 
# File 'lib/cascading/operations.rb', line 42

def regex_parser(*args)
  options = args.extract_options!

  pattern = args[0].to_s
  fields = Cascading.fields(options[:fields])
  groups = options[:groups].to_java(:int) if options[:groups]
  parameters = [fields, pattern, groups].compact

  Java::CascadingOperationRegex::RegexParser.new(*parameters)
end

#regex_replace(*args) ⇒ Object 



180
181
182
183
184
185
186
187
188
189
190
 
# File 'lib/cascading/operations.rb', line 180

def regex_replace(*args)
  options = args.extract_options!

  fields = fields(args[0])
  pattern = args[1]
  replacement = args[2]
  replace_all = options[:replace_all]

  parameters = [fields, pattern.to_s, replacement.to_s, replace_all].compact
  Java::CascadingOperationRegex::RegexReplace.new(*parameters)
end

#regex_split_generator(*args) ⇒ Object 



62
63
64
65
66
67
68
69
 
# File 'lib/cascading/operations.rb', line 62

def regex_split_generator(*args)
  options = args.extract_options!

  fields = Cascading.fields(args)
  pattern = options[:pattern].to_s
  parameters = [fields, pattern].compact
  Java::CascadingOperationRegex::RegexSplitGenerator.new(*parameters)
end

#regex_splitter(*args) ⇒ Object 



53
54
55
56
57
58
59
60
 
# File 'lib/cascading/operations.rb', line 53

def regex_splitter(*args)
  options = args.extract_options!

  fields = Cascading.fields(args)
  pattern = options[:pattern].to_s
  parameters = [fields, pattern].compact
  Java::CascadingOperationRegex::RegexSplitter.new(*parameters)
end

#to_java_comparable_array(arr) ⇒ Object 



115
116
117
118
119
 
# File 'lib/cascading/operations.rb', line 115

def to_java_comparable_array(arr)
  (arr.map do |v|
    coerce_to_java(v)
  end).to_java(java.lang.Comparable)
end