megam_api 0.100 → 1.5.beta2

data/lib/megam/core/billedhistories.rb

@@ -14,7 +14,7 @@
 ## limitations under the License.
 ##
 module Megam
-  class Billedhistories < Megam::ServerAPI
+  class Billedhistories < Megam::RestAdapter
     def initialize(o)
       @id = nil
       @accounts_id = nil

data/lib/megam/core/billedhistories_collection.rb

@@ -101,19 +101,16 @@ module Megam
       @billedhistories[res]
     end
 
-    # Transform the ruby obj ->  to a Hash
-    def to_hash
-      index_hash = Hash.new
-      self.each do |billedhistories|
-        index_hash[billedhistories.accounts_id] = billedhistories.to_s
-      end
-      index_hash
+    def to_s
+        @billedhistories.join(", ")
+    end
+
+    def for_json
+        to_a.map { |item| item.to_s }
     end
 
-    # Serialize this object as a hash: called from JsonCompat.
-    # Verify if this called from JsonCompat during testing.
     def to_json(*a)
-      for_json.to_json(*a)
+        Megam::JSONCompat.to_json(for_json, *a)
     end
 
     def self.json_create(o)
@@ -135,10 +132,5 @@ module Megam
       end
       true
     end
-
-    def to_s
-      Megam::Stuff.styled_hash(to_hash)
-    end
-
   end
 end

data/lib/megam/core/components.rb

@@ -15,7 +15,7 @@
 #
 
 module Megam
-  class Components < Megam::ServerAPI
+  class Components < Megam::RestAdapter
     def initialize(o)
       @id = nil
       @name = nil

data/lib/megam/core/components_collection.rb

@@ -14,132 +14,125 @@
 # limitations under the License.
 #
 module Megam
-  class ComponentsCollection
-    include Enumerable
-
-    attr_reader :iterator
-    def initialize
-      @components = Array.new
-      @components_by_name = Hash.new
-      @insert_after_idx = nil
-    end
-
-    def all_components
-      @components
-    end
+    class ComponentsCollection
+        include Enumerable
+
+        attr_reader :iterator
+        def initialize
+            @components = Array.new
+            @components_by_name = Hash.new
+            @insert_after_idx = nil
+        end
 
-    def [](index)
-      @components[index]
-    end
+        def all_components
+            @components
+        end
 
-    def []=(index, arg)
-      is_megam_components(arg)
-      @components[index] = arg
-      @components_by_name[arg.name] = index
-    end
+        def [](index)
+            @components[index]
+        end
 
-    def <<(*args)
-      args.flatten.each do |a|
-        is_megam_components(a)
-        @components << a
-        @components_by_name[a.name] = @components.length - 1
-      end
-      self
-    end
+        def []=(index, arg)
+            is_megam_components(arg)
+            @components[index] = arg
+            @components_by_name[arg.name] = index
+        end
 
-    # 'push' is an alias method to <<
-    alias_method :push, :<<
-
-    def insert(components)
-      is_megam_components(components)
-      if @insert_after_idx
-        # in the middle of executing a run, so any nodes inserted now should
-        # be placed after the most recent addition done by the currently executing
-        # node
-        @components.insert(@insert_after_idx + 1, components)
-        # update name -> location mappings and register new node
-        @components_by_name.each_key do |key|
-        @components_by_name[key] += 1 if @components_by_name[key] > @insert_after_idx
+        def <<(*args)
+            args.flatten.each do |a|
+                is_megam_components(a)
+                @components << a
+                @components_by_name[a.name] = @components.length - 1
+            end
+            self
         end
-        @components_by_name[components.name] = @insert_after_idx + 1
-        @insert_after_idx += 1
-      else
-      @components << components
-      @components_by_name[components.name] = @components.length - 1
-      end
-    end
 
-    def each
-      @components.each do |components|
-        yield components
-      end
-    end
+        # 'push' is an alias method to <<
+        alias_method :push, :<<
+
+        def insert(components)
+            is_megam_components(components)
+            if @insert_after_idx
+                # in the middle of executing a run, so any nodes inserted now should
+                # be placed after the most recent addition done by the currently executing
+                # node
+                @components.insert(@insert_after_idx + 1, components)
+                # update name -> location mappings and register new node
+                @components_by_name.each_key do |key|
+                    @components_by_name[key] += 1 if @components_by_name[key] > @insert_after_idx
+                end
+                @components_by_name[components.name] = @insert_after_idx + 1
+                @insert_after_idx += 1
+            else
+                @components << components
+                @components_by_name[components.name] = @components.length - 1
+            end
+        end
 
-    def each_index
-      @components.each_index do |i|
-        yield i
-      end
-    end
+        def each
+            @components.each do |components|
+                yield components
+            end
+        end
 
-    def empty?
-      @components.empty?
-    end
+        def each_index
+            @components.each_index do |i|
+                yield i
+            end
+        end
 
-    def lookup(components)
-      lookup_by = nil
-      if components.kind_of?(Megam::Components)
-      lookup_by = components.name
-      elsif components.kind_of?(String)
-      lookup_by = components
-      else
-        raise ArgumentError, "Must pass a Megam::components or String to lookup"
-      end
-      res = @components_by_name[lookup_by]
-      unless res
-        raise ArgumentError, "Cannot find a node matching #{lookup_by} (did you define it first?)"
-      end
-      @components[res]
-    end
+        def empty?
+            @components.empty?
+        end
 
-    # Transform the ruby obj ->  to a Hash
-    def to_hash
-      index_hash = Hash.new
-      self.each do |components|
-        index_hash[components.name] = components.to_s
-      end
-      index_hash
-    end
+        def lookup(components)
+            lookup_by = nil
+            if components.kind_of?(Megam::Components)
+                lookup_by = components.name
+            elsif components.kind_of?(String)
+                lookup_by = components
+            else
+                raise ArgumentError, "Must pass a Megam::components or String to lookup"
+            end
+            res = @components_by_name[lookup_by]
+            unless res
+                raise ArgumentError, "Cannot find a node matching #{lookup_by} (did you define it first?)"
+            end
+            @components[res]
+        end
 
-    # Serialize this object as a hash: called from JsonCompat.
-    # Verify if this called from JsonCompat during testing.
-    def to_json(*a)
-      for_json.to_json(*a)
-    end
+        def to_s
+            @components.join(", ")
+        end
 
-    def self.json_create(o)
-      collection = self.new()
-      o["results"].each do |components_list|
-        components_array = components_list.kind_of?(Array) ? components_list : [ components_list ]
-        components_array.each do |components|
-          collection.insert(components)
+        def for_json
+            to_a.map { |item| item.to_s }
+        end
 
+        def to_json(*a)
+            Megam::JSONCompat.to_json(for_json, *a)
         end
-      end
-      collection
-    end
 
-    private
 
-    def is_megam_components(arg)
-      unless arg.kind_of?(Megam::Components)
-        raise ArgumentError, "Members must be Megam::components"
-      end
-      true
-    end
+        def self.json_create(o)
+            collection = self.new()
+            o["results"].each do |components_list|
+                components_array = components_list.kind_of?(Array) ? components_list : [ components_list ]
+                components_array.each do |components|
+                    collection.insert(components)
 
-    def to_s
-      Megam::Stuff.styled_hash(to_hash)
-    end
+                end
+            end
+            collection
+        end
 
-  end
+        private
+
+        def is_megam_components(arg)
+            unless arg.kind_of?(Megam::Components)
+                raise ArgumentError, "Members must be Megam::components"
+            end
+            true
+        end
+    end
 end

data/lib/megam/core/domain_collection.rb

@@ -14,131 +14,124 @@
 # limitations under the License.
 #
 module Megam
-  class DomainsCollection
-    include Enumerable
-
-    attr_reader :iterator
-    def initialize
-      @domains = Array.new
-      @domains_by_name = Hash.new
-      @insert_after_idx = nil
-    end
+    class DomainsCollection
+        include Enumerable
+
+        attr_reader :iterator
+        def initialize
+            @domains = Array.new
+            @domains_by_name = Hash.new
+            @insert_after_idx = nil
+        end
 
-    def all_domains
-      @domains
-    end
+        def all_domains
+            @domains
+        end
 
-    def [](index)
-      @domains[index]
-    end
+        def [](index)
+            @domains[index]
+        end
 
-    def []=(index, arg)
-      is_megam_domains(arg)
-      @domains[index] = arg
-      @domains_by_name[arg.name] = index
-    end
+        def []=(index, arg)
+            is_megam_domains(arg)
+            @domains[index] = arg
+            @domains_by_name[arg.name] = index
+        end
 
-    def <<(*args)
-      args.flatten.each do |a|
-        is_megam_domains(a)
-        @domains << a
-        @domains_by_name[a.name] =@domains.length - 1
-      end
-      self
-    end
+        def <<(*args)
+            args.flatten.each do |a|
+                is_megam_domains(a)
+                @domains << a
+                @domains_by_name[a.name] =@domains.length - 1
+            end
+            self
+        end
 
-    # 'push' is an alias method to <<
-    alias_method :push, :<<
-
-    def insert(domains)
-      is_megam_domains(domains)
-      if @insert_after_idx
-        # in the middle of executing a run, so any domain inserted now should
-        # be placed after the most recent addition done by the currently executing
-        # domain
-        @domains.insert(@insert_after_idx + 1, domains)
-        # update name -> location mappings and register new sshkeys
-        @domains_by_name.each_key do |key|
-        @domains_by_name[key] += 1 if@domains_by_name[key] > @insert_after_idx
+        # 'push' is an alias method to <<
+        alias_method :push, :<<
+
+        def insert(domains)
+            is_megam_domains(domains)
+            if @insert_after_idx
+                # in the middle of executing a run, so any domain inserted now should
+                # be placed after the most recent addition done by the currently executing
+                # domain
+                @domains.insert(@insert_after_idx + 1, domains)
+                # update name -> location mappings and register new sshkeys
+                @domains_by_name.each_key do |key|
+                    @domains_by_name[key] += 1 if@domains_by_name[key] > @insert_after_idx
+                end
+                @domains_by_name[domains.name] = @insert_after_idx + 1
+                @insert_after_idx += 1
+            else
+                @domains << domains
+                @domains_by_name[domains.name] =@domains.length - 1
+            end
         end
-        @domains_by_name[domains.name] = @insert_after_idx + 1
-        @insert_after_idx += 1
-      else
-      @domains << domains
-      @domains_by_name[domains.name] =@domains.length - 1
-      end
-    end
 
-    def each
-      @domains.each do |domains|
-        yield domains
-      end
-    end
+        def each
+            @domains.each do |domains|
+                yield domains
+            end
+        end
 
-    def each_index
-      @domains.each_index do |i|
-        yield i
-      end
-    end
+        def each_index
+            @domains.each_index do |i|
+                yield i
+            end
+        end
 
-    def empty?
-      @domains.empty?
-    end
+        def empty?
+            @domains.empty?
+        end
 
-    def lookup(domains)
-      lookup_by = nil
-      if domains.kind_of?(Megam::Domains)
-      lookup_by = domains.name
-    elsif domains.kind_of?(String)
-      lookup_by = domains
-      else
-        raise ArgumentError, "Must pass a Megam::Domains or String to lookup"
-      end
-      res =@domains_by_name[lookup_by]
-      unless res
-        raise ArgumentError, "Cannot find a domain matching #{lookup_by} (did you define it first?)"
-      end
-      @domains[res]
-    end
+        def lookup(domains)
+            lookup_by = nil
+            if domains.kind_of?(Megam::Domains)
+                lookup_by = domains.name
+            elsif domains.kind_of?(String)
+                lookup_by = domains
+            else
+                raise ArgumentError, "Must pass a Megam::Domains or String to lookup"
+            end
+            res =@domains_by_name[lookup_by]
+            unless res
+                raise ArgumentError, "Cannot find a domain matching #{lookup_by} (did you define it first?)"
+            end
+            @domains[res]
+        end
 
-    # Transform the ruby obj ->  to a Hash
-    def to_hash
-      index_hash = Hash.new
-      self.each do |domains|
-        index_hash[domains.name] = domains.to_s
-      end
-      index_hash
-    end
 
-    # Serialize this object as a hash: called from JsonCompat.
-    # Verify if this called from JsonCompat during testing.
-    def to_json(*a)
-      for_json.to_json(*a)
-    end
+        def to_s
+          @domains.join(", ")
+        end
 
-    def self.json_create(o)
-      collection = self.new()
-      o["results"].each do |domains_list|
-        domains_array = domains_list.kind_of?(Array) ? domains_list : [ domains_list ]
-        domains_array.each do |domains|
-          collection.insert(domains)
+        def for_json
+            to_a.map { |item| item.to_s }
         end
-      end
-      collection
-    end
 
-    private
+        def to_json(*a)
+            Megam::JSONCompat.to_json(for_json, *a)
+        end
 
-    def is_megam_domains(arg)
-      unless arg.kind_of?(Megam::Domains)
-        raise ArgumentError, "Members must be Megam::Domains's"
-      end
-      true
-    end
+        def self.json_create(o)
+            collection = self.new()
+            o["results"].each do |domains_list|
+                domains_array = domains_list.kind_of?(Array) ? domains_list : [ domains_list ]
+                domains_array.each do |domains|
+                    collection.insert(domains)
+                end
+            end
+            collection
+        end
 
-    def to_s
-      Megam::Stuff.styled_hash(to_hash)
-    end
+        private
 
-  end
+        def is_megam_domains(arg)
+            unless arg.kind_of?(Megam::Domains)
+                raise ArgumentError, "Members must be Megam::Domains's"
+            end
+            true
+        end
+    end
 end