Module: ECS

Defined in:
lib/ecs.rb,
lib/ecs/help.rb,
lib/ecs/errors.rb,
lib/ecs/operations.rb,
lib/ecs/response_groups.rb,
lib/ecs/time_management.rb,
lib/ecs/help_response_group.rb

Defined Under Namespace

Modules: TimeManagement Classes: Errors, Help, HelpResponseGroup, Operations, ResponseGroups

Constant Summary collapse

@@associate_id =

[ ‘help’, ‘help_response_group’, ‘operations’, ‘response_groups’, ‘time_management’ ].each { |f| require( File.join( File.dirname( __FILE__ ), ‘ecs’, f ) ) }

Dir[File.join( File.join( File.dirname( __FILE__ ), 'ecs' ), "*.rb" )].each { |f| require f }
Dir[File.join( File.join( File.dirname( __FILE__ ), 'ecs', 'operation' ), "*.rb" )].each { |f| require f }
Dir[File.join( File.join( File.dirname( __FILE__ ), 'ecs', 'response_group' ), "*.rb" )].each { |f| require f }

'limn-20'
@@access_key_id = 
''
@@default_default_locale = 
:us
@@default_locale = 
@@default_default_locale
@@cache_directory = 
''
@@cache = 
true
@@cache_suffix = 
'ecs_cache'
@@counter = 
0
@@strip_namespace =

libxml-ruby is not able to do XML::Document#find or XML::Node#find with xml returned from Amazon. If you remove the namespace from the xml, it works perfectly

true

Class Method Summary collapse

Class Method Details

.access_key_id ⇒ Object 



87
88
89
 
# File 'lib/ecs.rb', line 87

def self.access_key_id
  @@access_key_id
end

.access_key_id=(i) ⇒ Object 



90
91
92
 
# File 'lib/ecs.rb', line 90

def self.access_key_id=( i )
  @@access_key_id = i.to_s
end

.api_version ⇒ Object 



131
132
133
 
# File 'lib/ecs.rb', line 131

def self.api_version
  '2007-02-22'
end

.associate_id ⇒ Object 



81
82
83
 
# File 'lib/ecs.rb', line 81

def self.associate_id
  @@associate_id
end

.associate_id=(k) ⇒ Object 



84
85
86
 
# File 'lib/ecs.rb', line 84

def self.associate_id=( k )
  @@associate_id = k.to_s
end

.available_locales ⇒ Object 



115
116
117
 
# File 'lib/ecs.rb', line 115

def self.available_locales
  [ :ca, :de, :fr, :jp, :uk, :us ]
end

.base_urls ⇒ Object 



119
120
121
122
123
124
125
126
127
128
 
# File 'lib/ecs.rb', line 119

def self.base_urls
  {
    :ca => 'http://webservices.amazon.ca/onca/xml?Service=AWSECommerceService',
    :de => 'http://webservices.amazon.de/onca/xml?Service=AWSECommerceService',
    :fr => 'http://webservices.amazon.fr/onca/xml?Service=AWSECommerceService',
    :jp => 'http://webservices.amazon.co.jp/onca/xml?Service=AWSECommerceService',
    :uk => 'http://webservices.amazon.co.uk/onca/xml?Service=AWSECommerceService',
    :us => 'http://webservices.amazon.com/onca/xml?Service=AWSECommerceService'
  }
end

.cache=(true_or_false = true) ⇒ Object 



257
258
259
 
# File 'lib/ecs.rb', line 257

def self.cache=( true_or_false=true )
  @@cache = true_or_false != false
end

.cache? ⇒ Boolean

Returns:

  • (Boolean) 


254
255
256
 
# File 'lib/ecs.rb', line 254

def self.cache?
  @@cache != false
end

.cache_directory ⇒ Object 



104
105
106
 
# File 'lib/ecs.rb', line 104

def self.cache_directory
  @@cache_directory
end

.cache_directory=(d = '') ⇒ Object 



107
108
109
110
111
112
 
# File 'lib/ecs.rb', line 107

def self.cache_directory=( d='' )
  directory = File.expand_path( d )
  FileUtils.mkdir_p( directory ) unless File.exist?( directory )
  raise( "#{directory} is not a suitable cache directory" ) unless File.writable?( directory ) && File.directory?( directory )
  @@cache_directory = directory
end

.cached?(p = {}) ⇒ Boolean

Returns:

  • (Boolean) 


261
262
263
 
# File 'lib/ecs.rb', line 261

def self.cached?( p={} )
  File.exist?( p.is_a?( String ) ? p : self.resolve_cache_tag( p ) )
end

.call_web_service(p = {}) ⇒ Object 



142
143
144
145
146
147
148
149
150
151
152
153
154
155
 
# File 'lib/ecs.rb', line 142

def self.call_web_service( p={} )
  parameters = p.is_a?( Hash ) ? p : {}

  locale = self.resolve_locale( parameters[:locale] )
  parameters.delete( :locale )

  sleep( ECS::TimeManagement.sleep_duration )
  self.increment_counter
  url = "#{ self.base_urls[locale] }&AWSAccessKeyId=#{self.access_key_id}&Version=#{self.api_version}&AssociateTag=#{self.associate_id}&#{ parameters.keys.map{ |k| "#{ERB::Util.url_encode( k.to_s ) }=#{ERB::Util.url_encode( parameters[k].is_a?( Array ) ? parameters[k].join( ',' ) : parameters[k].to_s )}" }.join( '&' ) }"
  #puts url
  r = Net::HTTP.get_response( URI.parse( url ) )
  r.value # this will raise an error if there was one.
  @@strip_namespace && r.body =~ /(.*)xmlns\s*=\s*".*?"(.*)/m ? "#{$1}#{$2}" : r.body
end

.clear_cache(tag = nil) ⇒ Object 



246
247
248
249
250
251
252
 
# File 'lib/ecs.rb', line 246

def self.clear_cache( tag=nil )
  if tag.nil?
    Dir[File.join( self.cache_directory, "*.#{@@cache_suffix}" )].each { |f| File.unlink( f ) }
  else
    File.unlink( tag )
  end
end

.counter ⇒ Object 



71
72
73
 
# File 'lib/ecs.rb', line 71

def self.counter
  @@counter
end

.default_locale ⇒ Object 



94
95
96
 
# File 'lib/ecs.rb', line 94

def self.default_locale
  @@default_locale
end

.default_locale=(loc) ⇒ Object 



97
98
99
 
# File 'lib/ecs.rb', line 97

def self.default_locale=( loc )
  @@default_locale = self.resolve_locale( loc )
end

.increment_counter ⇒ Object 



77
78
79
 
# File 'lib/ecs.rb', line 77

def self.increment_counter
  @@counter += 1
end

.method_missing(meth, *args) ⇒ Object 



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/ecs.rb', line 40

def self.method_missing( meth, *args )
  meth_s = meth.to_s
  a = *args
  begin
    klass_name = meth_s.camel_case
    instance = nil
    case meth_s
    when /^(.*)_response_group$/
      instance = self.resolve_response_group_klass( klass_name )
    when /^search_([^_]*)_by_([^_]*)$/
      # Allow things like ECS.search_Books_by_Author( 'Marcus Aurelius' )
      params = { :SearchIndex => $1 }.merge( a.is_a?( Hash ) ? a : { $2.to_sym => a } )
      instance = self.item_search( params )
    else
      klass = self.resolve_operation_klass( klass_name )
      instance = klass.new
      instance.parameters = a.is_a?( Hash ) ? a : {}

      # If no ResponseGroup is set, then allow the defaults
      unless instance.parameters[:ResponseGroup].nil?
        # Otherwise, be sure :Request is included
        instance.parameters[:ResponseGroup] = [instance.parameters[:ResponseGroup]] unless instance.parameters[:ResponseGroup].is_a?( Array )
        instance.parameters[:ResponseGroup] << :Request unless instance.parameters[:ResponseGroup].include?( :Request ) || instance.parameters[:ResponseGroup].include?( 'Request' )
      end
    end
    instance
  rescue NameError => e
    raise NameError, "#{e.message}"#Are you sure that ECS::#{klass_name} is defined?"
  end
end

.query_string(p = {}) ⇒ Object 



266
267
268
 
# File 'lib/ecs.rb', line 266

def self.query_string( p={} )
  ( p.is_a?( Hash ) ? p : {} ).keys.map{ |k| k.to_s }.sort.map{ |k| "#{k}=#{p[k.to_sym]}" }.join( '&' )
end

.read_cache(tag_or_parameters) ⇒ Object 



237
238
239
240
 
# File 'lib/ecs.rb', line 237

def self.read_cache( tag_or_parameters )
  tag = tag_or_parameters.is_a?( String ) ? tag_or_parameters : self.resolve_cache_tag( tag_or_parameters )
  XML::Document.file( tag ) if File.exist?( tag )
end

.reset_counter ⇒ Object 



74
75
76
 
# File 'lib/ecs.rb', line 74

def self.reset_counter
  @@counter = 0
end

.reset_default_locale ⇒ Object 



100
101
102
 
# File 'lib/ecs.rb', line 100

def self.reset_default_locale
  @@default_locale = @@default_default_locale
end

.resolve_cache_tag(p = {}) ⇒ Object 



270
271
272
 
# File 'lib/ecs.rb', line 270

def self.resolve_cache_tag( p={} )
  "#{cache_directory}/#{Digest::MD5.hexdigest( p.is_a?( String ) ? p : query_string( p ) )}.#{@@cache_suffix}"
end

.resolve_error_klass(name = '') ⇒ Object 



199
200
201
202
203
204
205
206
207
208
209
210
211
 
# File 'lib/ecs.rb', line 199

def self.resolve_error_klass( name='' )
    klass_name = ECS::Help.resolve_error_name( name )
    klass = ECS::Errors[klass_name]
    if klass.nil?
      string_to_eval = "class #{klass_name.to_s} < RuntimeError
                        end
                        #{klass_name}"
#          puts string_to_eval
      klass = eval( string_to_eval, binding, __FILE__, __LINE__ )
      ECS::Errors[klass_name] = klass
    end
    klass
end

.resolve_locale(l = nil) ⇒ Object 



157
158
159
 
# File 'lib/ecs.rb', line 157

def self.resolve_locale( l=nil )
  !l.nil? && self.available_locales.include?( l.to_s.downcase.to_sym ) ? l.to_s.downcase.to_sym : self.default_locale
end

.resolve_operation_klass(name = '') ⇒ Object 



179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
 
# File 'lib/ecs.rb', line 179

def self.resolve_operation_klass( name='' )
    klass_name = ECS::Help.resolve_operation_name( name )
    klass = ECS::Operations[klass_name]
    if klass.nil?
      string_to_eval = "class #{klass_name} < Help
                          @@operation_name=nil
                          @@help_xml=nil
                          @@required_parameters=nil
                          @@available_parameters=nil
                          @@default_response_groups=nil
                          @@available_response_groups=nil
                          ECS::Operations['#{klass_name}'] = self
                        end
                        #{klass_name}"
#          puts string_to_eval
      klass = instance_eval( string_to_eval, __FILE__, __LINE__ )
      ECS::Operations[klass_name] = klass
    end
    klass
end

.resolve_response_group_klass(name = '') ⇒ Object 



161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
 
# File 'lib/ecs.rb', line 161

def self.resolve_response_group_klass( name='' )
  klass_name = ECS::HelpResponseGroup.resolve_response_group_name( name )
  klass = ECS::ResponseGroups[klass_name]
  if klass.nil?
    string_to_eval = "class #{klass_name} < HelpResponseGroup
                        @@response_group_name=nil
                        @@valid_operations=nil
                        @@elements=nil
                        @@help_xml=nil
                        ECS::ResponseGroups['#{klass_name}'] = self
                      end
                      #{klass_name}"
    #puts string_to_eval
    klass = instance_eval( string_to_eval, __FILE__, __LINE__ )
    ECS::ResponseGroups[klass_name] = klass
  end
  klass
end

.strip_namespace=(s) ⇒ Object 



138
139
140
 
# File 'lib/ecs.rb', line 138

def self.strip_namespace=( s )
  @@strip_namespace = s != false
end

.strip_namespace? ⇒ Boolean

Returns:

  • (Boolean) 


135
136
137
 
# File 'lib/ecs.rb', line 135

def self.strip_namespace?
  @@strip_namespace != false
end

.write_cache(tag_or_parameters, content) ⇒ Object 



241
242
243
244
 
# File 'lib/ecs.rb', line 241

def self.write_cache( tag_or_parameters, content )
  tag = tag_or_parameters.is_a?( String ) ? tag_or_parameters : self.resolve_cache_tag( tag_or_parameters )
  File.open( tag, 'w' ) { |f| f << content }
end

.xml_for_parameters(parameters = {}, force = false) ⇒ Object 



214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
 
# File 'lib/ecs.rb', line 214

def self.xml_for_parameters( parameters={}, force=false )
  # if you pass a block to this method, the XML::Document object
  # will be yielded (if it's not cached) and you will be able to return
  # true to cache it or false to not cache it.  The object is yielded
  # regardless of the value of ECS.cache?
  # In other words, ECS.cache? is respected only when there is no block
  tag = self.resolve_cache_tag( parameters )
  xml = nil

  xml = self.read_cache( tag ) unless force

  if xml.nil?
    xml = self.call_web_service( parameters )
    parser = XML::Parser.new
    parser.string = xml
    xml = parser.parse
    we_should_cache = block_given? ? yield( xml ) : self.cache?
    self.write_cache( tag, xml.to_s ) if we_should_cache
  end
  
  xml
end