carrot_rpc 0.2.3.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8add259a5bc250a315ce9feefe6b37cf8e920d44
+  data.tar.gz: 94a6f21f8b5cca40e4fd040564756c4d6b173bcb
+SHA512:
+  metadata.gz: ffae0ddaf0342282814713c47487203008239979fb14c009f21c12a436dcc23fbc6c9395dcc0ad52dd034d5997f72d716f20f04ac5e8cc8a85b08e0ef85c0c0c
+  data.tar.gz: a08ecc6881122adca9f7f34d77d172f5b20ef62b3590e8a5073be41dee8fc66e1678b3194cb90b9abc2335c849afa0bf7d1cf5e870373a105e62be5f94ccc6fb

data/.gitignore

@@ -0,0 +1,50 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+/coverage/
+
+## Environment normalisation:
+/.bundle/
+/vendor/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
+
+# Editor Artifacts
+*.swo
+*.swp
+.idea
+
+# Ignore Mac Dir files
+.DS_Store
+*./DS_Store
+
+*.log
+
+# RSpec failure tracker for --only-failures and --next-failure
+spec/examples.txt

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,35 @@
+AllCops:
+  DisplayCopNames: true
+  TargetRubyVersion: 2.2
+
+Metrics/LineLength:
+  Max: 120
+
+Style/BlockDelimiters:
+  EnforcedStyle: semantic
+Style/ClassAndModuleChildren:
+  Description: >-
+                 Compact style ensures that the parent classes and modules are not reopened for each child class and
+                 module.  Reopening the parent class or module can lead to the parent class or module not being loaded
+                 as the child already defined it.
+  EnforcedStyle: compact
+Style/GuardClause:
+  Description: >-
+                 Modifiers prevent placing break points on just the condition or just the body.  Similarly, coverage of
+                 the line cannot tell you if the body is ever executed.
+  Enabled: false
+Style/IfUnlessModifier:
+  Description: >-
+                 Modifiers prevent placing break points on just the condition or just the body.  Similarly, coverage of
+                 the line cannot tell you if the body is ever executed.
+  Enabled: false
+Style/StringLiterals:
+  Description: >-
+                 Double quotes work for Strings in both Ruby and Elixir, so developers switch languages can use
+                 consistent quoting. (Single quotes are char lists in Elixir.)
+  EnforcedStyle: double_quotes
+Style/WhileUntilModifier:
+  Description: >-
+                 Modifiers prevent placing break points on just the condition or just the body.  Similarly, coverage of
+                 the line cannot tell you if the body is ever executed.
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.1

data/CHANGELOG.md

@@ -0,0 +1,149 @@
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+**Table of Contents**  *generated with [DocToc](https://github.com/thlorenz/doctoc)*
+
+- [Changelog](#changelog)
+  - [v0.2.1](#v021)
+    - [Bug Fixes](#bug-fixes)
+  - [v0.2.0](#v020)
+    - [Enhancements](#enhancements)
+    - [Bug Fixes](#bug-fixes-1)
+    - [Incompatible Changes](#incompatible-changes)
+  - [v0.1.2](#v012)
+    - [Enhancements](#enhancements-1)
+    - [Bug Fixes](#bug-fixes-2)
+  - [v0.1.1](#v011)
+    - [Enhancements](#enhancements-2)
+    - [Bug Fixes](#bug-fixes-3)
+    - [Incompatible Changes](#incompatible-changes-1)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+
+# Changelog
+All significant changes in the project are documented here.
+
+## v0.2.1
+
+### Bug Fixes
+* [#6](https://github.com/C-S-D/carrot_rpc/pull/6) - [shamil614](https://github.com/shamil614)
+  * Error class not loaded in RpcServer
+  * RpcServer should not rename json keys
+  * RpcClient dasherizes keys before serializing hash to json. Better conformity to json property naming conventions.
+  * RpcClient underscores keys after receiving response from server. Better conformity to ruby naming conventions.
+* [#7](https://github.com/C-S-D/carrot_rpc/pull/7) - [shamil614](https://github.com/shamil614)
+  * Make sure hash keys are strings before renaming
+
+
+## v0.2.0
+
+### Enhancements
+* [#5](https://github.com/C-S-D/carrot_rpc/pull/5) - [KronicDeth](http://github.com/KronicDeth)
+  * Gems ordered and documented in gemspec and `Gemfile`
+  * Temorpary (`#`) files removed from git
+  * Rubocop is enabled and used on CircleCI
+    * Unused variables are prefixed with `_`
+    * `fail` is used instead of `raise` when first raising an exception
+    * Remove usage of deprecated methods
+    * Print error if `byebug` can't be loaded instead of failing silently, but CLI still starts
+    * Stop shadowing outer local variables in blocks
+    * Remove unused assignments
+    * Set and enforce max line length to 120
+    * Use `find` instead of `select {}.first` for better performance
+    * `queue_name` will retrieve the current queue name while `queue_name(new_name)` will set it.
+    * Align hashes
+    * Align parameters
+    * Favor symbolic `&&` over `and`. (They have different precedence too)
+    * Remove block comments
+    * Assign to variable outside conditionals instead of on each branch
+    * Remove extra empty lines
+    * Don't favor guard clauses as they prevent break pointing the body and guard separately and obscure bodies that don't have code coverage.
+    * Remove extra spacing
+    * Correct indentation
+    * Freeze `CarrotRpc::VERSION` so it is immutable
+    * Use `until` instead of negated `while`
+    * Use `_` to separate digits in large numerals
+    * Use `( )` for sigils
+    * Remove redundant `self.` for method calls
+    * Use `%r{}` instead of `//` for regexps
+    * Use newlines instead of `;`
+    * Add spacing around blocks and braces
+    * Enforce double quotes for all strings as double quotes work for strings in both Ruby and Elixir. (Single quotes are for Char Lists in Elixir)
+    * Use `&:<method>` instead of calling a non-args method in blocks
+    * Use `attr_reader` instead of trivial accessor methods
+    * Remove unneed interpolation
+    * Use double quotes instead of `%q`
+    * Use `%w` for word arrays
+    * Extract methods to lower to AbcSize metric and Method Length
+    * Extract classes and modules to lower Class Length
+    * Use `const_get` and `constantize` instead of security risk `eval`
+  * Enable all RSpec 3 recommended options
+    * Fix order-dependency of specs.
+  * Use `autoload` to delay loading
+  * Use compact class and module children to prevent parent from being missed when loading.
+  * Add `rake spec`
+  * Add Luke Imhoff as an author
+  * Set gem home page to this repository
+  * Semantic block delimiters, so we always think about procedural vs functional blocks to make Elixir coding easier.
+
+### Bug Fixes
+* [#5](https://github.com/C-S-D/carrot_rpc/pull/5) - [KronicDeth](http://github.com/KronicDeth)
+  * `ClientServer::ClassMethods` has been moved under `CarrotRpc` namespace as `CarrotRpc::ClientServer`
+  * `HashExtensions` has been moved under `CarrotRpc` namespace as `CarrotRpc::HashExtensions`
+
+### Incompatible Changes
+* [#5](https://github.com/C-S-D/carrot_rpc/pull/5) - [KronicDeth](http://github.com/KronicDeth)
+  * `ClientServer::ClassMethods` renamed to `CarrotRpc::ClientServer`
+  * `HashExtensions` renamed to `CarrotRpc::HashExtensions`
+  * `ClientServer::ClassMethods#get_queue_name` renamed to `CarrotRpc::ClientServer#queue_name()` (no args is the reader, one argument is the writer)
+
+## v0.1.2
+
+### Enhancements
+* [#4](https://github.com/C-S-D/carrot_rpc/pull1) - [shamil614](https://github.com/shamil614)
+  * Rename the keys in the parsed payload from '-' to '_'
+  * Added integration specs to test functionality
+  * Logging to test.log file
+  * Setup for circleci integration tests to rabbitmq
+
+### Bug Fixes
+* [#4](https://github.com/C-S-D/carrot_rpc/pull1) - [shamil614](https://github.com/shamil614)
+  * Some require statements not properly loading modules
+  * Consistent use of require vs require_relative
+
+## v0.1.1
+
+### Enhancements
+* [#1](https://github.com/C-S-D/carrot_rpc/pull1) - [shamil614](https://github.com/shamil614)
+  * `CarrotRpc.configuration.bunny` can be set to custom
+    [`Bunny` instance](http://www.rubydoc.info/gems/bunny/Bunny#new-class_method).
+  * `CarrotRpc::RpcClient` and `CarrotRpc::RpcServer` subclasses can set their queue name with the `queue_name` class
+    method. (It can be retrieved with `get_queue_name`.
+  * `carrot_rpc`'s `--autoload_rails` boolean flag determines whether to load Rails environment.  The Rails path is
+    assumed to the be the current working directory.
+  * If a `CarrotRpc::RpcServer` method invoked from a JSON RPC `:method` raises an `CarrotRpc::Error`, then that error
+    is converted to a JSON RPC error and sent back to the client.
+
+### Bug Fixes
+* [#1](https://github.com/C-S-D/carrot_rpc/pull/1) - [shamil614](https://github.com/shamil614)
+  * Send `jsonrpc` key instead of incorrect `json_rpc` key in JSON RPC response messages
+  * All files under `bin` are marked as gem executables instead of just `carrot_rpc`
+  * Fix files not loading properly when using `carrot_rpc`
+  * Fix bug in logger file setup
+  * The logger for each `CarrotRpc::RpcServer` is set before the server is started in
+    `CarrotRpc::ServerRunner#run_servers` to prevent a race condition where `#start` may try to use the logger.
+
+### Incompatible Changes
+* [#1](https://github.com/C-S-D/carrot_rpc/pull/1) - [shamil614](https://github.com/shamil614)
+  * `CarrotRpc.configuration.bunny` **MUST** be set to a
+    [`Bunny` instance](http://www.rubydoc.info/gems/bunny/Bunny#new-class_method), usually using `Bunny.new`.
+  * `CarrotRpc::RpcClient` and `CarrotRpc::RpcServer` subclasses **MUST** set their queue name with the `queue_name`
+    class method.
+  * `:channel` keyword argument is no longer accepted in `CarrotRpc::RpcClient.new`.  The channel had already been
+    created from the `config.bunny.create_channel`, so the keyword argument was unused.
+  * `CarrotRpc::RpcClient#logger` is now read-only and is set from `config.logger`.
+  * `CarrotRpc::RpcServer#logger` is now read-only and is set from `config.logger`.
+  * `CarrotRpc.configuration.logger` is set to the `CarrotRpc::ServerServer#logger`.
+  * `carrot_rpc`'s `--rails_path PATH` flag has been replaced with `--autoload_rails` boolean flag that automatically
+     assumes the Rails path is the current working directory.
+  * `CarrotRpc.connfiguration.rails_path` no longer exists.  The Rails path is assumed to be the current working
+    directory.

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http:contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+ruby "2.2.3"
+# Specify your gem's dependencies in carrot_rpc.gemspec
+gemspec
+
+group :test do
+  gem "rspec_junit_formatter", "0.2.2"
+end

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Communication Service For The Deaf
+
+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/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Scott Hamilton
+
+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,172 @@
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+**Table of Contents**  *generated with [DocToc](https://github.com/thlorenz/doctoc)*
+
+- [CarrotRpc](#carrotrpc)
+  - [Installation](#installation)
+  - [Configuration](#configuration)
+    - [Server](#server)
+    - [Client](#client)
+  - [Usage](#usage)
+    - [Writing Servers](#writing-servers)
+    - [Writing Clients](#writing-clients)
+  - [Development](#development)
+  - [Contributing](#contributing)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+
+# CarrotRpc
+
+An opinionated approach to doing Remote Procedure Call (RPC) with RabbitMQ and the bunny gem. CarrotRpc serves as a way to streamline the RPC workflow so developers can focus on the implementation and not the plumbing when working with RabbitMQ.
+
+[![Circle CI](https://circleci.com/gh/C-S-D/carrot_rpc.svg?style=svg)](https://circleci.com/gh/C-S-D/carrot_rpc)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'carrot_rpc'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install carrot_rpc
+
+## Configuration
+There's two modes for CarrotRpc: server and client. The server is run via command line, and the client is run in your ruby application during the request / response lifecycle (like your Rails Controller).
+### Server
+The server is configured via command line and run in it's own process.
+
+Carrot is easy to run via command line: 
+```bash
+carrot_rpc
+```
+By typing in `carrot_rpc -h` you will see all the command line options:
+```bash
+Usage: server [options]
+
+Process options:
+    -d, --daemonize              run daemonized in the background (default: false)
+        --pidfile PIDFILE        the pid filename
+    -s, --runloop_sleep VALUE    Configurable sleep time in the runloop
+        --autoload_rails VALUE   loads rails env by default. Uses Rails Logger by default.
+        --logfile VALUE          relative path and name for Log file. Overrides Rails logger.
+        --loglevel VALUE         levels of loggin: DEBUG < INFO < WARN < ERROR < FATAL < UNKNOWN
+        --rabbitmq_url VALUE     connection string to RabbitMQ 'amqp://user:pass@host:10000/vhost'
+
+Ruby options:
+    -I, --include PATH           an additional $LOAD_PATH
+        --debug                  set $DEBUG to true
+        --warn                   enable warnings
+
+Common options:
+    -h, --help
+    -v, --version
+```
+
+
+### Client
+Clients are configured by initializing `CarrotRpc::Configuration`. The most common way in Rails is to setup an initializer in `/config/initializers/carrot_rpc.rb`
+
+```ruby
+CarrotRpc.configure do |config|
+  # Required on the client to connect to RabbitMQ. 
+  # Bunny defaults to connecting to ENV['RABBITMQ_URL']. See Bunny docs.
+  config.bunny = Bunny.new.start
+  # Set the log level. Ruby Logger Docs http://ruby-doc.org/stdlib-2.2.0/libdoc/logger/rdoc/Logger.html
+  config.loglevel = Logger::INFO
+  # Create a new logger or use the Rails logger. 
+  # When using Rails, use a tagged log to make it easier to track RPC.
+  config.logger = CarrotRpc::TaggedLog.new(logger: Rails.logger, tags: ["Carrot RPC Client"])
+  
+  # Don't use. Server implementation only. The values below are set via CLI:
+  # config.pidfile = nil
+  # config.runloop_sleep = 0
+  # config.logfile = nil
+end
+```
+
+## Usage
+### Writing Servers
+Carrot CLI will look for your servers in `app/servers` directory. This directory should not be autoloaded by the host application.
+
+
+Example Server: `app/servers/car_server.rb`
+```ruby
+class CarServer < CarrotRpc::RpcServer
+  def show(params)
+    # ...do something
+    Car.find(params[:id]).to_json
+  end
+end
+```
+The method can return any data that can be stringified. But CarrotRPC uses [JSON RPC 2.0](http://www.jsonrpc.org/specification) as protocol for the message workflow.
+
+With a standard Rails configuration `app/servers` will be marked as `eager_load: true` because `app` is `eager_load: true`.  This is a problem because `Rails.application.eager_load!` is called when running `carrot_rpc`, which would lead to `app/servers/**/*.rb` being double loaded.  To prevent the double loading, `app/servers` itself needs to be added as
+a non-eager-load path, but still a load path.
+
+In `config/application.rb`
+```ruby
+module MyApp
+  class Application < Rails::Application
+    config.paths.add "app/servers",
+                     # `app/servers` MUST NOT be an eager_load path (to override the setting inherited from "app"), so
+                     # that `carrot_rpc` does not double load `app/servers/**/*.rb` when first loading Rails and the
+                     # servers.
+                     eager_load: false,
+                     # A load path so `carrot_rpc` can find load path ending in `app/servers` to scan for servers to
+                     # load
+                     load_path: true
+  end
+end
+```
+
+### Writing Clients
+Clients are not run in the CLI, and are typlically invoked during a request / response lifecycle in a web application. In the case of Rails, Clients would most likely be used in a controller action. Clients should be written in the `app/clients` directory of the host application, and should be autoloaded by Rails.
+
+Example Client: `app/clients/cars_client.rb`
+```ruby
+  class CarClient < CarrotRpc::RpcClient
+    # By default RpcClient defines the following Railsy inspired methods:
+    # def show(params)
+    # def index(params)
+    # def create(params)
+    # def update(params)
+    # You can easily add your own like so:
+    def foo_method(params)
+      remote_call('foo_method', params)
+    end
+  end
+```
+
+Example Rails Controller:
+```ruby
+class CarsController < ApplicationController
+  def show
+    car_client = CarClient.new
+    car_client.start
+    result = car_client.show({id: 1})
+    # Good idea to clean up connections when finished.
+    car_client.channel.close
+  end
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/carrot_rpc/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,7 @@
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/carrot_rpc

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+require "bunny"
+require_relative "../lib/carrot_rpc"
+require_relative "../lib/carrot_rpc/cli"
+require_relative "../lib/carrot_rpc/server_runner"
+
+CarrotRpc::CLI.parse_options(ARGV)
+
+CarrotRpc.configure do |config|
+  # Defaults to using ENV['RABBITMQ_URL'] for connection string.
+  config.bunny = Bunny.new if config.bunny.nil?
+end
+
+config = CarrotRpc.configuration
+config.bunny.start
+
+runner = CarrotRpc::ServerRunner.new(pidfile: config.pidfile, runloop_sleep: config.runloop_sleep,
+                                     daemonize: config.daemonize)
+runner.run!

data/bin/console

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "carrot_rpc"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+begin
+  require "byebug"
+rescue LoadError
+  $stderr.puts "byebug could not be loaded"
+end
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/carrot_rpc.gemspec

@@ -0,0 +1,49 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "carrot_rpc/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "carrot_rpc"
+  spec.version       = CarrotRpc::VERSION
+  spec.authors       = ["Scott Hamilton", "Luke Imhoff"]
+  spec.email         = ["shamil614@gmail.com", "Kronic.Deth@gmail.com"]
+
+  spec.summary       = "Remote Procedure Call (RPC) using the Bunny Gem over RabbitMQ"
+  spec.description   = "Streamlined approach to setting up RPC over RabbitMQ."
+  spec.homepage      = "https://github.com/C-S-D/carrot_rpc"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  unless spec.respond_to?(:metadata)
+    fail "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+
+  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Production requirements
+
+  # Common extensions from Rails
+  spec.add_dependency "activesupport", "~> 4.2"
+  # The RabbitMQ library
+  spec.add_dependency "bunny", "~> 2.2"
+
+  # Development / Test Gems
+
+  # debugger
+  spec.add_development_dependency "byebug"
+  # Gemfile support for grouping gems for development-only or test-only
+  spec.add_development_dependency "bundler", "~> 1.9"
+  # Running commandline scripts
+  spec.add_development_dependency "rake", "~> 10.0"
+  # Unit test framework
+  spec.add_development_dependency "rspec"
+  # Style-checker
+  spec.add_development_dependency "rubocop"
+
+  spec.required_ruby_version = "~> 2.2"
+end

data/circle.yml

@@ -0,0 +1,8 @@
+machine:
+  services:
+    - rabbitmq-server
+test:
+  override:
+    - RAILS_ENV=test bundle exec rspec -r rspec_junit_formatter --format RspecJunitFormatter -o $CIRCLE_TEST_REPORTS/rspec/junit.xml
+  post:
+    - bundle exec rubocop