I have a questions list, and I need to separate them. The relationship is
Question_set has_many questions
BookVolume has_many questions
Subject has_many book_volumes
Publisher has_many subjects
Section has_many :questions
Now I only put questions and their relative model id, name into hash inside an array.
data = []
question_set.questions.each do |q|
data << {publisher: {id: q.publisher.id, name: q.publisher.name}, subject: {id: q.book_volume.subject.id, name: q.book_volume.subject.name}, volume: {id: q.book_volume_id, name: q.book_volume.name}, chapter: [{id: q.section_id, name: q.section.name}]}
end
Therefore, the data basically will be
>>data
[
{
:publisher => {
:id => 96,
:name => "P1"
},
:subject => {
:id => 233,
:name => "S1"
},
:volume => {
:id => 1136,
:name => "V1"
},
:chapter => [
{
:id => 16155,
:name => "C1"
}
]
},
{
:publisher => {
:id => 96,
:name => "P1"
},
:subject => {
:id => 233,
:name => "S1"
},
:volume => {
:id => 1136,
:name => "V1"
},
:chapter => [
{
:id => 16158,
:name => "C2"
}
]
}
]
However, I want the chapter to be combined if they got the same publisher, subject and volume
So, in this case, it will be
>>data
[
{
:publisher => {
:id => 96,
:name => "P1"
},
:subject => {
:id => 233,
:name => "S1"
},
:volume => {
:id => 1136,
:name => "V1"
},
:chapter => [
{
:id => 16155,
:name => "C2"
},
{
:id => 16158,
:name => "C2"
}
]
}
]
Code
def group_em(data)
data.group_by { |h| [h[:publisher], h[:subject], h[:volume]] }.
map do |k,v|
h = { publisher: k[0], subject: k[1], volume: k[2] }
h.update(chapters: v.each_with_object([]) { |f,a|
a << f[:chapter] }.flatten)
end
end
Example
Let data equal the array of hashes (the first array above).
group_em(data)
#=> [{:publisher=>{:id=>96, :name=>"P1"},
# :subject=>{:id=>233, :name=>"S1"},
# :volume=>{:id=>1136, :name=>"V1"},
# :chapters=>[{:id=>16155, :name=>"C1"}, {:id=>16158, :name=>"C2"}]
# }
# ]
Here data contains only two hashes and those hashes have the same values for the keys :publisher, :subject and :volume. This code allows the array to have any number of hashes, and will group them by an array of the values of those three keys, producing one hash for each of those groups. Moreover, the values of the key :chapters are arrays containing a single hash, but this code permits that array to contain multiple hashes. (If that array will always have exactly one hash, consider making the value of :chapters the hash itself rather than an array containing that hash.)
Explanation
See Enumerable#group_by and Hash#update (aka Hash#merge!).
The steps are as follows.
h = data.group_by { |h| [h[:publisher], h[:subject], h[:volume]] }
#=> {
# [{:id=>96, :name=>"P1"},
# {:id=>233, :name=>"S1"},
# {:id=>1136, :name=>"V1"}
# ]=>[{:publisher=>{:id=>96, :name=>"P1"},
# :subject=>{:id=>233, :name=>"S1"},
# :volume=>{:id=>1136, :name=>"V1"},
# :chapter=>[{:id=>16155, :name=>"C1"}]
# },
# {:publisher=>{:id=>96, :name=>"P1"},
# :subject=>{:id=>233, :name=>"S1"},
# :volume=>{:id=>1136, :name=>"V1"},
# :chapter=>[{:id=>16158, :name=>"C2"}]
# }
# ]
# }
The first key-value pair is passed to map's block and the block variables are assigned.
k,v = h.first
#=> [[{:id=>96, :name=>"P1"}, {:id=>233, :name=>"S1"}, {:id=>1136, :name=>"V1"}],
# [{:publisher=>{:id=>96, :name=>"P1"}, :subject=>{:id=>233, :name=>"S1"},
# :volume=>{:id=>1136, :name=>"V1"}, :chapter=>[{:id=>16155, :name=>"C1"}]},
# {:publisher=>{:id=>96, :name=>"P1"}, :subject=>{:id=>233, :name=>"S1"},
# :volume=>{:id=>1136, :name=>"V1"}, :chapter=>[{:id=>16158, :name=>"C2"}]}]]
k #=> [{:id=>96, :name=>"P1"}, {:id=>233, :name=>"S1"}, {:id=>1136, :name=>"V1"}]
v #=> [{:publisher=>{:id=>96, :name=>"P1"},
# :subject=>{:id=>233, :name=>"S1"},
# :volume=>{:id=>1136, :name=>"V1"},
# :chapter=>[{:id=>16155, :name=>"C1"}]},
# {:publisher=>{:id=>96, :name=>"P1"},
# :subject=>{:id=>233, :name=>"S1"},
# :volume=>{:id=>1136, :name=>"V1"},
# :chapter=>[{:id=>16158, :name=>"C2"}]}]
and the block calculation is performed.
h = { publisher: k[0], subject: k[1], volume: k[2] }
#=> {:publisher=>{:id=>96, :name=>"P1"},
# :subject=>{:id=>233, :name=>"S1"},
# :volume=>{:id=>1136, :name=>"V1"}
# }
a = v.each_with_object([]) { |f,a| a << f[:chapter] }
#=> [[{:id=>16155, :name=>"C1"}], [{:id=>16158, :name=>"C2"}]]
b = a.flatten
#=> [{:id=>16155, :name=>"C1"}, {:id=>16158, :name=>"C2"}]
h.update(chapters: b)
#=> {:publisher=>{:id=>96, :name=>"P1"},
# :subject=>{:id=>233, :name=>"S1"},
# :volume=>{:id=>1136, :name=>"V1"},
# :chapters=>[{:id=>16155, :name=>"C1"}, {:id=>16158, :name=>"C2"}]
# }
Hash#merge could be used in place of Hash#update.
How about:
data = {}
question_set.questions.each do |q|
key = "#{q.publisher.id}:#{q.book_volume.subject.id}:#{q.book_volume_id}"
if data[key].present?
data[key][:chapter] << {id: q.section_id, name: q.section.name}
else
data[key] = {publisher: {id: q.publisher.id, name: q.publisher.name}, subject: {id: q.book_volume.subject.id, name: q.book_volume.subject.name}, volume: {id: q.book_volume_id, name: q.book_volume.name}, chapter: [{id: q.section_id, name: q.section.name}]}
end
end
result = data.values
use the combination of publisher'id, subject'id and volume'id as a unique key to combine your data.
Related
Hash
data = {
:recordset => {
:row => {
:property => [
{:name => "Code", :value => "C0001"},
{:name => "Customer", :value => "ROSSI MARIO"}
]
}
},
:#xmlns => "http://localhost/test"
}
Code Used
result = data[:recordset][:row].each_with_object([]) do |hash, out|
out << hash[:property].each_with_object({}) do |h, o|
o[h[:name]] = h[:value]
end
end
I cannot get the following output:
[{"Code"=>"C0001", "Customer"=>"ROSSI MARIO", "Phone1"=>"1234567890"}
Error message:
TypeError no implicit conversion of Symbol into Integer
It works correctly in case of multi records
data = {
:recordset => {
:row => [{
:property => [
{:name => "Code", :value => "C0001"},
{:name => "Customer", :value => "ROSSI MARIO"},
{:name => "Phone1", :value => "1234567890"}
]
}, {
:property => [
{:name => "Code", :value => "C0002"},
{:name => "Customer", :value => "VERDE VINCENT"},
{:name => "Phone1", :value => "9876543210"},
{:name => "Phone2", :value => "2468101214"}
]
}]
},
:#xmlns => "http://localhost/test"
}
Code used
data.keys
#=> [:recordset, :#xmlns]
data[:recordset][:row].count
#=> 2 # There are 2 set of attribute-value pairs
result = data[:recordset][:row].each_with_object([]) do |hash, out|
out << hash[:property].each_with_object({}) do |h, o|
o[h[:name]] = h[:value]
end
end
#=> [
# {"Code"=>"C0001", "Customer"=>"ROSSI MARIO", "Phone1"=>"1234567890"},
# {"Code"=>"C0002", "Customer"=>"VERDE VINCENT", "Phone1"=>"9876543210", "Phone2"=>"2468101214"}
# ]
In the first case data[:recordset][:row] is not an Array, it's a Hash, so when you iterate it, the hash variable becomes the array:
[:property, [{:name=>"Code", :value=>"C0001"}, {:name=>"Customer", :value=>"ROSSI MARIO"}]]
In the second case, it's an Array, not a Hash, so when you iterate it, it becomes the hash:
{:property=>[{:name=>"Code", :value=>"C0001"}, {:name=>"Customer", :value=>"ROSSI MARIO"}, {:name=>"Phone1", :value=>"1234567890"}]}
You're always assuming it's the second format. You could force it into an array, and then flatten by 1 level to treat both instances the same:
result = [data[:recordset][:row]].flatten(1).each_with_object([]) do |hash, out|
out << hash[:property].each_with_object({}) do |h, o|
o[h[:name]] = h[:value]
end
end
# => [{"Code"=>"C0001", "Customer"=>"ROSSI MARIO"}] # result from example 1
# => [{"Code"=>"C0001", "Customer"=>"ROSSI MARIO", "Phone1"=>"1234567890"},
# {"Code"=>"C0002", "Customer"=>"VERDE VINCENT",
# "Phone1"=>"9876543210", "Phone2"=>"2468101214"}] # result from example 2
It's tempting to try and use Kernal#Array() instead of [].flatten(1), but you have to remember that Hash implements to_a to return a nested array of keys and values, so Kernal#Array() doesn't work like you'd want it to:
Array(data[:recordset][:row]) # using the first example data
# => [[:property, [{:name=>"Code", :value=>"C0001"}, {:name=>"Customer", :value=>"ROSSI MARIO"}]]]
You can create an array if it's not an array to normalize the input before processing it.
info = data[:recordset][:row]
info = [info] unless info.is_an? Array
result = info.each_with_object([]) do ....
How can I merge two params together from my permissions hash that share the same "school_id" and "plan_type'. Then delete the permission that was merged from the hash, just leaving one. There can also be more than two that match.
[{"school_id"=>"1",
"plan_type"=>"All",
"view"=>"true",
"create"=>"true",
"approve"=>"true",
"grant"=>"true",
"region_id"=>nil},
{"school_id"=>"1", "plan_type"=>"All", "edit"=>"true", "region_id"=>nil},
{"school_id"=>"2",
"plan_type"=>"All",
"edit"=>"true",
"grant"=>"true",
"region_id"=>nil}]
def create_permissions(user, params)
permissions = params[:permissions].values.map { |perm|
if perm[:plan_type] == "" || perm[:plan_type] == "All Plans"
perm[:plan_type] = "All"
end
#perm_type = get_permission_type(perm)
case
when 'school' then perm.merge(region_id: nil)
when 'region' then perm.merge(school_id: nil)
end
}.tap { |permissions|
new_permissions = []
permissions.each do |perm|
set_permissions = permissions.find {|x| (x != perm && x[:school_id] == perm[:school_id] && x[:plan_type] == perm[:plan_type]) }
end
params[:user][:region_ids] = permissions.map { |perm| perm[:region_id] }.compact
params[:user][:school_ids] = permissions.map { |perm| perm[:school_id] }.compact
}
end
Output:
[{"school_id"=>"1",
"plan_type"=>"All",
"view"=>"true",
"create"=>"true",
"approve"=>"true",
"grant"=>"true",
"region_id"=>nil},
"edit"=>"true"
{"school_id"=>"2",
"plan_type"=>"All",
"edit"=>"true",
"grant"=>"true",
"region_id"=>nil}]
Group by school_id and then reduce by merging hashes:
input.group_by { |e| e['school_id'] }
.values
.map { |v| p v.reduce(&:merge) }
To group by many fields, one might use an array of desired fields, a concatenated string, whatever:
input.group_by { |e| [e['school_id'], e['plan_type']] }
.values
.map { |v| p v.reduce(&:merge) }
or, to keep nifty captions:
input.group_by { |e| "School: #{e['school_id']}, Plan: #{e['plan_type']}" }
.map { |k,v| [k, v.reduce(&:merge)] }
.to_h
#⇒ {
# "School: 1, Plan: All" => {
# "approve" => "true",
# "create" => "true",
# "edit" => "true",
# "grant" => "true",
# "plan_type" => "All",
# "region_id" => nil,
# "school_id" => "1",
# "view" => "true"
# },
# "School: 2, Plan: All" => {
# "edit" => "true",
# "grant" => "true",
# "plan_type" => "All",
# "region_id" => nil,
# "school_id" => "2"
# }
#}
arr1 = arr.group_by { |e| [e["school_id"],e["plan_type"]] }.values
=> {["1", "All"]=>[{"school_id"=>"1", "plan_type"=>"All", "view"=>"true", "create"=>"true", "approve"=>"true", "grant"=>"true", "region_id"=>nil}, {"school_id"=>"1", "plan_type"=>"All", "edit"=>"true", "region_id"=>nil}], ["2", "All"]=>[{"school_id"=>"2", "plan_type"=>"All", "edit"=>"true", "grant"=>"true", "region_id"=>nil}]}
arr1.map{ |i| i.inject({}) { |sum, e| sum.merge e}}
=> [{"school_id"=>"1", "plan_type"=>"All", "view"=>"true", "create"=>"true", "approve"=>"true", "grant"=>"true", "region_id"=>nil, "edit"=>"true"}, {"school_id"=>"2", "plan_type"=>"All", "edit"=>"true", "grant"=>"true", "region_id"=>nil}]
I would like to parse a text to get array of mentioneess from that text :
class Mentionee
attr_reader :id, :display_name
def initialize(id:, display_name:)
#id = id
#display_name = display_name
end
def self.parse(text)
# ???
end
end
mentionees = Mentionee.parse('[1:John C.] [2: Smith X.] you are awesome!')
mentioneess[0].id # => '1'
mentioneess[0].display_name # => 'John C.'
mentioneess[1].id # => '2'
mentioneess[1].display_name # => 'Smith X.'
I think this would help you.
> '[1:John C.] [2: Smith X.] you are awesome!'.scan(/(?<=\[)(\d+)(?=:\s*([^\]]+))/)
=> [["1", "John C."], ["2", "Smith X."]]
If I have understood you want to parse text passed to method parse
def self.parse(text)
text.scan(/\[(.*?):(.*?)\]/).map do |e|
{id: e[0], display_name: e[1]}
end
end
Will produce:
[
{id: "1", display_name: "John C."},
{id: "2", display_name: "Smith X."}
]
and you will be able to use as you described
mentionees = Mentionee.parse('[1:John C.] [2: Smith X.] you are awesome!')
mentioneess[0][:id] # => 1
mentioneess[0][:display_name] # => 'John C.'
mentioneess[1][:id] # => 2
mentioneess[1][:display_name] # => 'Smith X.'
This is what I've been getting:
{:user=>{:employees=>{...}, :login=>"dernalia", :id=>1, :role=>2}}
What is generating the hash:
def management_tree(args = {})
args = {:users => [], :result => {}}.merge(args) #defaults
result = args[:result]
if not args[:users].include? self.login #prevent duplicates
result.merge!({:user => {:id => self.id,
:login => self.login,
:role => self.role,
:employees => employee_tree(args[:users] + [self.login], args[:result])
}
})
end
logger.info result.inspect
return result
end
def employee_tree(users, result)
if self.employees.length > 0
self.employees.each {|emp| (emp.management_tree({:users => users, :result => result})) }
end
return result
end
Now... it's supposed to return something like this:
{:user=>{:login=>"me", :id=>1, :role=>2,
:employees=>{
:user => {:login => "2", ...},
:user => {:login => "3",
:employees => {...}
}
}}
Some console output:
% bundle exec script/console
Loading development environment (Rails 2.3.8)
>> require "awesome_print"
=> []
>> ap User.find(1).management_tree[:employees]
nil
=> nil
>> ap User.find(1).management_tree
{
:user => {
:employees => {...},
:role => 2,
:login => "me",
:id => 1
}
}
=> {:user=>{:employees=>{...}, :role=>2, :login=>"me", :id=>1}}
>>
now... it says that employees is nil... but it shouldn't be... it should have 3 hashes ... =\
but also, what does {...} mean? it seams terribly ambiguous
Ruby is clever about recursive structures and will use "..." instead of looping indefinitely.
For example:
a = [1, 2]
a << a # a is now recursive, since it contains itself
a.to_s # => [1, 2, [...]]
a[2][2][2][2][2][2][2] == a # => true
In your case, the {...} refers to any of the hashes already in the process of being outputed.
Maybe what you meant to do was to insert a copy of a hash? In the simple array example:
a = [1, 2]
a << a.dup # a is not recursive
a.to_s # => [1, 2, [1, 2]]
given a model like:
class SentenceItem < ActiveRecord::Base
after_update :send_changes
def send_changes
#### Is it possible to do a diff here with dirty/changed? Showing what's changed since the last save?
end
end
And that the sentence modle has a text field.
Is it possible to do a diff here with dirty/changed? Showing what's changed since the last save?
Thanks
Yes, there is a way. From the ActiveModel::Dirty documentation:
A newly instantiated object is unchanged:
person = Person.find_by_name('Uncle Bob')
person.changed? # => false
Change the name:
person.name = 'Bob'
person.changed? # => true
person.name_changed? # => true
person.name_was # => 'Uncle Bob'
person.name_change # => ['Uncle Bob', 'Bob']
person.name = 'Bill'
person.name_change # => ['Uncle Bob', 'Bill']
Which attributes have changed?
person.name = 'Bob'
person.changed # => ['name']
person.changes # => { 'name' => ['Bill', 'Bob'] }