simple_request 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d43c9c4936e8b17e5e8b3b6953f3f1cc2023047af6326ca1ad72087fe74db6ff
-  data.tar.gz: c6c4391c995fa95c93d82b3cbc9c93f2d19782d59606959ad84d4b99f8cccf27
+  metadata.gz: a380dc73a4972d042555cffee97ee309aeb6d81d4835227e637af3c5f57b5561
+  data.tar.gz: b8c806ca0039fd0e40e134cd43756135a2ce01fab77cdc8f48d794a2df279610
 SHA512:
-  metadata.gz: 6a1839bd78dfeabd6d9fe0461d2d994afcf959c57b37742438bdfaeb9cd9888966041f29b0d25dd09be6146b5d4a43891650da09a15afa6fb2bce88c0d1cb050
-  data.tar.gz: 5f4b1250a0226f84f555f093a9ac6de80d650f2d450718807431800f668bfbced1c4a0e6f7e8041927942a31c66d85c9eed06b812fe5eeb4c85c37e8e65b20fc
+  metadata.gz: dd9e89b641c451af6e22baf4963222f83cd47299601fd146ab9da0b0ae8be481829e1756ad73f355fc47852ad2b6ee9a87c6ed37357e05161f23e59f7b58f307
+  data.tar.gz: 4d7f9ada57b7935e8bec920179b6ce1bb55314e2782bc0828d8063515cf2dd50e37ebda0d133b65be3415451417079974b9cff649af1c97192b256fb399d19c4

data/.gitignore

@@ -9,3 +9,4 @@
 
 # rspec failure tracking
 .rspec_status
+/simple_request-0.1.1.gem

data/Changelog.md

@@ -0,0 +1,9 @@
+# Changeslog
+
+## 2020-02-04
+- Changed rspec examples from localhost project to JSONPlaceholder API
+- Added `to_csv` in array class to convert array to csv 
+- Added `wrap` in array class to convert hash or nill to an array (Powered by rails core repo)
+- Added `keys` in hash class to symbolize and stringify hash keys
+- Added `string_colorize` in String class to colorize any string 
+- Supported csv format you can export the response to csv by `request.csv`

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    simple_request (0.1.0)
+    simple_request (0.1.1)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -65,8 +65,14 @@ request.json
 request.plain
 # OUTPUT
 #  "{\"message\":\"City created successfully\",\"city\":{\"data\":{\"id\":\"10\",\"type\":\"city_details\",\"attributes\":{\"name_en\":\"Mukalla\",\"name_ar\":\"المكلا\",\"suggested_time\":0,\"suggested\":false,\"status\":\"active\"}}}}"
+
+request.csv
+# This will export the whole response you can specify the path you want to export by passing the exact path as string split by comma
+# example
+request.csv('city,data,attributes')
 ```
 
+
 ### PUT, Patch Request
 ```ruby
 

data/lib/simple_helper/array/to_csv.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+# Usage [{first_name: 'MaJeD', last_name: 'BoJaN'}, {first_name: 'Mohammed', last_name: 'majed'}].to_csv('file_name.csv')
+class Array
+  def to_csv(csv_filename = 'file_name.csv')
+    CSV.open(csv_filename, 'wb') do |csv|
+      csv << first.keys
+      each do |hash|
+        csv << hash.values # _at(*keys)
+      end
+    end
+  end
+end

data/lib/simple_helper/array/wrap.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+class Array
+  # Powered by rails core
+  # Wraps its argument in an array unless it is already an array (or array-like).
+  #
+  # Specifically:
+  #
+  # * If the argument is +nil+ an empty array is returned.
+  # * Otherwise, if the argument responds to +to_ary+ it is invoked, and its result returned.
+  # * Otherwise, returns an array with the argument as its single element.
+  #
+  #     Array.wrap(nil)       # => []
+  #     Array.wrap([1, 2, 3]) # => [1, 2, 3]
+  #     Array.wrap(0)         # => [0]
+  #
+  # This method is similar in purpose to <tt>Kernel#Array</tt>, but there are some differences:
+  #
+  # * If the argument responds to +to_ary+ the method is invoked. <tt>Kernel#Array</tt>
+  #   moves on to try +to_a+ if the returned value is +nil+, but <tt>Array.wrap</tt> returns
+  #   an array with the argument as its single element right away.
+  # * If the returned value from +to_ary+ is neither +nil+ nor an +Array+ object, <tt>Kernel#Array</tt>
+  #   raises an exception, while <tt>Array.wrap</tt> does not, it just returns the value.
+  # * It does not call +to_a+ on the argument, if the argument does not respond to +to_ary+
+  #   it returns an array with the argument as its single element.
+  #
+  # The last point is easily explained with some enumerables:
+  #
+  #   Array(foo: :bar)      # => [[:foo, :bar]]
+  #   Array.wrap(foo: :bar) # => [{:foo=>:bar}]
+  #
+  # There's also a related idiom that uses the splat operator:
+  #
+  #   [*object]
+  #
+  # which returns <tt>[]</tt> for +nil+, but calls to <tt>Array(object)</tt> otherwise.
+  #
+  # The differences with <tt>Kernel#Array</tt> explained above
+  # apply to the rest of <tt>object</tt>s.
+  def self.wrap(object)
+    if object.nil?
+      []
+    elsif object.respond_to?(:to_ary)
+      object.to_ary || [object]
+    else
+      [object]
+    end
+  end
+end

data/lib/simple_helper/const.rb

@@ -19,5 +19,17 @@ module SimpleHelper
     def self.supported_format
       ConstantData::SUPPORTED_FORMAT
     end
+
+    def self.colors
+      ConstantData::COLORS
+    end
+
+    def self.bg_colors
+      ConstantData::BG_COLORS
+    end
+
+    def self.fonts
+      ConstantData::FONTS
+   end
   end
 end

data/lib/simple_helper/float/trim.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Float
+  def trim
+    i = to_i
+    f = to_f
+    i == f ? i : f.round(1)
+  end
+end

data/lib/simple_helper/hash/keys.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+class Hash
+  # Returns a new hash with all keys converted to strings.
+  #
+  #   hash = { name: 'Rob', age: '28' }
+  #
+  #   hash.stringify_keys
+  #   # => {"name"=>"Rob", "age"=>"28"}
+  def stringify_keys
+    transform_keys(&:to_s)
+  end
+
+  # Destructively converts all keys to strings. Same as
+  # +stringify_keys+, but modifies +self+.
+  def stringify_keys!
+    transform_keys!(&:to_s)
+  end
+
+  # Returns a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+.
+  #
+  #   hash = { 'name' => 'Rob', 'age' => '28' }
+  #
+  #   hash.symbolize_keys
+  #   # => {:name=>"Rob", :age=>"28"}
+  def symbolize_keys
+    transform_keys do |key|
+      begin
+                             key.to_sym
+      rescue StandardError
+        key
+                           end
+    end
+  end
+  alias to_options symbolize_keys
+
+  # Destructively converts all keys to symbols, as long as they respond
+  # to +to_sym+. Same as +symbolize_keys+, but modifies +self+.
+  def symbolize_keys!
+    transform_keys! do |key|
+      begin
+                              key.to_sym
+      rescue StandardError
+        key
+                            end
+    end
+  end
+  alias to_options! symbolize_keys!
+
+  # Validates all keys in a hash match <tt>*valid_keys</tt>, raising
+  # +ArgumentError+ on a mismatch.
+  #
+  # Note that keys are treated differently than HashWithIndifferentAccess,
+  # meaning that string and symbol keys will not match.
+  #
+  #   { name: 'Rob', years: '28' }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key: :years. Valid keys are: :name, :age"
+  #   { name: 'Rob', age: '28' }.assert_valid_keys('name', 'age') # => raises "ArgumentError: Unknown key: :name. Valid keys are: 'name', 'age'"
+  #   { name: 'Rob', age: '28' }.assert_valid_keys(:name, :age)   # => passes, raises nothing
+  def assert_valid_keys(*valid_keys)
+    valid_keys.flatten!
+    each_key do |k|
+      unless valid_keys.include?(k)
+        raise ArgumentError, "Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}"
+      end
+    end
+  end
+
+  # Returns a new hash with all keys converted by the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  #
+  #  hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #  hash.deep_transform_keys{ |key| key.to_s.upcase }
+  #  # => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}
+  def deep_transform_keys(&block)
+    _deep_transform_keys_in_object(self, &block)
+  end
+
+  # Destructively converts all keys by using the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_transform_keys!(&block)
+    _deep_transform_keys_in_object!(self, &block)
+  end
+
+  # Returns a new hash with all keys converted to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  #
+  #   hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #   hash.deep_stringify_keys
+  #   # => {"person"=>{"name"=>"Rob", "age"=>"28"}}
+  def deep_stringify_keys
+    deep_transform_keys(&:to_s)
+  end
+
+  # Destructively converts all keys to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_stringify_keys!
+    deep_transform_keys!(&:to_s)
+  end
+
+  # Returns a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+. This includes the keys from the root hash
+  # and from all nested hashes and arrays.
+  #
+  #   hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }
+  #
+  #   hash.deep_symbolize_keys
+  #   # => {:person=>{:name=>"Rob", :age=>"28"}}
+  def deep_symbolize_keys
+    deep_transform_keys do |key|
+      begin
+                                  key.to_sym
+      rescue StandardError
+        key
+                                end
+    end
+  end
+
+  # Destructively converts all keys to symbols, as long as they respond
+  # to +to_sym+. This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_symbolize_keys!
+    deep_transform_keys! do |key|
+      begin
+                                   key.to_sym
+      rescue StandardError
+        key
+                                 end
+    end
+  end
+
+  private
+
+  # Support methods for deep transforming nested hashes and arrays.
+  def _deep_transform_keys_in_object(object, &block)
+    case object
+    when Hash
+      object.each_with_object({}) do |(key, value), result|
+        result[yield(key)] = _deep_transform_keys_in_object(value, &block)
+      end
+    when Array
+      object.map { |e| _deep_transform_keys_in_object(e, &block) }
+    else
+      object
+    end
+  end
+
+  def _deep_transform_keys_in_object!(object, &block)
+    case object
+    when Hash
+      object.keys.each do |key|
+        value = object.delete(key)
+        object[yield(key)] = _deep_transform_keys_in_object!(value, &block)
+      end
+      object
+    when Array
+      object.map! { |e| _deep_transform_keys_in_object!(e, &block) }
+    else
+      object
+    end
+  end
+end

data/lib/simple_helper/headers_processor.rb

@@ -8,7 +8,7 @@ module SimpleHelper
     def self.perform(headers)
       return {} if headers.nil? || !headers.respond_to?(:to_hash)
 
-      @headers = SimpleHelper::Utils.stringify_keys(headers)
+      @headers = headers.stringify_keys!
 
       return @headers unless @headers['Content-Type'].nil?
 

data/lib/simple_helper/http.rb

@@ -3,6 +3,7 @@
 require 'uri'
 require 'net/http'
 require_relative 'const'
+require_relative 'string/string_colorize'
 
 module SimpleHelper
   module Http
@@ -14,11 +15,11 @@ module SimpleHelper
           req.body = params.to_json
           http.request(req)
         rescue Timeout::Error || Net::OpenTimeout
-          puts "\e[31mTime out!\e[0m"
+          puts 'Time out'.bold.red.gray
         rescue Net::HTTPBadResponse || SocketError
-          puts "\e[31mRequest Failed!\e[0m"
+          puts 'Request Failed!'.bold.red.gray
         rescue StandardError
-          puts "\e[31mAn unknown error occurred!\e[0m"
+          puts 'An unknown error occurred!'.bold.red.gray
         end
       end
     end

data/lib/simple_helper/https.rb

@@ -3,6 +3,7 @@
 require 'uri'
 require 'net/https'
 require 'pry'
+require_relative 'string/string_colorize'
 module SimpleHelper
   module Https
     class << self
@@ -16,11 +17,11 @@ module SimpleHelper
           req.body = params.to_json
           https.request(req)
         rescue Timeout::Error || Net::OpenTimeout
-          puts "\e[31mTime out!\e[0m"
+          puts 'Time out'.bold.red.gray
         rescue Net::HTTPBadResponse || SocketError
-          puts "\e[31mRequest Failed!\e[0m"
+          puts 'Request Failed!'.bold.red.gray
         rescue StandardError
-          puts "\e[31mAn unknown error occurred!\e[0m"
+          puts 'An unknown error occurred!'.bold.red.gray
         end
       end
     end

data/lib/simple_helper/response_parser.rb

@@ -1,18 +1,22 @@
 # frozen_string_literal: true
 
 require 'pry'
+require_relative 'array/wrap'
+require_relative 'array/to_csv'
+require_relative 'string/string_colorize'
 
 module SimpleHelper
   class ResponseParser
-    attr_reader :body, :format
+    attr_reader :body, :format, :path
 
-    def initialize(body, format)
+    def initialize(body, format, path)
       @body = body
       @format = format
+      @path = path
     end
 
-    def self.perform(body, format)
-      new(body, format).parse
+    def self.perform(body, format, path)
+      new(body, format, path).parse
     end
 
     def parse
@@ -26,23 +30,27 @@ module SimpleHelper
 
     protected
 
-    # TODO: Support other formats like xml, csv
+    # TODO: Support other formats like xml
 
     UTF8_BOM = "\xEF\xBB\xBF"
 
     def json
       JSON.parse(body, quirks_mode: true, allow_nan: true)
     rescue JSON::ParserError
-      puts "Response cannot be parsed because it's not a string not valid JSON. please use .plain to get the the plain response"
+      puts "Response cannot be parsed because it's not a string nor valid JSON. please use .plain to get the the plain response".bold.brown.gray
     end
 
     def plain
       body
     end
 
-    # def csv
-    #   CSV.parse(body)
-    # end
+    def csv
+      data = path.nil? ? json : json.dig(*path.split(','))
+      raise ArgumentError, 'Cannot export nil or empty hash please pass proper path'.bold.brown.gray if data.nil?
+
+      Array.wrap(data).to_csv('file_name.csv')
+    end
+
     # def xml
     #   MultiXml.parse(body)
     # end

data/lib/simple_helper/string/string_colorize.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+class String
+  ##---------------bg Color-----------------##
+
+  def black
+    "\e[30m#{self}\e[0m"
+  end
+
+  def red
+    "\e[31m#{self}\e[0m"
+  end
+
+  def green
+    "\e[32m#{self}\e[0m"
+  end
+
+  def brown
+    "\e[33m#{self}\e[0m"
+  end
+
+  def blue
+    "\e[34m#{self}\e[0m"
+  end
+
+  def magenta
+    "\e[35m#{self}\e[0m"
+  end
+
+  def cyan
+    "\e[36m#{self}\e[0m"
+  end
+
+  def gray
+    "\e[37m#{self}\e[0m"
+  end
+
+  ##---------------bg Color-----------------##
+
+  def bg_black
+    "\e[40m#{self}\e[0m"
+  end
+
+  def bg_red
+    "\e[41m#{self}\e[0m"
+  end
+
+  def bg_green
+    "\e[42m#{self}\e[0m"
+  end
+
+  def bg_brown
+    "\e[43m#{self}\e[0m"
+  end
+
+  def bg_blue
+    "\e[44m#{self}\e[0m"
+  end
+
+  def bg_magenta
+    "\e[45m#{self}\e[0m"
+  end
+
+  def bg_cyan
+    "\e[46m#{self}\e[0m"
+  end
+
+  def bg_gray
+    "\e[47m#{self}\e[0m"
+  end
+
+  ##---------------Fonts--------------------##
+  def bold
+    "\e[1m#{self}\e[22m"
+  end
+
+  def italic
+    "\e[3m#{self}\e[23m"
+  end
+
+  def underline
+    "\e[4m#{self}\e[24m"
+  end
+
+  def blink
+    "\e[5m#{self}\e[25m"
+  end
+
+  def reverse_color
+    "\e[7m#{self}\e[27m"
+  end
+end
+
+# Usage
+# puts 'I'm back green'.bg_green
+# puts 'I'm red and back cyan'.red.bg_cyan
+# puts 'I'm bold and green and backround red'.bold.green.bg_red

data/lib/simple_helper/version.rb

@@ -1,3 +1,3 @@
 module SimpleHelper
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/simple_request.rb

@@ -1,15 +1,17 @@
 # frozen_string_literal: true
 
-require 'uri'
+# require 'uri'
 require 'pry'
-require 'json'
-# require 'net/http'
-# require 'net/https'
+# require 'json'
+
+# require_relative 'simple_helper/array/wrap'
+# require_relative 'simple_helper/string/string_colorize'
+# require_relative 'simple_helper/array/to_csv'
+require_relative 'simple_helper/hash/keys'
 
 require_relative 'simple_helper/const'
 require_relative 'simple_helper/http'
 require_relative 'simple_helper/https'
-require_relative 'simple_helper/utils'
 require_relative 'simple_helper/version'
 require_relative 'simple_helper/exceptions'
 require_relative 'simple_helper/response_parser'
@@ -19,7 +21,7 @@ class SimpleRequest
   attr_reader :options, :response
 
   def initialize(**options)
-    @options = SimpleHelper::Utils.symbolize_keys(options)
+    @options = options.symbolize_keys!
     validate
   end
 
@@ -49,10 +51,14 @@ class SimpleRequest
 
   SimpleHelper::Const.supported_format.each do |key|
     define_method key do
-      SimpleHelper::ResponseParser.perform(body_response, key)
+      SimpleHelper::ResponseParser.perform(body_response, key, nil)
     end
   end
 
+  def csv(path = nil)
+    SimpleHelper::ResponseParser.perform(body_response, 'csv', path)
+  end
+
   private
 
   def requested_class
@@ -83,8 +89,6 @@ class SimpleRequest
     URI(options[:url])
   end
 
-  def response_processor; end
-
   def validate
     # raise SimpleHelper::RedirectionTooDeep.new(last_response), 'HTTP redirects too deep' if options[:limit].to_i <= 0
 

data/simple_request.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["MaJeD BoJaN"]
   spec.email         = ["bojanmajed@gmail.com"]
 
-  spec.summary       = %q{Simple ruby gem that helps to make HTTP and HTTPS request from ruby projects.}
+  spec.summary       = 'Simple ruby gem that helps to make HTTP and HTTPS request from ruby projects.'
   spec.homepage      = "https://github.com/MajedBojan/simple_request"
   spec.license       = "MIT"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple_request
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - MaJeD BoJaN
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-01-23 00:00:00.000000000 Z
+date: 2020-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -73,14 +73,18 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- lib/simple_helper/array/to_csv.rb
+- lib/simple_helper/array/wrap.rb
 - lib/simple_helper/const.rb
 - lib/simple_helper/constant_data.rb
 - lib/simple_helper/exceptions.rb
+- lib/simple_helper/float/trim.rb
+- lib/simple_helper/hash/keys.rb
 - lib/simple_helper/headers_processor.rb
 - lib/simple_helper/http.rb
 - lib/simple_helper/https.rb
 - lib/simple_helper/response_parser.rb
-- lib/simple_helper/utils.rb
+- lib/simple_helper/string/string_colorize.rb
 - lib/simple_helper/version.rb
 - lib/simple_request.rb
 - simple_request-0.1.0.gem

data/lib/simple_helper/utils.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module SimpleHelper
-  module Utils
-    def self.stringify_keys(hash)
-      return hash.transform_keys(&:to_s) if hash.respond_to?(:transform_keys)
-
-      hash.each_with_object({}) do |(key, value), new_hash|
-        new_hash[key.to_s] = value
-      end
-    end
-
-    def self.symbolize_keys(obj)
-      case obj
-      when Array
-        obj.inject([]){|res, val|
-          res << case val
-          when Hash, Array
-            symbolize_keys(val)
-          else
-            val
-          end
-          res
-        }
-      when Hash
-        obj.inject({}){|res, (key, val)|
-          nkey = case key
-          when String
-            key.to_sym
-          else
-            key
-          end
-          nval = case val
-          when Hash, Array
-            symbolize_keys(val)
-          else
-            val
-          end
-          res[nkey] = nval
-          res
-        }
-      else
-        obj
-      end
-    end
-
-  end
-end