lumberg 1.0.1 → 2.0.0.pre4

data/lib/lumberg/whm/args.rb

@@ -1,113 +0,0 @@
-module Lumberg
-
-      #
-      # ==== Optional 
-      #  * <tt>:whatever</tt> - PENDING
-  module Whm
-    class Args
-      attr_reader :required_params, :boolean_params, :optional_params, :one_of_params
-      attr_reader :options
-      # Check the included hash for the included parameters.
-      # Raises WhmArgumentError when it's mising the proper params
-      #
-      # ==== Example
-      # 
-      #    Args.new(options) do |c|
-      #      c.requries  :user, :pass
-      #      c.booleans  :name
-      #      c.optionals :whatever
-      #    end
-      def initialize(options)
-        @required_params ||= []
-        @boolean_params  ||= []
-        @optional_params ||= []
-        @one_of_params   ||= []
-        @options = options
-
-        yield self 
-
-        requires!
-        booleans!
-        one_ofs!
-        valid_options!
-      end
-
-      # Specifies the required arguments
-      def requires(*values)
-        @optional_params.concat(values)
-        @required_params = values
-      end
-
-      # Specifies which arguments are boolean
-      def booleans(*values)
-        @optional_params.concat(values)
-        @boolean_params = values
-      end
-
-      # Specifies which arguments are optional
-      def optionals(*values)
-        @optional_params.concat(values)
-      end
-
-      # Specifies which arguments take one of a set of arguments
-      def one_of(*values)
-        @optional_params.concat(values)
-        @one_of_params = values 
-      end
-
-      protected
-
-      # Verifies that all required arguments are present
-      def requires!
-        @required_params.each do |param| 
-          key = (param.is_a?(Array) ? param.first : param)
-          verify_required_param(key)
-        end
-      end
-
-
-      # Checks to see if supplied params (which are booleans) contain
-      # either a 1 ("Yes") or 0 ("No") value.
-      def booleans!
-        @boolean_params.each do |param|
-          key = (param.is_a?(Array) ? param.first : param)
-          verify_boolean_param(key)
-        end
-      end
-
-      # Verifies that only valid arguments were set
-      def valid_options!
-        @options.keys.uniq.each do |key|
-          raise WhmArgumentError.new("Not a valid parameter: #{key}") unless @optional_params.include?(key)
-        end
-      end  
-
-      # Verifies that the one_of arguments were used correctly
-      def one_ofs!
-        if @one_of_params.size > 1
-          specified = @options.keys.select { |key| @one_of_params.include?(key) }.uniq
-          if specified.size > 1 || specified.size == 0
-            raise WhmArgumentError.new("The parameters may include only one of '#{@one_of_params.join(', ')}'") 
-          end
-        else
-          raise WhmArgumentError.new("One of requires two or more items") unless @one_of_params.empty?
-        end
-      end
-
-      private
-      
-      # Internal method for verifiying required arguments
-      def verify_required_param(param)
-        raise WhmArgumentError.new("Missing required parameter: #{param}") unless @options.has_key?(param) 
-        raise WhmArgumentError.new("Required parameter cannot be blank: #{param}") if (@options[param].nil? || (@options[param].respond_to?(:empty?) && @options[param].empty?))
-      end
-
-      # Internal method for verifying boolean arguments
-      def verify_boolean_param(param)
-        if @options.include?(param) && ![true, false].include?(@options[param])
-          raise WhmArgumentError.new("Boolean parameter must be \"true\" or \"false\": #{param}")
-        end
-      end
-    end
-  end
-end

data/lib/net_http_hacked.rb

@@ -1,42 +0,0 @@
-module Net
-  class HTTP
-    @skip_bad_headers = false
-
-    class << self
-      # Accessor for @skip_bad_headers
-      def skip_bad_headers
-        @skip_bad_headers
-      end
-
-      # Mutator for @skip_bad_headers
-      def skip_bad_headers=(value)
-        @skip_bad_headers = value
-      end
-    end
-  end
-
-  class << HTTPResponse
-    # Parses each response header and strips out bad headers if skip_bad_headers is set
-    def each_response_header(sock)
-      key = value = nil
-      while true
-        line = sock.readuntil("\n", true).sub(/\s+\z/, '')
-        break if line.empty?
-        if line[0] == ?\s or line[0] == ?\t and value
-          value << ' ' unless value.empty?
-          value << line.strip
-        else
-          tmp_key, tmp_value = line.strip.split(/\s*:\s*/, 2)
-          next if tmp_value.nil? && Net::HTTP.skip_bad_headers
-
-          yield key, value if key
-
-          key   = tmp_key
-          value = tmp_value
-          raise HTTPBadResponse, 'wrong header line format' if value.nil?
-        end
-      end
-      yield key, value if key
-    end
-  end
-end

data/spec/vcr_cassettes/whm/server/response_type.yml

@@ -1,85 +0,0 @@
---- 
-- !ruby/struct:VCR::HTTPInteraction 
-  request: !ruby/struct:VCR::Request 
-    method: :get
-    uri: https://myhost.com:2087/json-api/testing
-    body: 
-    headers: 
-      authorization: 
-      - WHM root:iscool
-  response: !ruby/struct:VCR::Response 
-    status: !ruby/struct:VCR::ResponseStatus 
-      code: 200
-      message: OK
-    headers: 
-      server: 
-      - cpsrvd/11.28.64
-      transfer-encoding: 
-      - chunked
-      content-type: 
-      - text/plain
-    body: "{\"result\":[ { \"status\": 1, \"statusmsg\": null } ] }"
-    http_version: "1.1"
-- !ruby/struct:VCR::HTTPInteraction 
-  request: !ruby/struct:VCR::Request 
-    method: :get
-    uri: https://myhost.com:2087/json-api/testing_error
-    body: 
-    headers: 
-      authorization: 
-      - WHM root:iscool
-  response: !ruby/struct:VCR::Response 
-    status: !ruby/struct:VCR::ResponseStatus 
-      code: 200
-      message: OK
-    headers: 
-      server: 
-      - cpsrvd/11.28.64
-      transfer-encoding: 
-      - chunked
-      content-type: 
-      - text/plain
-    body: "{\"error\":\"Unknown App Requested: testing_error\"}"
-    http_version: "1.1"
-- !ruby/struct:VCR::HTTPInteraction 
-  request: !ruby/struct:VCR::Request 
-    method: :get
-    uri: https://myhost.com:2087/json-api/testing_query
-    body: 
-    headers: 
-      authorization: 
-      - WHM root:iscool
-  response: !ruby/struct:VCR::Response 
-    status: !ruby/struct:VCR::ResponseStatus 
-      code: 200
-      message: OK
-    headers: 
-      server: 
-      - cpsrvd/11.28.64
-      transfer-encoding: 
-      - chunked
-      content-type: 
-      - text/plain
-    body: "{ \"status\":1, \"statusmsg\":\"Ok\", \"acct\":[ { \"Item\":\"Parameters/Results\", \"Next Item\":\"Parameters/Results\" }, { \"Item\":\"Parameters/Results\", \"Next Item\":\"Parameters/Results\" } ] }"
-    http_version: "1.1"
-- !ruby/struct:VCR::HTTPInteraction 
-  request: !ruby/struct:VCR::Request 
-    method: :get
-    uri: https://myhost.com:2087/json-api/testing_unknown
-    body: 
-    headers: 
-      authorization: 
-      - WHM root:iscool
-  response: !ruby/struct:VCR::Response 
-    status: !ruby/struct:VCR::ResponseStatus 
-      code: 200
-      message: OK
-    headers: 
-      server: 
-      - cpsrvd/11.28.64
-      transfer-encoding: 
-      - chunked
-      content-type: 
-      - text/plain
-    body: "{ \"wtf\":1 }"
-    http_version: "1.1"

data/spec/whm/args_spec.rb

@@ -1,179 +0,0 @@
-require 'spec_helper'
-require 'lumberg/whm/args'
-
-module Lumberg
-  describe Whm::Args do
-    context "required_parms" do
-      it "raises an error when missing" do
-        options = {:arg1 => true}
-        args = lambda { 
-          Whm::Args.new(options) do |c|
-            c.requires :arg2
-          end
-        }
-        expect { args.call }.to raise_error(WhmArgumentError, /Missing required parameter: arg2/)
-      end
-
-      it "does not raise an error with valid params" do
-        options = {:arg1 => true}
-        args =  Whm::Args.new(options) { |c|
-          c.requires :arg1
-        }
-
-        args.required_params.should have(1).value
-        args.required_params.should include(:arg1)
-      end
-
-      it "sets optional_params" do
-        options = {:arg1 => true, :arg2 => 2}
-        args =  Whm::Args.new(options) { |c|
-          c.requires :arg1, :arg2
-        }
-
-        args.optional_params.should have(2).values
-        args.required_params.should have(2).values
-
-        args.optional_params.should include(*args.required_params)
-      end
-
-      it "does not set boolean_params" do
-        options = {:arg1 => true, :arg2 => 2}
-        args =  Whm::Args.new(options) { |c|
-          c.requires :arg1, :arg2
-        }
-
-        args.boolean_params.should be_empty
-      end
-    end
-
-    context "boolean_params" do
-      it "raises an error when the param is not boolean" do
-        options = {:arg1 => 'string'}
-        args = lambda { 
-          Whm::Args.new(options) do |c|
-            c.booleans :arg1
-          end
-        }
-        expect { args.call }.to raise_error(WhmArgumentError, /Boolean parameter must be.*: arg1/)
-      end
-
-      it "raises an error with boolean params" do
-        options = {:arg1 => true}
-        args =  Whm::Args.new(options) { |c|
-          c.booleans :arg1
-        }
-
-        args.boolean_params.should have(1).value
-        args.boolean_params.should include(:arg1)
-      end
-
-      it "sets optional_params" do
-        options = {:arg1 => true, :arg2 => false}
-        args =  Whm::Args.new(options) { |c|
-          c.booleans :arg1, :arg2
-        }
-
-        args.optional_params.should have(2).values
-        args.boolean_params.should have(2).values
-
-        args.optional_params.should include(:arg1, :arg2)
-      end
-
-      it "sets required_params" do
-        options = {:arg1 => true, :arg2 => false}
-        args =  Whm::Args.new(options) { |c|
-          c.booleans :arg1, :arg2
-        }
-
-        args.required_params.should be_empty
-      end
-    end
-
-    context "optional_params" do
-      it "raises an error with unknown params" do
-        options = {:arg1 => true}
-        args = lambda { 
-          Whm::Args.new(options) do |c|
-            c.optionals :arg2
-          end
-        }
-
-        expect { args.call }.to raise_error(WhmArgumentError, /Not a valid parameter: arg1/)
-      end
-
-      it "does not raise an error with known params" do
-        options = {:arg1 => true, :arg2 => 2}
-        args =  Whm::Args.new(options) { |c|
-          c.optionals :arg1, :arg2
-        }
-
-        args.optional_params.should have(2).values
-        args.optional_params.should include(:arg1, :arg2)
-      end
-
-      it "does not set required_params" do
-        options = {:arg1 => true, :arg2 => 2}
-        args =  Whm::Args.new(options) { |c|
-          c.optionals :arg1, :arg2
-        }
-        
-        args.required_params.should be_empty
-      end
-
-      it "does not set boolean_params" do
-        options = {:arg1 => true, :arg2 => 2}
-        args =  Whm::Args.new(options) { |c|
-          c.optionals :arg1, :arg2
-        }
-        
-        args.boolean_params.should be_empty
-      end
-    end
-
-    context "one_of" do
-      it "allows one arg" do
-        options = {:arg1 => true}
-        args = lambda {
-          Whm::Args.new(options) do |c|
-            c.one_of :arg1
-          end
-        }
-
-        expect { args.call }.to raise_error(WhmArgumentError, /One of requires two or more items/)
-      end
-
-      it "allows two or more args" do
-        options = {:arg1 => true}
-
-        args = Whm::Args.new(options) do |c|
-          c.one_of :arg1, :arg2
-        end
-
-        args.one_of_params.should have(2).values
-        args.one_of_params.should include(:arg1, :arg2)
-      end
-
-      it "does not allow 0 params" do
-        options = {}
-        args = lambda {
-          Whm::Args.new(options) do |c|
-            c.one_of :arg1, :arg2
-          end
-        }
-
-        expect { args.call }.to raise_error(WhmArgumentError, /The parameters may include only one of 'arg1, arg2'/)
-      end
-
-      it "does not allow both args" do
-        options = {:arg1 => true, :arg2 => 2}
-        args = lambda {
-          Whm::Args.new(options) do |c|
-            c.one_of :arg1, :arg2
-          end
-        }
-
-        expect { args.call }.to raise_error(WhmArgumentError, /The parameters may include only one of 'arg1, arg2'/)
-      end
-    end
-  end
-end