eapi 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b1e95dc0187bc0b633dd39f04862c3f57f1c412f
+  data.tar.gz: 35a9ef27b0186c91592e4a7d1bee6d43a717e13e
+SHA512:
+  metadata.gz: e68a34cf0a19910cda0eebdd3e855bcf3fe70fa4ab34de5c3e6f0c6bc7b67b25493f8d0a8acdf77a54fb25bffe06c841d889331abefaee245614668560d38508
+  data.tar.gz: 3f0961bb4964307784f5e251640b39c52ee6e488592462712b41c3b0996e75f327b9726454ec1d340dc3ce27b24a8089475201fa39946b108a7869260988a53c

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -0,0 +1,57 @@
+.idea
+
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/.travis.yml

@@ -0,0 +1,15 @@
+language: ruby
+cache: bundler
+
+rvm:
+  - 2.1.1
+  - 2.0.0
+
+script: 'bundle exec rake spec'
+
+notifications:
+  email:
+    recipients:
+      - eturino@eturino.com
+    on_failure: change
+    on_success: never

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in eapi.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Eduardo Turiño
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,32 @@
+# Eapi (Elastic API)
+
+ruby gem for building complex structures that will end up in hashes (initially devised for ElasticSearch search requests)
+
+[![Coverage Status](https://coveralls.io/repos/eturino/eapi/badge.png)](https://coveralls.io/r/eturino/eapi)
+[![Build Status](https://travis-ci.org/eturino/eapi.svg?branch=master)](https://travis-ci.org/eturino/eapi)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'eapi'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install eapi
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/eturino/eapi/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rspec/core/rake_task'
+require 'bundler/gem_tasks'
+
+# Default directory to look in is `/specs`
+# Run with `rake spec`
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.rspec_opts = ['--color']
+end
+
+task :default => :spec
+

data/eapi.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'eapi/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "eapi"
+  spec.version       = Eapi::VERSION
+  spec.authors       = ["Eduardo Turiño"]
+  spec.email         = ["eturino@eturino.com"]
+  spec.summary       = %q{ruby gem for building complex structures that will end up in hashes (initially devised for ElasticSearch search requests)}
+  #spec.description   = %q{TODO: Write a longer description. Optional.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec-nc"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-nav"
+  spec.add_development_dependency "pry-rescue"
+  spec.add_development_dependency "pry-stack_explorer"
+  spec.add_development_dependency "pry-doc"
+  spec.add_development_dependency "coveralls"
+
+  spec.add_dependency 'activesupport', '~> 4'
+  spec.add_dependency 'activemodel', '~> 4'
+end

data/lib/eapi.rb

@@ -0,0 +1,16 @@
+require 'active_support/all'
+require 'active_model'
+
+require 'eapi/version'
+require 'eapi/errors'
+require 'eapi/multiple'
+require 'eapi/methods'
+require 'eapi/common'
+
+
+module Eapi
+  def self.method_missing(method, *args, &block)
+    klass = const_get("Eapi::#{method}")
+    klass.new *args, &block
+  end
+end

data/lib/eapi/common.rb

@@ -0,0 +1,48 @@
+module Eapi
+  module Common
+    extend ActiveSupport::Concern
+    included do
+      include ActiveModel::Validations
+      include Eapi::Methods::Properties::InstanceMethods
+    end
+
+    def initialize(** properties)
+      properties.each do |k, v|
+        normal_setter = "#{k}="
+        #TODO: what to do with unrecognised properties
+        send normal_setter, v if respond_to? normal_setter
+      end
+    end
+
+    def method_missing(method, *args)
+      catch(:response) do
+        Eapi::Methods::Types.check_asking_type method, self
+
+        # if nothing catch -> continue super
+        super
+      end
+    end
+
+    def to_h
+      raise Eapi::Errors::InvalidElementError, "errors: #{errors.full_messages}, self: #{self.inspect}" unless valid?
+
+      create_hash
+    end
+
+    def create_hash
+      {}.tap do |hash|
+        self.class.properties.each do |prop|
+          stored     = get(prop)
+          val        = (stored.present? && stored.respond_to?(:to_h)) ? stored.to_h : stored
+          hash[prop] = val unless val.nil?
+        end
+      end
+    end
+
+    module ClassMethods
+      include Eapi::Methods::Accessor
+      include Eapi::Methods::Types::ClassMethods
+      include Eapi::Methods::Properties::ClassMethods
+    end
+  end
+end

data/lib/eapi/errors.rb

@@ -0,0 +1,6 @@
+module Eapi
+  module Errors
+    class InvalidElementError < StandardError
+    end
+  end
+end

data/lib/eapi/methods.rb

@@ -0,0 +1,9 @@
+require 'eapi/methods/accessor'
+require 'eapi/methods/names'
+require 'eapi/methods/properties'
+require 'eapi/methods/types'
+
+module Eapi
+  module Methods
+  end
+end

data/lib/eapi/methods/accessor.rb

@@ -0,0 +1,55 @@
+module Eapi
+  module Methods
+
+    module Accessor
+      def define_multiple_accessor(field)
+        init          = Eapi::Methods::Names.init field
+        fluent_adder  = Eapi::Methods::Names.add field
+        fluent_setter = Eapi::Methods::Names.fluent_setter field
+        getter        = Eapi::Methods::Names.getter field
+
+        define_method fluent_adder do |value|
+          current = send(getter) || send(init)
+          current << value
+          send(fluent_setter, current)
+        end
+      end
+
+      def define_init(field, type_class)
+        init         = Eapi::Methods::Names.init field
+        instance_var = Eapi::Methods::Names.instance_var field
+
+        define_method init do
+          value = type_class.new
+          instance_variable_set instance_var, value
+        end
+      end
+
+      def define_accessors(field)
+        normal_setter = Eapi::Methods::Names.setter field
+        fluent_setter = Eapi::Methods::Names.fluent_setter field
+        getter        = Eapi::Methods::Names.getter field
+        instance_var  = Eapi::Methods::Names.instance_var field
+
+        define_method normal_setter do |value|
+          instance_variable_set instance_var, value
+        end
+
+        # fluent setter that calls the normal setter and returns self
+        define_method fluent_setter do |value|
+          send normal_setter, value
+          self
+        end
+
+        # special getter => if no arguments it is a getter, if arguments it calls the fluent setter
+        define_method getter do |*args|
+          if args.empty?
+            instance_variable_get instance_var
+          else
+            send fluent_setter, *args
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eapi/methods/names.rb

@@ -0,0 +1,34 @@
+module Eapi
+  module Methods
+
+    module Names
+      def self.init(field)
+        "init_#{field}"
+      end
+
+      def self.clear(field)
+        "clear_#{field}"
+      end
+
+      def self.add(field)
+        "add_#{field}"
+      end
+
+      def self.getter(field)
+        "#{field}"
+      end
+
+      def self.setter(field)
+        "#{field}="
+      end
+
+      def self.fluent_setter(field)
+        "set_#{field}"
+      end
+
+      def self.instance_var(field)
+        "@#{field}"
+      end
+    end
+  end
+end

data/lib/eapi/methods/properties.rb

@@ -0,0 +1,157 @@
+module Eapi
+  module Methods
+
+    module Properties
+      module InstanceMethods
+        def get(field)
+          getter = Eapi::Methods::Names.getter field
+          send(getter)
+        end
+
+        def set(field, value)
+          setter = Eapi::Methods::Names.fluent_setter field
+          send(setter, value)
+        end
+      end
+
+      module ClassMethods
+        def property(field, definition = {})
+          fs = field.to_sym
+          define_accessors fs
+          run_definition fs, definition
+          store_definition fs, definition
+        end
+
+        def properties
+          @_definitions.keys
+        end
+
+        def definition_for(field)
+          @_definitions ||= {}
+          @_definitions.fetch(field.to_sym, {}).dup
+        end
+
+        def store_definition(field, definition)
+          @_definitions        ||= {}
+          @_definitions[field] = definition
+        end
+
+        def run_definition(field, definition)
+          DefinitionRunner.new(self, field, definition).run
+        end
+
+        private :run_definition
+        private :store_definition
+      end
+    end
+
+    class DefinitionRunner < Struct.new(:klass, :field, :definition)
+      def run
+        run_multiple_accessor
+        run_init
+        run_validations
+      end
+
+      private
+      def run_validations
+        run_required
+        run_validate_type
+        run_validate_with
+        run_validate_type_element
+        run_validate_element_with
+      end
+
+      def run_validate_type
+        if type
+          klass.send :validates_each, field do |record, attr, value|
+            return if value.nil? && !required
+
+            record.errors.add(attr, "must be a #{type}") unless value.kind_of?(type)
+          end
+        end
+      end
+
+      def run_validate_element_with
+        if multiple && validate_element_with
+          validates_each field do |record, attr, value|
+            if value.respond_to?(:each)
+              value.each do |v|
+                validate_element_with.call(record, attr, v)
+              end
+            end
+          end
+        end
+      end
+
+      def run_validate_type_element
+        if multiple && type_element
+          validates_each field do |record, attr, value|
+            if value.respond_to?(:each)
+              value.each do |v|
+                record.errors.add(attr, "element must be a #{type}") unless v.kind_of?(type)
+              end
+            end
+          end
+        end
+      end
+
+      def run_validate_with
+        if validate_with
+          klass.send :validates_each, field do |record, attr, value|
+            validate_with.call(record, attr, value)
+          end
+        end
+      end
+
+      def run_required
+        if required
+          klass.send :validates_presence_of, field
+        end
+      end
+
+      def run_init
+        if type || multiple
+          klass.send :define_init, field, type || Array
+        end
+      end
+
+      def run_multiple_accessor
+        if multiple
+          klass.send :define_multiple_accessor, field
+        end
+      end
+
+      def type_multiple?(type)
+        return false if type.nil?
+        return true if type == Array || type == Set
+
+        type.respond_to?(:is_multiple?) && type.is_multiple?
+      end
+
+      def validate_element_with
+        definition.fetch(:validate_element_with, nil)
+      end
+
+      def multiple
+        definition.fetch(:multiple, false) || type_multiple?(type)
+      end
+
+      def required
+        definition.fetch(:required, false)
+      end
+
+      def validate_with
+        definition.fetch(:validate_with, nil)
+      end
+
+      def type_element
+        definition.fetch(:type_element, nil)
+      end
+
+      def type
+        definition.fetch(:type, nil)
+      end
+    end
+
+  end
+end

data/lib/eapi/methods/types.rb

@@ -0,0 +1,35 @@
+module Eapi
+  module Methods
+
+    module Types
+      def self.type_question_method(method)
+        ms = method.to_s
+        if ms.start_with?('is_a_') && ms.end_with?('?')
+          ms.sub('is_a_', '').sub('?', '')
+        else
+          nil
+        end
+      end
+
+      def self.check_asking_type(method, obj)
+        type = Types.type_question_method method
+        if type
+          throw :response, obj.class.is?(type)
+        end
+      end
+
+
+      module ClassMethods
+        def is?(type)
+          @i_am_a && @i_am_a.include?(type.to_sym)
+        end
+
+        def is(*types)
+          @i_am_a ||= []
+          @i_am_a.concat(types.map(&:to_sym))
+        end
+      end
+
+    end
+  end
+end

data/lib/eapi/multiple.rb

@@ -0,0 +1,13 @@
+module Eapi
+  module Multiple
+    extend ActiveSupport::Concern
+    included do
+    end
+
+    module ClassMethods
+      def is_multiple?
+        true
+      end
+    end
+  end
+end

data/lib/eapi/version.rb

@@ -0,0 +1,3 @@
+module Eapi
+  VERSION = "0.0.1"
+end

data/spec/eapi_basic_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+RSpec.describe Eapi do
+
+  context 'basic behaviour' do
+    class Eapi::MyTestKlass
+      include Eapi::Common
+
+      property :something
+    end
+
+    describe '#something (fluent setter/getter)' do
+      describe '#something as getter' do
+        it 'return the value' do
+          eapi = Eapi::MyTestKlass.new something: :hey
+          expect(eapi.something).to eq :hey
+        end
+      end
+
+      describe '#something("val")' do
+        it 'set the value and return self' do
+          eapi = Eapi::MyTestKlass.new something: :hey
+          res  = eapi.something :other
+          expect(eapi).to be res
+          expect(eapi.something).to eq :other
+        end
+      end
+    end
+
+    describe 'Eapi.MyTestKlass(...)' do
+      it 'calls EapiTestClass.new' do
+        eapi = Eapi.MyTestKlass(something: :hey)
+        expect(eapi).to be_a Eapi::MyTestKlass
+        expect(eapi.something).to eq :hey
+      end
+    end
+  end
+
+end

data/spec/eapi_list_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+RSpec.describe Eapi do
+
+  context 'list' do
+    class Eapi::MyTestClassValMult
+      include Eapi::Common
+
+      property :something, multiple: true
+    end
+
+    it '#add_something' do
+      eapi = Eapi::MyTestClassValMult.new something: [1, 2]
+      res  = eapi.add_something 3
+      expect(res).to be eapi
+      expect(eapi.something).to eq [1, 2, 3]
+    end
+
+    it '#init_something called on first add if element is nil' do
+      eapi = Eapi::MyTestClassValMult.new
+      res  = eapi.add_something :a
+      expect(res).to be eapi
+      expect(eapi.something.to_a).to eq [:a]
+    end
+
+    class Eapi::MyTestClassValMultImpl
+      include Eapi::Common
+
+      property :something, type: Set
+    end
+
+    class MyMultiple
+      def self.is_multiple?
+        true
+      end
+
+      def <<(x)
+        @elements ||= []
+        @elements << x
+      end
+
+      def to_a
+        @elements.to_a
+      end
+    end
+
+    class Eapi::MyTestClassValMultImpl2
+      include Eapi::Common
+
+      property :something, type: MyMultiple
+    end
+
+    class MyMultipleEapi
+      include Eapi::Multiple
+
+      def <<(x)
+        @elements ||= []
+        @elements << x
+      end
+
+      def to_a
+        @elements.to_a
+      end
+    end
+
+    class Eapi::MyTestClassValMultImpl3
+      include Eapi::Common
+
+      property :something, type: MyMultipleEapi
+    end
+
+    it 'if type is Array or Set, or responds true to is_multiple?, it is multiple implicitly + uses that class to initialize the property when adding' do
+      [
+        [Eapi::MyTestClassValMult, Array],
+        [Eapi::MyTestClassValMultImpl, Set],
+        [Eapi::MyTestClassValMultImpl2, MyMultiple],
+        [Eapi::MyTestClassValMultImpl3, MyMultipleEapi],
+      ].each do |(eapi_class, type_class)|
+        eapi = eapi_class.new
+        res  = eapi.add_something :a
+        expect(res).to be eapi
+        expect(eapi.something.to_a).to eq [:a]
+        expect(eapi.something).to be_a_kind_of type_class
+      end
+    end
+
+    it 'validate elements' do
+      skip 'test TBD'
+    end
+  end
+
+end

data/spec/eapi_to_h_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+RSpec.describe Eapi do
+
+  context '#to_h' do
+    class Eapi::MyTestClassToH
+      include Eapi::Common
+
+      property :something, required: true
+      property :other
+    end
+
+    it 'raise error if invalid' do
+      eapi = Eapi::MyTestClassToH.new
+      expect { eapi.to_h }.to raise_error do |error|
+        expect(error).to be_a_kind_of Eapi::Errors::InvalidElementError
+        expect(error.message).to be_start_with "errors: [\"Something can't be blank\"], self: #<Eapi::MyTestClassToH"
+      end
+
+    end
+
+    it 'create a hash with elements (calling to_h to each element), avoiding nils' do
+      eapi = Eapi::MyTestClassToH.new
+      eapi.something 'hi'
+      expected = {something: 'hi'}
+      expect(eapi.to_h).to eq expected
+
+      class MyTestObject
+        def to_h
+          'hello'
+        end
+      end
+
+      element = MyTestObject.new
+      eapi    = Eapi::MyTestClassToH.new
+      eapi.something(element).other(true)
+      expected = {something: 'hello', other: true}
+
+      expect(eapi.to_h).to eq expected
+    end
+  end
+end

data/spec/eapi_validations_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+RSpec.describe Eapi do
+
+  context 'validations' do
+    describe '#valid?' do
+      it 'true if no validations' do
+        class Eapi::MyTestClassVal
+          include Eapi::Common
+
+          property :something
+        end
+
+        eapi = Eapi::MyTestClassVal.new something: :hey
+        expect(eapi).to be_valid
+      end
+
+      it 'false if validations not met' do
+        class Eapi::MyTestClassVal2
+          include Eapi::Common
+
+          property :something
+
+          validates_presence_of :something
+        end
+
+        eapi = Eapi::MyTestClassVal2.new
+        expect(eapi).not_to be_valid
+        expect(eapi.errors.full_messages).to eq ["Something can't be blank"]
+        expect(eapi.errors.messages).to eq({something: ["can't be blank"]})
+      end
+    end
+
+    it 'if required, same as validate presence' do
+      class Eapi::MyTestClassVal3
+        include Eapi::Common
+
+        property :something, required: true
+      end
+
+      eapi = Eapi::MyTestClassVal3.new
+      expect(eapi).not_to be_valid
+      expect(eapi.errors.full_messages).to eq ["Something can't be blank"]
+      expect(eapi.errors.messages).to eq({something: ["can't be blank"]})
+    end
+
+    it 'if type specified with a class, validates it' do
+      class Eapi::MyTestClassVal3
+        include Eapi::Common
+
+        property :something, type: Hash
+      end
+
+      eapi = Eapi::MyTestClassVal3.new something: 1
+      expect(eapi).not_to be_valid
+      expect(eapi.errors.full_messages).to eq ["Something must be a Hash"]
+      expect(eapi.errors.messages).to eq({something: ["must be a Hash"]})
+    end
+
+    it 'if validate_with: specified with a class, uses it to validate the property' do
+      class Eapi::MyTestClassVal4
+        include Eapi::Common
+
+        property :something, validate_with: ->(record, attr, value) do
+          record.errors.add(attr, "must pass my custom validation") unless value == :valid_val
+        end
+      end
+
+      eapi = Eapi::MyTestClassVal4.new something: 1
+
+      expect(eapi).not_to be_valid
+      expect(eapi.errors.full_messages).to eq ["Something must pass my custom validation"]
+      expect(eapi.errors.messages).to eq({something: ["must pass my custom validation"]})
+
+      eapi.something :valid_val
+      expect(eapi).to be_valid
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'coveralls'
+Coveralls.wear!
+
+require 'pry'
+require 'eapi'
+
+RSpec.configure do |config|
+  # some (optional) config here
+end

metadata

@@ -0,0 +1,243 @@
+--- !ruby/object:Gem::Specification
+name: eapi
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Eduardo Turiño
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-nc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-rescue
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-stack_explorer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-doc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+description: 
+email:
+- eturino@eturino.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".coveralls.yml"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- eapi.gemspec
+- lib/eapi.rb
+- lib/eapi/common.rb
+- lib/eapi/errors.rb
+- lib/eapi/methods.rb
+- lib/eapi/methods/accessor.rb
+- lib/eapi/methods/names.rb
+- lib/eapi/methods/properties.rb
+- lib/eapi/methods/types.rb
+- lib/eapi/multiple.rb
+- lib/eapi/version.rb
+- spec/eapi_basic_spec.rb
+- spec/eapi_list_spec.rb
+- spec/eapi_to_h_spec.rb
+- spec/eapi_validations_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: ruby gem for building complex structures that will end up in hashes (initially
+  devised for ElasticSearch search requests)
+test_files:
+- spec/eapi_basic_spec.rb
+- spec/eapi_list_spec.rb
+- spec/eapi_to_h_spec.rb
+- spec/eapi_validations_spec.rb
+- spec/spec_helper.rb
+has_rdoc: