darksky-ruby 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2de496ac9a489ecdb83e761649f6540bba2f94f3
-  data.tar.gz: aaf3e305a49d24c740c4ad9a6114b25cbd96b214
+  metadata.gz: 62a900ed0c6248ca0f923c8d21d9313d91710420
+  data.tar.gz: 87a437d159fca922f16601a92dbb947e841e93b7
 SHA512:
-  metadata.gz: c045f53b13b0e9c514557df793c13b5f148910bb544969178373ff3cfe3d8246d1beaa7094a62ff83fc7e74b024de5efafb6b70b20ac4673a0e76179f6468de5
-  data.tar.gz: bf159e9875b718220b04094347ec0a3c6a964d6368f5c9cf6e622bb081d61ed4962e1d9077ca01d08d18609b03063893625b7feefdbb5e8af08f21a162807d13
+  metadata.gz: 6b2b0f2b5e01e70b14512cafe490a317e8c18550aa13a996a27ef8f327a4d08eace4a8616d65d206128e55c4fe013665ffd132ff8d52b941161a28f6405a352b
+  data.tar.gz: 91fe232ff29d2d4e3fe70e6e08c90a64aa20b0ce07ffecc4d548783616befe65652d3e036cd9b873e60638b10b69eebe0e065bee9575174b6b019e56ea6b1f45

data/bin/darksky

@@ -13,15 +13,15 @@ opts = Trollop::options do
 end
 
 if opts[:log_given]
-  Darksky.logger = Logger.new(opts[:log])
-  Darksky.logger.level = Logger::WARN
+  Neko.logger = Logger.new(opts[:log])
+  Neko.logger.level = Logger::WARN
 end
 
 if opts[:verbose]
-  Darksky.logger = Logger.new(STDOUT) unless opts[:log_given]
-  Darksky.logger.level = Logger::DEBUG
+  Neko.logger = Logger.new(STDOUT) unless opts[:log_given]
+  Neko.logger.level = Logger::DEBUG
 end
-log = Darksky.logger
+log = Neko.logger
 
 log.debug("Command line arguments: #{opts}")
 
@@ -30,7 +30,7 @@ loc ||= ARGV.shift
 
 Trollop::die :loc, "is missing" if loc.nil?
 
-api = Darksky::API.new(key: opts[:key])
+api = DarkskyAPI.new(key: opts[:key])
 api.blocks = {minutely: false, hourly: false, daily: false, alerts: false, flags: false}
 
 if opts[:time_given]

data/darksky-ruby.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |s|
   s.authors       = ['Ken J.']
   s.email         = ['kenjij@gmail.com']
   s.summary       = %q{Pure simple Ruby based Darksky REST library}
-  s.description   = %q{Darksky library written in pure Ruby without external dependancy.}
+  s.description   = %q{Darksky library written in pure Ruby without external dependency.}
   s.homepage      = 'https://github.com/kenjij/darksky-ruby'
   s.license       = 'MIT'
 

data/lib/darksky-ruby/api.rb

@@ -1,77 +1,74 @@
 require 'json'
 
-module Darksky
+class DarkskyAPI
+  DARKSKY_URL = 'https://api.darksky.net/'
+  DARKSKY_PATH_TEMPLATE = '/forecast/%{key}/%{loc}'
+  DARKSKY_BLOCK_NAMES = [:currently, :minutely, :hourly, :daily, :alerts, :flags]
 
-  class API
+  attr_accessor :key, :latitude, :longitude, :location, :time, :options
 
-    DARKSKY_URL = 'https://api.darksky.net/'
-    DARKSKY_PATH_TEMPLATE = '/forecast/%{key}/%{loc}'
-    DARKSKY_BLOCK_NAMES = [:currently, :minutely, :hourly, :daily, :alerts, :flags]
-
-    attr_accessor :key, :latitude, :longitude, :location, :time, :options
-
-    def initialize(key:, options: {})
-      @key = key
-      @options = options
-    end
+  def initialize(key:, options: {})
+    @key = key
+    @options = options
+  end
 
-    def forecast(lat: @latitude, lon: @longitude, loc: @location, ts: @time)
-      loc = "#{lat},#{lon}" if lat && lon
-      raise ArgumentError, 'No location given to forecast' if loc.nil?
-      ts = ts.to_i if ts.class == Time
-      request(loc, ts)
-    end
+  def forecast(lat: @latitude, lon: @longitude, loc: @location, ts: @time)
+    loc = "#{lat},#{lon}" if lat && lon
+    loc = loc.gsub(/\s+/, '')
+    raise ArgumentError, 'No location given to forecast' if loc.nil?
+    ts = ts.to_i if ts.class == Time
+    request(loc, ts)
+  end
 
-    def timemachine(lat: @latitude, lon: @longitude, loc: @location, ts:)
-      forecast(lat: lat, lon: lon, loc: loc, ts: ts)
-    end
+  def timemachine(lat: @latitude, lon: @longitude, loc: @location, ts:)
+    forecast(lat: lat, lon: lon, loc: loc, ts: ts)
+  end
 
-    def blocks()
-      ex = options[:exclude]
-      ex.nil? ? ex = [] : ex = ex.split(',').map{ |n| n.to_sym }
-      h = {}
-      DARKSKY_BLOCK_NAMES.each { |n| h[n] = !ex.include?(n) }
-      return h
-    end
+  def blocks()
+    exc = options[:exclude]
+    exc.nil? ? exc = [] : exc = exc.split(',').map{ |n| n.to_sym }
+    h = {}
+    DARKSKY_BLOCK_NAMES.each { |n| h[n] = !exc.include?(n) }
+    return h
+  end
 
-    def blocks=(h)
-      ex = DARKSKY_BLOCK_NAMES.select { |n| h[n] == false }
-      options[:exclude] = ex.join(',')
-    end
+  def blocks=(h)
+    exc = DARKSKY_BLOCK_NAMES.select { |n| h[n] == false }
+    options[:exclude] = exc.join(',')
+  end
 
-    def param(key, val = nil)
-    end
+  def include_only(inc = [:currently])
+    exc = DARKSKY_BLOCK_NAMES.select { |n| !inc.include?(n) }
+    options[:exclude] = exc.join(',')
+  end
 
-    private
+  private
 
-    def request(loc, ts)
-      path = DARKSKY_PATH_TEMPLATE % {key: key, loc: loc}
-      path += ",#{ts}" if ts
-      options.empty? ? o = nil : o = options
-      data = http.get(path: path, params: o)
-      return handle_response_data(data)
-    end
+  def request(loc, ts)
+    path = DARKSKY_PATH_TEMPLATE % {key: key, loc: loc}
+    path += ",#{ts}" if ts
+    options.empty? ? o = nil : o = options
+    data = http.get(path: path, params: o)
+    return handle_response_data(data)
+  end
 
-    def http
-      unless @http
-        @http = HTTP.new(DARKSKY_URL)
-      end
-      return @http
+  def http
+    unless @http
+      @http = Neko::HTTP.new(DARKSKY_URL)
     end
+    return @http
+  end
 
-    def format_path(path)
-      path = '/' + path unless path.start_with?('/')
-      return path + '.json'
-    end
+  def format_path(path)
+    path = '/' + path unless path.start_with?('/')
+    return path + '.json'
+  end
 
-    def handle_response_data(data)
-      if data[:code] != 200
-        Darksky.logger.error("HTTP response error: #{data[:code]}\n#{data[:message]}")
-        return nil
-      end
-      return JSON.parse(data[:body], {symbolize_names: true})
+  def handle_response_data(data)
+    if data[:code] != 200
+      Neko.logger.error("HTTP response error: #{data[:code]}\n#{data[:message]}")
+      return nil
     end
-
+    return JSON.parse(data[:body], {symbolize_names: true})
   end
-
 end

data/lib/darksky-ruby/http.rb

@@ -1,13 +1,27 @@
+# NekoHTTP - Pure Ruby HTTP client using net/http
+# 
+# v.20190829
+
 require 'net/http'
 require 'openssl'
+require 'logger'
 
+module Neko
+  def self.logger=(logger)
+    @logger = logger
+  end
 
-module Darksky
+  def self.logger
+    @logger ||= NullLogger.new()
+  end
 
   class HTTP
-
     METHOD_HTTP_CLASS = {
-      get: Net::HTTP::Get
+      get: Net::HTTP::Get,
+      put: Net::HTTP::Put,
+      patch: Net::HTTP::Patch,
+      post: Net::HTTP::Post,
+      delete: Net::HTTP::Delete
     }
 
     def self.get(url, params)
@@ -17,10 +31,18 @@ module Darksky
       return data
     end
 
+    def self.post_form(url, params)
+      h = HTTP.new(url)
+      data = h.post(params: params)
+      h.close
+      return data
+    end
+
     attr_reader :init_uri, :http
-    attr_accessor :headers
+    attr_accessor :logger, :headers
 
     def initialize(url, hdrs = nil)
+      @logger = Neko.logger
       @init_uri = URI(url)
       raise ArgumentError, 'Invalid URL' unless @init_uri.class <= URI::HTTP
       @http = Net::HTTP.new(init_uri.host, init_uri.port)
@@ -33,6 +55,22 @@ module Darksky
       return operate(__method__, path: path, params: params, query: query)
     end
 
+    def post(path: nil, params: nil, body: nil, query: nil)
+      return operate(__method__, path: path, params: params, body: body, query: query)
+    end
+
+    def put(path: nil, params: nil, body: nil, query: nil)
+      return operate(__method__, path: path, params: params, body: body, query: query)
+    end
+
+    def patch(path: nil, params: nil, body: nil, query: nil)
+      return operate(__method__, path: path, params: params, body: body, query: query)
+    end
+
+    def delete(path: nil, params: nil, query: nil)
+      return operate(__method__, path: path, params: params, query: query)
+    end
+
     def close
       http.finish if http.started?
     end
@@ -41,12 +79,26 @@ module Darksky
 
     def operate(method, path: nil, params: nil, body: nil, query: nil)
       uri = uri_with_path(path)
-      if params
-        query = URI.encode_www_form(params)
-        Darksky.logger.info('Created urlencoded query from params')
+      case method
+      when :get, :delete
+        if params
+          query = URI.encode_www_form(params)
+          logger.info('Created urlencoded query from params')
+        end
+        uri.query = query
+        req = METHOD_HTTP_CLASS[method].new(uri)
+      when :put, :patch, :post
+        uri.query = query if query
+        req = METHOD_HTTP_CLASS[method].new(uri)
+        if params
+          req.form_data = params
+          logger.info('Created form data from params')
+        elsif body
+          req.body = body
+        end
+      else
+        return nil
       end
-      uri.query = query
-      req = METHOD_HTTP_CLASS[method].new(uri)
       data = send(req)
       data = redirect(method, uri, params: params, body: body, query: query) if data.class <= URI::HTTP
       return data
@@ -61,12 +113,12 @@ module Darksky
     def send(req)
       inject_headers_to(req)
       unless http.started?
-        Darksky.logger.info('HTTP session not started; starting now')
+        logger.info('HTTP session not started; starting now')
         http.start
-        Darksky.logger.debug("Opened connection to #{http.address}:#{http.port}")
+        logger.debug("Opened connection to #{http.address}:#{http.port}")
       end
-      Darksky.logger.debug("Sending HTTP #{req.method} request to #{req.path}")
-      Darksky.logger.debug("Body size: #{req.body.length}") if req.request_body_permitted?
+      logger.debug("Sending HTTP #{req.method} request to #{req.path}")
+      logger.debug("Body size: #{req.body.length}") if req.request_body_permitted?
       res = http.request(req)
       return handle_response(res)
     end
@@ -76,21 +128,21 @@ module Darksky
       headers.each do |k, v|
         req[k] = v
       end
-      Darksky.logger.info('Header injected into HTTP request header')
+      logger.info('Header injected into HTTP request header')
     end
 
     def handle_response(res)
       if res.connection_close?
-        Darksky.logger.info('HTTP response header says connection close; closing session now')
+        logger.info('HTTP response header says connection close; closing session now')
         close
       end
       case res
       when Net::HTTPRedirection
-        Darksky.logger.info('HTTP response was a redirect')
+        logger.info('HTTP response was a redirect')
         data = URI(res['Location'])
         if data.class == URI::Generic
           data = uri_with_path(res['Location'])
-          Darksky.logger.debug("Full URI object built for local redirect with path: #{data.path}")
+          logger.debug("Full URI object built for local redirect with path: #{data.path}")
         end
       # when Net::HTTPSuccess
       # when Net::HTTPClientError
@@ -108,16 +160,29 @@ module Darksky
 
     def redirect(method, uri, params: nil, body: nil, query: nil)
       if uri.host == init_uri.host && uri.port == init_uri.port
-        Darksky.logger.info("Local #{method.upcase} redirect, reusing HTTP session")
+        logger.info("Local #{method.upcase} redirect, reusing HTTP session")
         new_http = http
       else
-        Darksky.logger.info("External #{method.upcase} redirect, spawning new HTTP object")
+        logger.info("External #{method.upcase} redirect, spawning new HTTP object")
         new_http = HTTP.new("#{uri.scheme}://#{uri.host}#{uri.path}", headers)
       end
-      data = operate(method, uri, params: params, query: query)
+      case method
+      when :get, :delete
+        data = operate(method, uri, params: params, query: query)
+      when :put, :patch, :post
+        data = new_http.public_send(method, uri, params: params, body: body, query: query)
+      else
+        data = nil
+      end
       return data
     end
-
   end
 
+  class NullLogger < Logger
+    def initialize(*args)
+    end
+
+    def add(*args, &block)
+    end
+  end
 end

data/lib/darksky-ruby/version.rb

@@ -1,5 +1,5 @@
 module Darksky
 
-  Version = '0.0.1'
+  Version = '0.0.2'
 
 end

data/lib/darksky-ruby.rb

@@ -1,3 +1,2 @@
-require 'darksky-ruby/logger'
 require 'darksky-ruby/api'
 require 'darksky-ruby/http'

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: darksky-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Ken J.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-22 00:00:00.000000000 Z
+date: 2019-09-09 00:00:00.000000000 Z
 dependencies: []
-description: Darksky library written in pure Ruby without external dependancy.
+description: Darksky library written in pure Ruby without external dependency.
 email:
 - kenjij@gmail.com
 executables:
@@ -23,7 +23,6 @@ files:
 - lib/darksky-ruby.rb
 - lib/darksky-ruby/api.rb
 - lib/darksky-ruby/http.rb
-- lib/darksky-ruby/logger.rb
 - lib/darksky-ruby/trollop.rb
 - lib/darksky-ruby/version.rb
 homepage: https://github.com/kenjij/darksky-ruby
@@ -46,7 +45,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: Pure simple Ruby based Darksky REST library

data/lib/darksky-ruby/logger.rb

@@ -1,24 +0,0 @@
-require 'logger'
-
-
-module Darksky
-
-  def self.logger=(logger)
-    @logger = logger
-  end
-
-  def self.logger
-    @logger ||= NullLogger.new()
-  end
-
-  class NullLogger < Logger
-
-    def initialize(*args)
-    end
-
-    def add(*args, &block)
-    end
-
-  end
-
-end