eeml 0.0.1 → 0.0.2

data/test/data/no_namespace.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<eeml>
+  <environment>
+    <title>Minimal</title>
+    <data id="0">
+      <value>36.2</value>
+    </data>
+  </environment>
+</eeml>

data/test/test_environment.rb

@@ -163,6 +163,30 @@ class TestEnvironment < Test::Unit::TestCase
     assert_equal "36.2", datastream.value
   end
 
+  test "fails if no default namespace provided" do
+    assert_raise(MissingNamespace) {env = create_env_from_xml_file('no_namespace.xml')}
+  end
+
+  test "creates multiple environments from list xml" do
+    xml = File.read('test/data/list.xml')
+    list = Environment.new_list_from_eeml(xml)
+    assert 3, list.size
+    list.each do |obj|
+      assert obj.is_a? Environment
+    end
+    titles = list.map {|e| e.title}.sort
+    expected_titles = ["Badgerpower", "CurrentCost for house", "Power and Temperature"]
+    assert_equal expected_titles, titles
+    #TODO: check the environments fully (that no aliasing or other confusion has occurred in their parsing)
+  end
+
+  test "creates zero environments from list xml when has none" do
+    original_xml = File.read('test/data/list.xml')
+    xml = remove_nodes_called('environment', original_xml)
+    list = Environment.new_list_from_eeml(xml)
+    assert list.empty?, "should be empty list"
+  end
+
   def read_xml_file_one
     return File.read('test/data/doc_1.xml')
   end
@@ -246,20 +270,75 @@ class TestEnvironment < Test::Unit::TestCase
     assert_equal 'http://www.example.com/ourstudio/feeds/house.xml', env.feed_url
   end
 
-  # ---            ------------------------------------------------------------
-  # --- json stuff ------------------------------------------------------------
-  # ---            ------------------------------------------------------------
+  # ---                  ------------------------------------------------------
+  # --- json input stuff ------------------------------------------------------
+  # ---                  ------------------------------------------------------
 
   test "creating Env obj from a JSON string" do
     env = create_env_from_json_file_one
     assert_not_nil env
     assert_instance_of Environment, env
+    assert_equal('title here', env.title)
+    assert_equal('description here', env.description)
+    assert_equal('http://example.com/api/1247.xml', env.feed_url)
+    assert_equal('http://example.com/studio/', env.website)
+    assert_equal('frozen', env.status)
+    assert_equal('someone@example.com', env.email)
+    assert_equal('http://example.com/some/icon.gif', env.icon)
+    
+    #env attrs
+    assert_equal('1247', env.identifier)
+    assert_equal('2009-02-11T10:56:56Z', env.updated.strftime("%Y-%m-%dT%H:%M:%SZ"))
   end
 
+  test "location parses ok from json" do
+    env = create_env_from_json_file_one
+    assert_not_nil env.location
+    location = env.location
+    assert_equal "Up on the roof (somewhere)", location.name
+    assert_equal "50.1", location.latitude
+    assert_equal "48.7", location.longitude
+    assert_equal "1.34", location.elevation
+    assert_equal "physical", location.domain
+    assert_equal "outdoor", location.exposure
+    assert_equal "mobile", location.disposition
+  end
 
-  # ---           -------------------------------------------------------------
-  # --- csv stuff -------------------------------------------------------------
-  # ---           -------------------------------------------------------------
+  test "datastreams parse ok from json" do
+    env = create_env_from_json_file_one
+    assert_equal 3, env.datastreams.size
+
+    #the expected values for the datastreams in the test doc
+    expectations_list = [
+      #id, tag array, min, max, value, unit_symbol, unit_type, unit_value
+      ['0', ['tagD0'], '-9999.0', '1022.0', '0', 'C', 'basicSI', 'Celsius'], 
+      ['1', [], '0.0', '1023.0', '33', nil, nil, nil], 
+      ['2', ['tagD2a', 'tagD2b', 'tagD2c'], '23.4', '1021.0', '42.1', nil, nil, nil]
+    ]
+    env.datastreams.each_with_index do |ds, i|
+
+      e_identifier, e_tags, e_min_value, e_max_value, e_value, e_unit_symbol, e_unit_type, e_unit_value = expectations_list[i]
+
+      assert_equal e_identifier, ds.identifier
+
+      assert_equal e_tags.size, ds.tags.size, "should have right num of tags"
+      
+      e_tags.each do |expected_tag|
+        ds.tags.member? expected_tag
+      end
+
+      assert_equal e_min_value, ds.min_value
+      assert_equal e_max_value, ds.max_value
+      assert_equal e_value, ds.value
+      assert_equal e_unit_symbol, ds.unit_symbol
+      assert_equal e_unit_type, ds.unit_type
+      assert_equal e_unit_value, ds.unit_value
+    end
+  end
+
+  # ---                 -------------------------------------------------------
+  # --- csv input stuff -------------------------------------------------------
+  # ---                 -------------------------------------------------------
 
   def create_env_with_datastream_values(values)
     e = Environment.new
@@ -305,9 +384,10 @@ class TestEnvironment < Test::Unit::TestCase
     env.update_datastreams_from_csv_values!(values)
     assert_equal values, env.values_quick
   end
-  # ---              ----------------------------------------------------------
-  # --- output stuff ----------------------------------------------------------
-  # ---              ----------------------------------------------------------
+
+  # ---                   -----------------------------------------------------
+  # --- eeml output stuff -----------------------------------------------------
+  # ---                   -----------------------------------------------------
 
   test "should output to xml ok" do
     env = create_env_from_xml_file_one
@@ -331,7 +411,58 @@ class TestEnvironment < Test::Unit::TestCase
     assert_equal expected_xml, output_xml
   end
 
+  # ---                   -----------------------------------------------------
+  # --- json output stuff -----------------------------------------------------
+  # ---                   -----------------------------------------------------
+  #DEV NOTE: use jsondiff tool to visual-diff expected and actual json http://tlrobinson.net/projects/js/jsondiff/
+
+  #TODO: decide what trailing whitespace should be output after json, and eeml, and correct tests
+  test "basic output in public json format" do
+    input_xml = File.read('test/data/doc_2.xml')
+    env = create_env_from_xml_string(input_xml)
+    output_json = env.to_json
+    expected_json = File.read('test/data/doc_2_expected.json').rstrip
+    expected_hash = JSON.parse(expected_json)
+    output_hash = JSON.parse(output_json)
+    assert_equal(expected_hash, output_hash)
+  end
 
+  test "basic output in public json format - no location" do
+    input_xml = File.read('test/data/doc_2.xml')
+    input_xml = remove_first_node_called('location', input_xml)
+    env = create_env_from_xml_string(input_xml)
+    output_json = env.to_json
+    output_hash = JSON.parse(output_json)
+
+    expected_json = File.read('test/data/doc_2_expected.json')
+    expected_hash = JSON.parse(expected_json)
+    assert_not_nil expected_hash.delete("location")
+    assert_json_hashes_equal(expected_hash, output_hash)
+  end
+
+  test "basic output in public json format - location but no latitude" do
+    input_xml = File.read('test/data/doc_2.xml')
+    input_xml = remove_first_node_called('lat', input_xml)
+    env = create_env_from_xml_string(input_xml)
+    actual_json = env.to_json
+    actual_hash = JSON.parse(actual_json)
+
+    assert_nil env.location.latitude
+    expected_json = File.read('test/data/doc_2_expected.json')
+    expected_hash = JSON.parse(expected_json)
+    expected_hash["location"].delete("lat")
+    #File.open('tmp_expected.json', 'w') {|f| f.write expected_hash.to_json }
+    #File.open('tmp_actual.json', 'w') {|f| f.write actual_hash.to_json }
+
+    assert_json_hashes_equal(expected_hash, actual_hash)
+  end
+
+  test "basic output in public json format - minimal env" do
+    env = Environment.new
+    assert_nil env.identifier
+    output_json = env.to_json
+    assert_not_nil output_json
+  end
 
   # --- convenience stuff - don't put tests under here ------------------------------
 
@@ -366,5 +497,12 @@ class TestEnvironment < Test::Unit::TestCase
     return Environment.new_from_json(json)
   end
   
+  def prep_json_for_reading(json)
+    return nil if json.nil?
+    json.gsub(/","/, '"' + "\n" + '"').sort
+  end
+  
+
+
 
 end

data/test/test_helper.rb

@@ -5,13 +5,12 @@ require 'test/libxml_test_helper'
 # Thought a mock library will be useful for testing out any stuff that 
 # does any http-ing, but have no strong feelings about which one to use.
 # Looking at the syntax of each of the libraries, I liked the look of the
-# mocha syntax more, so was thinking to use that when required.
+# mocha syntax more, so was thinking to use that when/if required.
 #
 # require 'flexmock'
 require 'mocha'
 
 
-
 #consider adding custom assertions to clean code up
 #http://www.ruby-doc.org/stdlib/libdoc/test/unit/rdoc/classes/Test/Unit/Assertions.html
 
@@ -47,10 +46,71 @@ class Test::Unit::TestCase
     out
   end
 
+  #compare not the given json strings directly but their hash structures after parsing.
+  #also try to give a more concise diff, if they are different, using Hash.diff from activesupport
+  def assert_json_strings_equal(expected_string, actual_string, message=nil)
+    expected_structure = JSON.parse(expected_string)
+    actual_structure = JSON.parse(actual_string)
+    
+    diff = expected_structure.diff(actual_structure)
+    diff_string = diff.inspect.gsub(/"/, "'")
+    full_message = build_message(message, "Parsed JSON structure doesn't match expected.  Hash Diff (quotes changed): <?>\n" + 
+                                          "Full text: Expected: \n<?>\nbut was: <?>.\n", 
+                                 diff_string, expected_string, actual_string)
+    assert_block(full_message) do
+      expected_structure == actual_structure
+    end
+    #File.open('tmp.json', 'w') {|f| f.write output_json }
+    #File.open('tmp_split.json', 'w') {|f| f.write prep_json_for_reading(output_json) }
+    #File.open('tmp_expected_split.json', 'w') {|f| f.write prep_json_for_reading(expected_json)}    
+
+    #TODO: consider allowing submission of both to a json visual diff app, too. (only if switched on by an environment variable).
+  end
+
+  def assert_json_hashes_equal(expected_structure, actual_structure, message=nil)    
+    diff = expected_structure.diff(actual_structure)
+    diff_string = diff.inspect.gsub(/"/, "'")
+    full_message = build_message(message, "JSON structure doesn't match expected.  Hash Diff (quotes changed): <?>\n" + 
+                                          "Full values: Expected: \n<?>\nbut was: <?>.\n", diff_string, expected_structure.inspect, actual_structure.inspect)
+    assert_block(full_message) do
+      expected_structure == actual_structure
+    end
+  end
+
 end
 
+
+
+#TODO: don't add this Hash.diff(h2) for all hashes, only for ones we want to diff (e.g. on the fly during assert_json_strings_equal)
+#TODO: check rails license
+module ASCoreExtensions  #was ActiveSupport
+  module Hash #:nodoc:
+    module Diff
+      # Returns a hash that represents the difference between two hashes.
+      #
+      # Examples:
+      #
+      #   {1 => 2}.diff(1 => 2)         # => {}
+      #   {1 => 2}.diff(1 => 3)         # => {1 => 2}
+      #   {}.diff(1 => 2)               # => {1 => 2}
+      #   {1 => 2, 3 => 4}.diff(1 => 2) # => {3 => 4}
+      def diff(h2)
+        self.dup.delete_if { |k, v| h2[k] == v }.merge(h2.dup.delete_if { |k, v| self.has_key?(k) })
+      end
+    end
+  end
+end
+
+class Hash #:nodoc:
+  include ASCoreExtensions::Hash::Diff
+end
+
+
+
 $:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
 
 require 'eeml'
 
 include Eeml
+
+

data/test/test_libxml_eeml_parser_v005.rb

@@ -6,4 +6,7 @@ class TestLibXMLEemlParserV005 < Test::Unit::TestCase
     #p.make_environment_from_xml('bad')
   end
 
+  implement "re-populates env if env given" do
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: eeml
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Neill Bogie, Sam Mulube
@@ -30,7 +30,7 @@ cert_chain:
   yyRwZdVyDdsafg==
   -----END CERTIFICATE-----
 
-date: 2009-04-17 00:00:00 +01:00
+date: 2009-05-05 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -57,7 +57,7 @@ dependencies:
         version: "0"
     - - "="
       - !ruby/object:Gem::Version 
-        version: 1.1.3
+        version: 1.1.4
     version: 
 - !ruby/object:Gem::Dependency 
   name: rake
@@ -97,15 +97,14 @@ extra_rdoc_files:
 - README
 - lib/eeml.rb
 - lib/eeml/constants.rb
-- lib/eeml/feed_retriever.rb
-- lib/eeml/json_environment_parser.rb
+- lib/eeml/json_environment_parser_v005.rb
 - lib/eeml/output_registry.rb
 - lib/eeml/parser_registry.rb
 - lib/eeml/libxml_eeml_output_v005.rb
-- lib/eeml/feed_output.rb
 - lib/eeml/libxml_eeml_parser_v005.rb
 - lib/eeml/exceptions.rb
 - lib/eeml/csv_parser.rb
+- lib/eeml/json_output.rb
 - lib/eeml/environment.rb
 - lib/blank.rb
 files: 
@@ -120,20 +119,23 @@ files:
 - test/test_libxml_eeml_parser_v005.rb
 - test/test_helper.rb
 - test/data/minimal.xml
+- test/data/doc_2_expected.json
+- test/data/list.xml
 - test/data/out_empty.xml
+- test/data/no_namespace.xml
 - test/data/doc_1.xml
 - test/data/doc_1.json
+- test/data/doc_2.xml
 - lib/eeml.rb
 - lib/eeml/constants.rb
-- lib/eeml/feed_retriever.rb
-- lib/eeml/json_environment_parser.rb
+- lib/eeml/json_environment_parser_v005.rb
 - lib/eeml/output_registry.rb
 - lib/eeml/parser_registry.rb
 - lib/eeml/libxml_eeml_output_v005.rb
-- lib/eeml/feed_output.rb
 - lib/eeml/libxml_eeml_parser_v005.rb
 - lib/eeml/exceptions.rb
 - lib/eeml/csv_parser.rb
+- lib/eeml/json_output.rb
 - lib/eeml/environment.rb
 - lib/blank.rb
 - schemas/eeml/005.xsd

metadata.gz.sig

@@ -1,3 +1 @@
-(ѭ�س�
-A���5jj�Bh�k_�G�F�ȴ'*KLY�|4��Q��
-��<R���57z>ӱ�|�|]m��E:��a�.{�ҹ�J��h:�C�C�Է��DT���д���w�^d^
+>�t�{�����)g�Bcg�T8�Z"B��.���C釴�d��3����M|�����I����uJ��Z�����Z%t4y��jM�����9 �=4<�+W���Y��l��M��et^>puEz�J4���?@�Mn\�kR�1���)�/�ʶTMy{��mb��J71_&v��5&�g�ˡ�l���JJ�v���c�؏oY�w���d�wN�9�[��Z����8S1�<wC�
p�@�'�.�I�X�"X���B}�

data/lib/eeml/feed_output.rb

@@ -1,169 +0,0 @@
-module FeedOutput # :nodoc:
-  #TODO: move away from mixins for this functionality.
-  #TODO: This is v005-specific.
-  module EnvironmentNode # :nodoc:
-  include LibXML
-    #assumes a logger()
-    #assumes retrieved_at()
-
-    #TODO: Move these (now unused) methods to the publisher (e.g. a rails controller?) which will decide where it's going to host the env, 
-    #      and which will set the feed property accordingly before serialising the env.
-    # def public_feed_url
-    #   return "http://#{DEFAULT_HOST}/api/#{self.id}.xml"
-    # end
-
-    # def public_csv_url
-    #   return "http://#{DEFAULT_HOST}/api/#{self.id}.csv"
-    # end
-
-    # def public_json_url
-    #   return "http://#{DEFAULT_HOST}/api/#{self.id}.json"
-    # end
-
-
-    def create_eeml_document
-      doc = XML::Document.new
-      eeml = doc.root = XML::Node.new('eeml')
-      XML::Namespace.new(eeml, nil, Eeml::EEML_HREF)
-      XML::Namespace.new(eeml, 'xsi', Eeml::XSI_NAMESPACE)
-      eeml['version'] = Eeml::EEML_VERSION
-      eeml['xsi:schemaLocation'] = Eeml::EEML_SCHEMA_LOCATION
-      return doc
-    end
-
-    # Create a csv representation of this environment by iterating through all datastreams and returning 
-    # their values.
-    def to_csv
-      return self.datastreams.map { |d| d.value }.join(",")
-    end
-
-    # Create an xml representation of this environment. The document returned should be valid EEML.
-    # def to_eeml(options = { :full => true })
-    # # Returns the public feed URL for this environment.
-
-
-    #   logger.debug("*** Returning eeml representation of environment: #{self.identifier}")
-
-    #   doc = create_eeml_document
-
-    #   doc.root << to_xml_node(options)
-
-    #   return doc.to_s(:encoding => XML::Encoding::UTF_8)
-    # end
-
-    def to_xml_node_old(options = { :full => true })
-      logger.debug("*** Creating xml node for environment: #{self.identifier}")
-
-      environment_node = XML::Node.new('environment')
-      #TODO: this was retrieved_at in the db, but it's 'updated' in the xml.  Clarify w sam...   
-      #      ... env.retrieved_at doesn't make much sense to clients generating eeml using the gem.
-      environment_node['updated'] = self.updated.strftime(XML_TIME_FORMAT_STRING) unless self.updated.nil?      
-      environment_node['id'] = self.identifier.to_s unless self.identifier.blank?
-      #TODO: write all these strings out safely for xml
-      environment_node['creator'] = self.creator.to_s unless self.creator.blank?
-
-      #TODO: these all should really appear, even when absent?  likely make conditional.
-      unless self.title.blank?
-        environment_node << title_node = XML::Node.new('title')
-        title_node << self.title
-      end
-
-      unless self.feed_url.blank?
-        environment_node << feed_node = XML::Node.new('feed')
-        feed_node << self.feed_url
-      end
-      
-      unless self.status.blank?
-        environment_node << status_node = XML::Node.new('status')
-        status_node << self.status
-      end
-
-      unless self.description.blank?
-        environment_node << description_node = XML::Node.new('description')
-        description_node << self.description
-      end
-
-      unless self.icon.blank?
-        environment_node << icon_node = XML::Node.new('icon')
-        icon_node << self.icon
-      end
-
-      unless self.website.blank?
-        environment_node << website_node = XML::Node.new('website')
-        website_node << self.website
-      end
-
-      unless self.email.blank?
-        environment_node << email_node = XML::Node.new('email')
-        email_node << self.email
-      end
-
-      unless self.location.nil?
-        environment_node << location_node = XML::Node.new('location')
-        location_node['domain'] = self.location.domain
-        location_node['exposure'] = self.location.exposure unless self.location.exposure.blank?
-        location_node['disposition'] = self.location.disposition unless self.location.disposition.blank?
-        
-        unless self.location.name.blank?
-          location_node << location_name_node = XML::Node.new('name')
-          location_name_node << self.location.name
-        end
-
-        location_node << lat_node = XML::Node.new('lat')
-        lat_node << self.location.latitude
-
-        location_node << lng_node = XML::Node.new('lon')
-        lng_node << self.location.longitude
-
-        unless self.location.elevation.blank?
-          location_node << elevation_node = XML::Node.new('ele')
-          elevation_node << self.location.elevation
-        end
-      end
-
-      if options[:full] == true
-        self.datastreams.each do |datastream|
-          environment_node << datastream.to_xml_node unless datastream.nil?
-        end
-      end
-
-      return environment_node
-    end
-  end
-
-
-
-  module DataStreamNode # :nodoc:
-    include LibXML
-    # Create and return an XML::Node object representing this datastream. This method creates all
-    # required child nodes of the datastream object, including the list of tag elements, any units element
-    # and the value.
-    def to_xml_node
-      datastream_node = XML::Node.new('data')
-      datastream_node['id'] = self.identifier.to_s
-
-      self.tags.each do |tag|
-        tag_node = XML::Node.new('tag')
-        tag_node << tag
-        datastream_node << tag_node
-      end    
-
-      datastream_node << value_node = XML::Node.new('value')
-
-      value_node['minValue'] = self.min_value.to_s unless self.min_value.to_s.empty?
-      value_node['maxValue'] = self.max_value.to_s unless self.max_value.to_s.empty?
-
-      value_node << self.value.to_s
-      
-      unless self.unit_value.to_s.empty? && self.unit_type.to_s.empty? && self.unit_symbol.to_s.empty?
-        datastream_node << unit_node = XML::Node.new('unit')
-        unit_node['type'] = self.unit_type.to_s unless self.unit_type.to_s.empty?
-        unit_node['symbol'] = self.unit_symbol.to_s unless self.unit_symbol.to_s.empty?
-        unit_node << self.unit_value.to_s unless self.unit_value.to_s.empty?
-      end
-
-      return datastream_node
-    end
-  end
-
-end

data/lib/eeml/feed_retriever.rb

@@ -1,103 +0,0 @@
-require 'uri'
-require 'net/http'
-module Eeml
-
-  class FeedRetriever
-
-    DEFAULT_TIMEOUT = 5
-    PREMIUM_ENVIRONMENT_AGE = raise 3
-
-    attr_accessor :retrieval_errors #will hold an array of string error messages populated during feed retrieval.  currently populated only in fetch_remote_data
-    attr_accessor :logger
-    attr_accessor :feed_url, :retrieved_at
-    attr_accessor :feed_changed, :feed_retrieved
-    attr_accessor :feed_content, :mime_type
-
-    def initialize
-    end
-    
-    # only attempt to retrieve data if request is after our minimum time delta
-    #currently makes use of get_response() and fetch() to do actual retrieval.
-    def fetch_remote_data
-      @retrieval_errors = []
-      logger.debug("*** Attempting to fetch remote data")
-
-      # only attempt to retrieve data if this environment has a feed_url
-      if !self.feed_url.blank? && (self.retrieved_at.nil? || (Time.now.utc - self.retrieved_at.utc) > PREMIUM_ENVIRONMENT_AGE)
-        logger.debug("*** Our refresh delta has passed so retrieve remote data")
-        
-        self.feed_changed = false
-        self.feed_retrieved = false
-
-        response = get_response
-        
-        case response
-        when Net::HTTPSuccess
-          logger.debug("*** 200 ok... checking mime type #{response.content_type}.")
-          if MIME_TYPES.include?(response.content_type)
-            logger.debug("*** We have a valid mime type")
-
-            self.feed_content = response.body.to_s.strip
-            self.mime_type = response.content_type
-
-            self.retrieved_at = Time.now.utc.to_s(:db)
-          else
-            logger.debug("*** wrong mime-type.")
-            white_list = ['text/html', 'text/javascript', 'application/javascript'] # acceptably WRONG header values.
-            filtered_advice = ( white_list.member?(response.content_type) ? "  Got '#{response.content_type}'." : "" ) 
-            @retrieval_errors << "Wrong mime-type.  Need application/xml, text/csv, or variants." + filtered_advice
-          end
-        else
-          self.feed_retrieved = false
-          self.feed_changed = false
-          logger.debug("*** Unable to fetch remote data")
-        end
-      else
-        logger.debug("*** No feed url present or refresh delta not yet expired - don't do nothin")
-        # TODO remove after development
-      end
-    rescue URI::InvalidURIError, Timeout::Error, SystemCallError => e
-      self.feed_retrieved = false
-      self.feed_changed = false
-      @retrieval_errors << "Url bad or unavailable."
-      logger.error("*** Error retrieving feed from remote source: #{e}")
-    end
-
-    # private
-
-    # separating this method out makes mocking our response fairly simple
-    # basically we just create a dummy response object, and override this
-    # method with a stubbed version that returns our dummy response
-    def get_response
-      return fetch(feed_url)
-    end
-
-    # TODO: update test specs so this passes properly
-    # this fetch method recursively follows redirections up to a maximum depth of 10 redirections
-    def fetch(uri_str, limit = 10)
-      uri = create_uri(uri_str)
-
-      logger.debug("*** Fetching content from :#{uri}")
-      http_client = Net::HTTP.new(uri.host, uri.port)
-      
-      # the default timeout appears to be 60 seconds. this is very long
-      # override it to be 5 seconds
-      http_client.open_timeout = DEFAULT_TIMEOUT
-      http_client.read_timeout = DEFAULT_TIMEOUT
-      response = http_client.request_get(uri.request_uri)
-      logger.debug("*** Got response: #{response}")
-      case response
-      when Net::HTTPSuccess then response
-      when Net::HTTPRedirection then fetch(response['location'], limit - 1)
-      else response
-      end
-    end
-
-    def create_uri(uri_str)
-      logger.debug("*** Creating uri from: #{uri_str}")
-      uri = URI.parse(uri_str)
-      raise URI::InvalidURIError unless uri.is_a?(URI::HTTP) or uri.is_a?(URI::HTTPS)
-      return uri
-    end
-  end
-end

data/lib/eeml/json_environment_parser.rb

@@ -1,11 +0,0 @@
-module Eeml
-  #a parser for json environments
-  class JsonEnvironmentParser
-    def make_environment_from_json(json_str)
-      env = Environment.new
-      return env
-    end
-  end
-end
-
-