Code refactoring advice

ruby-talk
1

I have some code written that basically looks like below. I want to
design a Module, Method, Class, Whatever to make each xml component
accessible by a method and the ability to set attribs, params, clear
params, attribs, etc. I know how to implement the code to do all of
this, but I don't have any experience in created object oriented
implementations (background is all scripting, and some C so used to
making functions). Would appreciate any advice on how to make this OO.

#1/usr/bin/ruby

require 'rubygems'
require 'xml_struct'
require 'uuidtools'

setuprequest = lambda { |a|

    XMLVER = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"

    msguuid = UUID.random_create.to_s

    rqstuuid = UUID.random_create.to_s

    a.MyWrpWrp = {:xmlns => "mtvnCWWrpReq"}

    a.MyWrpWrp.MyWrpVer="1.0"

    a.MyWrpWrp.MsgUUID="#{msguuid}"

    a.MyWrpWrp.YoYoParms.SrcID

    a.MyWrpWrp.YoYoParms.TestInd

    a.MyWrpWrp.Wrp.WrpParms

    a.MyWrpWrp.Wrp.WrpParms.ApplID

    a.MyWrpWrp.Wrp.WrpParms.WrpID

    a.MyWrpWrp.Wrp.WrpParms.WrpVer

    a.MyWrpWrp.Wrp.WrpParms.RqstUUID="#{rqstuuid}"

    a.MyWrpWrp.Wrp.WrpParms.RoutingID

    a.MyWrpWrp.Wrp.WrpParms.Src.CustDefMsgSrc1

    a.MyWrpWrp.Wrp.BigWrap.LilWrap

    a.MyWrpWrp.Wrp.BigWrap.LilWrap.Mom

    a.MyWrpWrp.Wrp.BigWrap.LilWrap.Dad

    a.MyWrpWrp.Wrp.MsgData

    return a
}

request = XmlStruct.new

setuprequest.call(request)

puts request.to_s

Thanks,

Nathan

···

--
Posted via http://www.ruby-forum.com/.

2

Not that this makes it any more object oriented, but why use a lambda?
Sure it works but in this case I find that it obfuscates a bit why
not something like?:

equire 'rubygems'
require 'xml_struct'
require 'uuidtools'

def setuprequest(request=XMLStruct.new)
    XMLVER = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
    msguuid = UUID.random_create.to_s
    rqstuuid = UUID.random_create.to_s
    request.MyWrpWrp = {:xmlns => "mtvnCWWrpReq"}
    # etc

   return request # or more idiomatically just have request as the last line.
}

# Now since we provided a default parameter, and we are returning the
# request the usage simplifies to:

puts setuprequest.to_s

···

On 6/11/07, Nathan Taylor-Hoover <onebitcipher@gmail.com> wrote:

I have some code written that basically looks like below. I want to
design a Module, Method, Class, Whatever to make each xml component
accessible by a method and the ability to set attribs, params, clear
params, attribs, etc. I know how to implement the code to do all of
this, but I don't have any experience in created object oriented
implementations (background is all scripting, and some C so used to
making functions). Would appreciate any advice on how to make this OO.

#1/usr/bin/ruby

require 'rubygems'

require 'xml_struct'
require 'uuidtools'

setuprequest = lambda { |a|

    XMLVER = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"

    msguuid = UUID.random_create.to_s

    rqstuuid = UUID.random_create.to_s

    a.MyWrpWrp = {:xmlns => "mtvnCWWrpReq"}

    a.MyWrpWrp.MyWrpVer="1.0"

    a.MyWrpWrp.MsgUUID="#{msguuid}"

    a.MyWrpWrp.YoYoParms.SrcID

    a.MyWrpWrp.YoYoParms.TestInd

    a.MyWrpWrp.Wrp.WrpParms

    a.MyWrpWrp.Wrp.WrpParms.ApplID

    a.MyWrpWrp.Wrp.WrpParms.WrpID

    a.MyWrpWrp.Wrp.WrpParms.WrpVer

    a.MyWrpWrp.Wrp.WrpParms.RqstUUID="#{rqstuuid}"

    a.MyWrpWrp.Wrp.WrpParms.RoutingID

    a.MyWrpWrp.Wrp.WrpParms.Src.CustDefMsgSrc1

    a.MyWrpWrp.Wrp.BigWrap.LilWrap

    a.MyWrpWrp.Wrp.BigWrap.LilWrap.Mom

    a.MyWrpWrp.Wrp.BigWrap.LilWrap.Dad

    a.MyWrpWrp.Wrp.MsgData

    return a
}

request = XmlStruct.new

setuprequest.call(request)

puts request.to_s

--
Rick DeNatale

My blog on Ruby
http://talklikeaduck.denhaven2.com/

3

Thank you very much Rick. That was exactly the kind of advice I was looking
for. I really didn't need the OO capabilities. Was just looking for a way
to define functions basically. Ended up writing the code as below since I
am expanding it until it all works fine, and then including it into a larger
app.

#!/usr/bin/ruby

require 'rubygems'
require 'xml_struct'
require 'uuidtools'

XMLVER = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"

def createXmlRequest()
    request = XmlStruct.new
    msguuid = UUID.random_create.to_s
    rqstuuid = UUID.random_create.to_s
    request.BigWrapR = {:xmlns => "BurgerSpace"}
    request.BigWrapR.MyVer="1.0"
    request.BigWrapR.MsgUUID="#{msguuid}"
    request.BigWrapR.MyParm.SrcID
    request.BigWrapR.MyParm.Athing
    request.BigWrapR.Verg.VergParms
    request.BigWrapR.Verg.VergParms.ApplID
    request.BigWrapR.Verg.VergParms.VergID
    request.BigWrapR.Verg.VergParms.VergVer
    request.BigWrapR.Verg.VergParms.RqstUUID="#{rqstuuid}"
    request.BigWrapR.Verg.VergParms.RoutingID
    request.BigWrapR.Verg.VergParms.Src.CustDefMsgSrc1
    request.BigWrapR.Verg.Stuff.MoreStuff
    request.BigWrapR.Verg.Stuff.MoreStuff.Tag
    request.BigWrapR.Verg.Stuff.MoreStuff.AnTag
    request.BigWrapR.Verg.MsgData

    return request
end

def modNameSpace(request, namestring)
    request.BigWrapR = {:xmlns => "#{namestring}"}
end

request = createXmlRequest()

modNameSpace(request, "newNameSpace")

puts XMLVER + request.to_s

···

On 6/11/07, Rick DeNatale <rick.denatale@gmail.com> wrote:

On 6/11/07, Nathan Taylor-Hoover <onebitcipher@gmail.com> wrote:
> I have some code written that basically looks like below. I want to
> design a Module, Method, Class, Whatever to make each xml component
> accessible by a method and the ability to set attribs, params, clear
> params, attribs, etc. I know how to implement the code to do all of
> this, but I don't have any experience in created object oriented
> implementations (background is all scripting, and some C so used to
> making functions). Would appreciate any advice on how to make this OO.
>
> #1/usr/bin/ruby
>> require 'rubygems'
> require 'xml_struct'
> require 'uuidtools'
>
> setuprequest = lambda { |a|
>
> XMLVER = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
>
> msguuid = UUID.random_create.to_s
>
> rqstuuid = UUID.random_create.to_s
>
> a.MyWrpWrp = {:xmlns => "mtvnCWWrpReq"}
>
> a.MyWrpWrp.MyWrpVer="1.0"
>
> a.MyWrpWrp.MsgUUID="#{msguuid}"
>
> a.MyWrpWrp.YoYoParms.SrcID
>
> a.MyWrpWrp.YoYoParms.TestInd
>
> a.MyWrpWrp.Wrp.WrpParms
>
> a.MyWrpWrp.Wrp.WrpParms.ApplID
>
> a.MyWrpWrp.Wrp.WrpParms.WrpID
>
> a.MyWrpWrp.Wrp.WrpParms.WrpVer
>
> a.MyWrpWrp.Wrp.WrpParms.RqstUUID="#{rqstuuid}"
>
> a.MyWrpWrp.Wrp.WrpParms.RoutingID
>
> a.MyWrpWrp.Wrp.WrpParms.Src.CustDefMsgSrc1
>
> a.MyWrpWrp.Wrp.BigWrap.LilWrap
>
> a.MyWrpWrp.Wrp.BigWrap.LilWrap.Mom
>
> a.MyWrpWrp.Wrp.BigWrap.LilWrap.Dad
>
> a.MyWrpWrp.Wrp.MsgData
>
> return a
> }
>
> request = XmlStruct.new
>
> setuprequest.call(request)
>
> puts request.to_s

Not that this makes it any more object oriented, but why use a lambda?
Sure it works but in this case I find that it obfuscates a bit why
not something like?:

equire 'rubygems'
require 'xml_struct'
require 'uuidtools'

def setuprequest(request=XMLStruct.new)
    XMLVER = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
    msguuid = UUID.random_create.to_s
    rqstuuid = UUID.random_create.to_s
    request.MyWrpWrp = {:xmlns => "mtvnCWWrpReq"}
    # etc

   return request # or more idiomatically just have request as the last
line.
}

# Now since we provided a default parameter, and we are returning the
# request the usage simplifies to:

puts setuprequest.to_s

--
Rick DeNatale

My blog on Ruby
http://talklikeaduck.denhaven2.com/

4

Thank you very much Rick. That was exactly the kind of advice I was looking
for. I really didn't need the OO capabilities. Was just looking for a way
to define functions basically. Ended up writing the code as below since I
am expanding it until it all works fine, and then including it into a larger
app.

You can wrap this in a class (depending on what do you need to do with
the request.
If you don't do anything more than you have written, do (change the
name of the class as appropriate)

#!/usr/bin/ruby

require 'rubygems'
require 'xml_struct'
require 'uuidtools'

class XmlRequest
   XMLVER = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"

   def initialize

    @request = XmlStruct.new
    msguuid = UUID.random_create.to_s
    rqstuuid = UUID.random_create.to_s
    @request.BigWrapR = {:xmlns => "BurgerSpace"}
    @request.BigWrapR.MyVer="1.0"

...

    @request.BigWrapR.Verg.Stuff.MoreStuff.AnTag
    @request.BigWrapR.Verg.MsgData
end

def namespace=(namestring)
    @request.BigWrapR = {:xmlns => "#{namestring}"}
end

  def to_s
     XMLVER + @request.to_s
  end
end

request = XmlRequest.new
request.namespace = "newNameSpace"
puts request.to_s

Another possibility is to derive from XmlStruct (I don't know it, so
it's possible this will not
work):

class XmlRequest < XmlStruct
   XMLVER = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"

   def initialize
       super

    msguuid = UUID.random_create.to_s
    rqstuuid = UUID.random_create.to_s
    self.BigWrapR = {:xmlns => "BurgerSpace"}
    self.BigWrapR.MyVer="1.0"

...

    self.BigWrapR.Verg.Stuff.MoreStuff.AnTag
    self.BigWrapR.Verg.MsgData
end

def namespace=(namestring)
    self.BigWrapR = {:xmlns => "#{namestring}"}
end

  def to_s
     XMLVER + super
  end
end

request = XmlRequest.new
request.namespace = "newNameSpace"
puts request.to_s

The advantage of having all this wrapped in a class is two fold:
- you hide the details of the implementation - you have here two
different implementations that look the same from the outside
- you package the related code in an entity - you don't have a bunch
of functions any more

Jano

···

On 6/11/07, Nathan Taylor-Hoover <onebitcipher@gmail.com> wrote:

5

Thanks again! I have the pickaxe2, and the "ruby way" book however I
couldn't figure out from their documentation if you could include calls to
other classes without extending them (probably due to information overload
with all the advanced OO documentation). Also they seem to touch a little
lightly on the subclassing and clearer details on how to handle the
initialize method. These examples answered all my questions. Glad I joined
the mailing list! :smiley:

- Nathan

···

On 6/11/07, Jano Svitok <jan.svitok@gmail.com> wrote:

On 6/11/07, Nathan Taylor-Hoover <onebitcipher@gmail.com> wrote:
> Thank you very much Rick. That was exactly the kind of advice I was
looking
> for. I really didn't need the OO capabilities. Was just looking for a
way
> to define functions basically. Ended up writing the code as below since
I
> am expanding it until it all works fine, and then including it into a
larger
> app.

You can wrap this in a class (depending on what do you need to do with
the request.
If you don't do anything more than you have written, do (change the
name of the class as appropriate)

> #!/usr/bin/ruby
>
> require 'rubygems'
> require 'xml_struct'
> require 'uuidtools'

class XmlRequest
   XMLVER = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"

   def initialize
> @request = XmlStruct.new
> msguuid = UUID.random_create.to_s
> rqstuuid = UUID.random_create.to_s
> @request.BigWrapR = {:xmlns => "BurgerSpace"}
> @request.BigWrapR.MyVer="1.0"
...
> @request.BigWrapR.Verg.Stuff.MoreStuff.AnTag
> @request.BigWrapR.Verg.MsgData
> end
>
> def namespace=(namestring)
> @request.BigWrapR = {:xmlns => "#{namestring}"}
> end

  def to_s
     XMLVER + @request.to_s
  end
end

request = XmlRequest.new
request.namespace = "newNameSpace"
puts request.to_s

Another possibility is to derive from XmlStruct (I don't know it, so
it's possible this will not
work):

class XmlRequest < XmlStruct
   XMLVER = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"

   def initialize
       super
> msguuid = UUID.random_create.to_s
> rqstuuid = UUID.random_create.to_s
> self.BigWrapR = {:xmlns => "BurgerSpace"}
> self.BigWrapR.MyVer="1.0"
...
> self.BigWrapR.Verg.Stuff.MoreStuff.AnTag
> self.BigWrapR.Verg.MsgData
> end
>
> def namespace=(namestring)
> self.BigWrapR = {:xmlns => "#{namestring}"}
> end

  def to_s
     XMLVER + super
  end
end

request = XmlRequest.new
request.namespace = "newNameSpace"
puts request.to_s

The advantage of having all this wrapped in a class is two fold:
- you hide the details of the implementation - you have here two
different implementations that look the same from the outside
- you package the related code in an entity - you don't have a bunch
of functions any more

Jano