fray 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cbc5b801abec6fcb3adf401b109ba2139f77b551
+  data.tar.gz: fe0a8696dadca85d74ad19d58a2d323bd5642f74
+SHA512:
+  metadata.gz: ec0e0517aa367e0f83045a3ced7cdfd5d357d0b4a0cbec60ad6746ae9090cc1150f729ea7445bc981bf064539ff1b4f33425668ae1a720d9a6a5ad6c46f12ef5
+  data.tar.gz: 4100efae0591910023ad5f50b15f56789613880ea5f4acedd1e633dd48c8a777e2a32614e424ae3bcbd7d20054234d644f5d35b5e285c228cd521d42f77f856f

data/.gitignore

@@ -0,0 +1,4 @@
+/.bundle/
+/Gemfile.lock
+/tmp/
+/coverage/

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gem "codeclimate-test-reporter", group: :test, require: nil
+
+gemspec

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "fray"
+
+# 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
+
+# require "irb"
+# IRB.start

data/bin/setup

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

data/config.ru

@@ -0,0 +1,10 @@
+require 'rack'
+require 'bundler'
+
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+app = ->(env) do
+  ['200', {'Content-Type' => 'text/html'}, [Rack::Utils::parse_nested_query(env['QUERY_STRING']).inspect]]
+end
+
+Rack::Handler::WEBrick.run app

data/fray.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+# stub: arcgis-ruby 0.0.1 ruby lib
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |s|
+  s.name = "fray"
+  s.version = "0.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["Jake Sower"]
+  s.date = Time.now.strftime("%Y-%m-%d")
+  s.email = "jakesower@gmail.com"
+  s.summary = "API building blocks."
+  s.homepage = 'https://github.com/jakesower/fray'
+  s.license = 'apache'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'json-schema', '~> 2.6'
+
+  s.add_development_dependency 'rspec', '~> 3'
+  s.add_development_dependency 'rake', '~> 11'
+  s.add_development_dependency 'pry', '~> 0.10'
+end

data/lib/fray.rb

@@ -0,0 +1,8 @@
+require 'json'
+require 'json-schema'
+
+require 'fray/version'
+require 'fray/data'
+require 'fray/abortable_pipe'
+require 'fray/response_pipe'
+require 'fray/data/error_set'

data/lib/fray/abortable_pipe.rb

@@ -0,0 +1,69 @@
+#
+# Functor for handling errors as part of a chain of functions. Works much like
+# the pipe operator |> from Elixir, but also handles responses. If a function
+# within a `then` returns somethings that fulfills the initializing predicate,
+# the remainder of the pipe will not be used. Rather, the `catch` function will
+# be called (like with a JS promise). This function defaults to the identity
+# function.
+#
+# Anything that responds to #call can be passed to `then` or `catch` as an
+# argument, including vanilla lambdas.
+#
+# Examples:
+#
+# AbortablePipe.new(->(v) { v.is_a?(Fray::Response) }).
+#   then(->(x) { x + 1 }).
+#   then(->(x, y) { x * y }, 2). # note how extra params are handled
+#   catch(->(_) { 5 })
+#   run(4)
+#
+# Returns 10
+#
+# AbortablePipe.new(->(v) { v.is_a?(Fray::Response) }).
+#   abort_when().
+#   then(->(x) { Fray::Response.new('hi') }).
+#   then(->(x) { x * 2 }).
+#   catch(->(_) { 5 })
+#   run(4)
+#
+# Returns 5
+#
+module Fray
+  class AbortablePipe
+    def initialize(abort_predicate, thens = [], c = nil)
+      @abort_predicate = abort_predicate
+      @thens = thens
+      @catch = c || ->(x) { x }
+    end
+
+
+    def then(func, *args)
+      new_then = {
+        function: func,
+        args: args
+      }
+
+      AbortablePipe.new(@abort_predicate, @thens + [new_then], @catch)
+    end
+
+
+    def catch(func)
+      AbortablePipe.new(@abort_predicate, @thens, func)
+    end
+
+
+    def run(state = nil, thens = @thens)
+      if thens.empty?
+        state
+      else
+        first, rest = thens[0], thens[1..-1]
+        next_state = first[:function].call(state, *first[:args])
+
+        @abort_predicate.call(next_state) ?
+          @catch.call(next_state) :
+          run(next_state, rest)
+      end
+    end
+
+  end
+end

data/lib/fray/data.rb

@@ -0,0 +1,41 @@
+#
+# This module simply reads the files in data_structures and reifies them as
+# Structs with on-creation validations. The data strcture files use JSON schema
+# for a format: http://json-schema.org
+#
+module Fray::Data
+  class Base < OpenStruct
+    def initialize(hash)
+      if JSON::Validator.validate(__schema, hash)
+        super(JSON.parse(JSON.generate(hash)))
+        self.freeze
+      else
+        e = "#{hash.inspect} failed schema validation:\n\n" +
+            JSON::Validator.fully_validate(__schema, hash).join("\n")
+        raise ArgumentError, e
+      end
+    end
+  end
+
+
+  def self.define_schema_class(name, schema)
+    const_name = name.split('_').map{|chunk| chunk[0].upcase + chunk[1..-1]}.join('')
+    klass = Class.new(Base) do
+      define_method :__schema do
+        schema
+      end
+    end
+
+    Fray::Data.const_set(const_name.to_sym, klass.freeze)
+  end
+end
+
+
+#
+# Run through the json schemas and compile them
+#
+dir = File.dirname(File.expand_path(__FILE__))
+Dir["#{dir}/data_structures/*.json"].each do |path|
+  file_name = File.basename(path, '.json')
+  Fray::Data.define_schema_class(file_name, JSON.parse(File.read(path)))
+end

data/lib/fray/data/dataset.rb

@@ -0,0 +1,14 @@
+module Fray::Data
+  class Dataset < Dry::Types::Struct
+    attribute :code, Types::Coercible::String.enum(
+      *((100..102).map(&:to_s) +
+        (200..206).map(&:to_s) +
+        (300..308).map(&:to_s) +
+        (400..417).map(&:to_s) + ['429'] +
+        (500..504).map(&:to_s))
+    )
+
+    attribute :headers, Types::Hash.default({})
+    attribute :body, Types::String.default('')
+  end
+end

data/lib/fray/data/error_set.rb

@@ -0,0 +1,19 @@
+#
+# This module simply reads the files in data_structures and reifies them as
+# Structs with on-creation validations. The data strcture files use JSON schema
+# for a format: http://json-schema.org
+#
+module Fray::Data
+  class ErrorSet < Array
+    def initialize(array)
+      if array.all?{|elt| elt.is_a?(Fray::Data::Error)}
+        super(array)
+        self.freeze
+      else
+        msg = "All elements of a Fray::Data::ErrorSet must be instances of Fray::Data::Error. Got: #{array.inspect}"
+
+        raise ArgumentError, msg
+      end
+    end
+  end
+end

data/lib/fray/data/filter.rb

@@ -0,0 +1,6 @@
+module Fray::Data
+  class Filter < Dry::Types::Struct
+    attribute :subject, Types::String
+    attribute :target, Types::String
+  end
+end

data/lib/fray/data/query.rb

@@ -0,0 +1,15 @@
+require 'fray/data_structures/filter'
+
+module Fray::Data
+  class Query < Dry::Types::Struct
+    attribute :search, Types::Maybe::Coercible::String.default('')
+    attribute :include, Types::Maybe::Strict::Array
+    attribute :filters, Types::Array.member(Fray::Filter)
+    attribute :sort, Types::Maybe::Coercible::Hash
+    attribute :fields, Types::Array.member(Types::String)
+    attribute :page, Types::Hash.schema(
+      size: Types::Coercible::Int,
+      number: Types::Coercible::Int
+    ).default({size: 10, number: 1})
+  end
+end

data/lib/fray/data/response.rb

@@ -0,0 +1,6 @@
+module Fray::Data
+  class Response < Dry::Types::Struct
+    attribute :success, Types::Bool
+    attribute :body, Types::Hash.default({})
+  end
+end

data/lib/fray/data_structures/dataset.json

@@ -0,0 +1,78 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "Fray Dataset Schema",
+  "description": "Schema representing the results of a query",
+  "type": "object",
+  "required": [ "resource_type", "resources", "related" ],
+  "properties": {
+    "resource_type": {
+      "type": "string"
+    },
+    "resources": {
+      "description": "An array containing all of the *primary* resource results",
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/resource"
+      },
+      "uniqueItems": true
+    },
+    "related": {
+      "description": "An object containing linked resources by resource type",
+      "type": "object",
+      "patternProperties": {
+        "^[A-Za-z0-9_]+$": {
+          "description": "Object of resources of a particular type",
+          "type": "object",
+          "patternProperties": {
+            "^[A-Za-z0-9_]+": {
+              "description": "The resource with a type and ID",
+              "type": {
+                "$ref": "#/definitions/resource" }}}}}},
+    "statistics": {
+      "description": "All statistical meta-information about the request",
+      "type": "object",
+      "properties": {
+        "count": { "type": "integer" },
+        "total_count": { "type": "integer" }
+      }
+    },
+    "meta": {
+      "description": "Non-standard meta-information",
+      "type": "object",
+      "additionalProperties": true
+    }
+  },
+
+  "definitions": {
+    "resource": {
+      "description": "A single resource",
+      "type": "object",
+      "required": [ "id", "type", "attributes", "relationships" ],
+      "properties": {
+        "id": { "type": "string" },
+        "type": { "type": "string" },
+        "attributes": {
+          "type": "object",
+          "additionalProperties": true
+        },
+        "relationships": {
+          "description": "Related resources by type",
+          "type": "object",
+          "patternProperties": {
+            "^[A-Za-z0-9_]+$": {
+              "oneOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "array",
+                  "items": { "type": "string" }
+                }
+              ]
+            }
+          }
+        }
+      }
+    }
+  }
+}

data/lib/fray/data_structures/error.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "Fray Error",
+  "description": "Schema representing a single error that occured",
+  "type": "object",
+  "required": [
+    "status"
+  ],
+
+  "properties": {
+    "status": {
+      "description": "HTTP status code (4xx or 5xx)",
+      "type": "string",
+      "pattern": "^[45][0-9]{2}$"
+    }
+  },
+  "additionalProperties": true
+}

data/lib/fray/data_structures/query.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "Fray Query",
+  "description": "Schema representing query to be sent to a store",
+  "type": "object",
+  "required": [
+    "resource_type"
+  ],
+
+  "properties": {
+    "resource_type": {
+      "description": "The type of the primary resource(s)",
+      "type": "string"
+    },
+    "id": {
+      "description": "The ID of a single resource (used when appropriate)",
+      "type": "string"
+    },
+    "fields": {
+      "description": "List of fields to restrict results to (if absent, all fields will be included)",
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "include": {
+      "description": "Resource types related to the primary",
+      "type": "string"
+    },
+    "filters": {
+      "description": "Filters to be applied to the query",
+      "type": "object"
+    },
+    "page": {
+      "type": "object",
+      "required": [ "number", "size" ],
+      "properties": {
+        "number": { "type": "string" },
+        "size": { "type": "string" }
+      }
+    }
+  }
+}

data/lib/fray/data_structures/request.json

@@ -0,0 +1,55 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "Fray Request",
+  "description": "Schema representing an initial request for processing",
+  "type": "object",
+  "required": [
+    "resource_type",
+    "uri",
+    "root_uri",
+    "headers",
+    "query_parameters"
+  ],
+
+  "properties": {
+    "resource_type": {
+      "description": "The type of the primary resource(s)",
+      "type": "string"
+    },
+    "id": {
+      "description": "The ID of a single resource (used when appropriate)",
+      "type": "string"
+    },
+    "uri": {
+      "description": "The protocol, domain, and path of the incoming request",
+      "type": "string",
+      "format": "uri"
+    },
+    "root_uri": {
+      "description": "The root of the domain (used for links)",
+      "type": "string",
+      "format": "uri"
+    },
+    "headers": {
+      "description": "HTTP headers",
+      "type": "object",
+      "additionalProperties": true
+    },
+    "query_parameters": {
+      "description": "Query parameters from both query string and body",
+      "type": "object",
+      "required": [],
+      "properties": {
+        "page": {
+          "type": "object",
+          "required": [ "number", "size" ],
+          "properties": {
+            "number": { "type": "string" },
+            "size": { "type": "string" }
+          }
+        }
+      },
+      "additionalProperties": true
+    }
+  }
+}

data/lib/fray/data_structures/response.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "Fray Response",
+  "description": "Schema representing a successful result of a Fray pipe",
+  "type": "object",
+  "required": [ "status", "headers", "body" ],
+  "properties": {
+    "status": {
+      "description": "HTTP status code",
+      "type": "string",
+      "pattern": "^[1-5][0-9]{2}$"
+    },
+    "headers": {
+      "description": "HTTP headers",
+      "type": "object",
+      "additionalProperties": true
+    },
+    "body": {
+      "description": "The contents of the HTTP body",
+      "type": "string"
+    }
+  }
+}

data/lib/fray/response_pipe.rb

@@ -0,0 +1,38 @@
+#
+# Functor for handling errors as part of a chain of functions. Works much like
+# the pipe operator |> from Elixir, but also handles responses. If a function
+# within a `then` returns a Fray::Response (or subclass thereof), the
+# remainder of the pipe will not be used. Rather, the `catch` function will be
+# called (like with a JS promise). This function defaults to the identity
+# function.
+#
+# Anything that responds to #call can be passed to `then` or `catch` as an
+# argument, including vanilla lambdas.
+#
+# Examples:
+#
+# FunctionPipe.new.
+#   then(->(x) { x + 1 }).
+#   then(->(x, y) { x * y }, 2). # note how extra params are handled
+#   catch(->(_) { 5 })
+#   run(4)
+#
+# Returns 10
+#
+# FunctionPipe.new.
+#   then(->(x) { Fray::Response.new('hi') }).
+#   then(->(x) { x * 2 }).
+#   catch(->(_) { 5 })
+#   run(4)
+#
+# Returns 5
+#
+module Fray
+  class ResponsePipe < AbortablePipe
+    def initialize(thens = [], c = nil)
+      abort_predicate = ->(state) { state.is_a?(Fray::Data::Response) }
+      super(abort_predicate, thens, c)
+    end
+
+  end
+end

data/lib/fray/version.rb

@@ -0,0 +1,3 @@
+module Fray
+  VERSION = '0.0.0-pre'
+end

data/spec/fray_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Fray do
+  it 'has a version number' do
+    expect(Fray::VERSION).not_to be nil
+  end
+end

data/spec/lib/fray/abortable_pipe_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+RSpec.describe Fray::ResponsePipe do
+  context 'with some functions' do
+    subject(:pipe) { Fray::AbortablePipe.new(->(x) { x % 2 == 0 }) }
+
+    it 'runs a sequence of functions' do
+      result = pipe.
+        then(->(x) { x + 2 }).
+        then(->(x) { x * 5 }).
+        run(1)
+
+      expect(result).to eq(15)
+    end
+
+
+    it 'is immutable' do
+      p2 = pipe.then(->(x) { x * 3 })
+
+      expect(pipe.run(1)).to eq(1)
+      expect(p2.run(1)).to eq(3)
+    end
+
+
+    it 'is reusable' do
+      p = pipe.
+        then(->(x) { x + 2 })
+
+      expect(p.run(1)).to eq(3)
+      expect(p.run(3)).to eq(5)
+    end
+
+
+    it 'aborts when the predicate is true' do
+      result = pipe.
+        then(->(_) { 0 }).
+        then(->(_) { 1 }).
+        run
+
+      expect(result).to eq(0)
+    end
+
+
+    it 'catches even numbers' do
+      result = pipe.
+        then(->(x) { x * 2 }).
+        then(->(_) { raise "don't get here" }).
+        catch(->(_) { 'Inferno' }).
+        run(1)
+
+      expect(result).to eq('Inferno')
+    end
+
+
+    it "doesn't invoke catch if no even numbers are encountered" do
+      result = pipe.
+        then(->(x) { x * 3 }).
+        then(->(_) { 'Haven' }).
+        catch(->(_) { 'Inferno' }).
+        run(1)
+
+      expect(result).to eq('Haven')
+    end
+  end
+end

data/spec/lib/fray/data_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+RSpec.describe Fray::Data do
+  context "A Fray::Response" do
+    it "works with good inputs" do
+      r = Fray::Data::Response.new(
+        status: '200',
+        headers: {},
+        body: ''
+      )
+
+      expect(r.status).to eq('200')
+    end
+
+
+    it "fails with bad inputs" do
+      expect {
+        r = Fray::Data::Response.new(
+          status: '200',
+          headers: {},
+          body: []
+        )
+      }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/lib/fray/response_pipe_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+RSpec.describe Fray::ResponsePipe do
+  context 'with some functions' do
+    subject(:pipe) { Fray::ResponsePipe.new }
+    let(:response) {
+      Fray::Data::Response.new(
+        status: '200',
+        headers: {},
+        body: ''
+      )
+    }
+
+    it 'runs a sequence of functions' do
+      result = pipe.
+        then(->(x) { x * 2 }).
+        then(->(x) { x + 5 }).
+        run(1)
+
+      expect(result).to eq(7)
+    end
+
+
+    it 'is immutable' do
+      p2 = pipe.then(->(x) { x * 2 })
+
+      expect(pipe.run(1)).to eq(1)
+      expect(p2.run(1)).to eq(2)
+    end
+
+
+    it 'is reusable' do
+      p = pipe.
+        then(->(x) { x * 2 }).
+        then(->(x) { x + 5 })
+
+      expect(p.run(1)).to eq(7)
+      expect(p.run(2)).to eq(9)
+    end
+
+
+    it 'aborts on getting a Fray::Data::Response' do
+      result = pipe.
+        then(->(x) { x * 2 }).
+        then(->(_) { response }).
+        then(->(_) { 1 }).
+        run(1)
+
+      expect(result).to be_instance_of(Fray::Data::Response)
+    end
+
+
+    it 'catches Fray::Data::Responses' do
+      result = pipe.
+        then(->(x) { x * 2 }).
+        then(->(_) { response }).
+        then(->(_) { raise "don't get here" }).
+        catch(->(_) { 'Inferno' }).
+        run(1)
+
+      expect(result).to eq('Inferno')
+    end
+
+
+    it "doesn't invoke catch if no Fray::Data::Response is encountered" do
+      result = pipe.
+        then(->(x) { x * 2 }).
+        then(->(_) { 'Haven' }).
+        catch(->(_) { 'Inferno' }).
+        run(1)
+
+      expect(result).to eq('Haven')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+begin
+  require 'byebug'
+rescue LoadError; end
+
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'fray'

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: fray
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Jake Sower
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+description: 
+email: jakesower@gmail.com
+executables:
+- console
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Rakefile
+- bin/console
+- bin/setup
+- config.ru
+- fray.gemspec
+- lib/fray.rb
+- lib/fray/abortable_pipe.rb
+- lib/fray/data.rb
+- lib/fray/data/dataset.rb
+- lib/fray/data/error_set.rb
+- lib/fray/data/filter.rb
+- lib/fray/data/query.rb
+- lib/fray/data/response.rb
+- lib/fray/data_structures/dataset.json
+- lib/fray/data_structures/error.json
+- lib/fray/data_structures/query.json
+- lib/fray/data_structures/request.json
+- lib/fray/data_structures/response.json
+- lib/fray/response_pipe.rb
+- lib/fray/version.rb
+- spec/fray_spec.rb
+- spec/lib/fray/abortable_pipe_spec.rb
+- spec/lib/fray/data_spec.rb
+- spec/lib/fray/response_pipe_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/jakesower/fray
+licenses:
+- apache
+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.4.8
+signing_key: 
+specification_version: 4
+summary: API building blocks.
+test_files: []