nimbu-api 0.4.4 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff45e3502100e6c7b27a5e133fd72404d18ea95094de0cc2603a97218f53baf9
-  data.tar.gz: 828d0760339cd0077cbffff8a1a2454f80e518b0723a511942e3d4bd2f37aeb6
+  metadata.gz: e544e690c2986aa829287ab083b3caf6a89b2f24f9caeb9f4e748431f341b937
+  data.tar.gz: e85e1b223f23f61afd5809e484b3e7e2f4c7563783e55eff2c458c80802365ee
 SHA512:
-  metadata.gz: dbec9008321be132f0ad9ed0a2e873154c71dc8b1bd9d87d4b1a46734d9ca511eaf6f3384dc06cf63b5534448cd95a2557197cbf70174727b38da016bb344e6e
-  data.tar.gz: 8935d575d7e1bf6f416d990c3c3c16ecd10819ccc68bb9b5d20704a05f4438d0e78bc13226225c69343b88819ffea1a5777840065185762f97c9943b1677eaa4
+  metadata.gz: a42f47b2f1769df780d03ef826f91da50cf0310da8b61742fbd8d64b9ba4afe756bf7f0794274af285bf635f540906b6403e56ad15c5af83ef6a3ca002548355
+  data.tar.gz: a712940ff8ce221fc569651b6e82181d3bcc1f896ccb6a1f558b86b1fe0e889796fdf2da067684ba5423f98ad6bdd95a6a00fec40d1e20960116c9581197558d

data/.rubocop.yml

@@ -0,0 +1,13 @@
+inherit_gem:
+  rubocop-shopify: rubocop.yml
+
+require: rubocop-performance
+
+Performance:
+  Enabled: true
+
+AllCops:
+  TargetRubyVersion: 2.5
+  NewCops: disable
+  Exclude:
+    - 'vendor/**/*'

data/README.md

@@ -27,6 +27,7 @@ nimbu = Nimbu.new
 ```
 
 You can supply following configuration parameters, such as
+
 ```
   auto_pagination  # by default false, set to true traverses requests page links
   oauth_token      # oauth authorization token
@@ -40,13 +41,15 @@ You can supply following configuration parameters, such as
   per_page         # number of items per page, max 100
   user_agent       # custom user agent name, by default 'Nimbu Ruby Client'
 ```
+
 which are used throughout the API. These can be passed directly as hash options:
 
 ```ruby
-nimbu = Nimbu.new oauth_token: 'token'
+nimbu = Nimbu.new(oauth_token: 'token')
 ```
 
-Alternatively, you can configure the Nimbu settings by passing a block, for instance, with custom enterprise endpoint and website like
+Alternatively, you can configure the Nimbu settings by passing a block, for instance, with custom
+enterprise endpoint and website like
 
 ```ruby
 nimbu = Nimbu.new do |config|
@@ -57,25 +60,28 @@ nimbu = Nimbu.new do |config|
 end
 ```
 
-You can authenticate either using OAuth authentication or through basic authentication by passing your login and password:
+You can authenticate either using OAuth authentication or through basic authentication by passing
+your login and password:
 
 ```ruby
-nimbu = Nimbu.new login:'peter', password:'...'
+nimbu = Nimbu.new(login:'peter', password:'...')
 ```
 
 or use following convenience method:
 
 ```ruby
-nimbu = Nimbu.new basic_auth: 'login:password'
+nimbu = Nimbu.new(basic_auth: 'login:password')
 ```
 
-This gem follows the Nimbu API hierarchy. This means, i.e. if you want to create a new entry for a given channel,
-you can lookup the nimbu api spec and parse the request as in `nimbu.channels(channel_id: 'mychannel').entries.create`
+This gem follows the Nimbu API hierarchy. This means, i.e. if you want to create a new entry for a
+given channel, you can lookup the nimbu api spec and parse the request as in
+`nimbu.channels(channel_id: 'mychannel').entries.create`
 
-The response is always of type [Hashie::Mash] and allows to traverse all the json response attributes like method calls i.e.
+The response is always of type [Hashie::Mash] and allows to traverse all the json response
+attributes like method calls i.e.
 
 ```ruby
-entries = Nimbu::Channel::Entries.new :oauth_token => '...', :subdomain => '...', :channel_id => '...'
+entries = Nimbu::Channel::Entries.new(oauth_token: '...', subdomain:'...', channel_id:'...')
 entries.all do |entry|
   puts entry.title
 end
@@ -83,23 +89,25 @@ end
 
 ## Arguments & Parameters
 
-The library allows for flexible arguments parsing. This means arguments can be passed during instance creation:
+The library allows for flexible arguments parsing. This means arguments can be passed during
+instance creation:
 
 ```ruby
-  channel = Nimbu::Channel.new :oauth_token => '...', :subdomain => '...', :channel_id => '...'
-  channel.entries.list state: 'public'
+  channel = Nimbu::Channel.new(oauth_token:'...', subdomain:'...', channel_id:'...')
+  channel.entries.list(state: 'public')
 ```
 
-Further, arguments can be passed directly inside method called but then the order of parameters matters and hence please consult the method documentation or Nimbu specification. For instance:
+Further, arguments can be passed directly inside method called but then the order of parameters
+matters and hence please consult the method documentation or Nimbu specification. For instance:
 
 ```ruby
-  channel = Nimbu::Channel.new :oauth_token => '...', :subdomain => '...'
-  channel.entries.list channel_id: '...', state: 'public'
+  channel = Nimbu::Channel.new(oauth_token: '...', subdomain: '...')
+  channel.entries.list(channel_id: '...', state: 'public')
 ```
 
 Similarly, the arguments for the request can be passed inside the current scope such as:
 
 ```ruby
-  channel = Nimbu::Channel.new :oauth_token => '...', :subdomain => '...'
+  channel = Nimbu::Channel.new(oauth_token: '...', subdomain: '...')
   channel.entries(channel_id: '...').list(state: 'public')
-```
+```

data/lib/nimbu-api/client.rb

@@ -1,62 +1,81 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
-require 'nimbu-api/builder'
+require "nimbu-api/builder"
 
 module Nimbu
   class Client < Endpoint
+    def oauth(options = {}, &block)
+      Nimbu::Builder.new("Authorizations", current_options.merge(options), &block)
+    end
+    alias_method :authorizations, :oauth
+
+    def sites(options = {}, &block)
+      Nimbu::Builder.new("Sites", current_options.merge(options), &block)
+    end
+
+    def themes(options = {}, &block)
+      Nimbu::Builder.new("Themes", current_options.merge(options), &block)
+    end
+
+    def channels(options = {}, &block)
+      Nimbu::Builder.new("Channels", current_options.merge(options), &block)
+    end
 
-    def oauth(options={}, &block)
-      Nimbu::Builder.new('Authorizations', current_options.merge(options), &block)
+    def videos(options = {}, &block)
+      Nimbu::Builder.new("Videos", current_options.merge(options), &block)
     end
-    alias :authorizations :oauth
 
-    def sites(options={}, &block)
-      Nimbu::Builder.new('Sites', current_options.merge(options), &block)
+    def simulator(options = {}, &block)
+      Nimbu::Builder.new("Simulator", current_options.merge(options), &block)
     end
 
-    def themes(options={}, &block)
-      Nimbu::Builder.new('Themes', current_options.merge(options), &block)
+    def products(options = {}, &block)
+      Nimbu::Builder.new("Products", current_options.merge(options), &block)
     end
 
-    def channels(options={}, &block)
-      Nimbu::Builder.new('Channels', current_options.merge(options), &block)
+    def customers(options = {}, &block)
+      Nimbu::Builder.new("Customers", current_options.merge(options), &block)
     end
 
-    def videos(options={}, &block)
-      Nimbu::Builder.new('Videos', current_options.merge(options), &block)
+    def collections(options = {}, &block)
+      Nimbu::Builder.new("Collections", current_options.merge(options), &block)
     end
 
-    def simulator(options={}, &block)
-      Nimbu::Builder.new('Simulator', current_options.merge(options), &block)
+    def devices(options = {}, &block)
+      Nimbu::Builder.new("Devices", current_options.merge(options), &block)
     end
 
-    def products(options={}, &block)
-      Nimbu::Builder.new('Products', current_options.merge(options), &block)
+    def coupons(options = {}, &block)
+      Nimbu::Builder.new("Coupons", current_options.merge(options), &block)
     end
 
-    def customers(options={}, &block)
-      Nimbu::Builder.new('Customers', current_options.merge(options), &block)
+    def authenticate(options = {}, &block)
+      Nimbu::Builder.new("Login", current_options.merge(options), &block).response
     end
 
-    def collections(options={}, &block)
-      Nimbu::Builder.new('Collections', current_options.merge(options), &block)
+    def users(options = {}, &block)
+      Nimbu::Builder.new("Users", current_options.merge(options), &block)
     end
 
-    def devices(options={}, &block)
-      Nimbu::Builder.new('Devices', current_options.merge(options), &block)
+    def pages(options = {}, &block)
+      Nimbu::Builder.new("Pages", current_options.merge(options), &block)
     end
 
-    def coupons(options={}, &block)
-      Nimbu::Builder.new('Coupons', current_options.merge(options), &block)
+    def menus(options = {}, &block)
+      Nimbu::Builder.new("Menus", current_options.merge(options), &block)
     end
 
-    def authenticate(options={}, &block)
-      Nimbu::Builder.new('Login', current_options.merge(options), &block).response
+    def blogs(options = {}, &block)
+      Nimbu::Builder.new("Blogs", current_options.merge(options), &block)
     end
 
-    def users(options={}, &block)
-      Nimbu::Builder.new('Users', current_options.merge(options), &block)
+    def redirects(options = {}, &block)
+      Nimbu::Builder.new("Redirects", current_options.merge(options), &block)
     end
 
+    def uploads(options = {}, &block)
+      Nimbu::Builder.new("Uploads", current_options.merge(options), &block)
+    end
   end # Client
 end # Nimbu

data/lib/nimbu-api/connection.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module Nimbu
   module Connection
@@ -10,39 +11,39 @@ module Nimbu
       :url,
       :params,
       :request,
-      :ssl
+      :ssl,
     ].freeze
 
-    def default_options(options={})
+    def default_options(options = {})
       {
-        :ssl => options.fetch(:ssl) { ssl },
-        :url => options.fetch(:endpoint) { Nimbu.endpoint }
+        ssl: options.fetch(:ssl) { ssl },
+        url: options.fetch(:endpoint) { Nimbu.endpoint },
       }.merge(options)
     end
 
     # Default middleware stack that uses default adapter as specified at
     # configuration stage.
     #
-    def default_middleware(options={})
-      Proc.new do |builder|
+    def default_middleware(options = {})
+      proc do |builder|
         unless options[:with_attachments]
-          builder.use Nimbu::Request::Json
+          builder.use(Nimbu::Request::Json)
         end
-        builder.use Faraday::Request::Multipart
-        builder.use Faraday::Request::UrlEncoded
-        builder.use Nimbu::Request::OAuth2, oauth_token if oauth_token?
-        builder.use Nimbu::Request::BasicAuth, authentication if basic_authed?
-        builder.use Nimbu::Request::UserAgent
-        builder.use Nimbu::Request::SiteHeader, subdomain
-        builder.use Nimbu::Request::ContentLocale, content_locale
+        builder.use(Faraday::Request::Multipart)
+        builder.use(Faraday::Request::UrlEncoded)
+        builder.use(Nimbu::Request::OAuth2, oauth_token) if oauth_token?
+        builder.use(Nimbu::Request::BasicAuth, authentication) if basic_authed?
+        builder.use(Nimbu::Request::UserAgent)
+        builder.use(Nimbu::Request::SiteHeader, subdomain)
+        builder.use(Nimbu::Request::ContentLocale, content_locale)
 
-        builder.use Faraday::Response::Logger if ENV['DEBUG']
-        builder.use Nimbu::Response::RaiseError
+        builder.use(Faraday::Response::Logger) if ENV["DEBUG"]
+        builder.use(Nimbu::Response::RaiseError)
         unless options[:raw]
-          builder.use Nimbu::Response::Mashify
-          builder.use Nimbu::Response::Json
+          builder.use(Nimbu::Response::Mashify)
+          builder.use(Nimbu::Response::Json)
         end
-        builder.adapter adapter
+        builder.adapter(adapter)
       end
     end
 
@@ -61,25 +62,22 @@ module Nimbu
     # Exposes middleware builder to facilitate custom stacks and easy
     # addition of new extensions such as cache adapter.
     #
-    def stack(options={}, &block)
-      @stack ||= begin
-        if block_given?
-          Faraday::RackBuilder.new(&block)
-        else
-          Faraday::RackBuilder.new(&default_middleware(options))
-        end
+    def stack(options = {}, &block)
+      @stack ||= if block_given?
+        Faraday::RackBuilder.new(&block)
+      else
+        Faraday::RackBuilder.new(&default_middleware(options))
       end
     end
 
     # Returns a Fraday::Connection object
     #
-    def connection(options={})
-      conn_options = default_options(options).keep_if {|k,_| ALLOWED_OPTIONS.include? k }
+    def connection(options = {})
+      conn_options = default_options(options).keep_if { |k, _| ALLOWED_OPTIONS.include?(k) }
       clear_cache unless options.empty?
-      puts "OPTIONS:#{conn_options.inspect}" if ENV['DEBUG']
+      puts "OPTIONS:#{conn_options.inspect}" if ENV["DEBUG"]
 
-      Faraday.new(conn_options.merge(:builder => stack(options)))
+      Faraday.new(conn_options.merge(builder: stack(options)))
     end
-
   end # Connection
 end # Nimbu

data/lib/nimbu-api/endpoint.rb

@@ -1,4 +1,5 @@
 # -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 
 module Nimbu
   # Core class for api interface operations
@@ -8,14 +9,14 @@ module Nimbu
     include Connection
     include Request
 
-    attr_reader *Configuration.keys
-    attr_accessor *Request::Validations::VALID_API_KEYS
+    attr_reader(*Configuration.keys)
+    attr_accessor(*Request::Validations::VALID_API_KEYS)
 
     attr_accessor :current_options
 
     # Returns all API public methods for a given class.
     def self.inherited(klass)
-      klass.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+      klass.class_eval(<<-RUBY_EVAL, __FILE__, __LINE__ + 1)
         def self.actions
           self.new.api_methods_in(#{klass})
         end
@@ -28,17 +29,16 @@ module Nimbu
 
     def api_methods_in(klass)
       puts "---"
-      (klass.send(:instance_methods, false) - ['actions']).sort.each do |method|
+      (klass.send(:instance_methods, false) - ["actions"]).sort.each do |method|
         puts "|--> #{method}"
       end
       klass.included_modules.each do |mod|
-        if mod.to_s =~ /#{klass}/
-          puts "| \\ #{mod.to_s}"
-          mod.instance_methods(false).each do |met|
-            puts "|  |--> #{met}"
-          end
-          puts "| /"
+        next unless /#{klass}/.match?(mod.to_s)
+        puts "| \\ #{mod}"
+        mod.instance_methods(false).each do |met|
+          puts "|  |--> #{met}"
         end
+        puts "| /"
       end
       puts "---"
       nil
@@ -46,29 +46,29 @@ module Nimbu
 
     def append_arguments(method)
       _method = self.method(method)
-      if _method.arity == 0
-        args = "()"
+      args = if _method.arity == 0
+        "()"
       elsif _method.arity > 0
-        args = "(few)"
+        "(few)"
       else
-        args = "(else)"
+        "(else)"
       end
       args
     end
 
     # Callback to update current configuration options
-     class_eval do
-       Configuration.keys.each do |key|
-         define_method "#{key}=" do |arg|
-           self.instance_variable_set("@#{key}", arg)
-           self.current_options.merge!({:"#{key}" => arg})
-         end
-       end
-     end
+    class_eval do
+      Configuration.keys.each do |key|
+        define_method "#{key}=" do |arg|
+          instance_variable_set("@#{key}", arg)
+          current_options.merge!({ "#{key}": arg })
+        end
+      end
+    end
 
     # Create new API
     #
-    def initialize(options={}, &block)
+    def initialize(options = {}, &block)
       setup(options)
       client(options) if client_id? && client_secret?
       yield_or_eval(&block) if block_given?
@@ -76,14 +76,14 @@ module Nimbu
 
     def yield_or_eval(&block)
       return unless block
-      block.arity > 0 ? yield(self) : self.instance_eval(&block)
+      block.arity > 0 ? yield(self) : instance_eval(&block)
     end
 
     # Configure options and process basic authorization
     #
-    def setup(options={})
-      options.each do |k,v|
-        self.set(k,v,true)
+    def setup(options = {})
+      options.each do |k, v|
+        set(k, v, true)
       end
       options = Nimbu.options.merge(options)
       self.current_options = options
@@ -98,7 +98,7 @@ module Nimbu
     def process_basic_auth(auth)
       case auth
       when String
-        self.login, self.password = auth.split(':', 2)
+        self.login, self.password = auth.split(":", 2)
       when Hash
         self.login    = auth[:login]
         self.password = auth[:password]
@@ -109,9 +109,9 @@ module Nimbu
     def method_missing(method, *args, &block) # :nodoc:
       case method.to_s
       when /^(.*)\?$/
-        return !!self.send($1.to_s)
+        !!send(Regexp.last_match(1).to_s)
       when /^clear_(.*)$/
-        self.send("#{$1.to_s}=", nil)
+        send("#{Regexp.last_match(1)}=", nil)
       else
         super
       end
@@ -121,7 +121,7 @@ module Nimbu
     #
     # Returns Arguments instance.
     #
-    def arguments(args=(not_set = true), options={}, &block)
+    def arguments(args = (not_set = true), options = {}, &block)
       if not_set
         @arguments
       else
@@ -134,27 +134,27 @@ module Nimbu
     def with(args)
       case args
       when Hash
-        set args
+        set(args)
       else
-        ::Kernel.raise ArgumentError, 'This api does not support passed in arguments'
+        ::Kernel.raise ArgumentError, "This api does not support passed in arguments"
       end
     end
 
     # Set an option to a given value
-    def set(option, value=(not_set=true), ignore_setter=false, &block)
-      raise ArgumentError, 'value not set' if block and !not_set
+    def set(option, value = (not_set = true), ignore_setter = false, &block)
+      raise ArgumentError, "value not set" if block and !not_set
       return self if !not_set and value.nil?
 
       if not_set
-        set_options option
+        set_options(option)
         return self
       end
 
-      if respond_to?("#{option}=") and not ignore_setter
+      if respond_to?("#{option}=") and !ignore_setter
         return __send__("#{option}=", value)
       end
 
-      define_accessors option, value
+      define_accessors(option, value)
       self
     end
 
@@ -164,13 +164,13 @@ module Nimbu
     #
     def set_options(options)
       unless options.respond_to?(:each)
-        raise ArgumentError, 'cannot iterate over value'
+        raise ArgumentError, "cannot iterate over value"
       end
       options.each { |key, value| set(key, value) }
     end
 
     def define_accessors(option, value)
-      setter = proc { |val|  set option, val, true }
+      setter = proc { |val| set(option, val, true) }
       getter = proc { value }
 
       define_singleton_method("#{option}=", setter) if setter
@@ -179,7 +179,7 @@ module Nimbu
 
     # Dynamically define a method for setting request option
     #
-    def define_singleton_method(method_name, content=Proc.new)
+    def define_singleton_method(method_name, content = Proc.new)
       (class << self; self; end).class_eval do
         undef_method(method_name) if method_defined?(method_name)
         if String === content
@@ -191,9 +191,8 @@ module Nimbu
     end
 
     def _merge_mime_type(resource, params) # :nodoc:
-#       params['resource'] = resource
-#       params['mime_type'] = params['mime_type'] || :raw
+      #       params['resource'] = resource
+      #       params['mime_type'] = params['mime_type'] || :raw
     end
-
   end # Endpoint
 end # Nimbu

data/lib/nimbu-api/endpoints/activities.rb

@@ -1,16 +1,15 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module Nimbu
   module Endpoints
     class Activities < Endpoint
-
       def get(*args)
-        arguments(args, :required => [:activity_id])
+        arguments(args, required: [:activity_id])
 
         get_request("/activities/#{activity_id}", arguments.params)
       end
-      alias :find :get
-
+      alias_method :find, :get
     end # Authorizations
   end # Endpoints
 end # Nimbu

data/lib/nimbu-api/endpoints/authorizations.rb

@@ -1,18 +1,11 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module Nimbu
   module Endpoints
     class Authorizations < Endpoint
-
-      VALID_AUTH_PARAM_NAMES = %w[
-        scopes
-        add_scopes
-        remove_scopes
-        note
-        note_url
-        client_id
-        client_secret
-      ].freeze
+      VALID_AUTH_PARAM_NAMES = ["scopes", "add_scopes", "remove_scopes", "note", "note_url", "client_id",
+                                "client_secret",].freeze
 
       # List authorizations
       #
@@ -21,15 +14,15 @@ module Nimbu
       #  nimbu.oauth.list
       #  nimbu.oauth.list { |auth| ... }
       #
-      def list(*args)
+      def list(*args, &block)
         require_authentication
         arguments(args)
 
         response = get_request("/authorizations", arguments.params)
         return response unless block_given?
-        response.each { |el| yield el }
+        response.each(&block)
       end
-      alias :all :list
+      alias_method :all, :list
 
       # Get a single authorization
       #
@@ -39,11 +32,11 @@ module Nimbu
       #
       def get(*args)
         require_authentication
-        arguments(args, :required => [:authorization_id])
+        arguments(args, required: [:authorization_id])
 
         get_request("/authorizations/#{authorization_id}", arguments.params)
       end
-      alias :find :get
+      alias_method :find, :get
 
       # Create a new authorization
       #
@@ -60,7 +53,7 @@ module Nimbu
       def create(*args)
         require_authentication
         arguments(args) do
-          sift VALID_AUTH_PARAM_NAMES
+          sift(VALID_AUTH_PARAM_NAMES)
         end
 
         post_request("/authorizations", arguments.params)
@@ -81,13 +74,13 @@ module Nimbu
       #
       def update(*args)
         require_authentication
-        arguments(args, :required => [:authorization_id]) do
-          sift VALID_AUTH_PARAM_NAMES
+        arguments(args, required: [:authorization_id]) do
+          sift(VALID_AUTH_PARAM_NAMES)
         end
 
         patch_request("/authorizations/#{authorization_id}", arguments.params)
       end
-      alias :edit :update
+      alias_method :edit, :update
 
       # Delete an authorization
       #
@@ -96,18 +89,18 @@ module Nimbu
       #
       def delete(*args)
         require_authentication
-        arguments(args, :required => [:authorization_id])
+        arguments(args, required: [:authorization_id])
 
         delete_request("/authorizations/#{authorization_id}", arguments.params)
       end
-      alias :remove :delete
+      alias_method :remove, :delete
 
       private
 
       def require_authentication
-        raise ArgumentError, 'You can only access authentication tokens through Basic Authentication' unless authenticated?
+        raise ArgumentError,
+          "You can only access authentication tokens through Basic Authentication" unless authenticated?
       end
-
     end # Authorizations
   end # Endpoints
 end # Nimbu