gql 0.0.10 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a62133987b6e3870e58eae49d16b0e9b7c71520d
-  data.tar.gz: d13a2cf25e549aa1ae11e5e0d4f0b5de924698f6
+  metadata.gz: defb9d23450cd1caa407d256c9cc8606ced22880
+  data.tar.gz: 069be6463c76f8add762ce9dff462e3d36a15a0c
 SHA512:
-  metadata.gz: d099ea7a0be26f2df9f0006224c9f92f3e958abcfd80104b1a4f332763cee38b5fd39549f125b68d5a3331f33a81e6975db3d0bcf1b3f546341d44b72eb124a5
-  data.tar.gz: 40936dedec0db03b6da4a80f80bd8329d66187a43c04628cd6a7f02591c456c1ac8e2de656d7651f897c2258e00402b2547be210efefffb095c5c8b58027f95a
+  metadata.gz: c5d31f91c8bb62a86e08a1fe77ba99a860766b67b91099aa8ada33e75cd13f8a57934795b2d14722dd435407a40c775c378deab6922790e6d41252a5faaa7d5a
+  data.tar.gz: d7edece3f9ff42860d183bdbd41584ae69bc0d96b82936c8e7b7c625857746edda3f0c27826a72c6ff7f0b989a5a3796a0dae2a241c47274d32d581864c44b81

data/README.md

@@ -36,7 +36,7 @@ TODO: Write usage instructions here
 Run `bin/console` for an interactive prompt (loaded with example models/data) and enter the following:
 
 ```ruby
-puts q(<<-QUERY_STRING).to_json
+puts query(<<-QUERY_STRING).to_json
   user(<token>) {
     id,
     is_admin,

data/lib/gql.rb

@@ -23,14 +23,14 @@ module GQL
     extend ActiveSupport::Autoload
 
     autoload_at 'gql/errors' do
+      autoload :CallNotFound
+      autoload :FieldNotFound
       autoload :InvalidNodeClass
+      autoload :NoMethodError
+      autoload :RootClassNotSet
       autoload :ScanError
       autoload :SyntaxError
-      autoload :UndefinedCall
-      autoload :UndefinedField
       autoload :UndefinedNodeClass
-      autoload :UndefinedRoot
-      autoload :UndefinedFieldType
     end
   end
 
@@ -50,7 +50,13 @@ module GQL
       Thread.current[:gql_config] ||= Config.new
     end
 
-    %w(root_node_class field_types default_list_class).each do |method|
+    def config=(value)
+      Thread.current[:gql_config] = value
+    end
+
+    %w(root_node_class root_target_proc field_types
+       default_list_class default_field_proc
+       default_call_proc).each do |method|
       module_eval <<-DELEGATORS, __FILE__, __LINE__ + 1
         def #{method}
           config.#{method}

data/lib/gql/call.rb

@@ -6,20 +6,11 @@ module GQL
 
     class << self
       def returns(result_class = nil, &block)
-        if result_class
-          self.result_class = result_class
-        elsif block_given?
-          Class.new(Node).tap do |result_class|
-            result_class.default_proc = -> id { -> { target[id] } }
-            result_class.class_eval(&block)
-
-            returns result_class
-          end
-        end
+        self.result_class = result_class || result_class_from_block(block)
       end
 
       def execute(caller_class, ast_node, target, variables, context)
-        args = substitute_variables(ast_node.arguments, variables)
+        args = substitute_variables(ast_node.arguments, variables.dup)
         target = new(target, context).execute(*args)
 
         next_class = result_class || caller_class
@@ -30,8 +21,16 @@ module GQL
 
       private
         def substitute_variables(args, variables)
+          return args unless variables.any?
           args.map { |arg| arg.is_a?(::Symbol) ? variables[arg] : arg }
         end
+
+        def result_class_from_block(block)
+          Class.new(Node).tap do |result_class|
+            result_class.field_proc = -> id { -> { target[id] } }
+            result_class.class_eval(&block)
+          end
+        end
     end
 
     attr_reader :target, :context

data/lib/gql/config.rb

@@ -9,13 +9,21 @@ module GQL
         raise Errors::InvalidNodeClass.new(value, Node)
       end
 
-      if ENV['DEBUG']
+      if value && ENV['DEBUG']
         value.call :_schema, -> { context[:_schema_root] }, returns: Schema::Root
       end
 
       @@root_node_class = value
     end
 
+    def root_target_proc
+      @@root_target_proc ||= -> context { nil }
+    end
+
+    def root_target_proc=(value)
+      @@root_target_proc = value
+    end
+
     def field_types
       @@field_types ||= {
         array:      Array,
@@ -36,7 +44,27 @@ module GQL
     end
 
     def default_list_class=(value)
+      unless value.nil? || value <= Node
+        raise Errors::InvalidNodeClass.new(value, Node)
+      end
+
       @@default_list_class = value
     end
+
+    def default_field_proc
+      @@default_field_proc ||= -> id { -> { target.public_send(id) } }
+    end
+
+    def default_field_proc=(value)
+      @@default_field_proc = value
+    end
+
+    def default_call_proc
+      @@default_call_proc ||= -> id { -> (*args) { target.public_send(id, *args) } }
+    end
+
+    def default_call_proc=(value)
+      @@default_call_proc = value
+    end
   end
 end

data/lib/gql/errors.rb

@@ -6,60 +6,86 @@ module GQL
   end
 
   module Errors
-    class UndefinedRoot < Error
-      def initialize
-        super('Root node class is undefined. Define it with `GQL.root_node_class = MyRootNode`.')
+    class NotFoundError < Error
+      private
+        def construct_message(node_class, id, name, method)
+          items = node_class.send(method).keys.sort.map { |key| "`#{key}'" }
+
+          msg =  "#{node_class} has no #{name} named `#{id}'."
+          msg << " Available #{name.pluralize}: #{items.to_sentence}." if items.any?
+          msg
+        end
+    end
+
+    class CallNotFound < NotFoundError
+      def initialize(id, node_class)
+        msg = construct_message(node_class, id, 'call', :calls)
+
+        super(msg)
       end
     end
 
-    class UndefinedNodeClass < Error
-      def initialize(node_class, name)
-        super("#{node_class} must define a #{name} class. Set it with `self.#{name}_class = My#{name.camelize}Class`.")
+    class FieldNotFound < NotFoundError
+      def initialize(id, node_class)
+        msg = construct_message(node_class, id, 'field', :fields)
+
+        super(msg)
       end
     end
 
     class InvalidNodeClass < Error
       def initialize(node_class, super_class)
-        super("#{node_class} must be a (subclass of) #{super_class}.")
+        msg = "#{node_class} must be a (subclass of) #{super_class}."
+
+        super(msg)
       end
     end
 
-    class UndefinedFieldType < Error
-      def initialize(id)
-        types = GQL.field_types.keys.sort.map { |id| "`#{id}`" }
-        types = types.size > 0 ? " Available types: #{types.to_sentence}." : ''
+    class NoMethodError < Error
+      attr_reader :cause
 
-        super("The field type `#{id}` is undefined. Define it with `GQL.field_types[:#{id}] = My#{id.to_s.camelize}`.#{types}")
-      end
-    end
+      def initialize(node_class, id, cause)
+        @cause = cause
 
-    class UndefinedCall < Error
-      def initialize(id, node_class)
-        calls = node_class.calls.keys.sort.map { |id| "`#{id}`" }
-        calls = calls.size > 0 ? " Available calls: #{calls.to_sentence}." : ''
+        msg =  "Undefined method `#{id}' for #{node_class}. "
+        msg << "Did you try to add a field of type `#{id}'? "
+        msg << "If so, you have to register your field type first "
+        msg << "like this: `GQL.field_types[:#{id}] = My#{id.to_s.camelize}'. "
+        msg << "The following field types are currently registered: "
+        msg << GQL.field_types.keys.sort.map { |id| "`#{id}'" }.to_sentence
 
-        super("#{node_class} has no call named `#{id}`.#{calls}")
+        super(msg)
       end
     end
 
-    class UndefinedField < Error
-      def initialize(id, node_class)
-        fields = node_class.fields.keys.sort.map { |id| "`#{id}`" }
-        fields = fields.size > 0 ? " Available fields: #{fields.to_sentence}." : ''
+    class RootClassNotSet < Error
+      def initialize
+        msg =  "GQL root node class is not set. "
+        msg << "Set it with `GQL.root_node_class = MyRootNode'."
 
-        super("#{node_class} has no field named `#{id}`.#{fields}")
+        super(msg)
       end
     end
 
+    class ScanError < Error
+    end
+
     class SyntaxError < Error
       def initialize(lineno, value, token)
         token = 'character' if token == 'error' || token == %Q{"#{value}"}
+        msg = "Unexpected #{token}: `#{value}' (line #{lineno})."
 
-        super("Unexpected #{token}: `#{value}` (line #{lineno}).")
+        super(msg)
       end
     end
 
-    class ScanError < Error
+    class UndefinedNodeClass < Error
+      def initialize(node_class, name)
+        msg =  "#{node_class} must have a #{name} class set. "
+        msg << "Set it with `self.#{name}_class = My#{name.camelize}Class'."
+
+        super(msg)
+      end
     end
   end
 end

data/lib/gql/executor.rb

@@ -10,11 +10,13 @@ module GQL
     def execute(context = {})
       node_class = GQL.root_node_class
 
-      raise Errors::UndefinedRoot if node_class.nil?
+      raise Errors::RootClassNotSet if node_class.nil?
 
       context[:_schema_root] = node_class if ENV['DEBUG']
 
-      node = node_class.new(ast_root, nil, variables, context)
+      target = GQL.root_target_proc.call(context)
+
+      node = node_class.new(ast_root, target, variables, context)
       node.value
     end
   end

data/lib/gql/has_calls.rb

@@ -0,0 +1,83 @@
+require 'active_support/concern'
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/object/try'
+
+module GQL
+  module HasCalls
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :calls, :call_proc, instance_accessor: false, instance_predicate: false
+      self.calls = {}
+    end
+
+    module ClassMethods
+      def call(id, *args)
+        options = args.extract_options!
+
+        call_spec = args.shift || proc_for_call(id)
+        result_spec = options[:returns] || call_spec.try(:result_class)
+        result_class = result_class_from_spec(result_spec)
+
+        Node.validate_is_subclass! result_class, 'result' if result_class
+
+        call_class = call_class_from_spec(call_spec)
+        call_class.id = id.to_s
+        call_class.result_class = result_class
+
+        self.const_set "#{id.to_s.camelize}Call", call_class
+        self.calls = calls.merge(id.to_sym => call_class)
+      end
+
+      private
+        def proc_for_call(id)
+          instance_exec id, &(call_proc || GQL.default_call_proc)
+        end
+
+        def result_class_from_spec(spec)
+          return spec unless spec.is_a? ::Array
+
+          result_class_from_connection_spec spec.dup
+        end
+
+        def result_class_from_connection_spec(spec)
+          if spec.size == 1
+            spec.unshift GQL.default_list_class
+          end
+
+          options = {
+            list_class: spec.first,
+            item_class: spec.last
+          }
+
+          Connection.build_class :result, nil, options
+        end
+
+        def call_class_from_spec(spec)
+          return Class.new(spec) unless spec.is_a?(Proc)
+
+          Class.new(Call).tap do |call_class|
+            call_class.class_eval do
+              self.proc = spec
+
+              def execute(*args)
+                instance_exec(*args, &self.class.proc)
+              end
+            end
+          end
+        end
+    end
+
+    private
+      def value_of_call(ast_call)
+        call_class = call_class_for_id(ast_call.id)
+        call_class.execute(self.class, ast_call, target, variables, context)
+      end
+
+      def call_class_for_id(id)
+        self.class.calls[id] or raise Errors::CallNotFound.new(id, self.class)
+      end
+  end
+end

data/lib/gql/has_fields.rb

@@ -0,0 +1,103 @@
+require 'active_support/concern'
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/string/inflections'
+
+module GQL
+  module HasFields
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :fields, :field_proc, instance_accessor: false, instance_predicate: false
+      self.fields = {}
+    end
+
+    module ClassMethods
+      def field(id, *args)
+        options = args.extract_options!
+        type = options.delete(:type) || Node
+        proc = args.shift || proc_for_field(id)
+
+        Node.validate_is_subclass! type, 'type'
+
+        type.build_class(id, proc, options).tap do |field_class|
+          self.const_set "#{id.to_s.camelize}Field", field_class
+          self.fields = fields.merge(id.to_sym => field_class)
+        end
+      end
+
+      def cursor(id_or_proc)
+        id = id_or_proc.is_a?(Proc) ? nil : id_or_proc
+        proc = id ? -> { target.public_send(id) } : id_or_proc
+
+        field :cursor, proc, type: Raw
+      end
+
+      def respond_to?(method, *args)
+        super || GQL.field_types.has_key?(method)
+      end
+
+      def method_missing(method, *args, &block)
+        if type = GQL.field_types[method]
+          define_field_method method, type
+          send method, *args, &block
+        else
+          super
+        end
+      rescue NoMethodError => exc
+        raise Errors::NoMethodError.new(self, method, exc)
+      end
+
+      private
+        def proc_for_field(id)
+          instance_exec id, &(field_proc || GQL.default_field_proc)
+        end
+
+        def define_field_method(name, type)
+          Node.define_singleton_method name do |*args, &block|
+            options = args.extract_options!.merge(type: type)
+            args = args.push(options)
+
+            field(*args, &block)
+          end
+        end
+    end
+
+    private
+      def value_of_fields(ast_fields)
+        ast_fields.reduce({}) do |result, ast_field|
+          key = ast_field.alias_id || ast_field.id
+
+          result.merge key => value_of_field(ast_field)
+        end
+      end
+
+      def value_of_field(ast_field)
+        if ast_field.id == :node
+          field = self.class.new(ast_field, target, variables, context)
+          field.value
+        else
+          field_class = field_class_for_id(ast_field.id)
+          next_target = target_for_field(target, field_class.proc)
+
+          field = field_class.new(ast_field, next_target, variables, context)
+          field.value
+        end
+      end
+
+      def field_class_for_id(id)
+        self.class.fields[id] or raise Errors::FieldNotFound.new(id, self.class)
+      end
+
+      def target_for_field(current_target, proc)
+        method = ExecutionContext.new(current_target, context)
+        method.execute proc
+      end
+
+      class ExecutionContext < Struct.new(:target, :context)
+        def execute(method, args = [])
+          instance_exec(*args, &method)
+        end
+      end
+  end
+end

data/lib/gql/node.rb

@@ -1,27 +1,14 @@
 require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/string/inflections'
-require 'active_support/core_ext/array/extract_options'
-require 'active_support/core_ext/object/try'
+
+require 'gql/has_calls'
+require 'gql/has_fields'
 
 module GQL
   class Node
-    class ExecutionContext
-      attr_reader :target, :context
-
-      def initialize(target, context)
-        @target, @context = target, context
-      end
-
-      def execute(method, args = [])
-        instance_exec(*args, &method)
-      end
-    end
-
-    class_attribute :id, :proc, :calls, :fields, :default_proc, instance_accessor: false, instance_predicate: false
+    include HasCalls
+    include HasFields
 
-    self.calls = {}
-    self.fields = {}
-    self.default_proc = -> id { -> { target.public_send(id) } }
+    class_attribute :id, :proc, instance_accessor: false, instance_predicate: false
 
     class << self
       def build_class(id, proc, options = {})
@@ -31,76 +18,6 @@ module GQL
         end
       end
 
-      def call(id, *args)
-        if id.is_a? Hash
-          id.each do |name, call_class|
-            call name, call_class
-          end
-        else
-          options = args.extract_options!
-
-          proc_or_class = args.shift || -> (*pargs) { target.public_send(id, *pargs) }
-          result_class = options[:returns] || proc_or_class.try(:result_class)
-
-          if result_class.is_a? ::Array
-            if result_class.size == 1
-              result_class.unshift GQL.default_list_class || Connection
-            end
-
-            options = {
-              list_class: result_class.first,
-              item_class: result_class.last
-            }
-
-            result_class = Connection.build_class(:result, nil, options)
-          elsif result_class
-            Node.validate_is_subclass! result_class, 'result'
-          end
-
-          call_class =
-            if proc_or_class.is_a? Proc
-              Class.new(Call).tap do |klass|
-                klass.class_eval do
-                  self.proc = proc_or_class
-
-                  def execute(*args)
-                    instance_exec(*args, &self.class.proc)
-                  end
-                end
-
-                self.const_set "#{id.to_s.camelize}Call", klass
-              end
-            else
-              proc_or_class
-            end
-
-          call_class.id = id.to_s
-          call_class.result_class = result_class
-
-          self.calls = calls.merge(id.to_sym => call_class)
-        end
-      end
-
-      def field(id, *args)
-        options = args.extract_options!
-        proc    = args.shift || instance_exec(id, &default_proc)
-        type    = options.delete(:type) || Node
-
-        Node.validate_is_subclass! type, 'type'
-
-        type.build_class(id, proc, options).tap do |field_class|
-          self.const_set "#{id.to_s.camelize}Field", field_class
-          self.fields = fields.merge(id.to_sym => field_class)
-        end
-      end
-
-      def cursor(id_or_proc)
-        id = id_or_proc.is_a?(Proc) ? nil : id_or_proc
-        proc = id ? -> { target.public_send(id) } : id_or_proc
-
-        field :cursor, proc, type: Raw
-      end
-
       def validate_is_subclass!(subclass, name)
         if subclass.nil?
           raise Errors::UndefinedNodeClass.new(self, name)
@@ -110,27 +27,6 @@ module GQL
           raise Errors::InvalidNodeClass.new(subclass, self)
         end
       end
-
-      def respond_to?(method, *args)
-        super || GQL.field_types.has_key?(method)
-      end
-
-      def method_missing(method, *args, &block)
-        if type = GQL.field_types[method]
-          Node.define_singleton_method method do |*margs, &mblock|
-            options = margs.extract_options!.merge(type: type)
-            margs = margs.push(options)
-
-            field(*margs, &mblock)
-          end
-
-          send method, *args, &block
-        else
-          super
-        end
-      rescue NoMethodError
-        raise Errors::UndefinedFieldType, method
-      end
     end
 
     attr_reader :ast_node, :target, :variables, :context
@@ -150,44 +46,6 @@ module GQL
       end
     end
 
-    def value_of_call(ast_call)
-      call_class = self.class.calls[ast_call.id]
-
-      if call_class.nil?
-        raise Errors::UndefinedCall.new(ast_call.id, self.class)
-      end
-
-      call_class.execute(self.class, ast_call, target, variables, context)
-    end
-
-    def value_of_fields(ast_fields)
-      ast_fields.reduce({}) do |result, ast_field|
-        key = ast_field.alias_id || ast_field.id
-
-        result.merge key => value_of_field(ast_field)
-      end
-    end
-
-    def value_of_field(ast_field)
-      case ast_field.id
-      when :node
-        field = self.class.new(ast_field, target, variables, context)
-        field.value
-      else
-        field_class = self.class.fields[ast_field.id]
-
-        if field_class.nil?
-          raise Errors::UndefinedField.new(ast_field.id, self.class)
-        end
-
-        method = ExecutionContext.new(target, context)
-        target = method.execute(field_class.proc)
-
-        field = field_class.new(ast_field, target, variables, context)
-        field.value
-      end
-    end
-
     def raw_value
       nil
     end

data/lib/gql/parser.rb

@@ -27,6 +27,15 @@ module_eval(<<'...end parser.racc/module_eval...', 'parser.racc', 135)
     end
   end
 
+  class Root < Struct.new(:call, :fields)
+    def as_json(*)
+      {
+        call:       call.as_json,
+        fields:     fields.as_json
+      }
+    end
+  end
+
   class Node < Struct.new(:id, :alias_id, :call, :fields)
     def as_json(*)
       {
@@ -300,14 +309,14 @@ module_eval(<<'.,.,', 'parser.racc', 4)
 
 module_eval(<<'.,.,', 'parser.racc', 8)
   def _reduce_2(val, _values, result)
-      result = Node.new(nil, nil, val[0], nil   )  
+      result = Root.new(val[0], nil   )  
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.racc', 9)
   def _reduce_3(val, _values, result)
-      result = Node.new(nil, nil, nil,    val[1])  
+      result = Root.new(nil,    val[1])  
     result
   end
 .,.,

data/lib/gql/schema/call.rb

@@ -6,15 +6,7 @@ module GQL
       string  :id
       string  :type,         -> { target.name }
       object  :result_class, -> { target.result_class || Placeholder }, node_class: Node
-
-
-      array :parameters, -> {
-        if target.proc
-          target.proc.parameters
-        else
-          target.instance_method(:execute).parameters
-        end
-      }, item_class: Parameter
+      array   :parameters,   -> { (target.proc || target.instance_method(:execute)).parameters }, item_class: Parameter
     end
   end
 end

data/lib/gql/schema/list.rb

@@ -1,6 +1,6 @@
 module GQL
   module Schema
-    class List < GQL::Connection
+    class List < GQL::Node
       number :count
 
       call :reverse

data/lib/gql/schema/parameter.rb

@@ -1,30 +1,20 @@
 module GQL
   module Schema
     class Parameter < GQL::Node
-      cursor -> { target[1].to_s }
+      MODES = {
+        req:      'required',
+        opt:      'optional',
+        rest:     'rest',
+        keyreq:   'required keyword',
+        key:      'optional keyword',
+        keyrest:  'keyword rest',
+        block:    'block'
+      }.freeze
 
-      string :id, -> { target[1].to_s }
+      cursor -> { target[1].to_s }
 
-      string :mode, -> {
-        case target[0]
-        when :req
-          'required'
-        when :opt
-          'optional'
-        when :rest
-          'rest'
-        when :keyreq
-          'required keyword'
-        when :key
-          'optional keyword'
-        when :keyrest
-          'keyword rest'
-        when :block
-          'block'
-        else
-          target[0].to_s
-        end
-      }
+      string :id,   -> { target[1].to_s }
+      string :mode, -> { MODES[target[0]] || target[0].to_s }
     end
   end
 end

data/lib/gql/tokenizer.rb

@@ -103,7 +103,10 @@ class GQL::Parser < Racc::Parser
       when (text = @ss.scan(/.*(?=\*\/)/))
         ;
 
-      when (text = @ss.scan(/(.|\n)*(?=\*\/)/))
+      when (text = @ss.scan(/.+(?=\n)/))
+        ;
+
+      when (text = @ss.scan(/\n/))
         ;
 
       else

data/lib/gql/version.rb

@@ -1,3 +1,3 @@
 module GQL
-  VERSION = '0.0.10'
+  VERSION = '0.0.11'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gql
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.11
 platform: ruby
 authors:
 - Martin Andert
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-08 00:00:00.000000000 Z
+date: 2015-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -111,6 +125,8 @@ files:
 - lib/gql/connection.rb
 - lib/gql/errors.rb
 - lib/gql/executor.rb
+- lib/gql/has_calls.rb
+- lib/gql/has_fields.rb
 - lib/gql/node.rb
 - lib/gql/number.rb
 - lib/gql/object.rb
@@ -138,7 +154,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.0
+      version: '2.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="