midas-touch 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 46e9074dc53fc0fcc84be15c3b62da210dc60ef1
+  data.tar.gz: f51bf777fa2c077f3655f2773aae8f144ca87404
+SHA512:
+  metadata.gz: b73168f9da024cd3ec38f56c076ec71283542d7ed05aaf9d0bfe838d9764c54a867e7d4dd5087d04d5b8ab103fab407b59a7e064ed617b93f0546ed9455cfe80
+  data.tar.gz: e239e8af613aea11c42c2f8fe0a95f0936f4dbbf2a24645e222ab120c5c2272b86c68adf3c93f04afd9d26dfa0df8c38d6fb94da36ee19889fbd3895b973f53a

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Darren Coxall
+
+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,131 @@
+# Midas Touch
+
+> Everything I touch turns to gold!
+
+Midas provides a collection of classes to help manage inputs. The concept is
+simple. You have a collection of inputs. Those inputs can each have multiple
+filters as well as multiple validation rules.
+
+If you choose you can filter and validate the individual inputs or do them all
+together in a group.
+
+**Midas provides no pre-created validation or filter rules. I believe everyone
+should understand the exact way their validations and filters work.**
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'midas-touch'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install midas-touch
+
+## Usage
+
+### Sinatra DSL
+
+#### Classic
+
+    require "sinatra"
+    require "midas-touch"
+
+    post("foo") do
+      form do
+        filters :strip
+        field :first_name, :required
+        field :last_name,  :required
+        field :contact,    :phone_number
+      end
+
+      if form.valid?
+        # do something
+      else
+        # render the form
+      end
+    end
+
+    # in foo.html.erb
+    <% if form.error_on?(:first_name) %>
+      First name is required
+    <% end %>
+    <input name="first_name" value="<%= form[:first_name] %>" >
+
+#### Modular
+
+    require "sinatra/base"
+    require "midas-touch"
+
+    class Application < Sinatra::Base
+      helpers Sinatra::MidasTouch
+    end
+
+
+#### Creating filters
+
+    class StripFilter < MidasTouch::Filter
+      def call(value)
+        value.respond_to?(:strip) ? value.strip : value
+      end
+    end
+
+    # Register filter for Sinatra DSL
+    MidasTouch.register_filter(StripFilter.new(:strip))
+
+#### Creating validators
+
+    class PositiveNumberValidator < MidasTouch::Validation
+      def call(value)
+        value.to_f > 0
+      end
+    end
+
+    # Register validation for Sinatra DSL
+    MidasTouch.register_validation(PositiveNumberValidator.new(:positive))
+
+#### Using inputs
+
+    first_name = MidasTouch::Input.new(:first_name)
+    first_name.filters << MidasTouch.find_filter(:strip)
+    first_name.validations << MidasTouch.find_validator(:positive)
+    first_name.value = " Darren Coxall "
+
+    # filter
+    first_name.filter! # => "Darren Coxall"
+
+    # validate
+    first_name.valid? # => false
+
+#### Using groups
+
+    form = MidasTouch::InputGroup.new
+    form.inputs << first_name # first_name is MidasTouch::Input instance
+
+    # form wide filtering
+    form.filters << MidasTouch.find_filter(:strip)
+    form.filter!
+
+    # validation
+    form.valid? # => false
+
+#### Accessing values
+
+    # form = MidasTouch::InputGroup.new
+    form[:first_name] # => "Darren Coxall"
+    form[:unknown]    # => nil
+
+    # Finding the input object
+    form.input(:first_name) # => MidasTouch::Input
+
+## Contributing
+
+All contributions should be tested using Cucumber. To run the test suite do the
+following:
+
+    $ bundle install
+    $ bundle exec rake

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require 'cucumber'
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = "features --format pretty"
+end
+
+task :default => :features
+

data/features/filters.feature

@@ -0,0 +1,16 @@
+Feature: Filter logic
+
+  In order to easily filter inputs (strip whitespace, upcase, etc)
+  then we require the ability to define filters that can be executed
+  on values.
+
+  Scenario: Use of the base filter class
+    Given I wish to create a new filter
+    When I create a sub-class of "MidasTouch::Filter"
+    Then the class can be initialized with a name
+    And responds to the call method
+
+  Scenario: Registering filters for easy access
+    Given I have a Filter
+    When I register it with MidasTouch
+    Then I can retrieve it by name

data/features/input_group.feature

@@ -0,0 +1,26 @@
+Feature: Handling collections of input
+
+  We can handle collections of inputs easily via the use
+  of an InputGroup which allows us to filter and validate
+  numerous inputs.
+
+  Scenario: Adding inputs to a group
+    Given I have an InputGroup
+    Then I can add inputs
+
+  Scenario: Adding group filters
+    Given I have an InputGroup
+    And it has a Filter
+    When it is filtered
+    Then all inputs are filtered
+
+  Scenario: Adding group validations
+    Given I have an InputGroup
+    And it has a validation rule
+    When it is validated
+    Then all inputs are validated
+
+  Scenario: Enumerate over values
+    Given I have an InputGroup
+    And it has inputs
+    Then I can iterate over the names and values

data/features/input_representation.feature

@@ -0,0 +1,28 @@
+Feature: Input Representation
+
+  In order to provide an Object Orientated approach to
+  input cleansing and validation, inputs must be
+  representable as objects within Midas.
+
+  Scenario: Creating a new Input
+    Given I wish to create an input
+    Then I can create one by calling "MidasTouch::Input.new(:name)"
+    And it will be named "name"
+
+  Scenario: Setting an inputs value
+    Given I have an Input
+    Then I can set the value
+
+  Scenario: Adding filters to an input
+    Given I have an Input
+    When I add a filter
+    Then the input can be filtered
+
+  Scenario: Adding validation rules to an input
+    Given I have an Input
+    When I add a validation rule
+    Then the input can be validated
+
+  Scenario: Manually invalidating an input
+    Given I have an Input
+    Then I can manually mark it as invalid

data/features/sinatra.feature

@@ -0,0 +1,54 @@
+Feature: Extending Sinatra applications
+
+  The Midas gem provides a DSL for Sinatra based applications
+  allowing them to define inputs and rules with more ease.
+
+  Background:
+    Given there is a filter called "strip"
+    And there is a validation called "duck_only"
+    And the following application:
+      """
+      helpers Sinatra::MidasTouch
+      get('/form') do
+        form do
+          filters :strip
+          field :first_name
+          field :last_name
+        end
+        form.inputs.map { |input|
+          input.name.to_s + ' : ' + (input.value or 'nil')
+        }.join(',')
+      end
+
+      get('/validate') do
+        form do
+          field :example, :duck_only
+        end
+        form.valid?.inspect
+      end
+      """
+
+  Scenario: Using the sinatra DSL for inputs (without params)
+    When we make a request to "form"
+    Then the inputs have no value
+
+  Scenario: Using the sinatra DSL for inputs (with params)
+    When we make a request to "form" with the following params:
+      | first_name | foo |
+      | last_name  | bar |
+    Then the inputs have values
+
+  Scenario: Using the sinatra DSL for validation (without params)
+    When we make a request to "validate"
+    Then the response body is "false"
+
+  Scenario Outline: Using the sinatra DSL for validation (with params)
+    When we make a request to "validate" with the following params:
+      | example | <param value> |
+    Then the response body is "<result>"
+
+    Examples:
+      | param value | result |
+      | foo         | false  |
+      | fooduck     | false  |
+      | duck        | true   |

data/features/step-definitions/filter_steps.rb

@@ -0,0 +1,15 @@
+Given(/^I wish to create a new filter$/) do
+  @expected_class = MidasTouch::Filter
+end
+
+Given(/^I have a Filter$/) do
+  @filter = MidasTouch::Filter.new(:test)
+end
+
+When(/^I register it with MidasTouch$/) do
+  MidasTouch.register_filter(@filter)
+end
+
+Then(/^I can retrieve it by name$/) do
+  assert_equal(@filter, MidasTouch.find_filter(:test))
+end

data/features/step-definitions/general_steps.rb

@@ -0,0 +1,11 @@
+When(/^I create a sub\-class of "(.*?)"$/) do |klass|
+  @klass = Class.new(Object.const_get(klass))
+end
+
+Then(/^the class can be initialized with a name$/) do
+  @instance = @klass.new(:name)
+end
+
+Then(/^responds to the call method$/) do
+  assert_respond_to(@instance, :call)
+end

data/features/step-definitions/input_group_steps.rb

@@ -0,0 +1,68 @@
+Given(/^I have an InputGroup$/) do
+  @group = MidasTouch::InputGroup.new
+end
+
+Then(/^I can add inputs$/) do
+  @group.inputs << MidasTouch::Input.new(:foo)
+  @group.inputs << MidasTouch::Input.new(:bar)
+  assert_includes(@group.fields, :foo)
+  assert_includes(@group.fields, :bar)
+end
+
+And(/^it has a Filter$/) do
+  filter = Class.new(MidasTouch::Filter) do
+    def call(value)
+      value.to_s.upcase
+    end
+  end.new(:upcase)
+  @group.filters << filter
+end
+
+When(/^it is filtered$/) do
+  @group.inputs << MidasTouch::Input.new(:foo)
+  @group.inputs << MidasTouch::Input.new(:bar)
+  @group.input(:foo).value = "foo"
+  @group.input(:bar).value = "bar"
+  @group.filter!
+end
+
+Then(/^all inputs are filtered$/) do
+  values = @group.inputs.map(&:value)
+  assert_includes(values, "FOO")
+  assert_includes(values, "BAR")
+end
+
+And(/^it has a validation rule$/) do
+  validation = Class.new(MidasTouch::Validation) do
+    def call(value)
+      value == "duck"
+    end
+  end.new(:is_duck)
+  @group.validations << validation
+end
+
+And(/^it has inputs$/) do
+  @group.inputs << MidasTouch::Input.new(:foo)
+  @group.inputs << MidasTouch::Input.new(:bar)
+  @group.input(:foo).value = "foo"
+  @group.input(:bar).value = "bar"
+end
+
+When(/^it is validated$/) do
+  @group.inputs << MidasTouch::Input.new(:bar)
+  @group.inputs << MidasTouch::Input.new(:baz)
+  @group.input(:bar).value = "duck"
+  @group.input(:baz).value = "bar"
+  @result = @group.valid?
+end
+
+Then(/^all inputs are validated$/) do
+  refute(@result)
+  assert(@group.error_on?(:baz))
+end
+
+Then(/^I can iterate over the names and values$/) do
+  act = Hash[@group.map { |k, v| [k, v] }]
+  exp = { :foo => "foo", :bar => "bar" }
+  assert_equal(exp, act)
+end

data/features/step-definitions/input_steps.rb

@@ -0,0 +1,60 @@
+Given(/^I wish to create an input$/) do
+  @expected_class = MidasTouch::Input
+end
+
+Then(/^I can create one by calling "(.*?)"$/) do |code|
+  @eval_result = eval(code)
+  assert_instance_of(@expected_class, @eval_result)
+end
+
+Then(/^it will be named "(.*?)"$/) do |name|
+  assert_equal(name, @eval_result.name.to_s)
+end
+
+Given(/^I have an Input$/) do
+  @input = MidasTouch::Input.new(:example)
+end
+
+Then(/^I can set the value$/) do
+  @input.value = "raw input value"
+  assert_equal("raw input value", @input.value)
+end
+
+When(/^I add a filter$/) do
+  filter = Class.new(MidasTouch::Filter) do
+    def call(value)
+      value.to_s.upcase
+    end
+  end.new(:example)
+
+  @input.filters << filter
+end
+
+When(/^I add a validation rule$/) do
+  rule = Class.new(MidasTouch::Validation) do
+    def call(value)
+      value == "duck"
+    end
+  end.new(:example)
+
+  @input.validations << rule
+end
+
+Then(/^the input can be filtered$/) do
+  @input.value = "example"
+  @input.filter!
+  assert_equal("EXAMPLE", @input.value)
+end
+
+Then(/^the input can be validated$/) do
+  @input.value = "example"
+  refute(@input.valid?)
+  @input.value = "duck"
+  assert(@input.valid?)
+end
+
+Then(/^I can manually mark it as invalid$/) do
+  @input.invalidate!
+  @input.value = "duck"
+  refute(@input.valid?)
+end

data/features/step-definitions/sinatra_steps.rb

@@ -0,0 +1,53 @@
+Given(/^the following application:$/) do |string|
+  mock_app do
+    class_eval(string)
+  end
+end
+
+Then(/^we have an InputGroup$/) do
+  assert_instance_of(MidasTouch::InputGroup, @result)
+end
+
+Given(/^there is a filter called "(.*?)"$/) do |name|
+  filter = ::MidasTouch::Filter.new(name)
+  ::MidasTouch.register_filter(filter)
+end
+
+Given(/^there is a validation called "(.*?)"$/) do |name|
+  validation = Class.new(::MidasTouch::Validation) do
+    def call(value)
+      value == "duck"
+    end
+  end.new(name)
+  ::MidasTouch.register_validation(validation)
+end
+
+Then(/^the group has the following inputs:$/) do |table|
+  names = table.raw.flatten
+  @result.inputs.each do |input|
+    assert_includes(names, input.name.to_s)
+  end
+end
+
+When(/^we make a request to "(.*?)"$/) do |path|
+  get(path)
+end
+
+When(/^we make a request to "(.*?)" with the following params:$/) do |path, params|
+  get(path, @params = params.rows_hash)
+end
+
+Then(/^the inputs have no value$/) do
+  last_response.body.split(',').each do |line|
+    assert_match("_name : nil", line)
+  end
+end
+
+Then(/^the inputs have values$/) do
+  vals = last_response.body.split(",").map { |line| line.split(' : ') }
+  assert_equal(@params, Hash[vals])
+end
+
+Then(/^the response body is "(.*?)"$/) do |body|
+  assert_equal(body, last_response.body)
+end

data/features/step-definitions/validation_steps.rb

@@ -0,0 +1,15 @@
+Given(/^I wish to create a validation rule$/) do
+  @expected_class = MidasTouch::Validation
+end
+
+Given(/^I have a validation rule$/) do
+  @rule = MidasTouch::Validation.new(:example)
+end
+
+When(/^I register the with MidasTouch$/) do
+  MidasTouch.register_validation(@rule)
+end
+
+Then(/^it can be retrieved with its name$/) do
+  assert_equal(@rule, MidasTouch.find_validation(:example))
+end

data/features/support/env.rb

@@ -0,0 +1,27 @@
+lib = File.expand_path("../../../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "rack/test"
+require "sinatra/base"
+require "midas-touch"
+require "minitest"
+require "minitest/unit"
+
+World(MiniTest::Assertions)
+
+module Midas
+  module TestHelpers
+    def mock_app(&block)
+      @app = Sinatra.new(Sinatra::Base) do
+        class_eval(&block)
+      end
+    end
+
+    def app
+      @app ||= Class.new(Sinatra::Base)
+    end
+  end
+end
+
+World(Rack::Test::Methods)
+World(Midas::TestHelpers)

data/features/validation.feature

@@ -0,0 +1,15 @@
+Feature: Validation rule representation
+
+  Validation rules need to be represented as standard objects
+  that can easily be added to inputs.
+
+  Scenario: Creating a validation rule
+    Given I wish to create a validation rule
+    When I create a sub-class of "MidasTouch::Validation"
+    Then the class can be initialized with a name
+    And responds to the call method
+
+  Scenario: Registering validation rules
+    Given I have a validation rule
+    When I register the with MidasTouch
+    Then it can be retrieved with its name

data/lib/midas-touch/filter.rb

@@ -0,0 +1,16 @@
+module MidasTouch
+  class Filter
+
+    attr_accessor :name
+    private :name=
+
+    def initialize(name)
+      self.name = name.to_sym
+    end
+
+    def call(value)
+      value
+    end
+
+  end
+end

data/lib/midas-touch/input.rb

@@ -0,0 +1,38 @@
+module MidasTouch
+  class Input
+
+    attr_accessor :name
+    private :name=
+
+    attr_accessor :value
+    attr_accessor :filters
+    attr_accessor :validations
+
+    def initialize(name)
+      self.name        = name.to_sym
+      self.filters     = Array.new
+      self.validations = Array.new
+      @invalidate = false
+    end
+
+    def filter!
+      filters.each do |filter|
+        self.value = filter.call(self.value)
+      end
+      self.value
+    end
+
+    def valid?
+      return false if @invalidate
+      validations.each do |rule|
+        return false if !rule.call(self.value)
+      end
+      true
+    end
+
+    def invalidate!
+      @invalidate = true
+    end
+
+  end
+end

data/lib/midas-touch/input_group.rb

@@ -0,0 +1,67 @@
+module MidasTouch
+  class InputGroup
+
+    include Enumerable
+
+    attr_accessor :inputs
+    attr_accessor :filters
+    attr_accessor :validations
+
+    def initialize
+      @inputs      = Array.new
+      @filters     = Array.new
+      @validations = Array.new
+      @failures    = Array.new
+    end
+
+    def input(name)
+      name = name.to_sym
+      @inputs.find { |input| input.name == name }
+    end
+
+    def [](name)
+      input = input(name)
+      input.value if input
+    end
+
+    def filter!
+      @inputs.each do |input|
+        filters.each { |filter| input.value = filter.call(input.value) }
+        input.filter!
+      end
+    end
+
+    def fields
+      @inputs.map(&:name)
+    end
+    alias_method :keys, :fields
+
+    def valid?
+      @failures = Array.new
+      @inputs.each do |input|
+        validations.each do |rule|
+          if !rule.call(input.value)
+            @failures << input
+            break
+          end
+        end
+        @failures << input unless input.valid?
+      end
+      @failures.uniq!
+      @failures.empty?
+    end
+
+    def error_on?(name)
+      @failures.include?(input(name))
+    end
+
+    def to_h
+      Hash[@inputs.map { |input| [input.name, input.value] }]
+    end
+
+    def each(&block)
+      to_h.each(&block)
+    end
+
+  end
+end

data/lib/midas-touch/validation.rb

@@ -0,0 +1,16 @@
+module MidasTouch
+  class Validation
+
+    attr_accessor :name
+    private :name=
+
+    def initialize(name)
+      self.name = name.to_sym
+    end
+
+    def call(value)
+      true
+    end
+
+  end
+end

data/lib/midas-touch/version.rb

@@ -0,0 +1,3 @@
+module MidasTouch
+  VERSION = "1.0.0"
+end

data/lib/midas-touch.rb

@@ -0,0 +1,36 @@
+require "midas-touch/version"
+require "midas-touch/filter"
+require "midas-touch/validation"
+require "midas-touch/input"
+require "midas-touch/input_group"
+
+module MidasTouch
+
+  @@filters     = Hash.new
+  @@validations = Hash.new
+
+  class << self
+
+    def register_filter(filter)
+      @@filters[filter.name] = filter
+    end
+
+    def find_filter(name)
+      @@filters.fetch(name.to_sym)
+    end
+
+    def register_validation(validation)
+      @@validations[validation.name] = validation
+    end
+
+    def find_validation(name)
+      @@validations.fetch(name.to_sym)
+    end
+
+  end
+
+end
+
+if self.class.const_defined?(:Sinatra)
+  require "sinatra/midas-touch"
+end

data/lib/sinatra/midas-touch/dsl.rb

@@ -0,0 +1,29 @@
+module Sinatra
+  module MidasTouch
+    class DSL
+
+      attr_reader :group
+
+      def initialize(params)
+        @params = params
+        @group = ::MidasTouch::InputGroup.new
+      end
+
+      def field(name, *args)
+        input = ::MidasTouch::Input.new(name)
+        args.each do |rule|
+          input.validations << ::MidasTouch.find_validation(rule)
+        end
+        input.value = @params[name]
+        @group.inputs << input
+      end
+
+      def filters(*names)
+        names.each do |name|
+          @group.filters << ::MidasTouch.find_filter(name)
+        end
+      end
+
+    end
+  end
+end

data/lib/sinatra/midas-touch.rb

@@ -0,0 +1,16 @@
+require 'sinatra/midas-touch/dsl'
+
+module Sinatra
+  module MidasTouch
+    def form(&block)
+      if block_given?
+        @form = DSL.new(params)
+        @form.instance_eval(&block)
+        @form.group.filter!
+      end
+      @form.group
+    end
+  end
+
+  helpers MidasTouch
+end

data/midas-touch.gemspec

@@ -0,0 +1,25 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'midas-touch/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "midas-touch"
+  spec.version       = MidasTouch::VERSION
+  spec.authors       = ["Darren Coxall"]
+  spec.email         = ["darren@simplybusiness.co.uk"]
+  spec.summary       = %q{Turn all your inputs to Gold.}
+  spec.description   = %q{Clean and validate your inputs from forms or other areas of your application.}
+  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 "rack-test"
+  spec.add_development_dependency "cucumber"
+  spec.add_development_dependency "minitest", "~> 5.3.5"
+  spec.add_development_dependency "sinatra"
+end

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification
+name: midas-touch
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Darren Coxall
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-26 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: rack-test
+  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: cucumber
+  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: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 5.3.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 5.3.5
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  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'
+description: Clean and validate your inputs from forms or other areas of your application.
+email:
+- darren@simplybusiness.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- features/filters.feature
+- features/input_group.feature
+- features/input_representation.feature
+- features/sinatra.feature
+- features/step-definitions/filter_steps.rb
+- features/step-definitions/general_steps.rb
+- features/step-definitions/input_group_steps.rb
+- features/step-definitions/input_steps.rb
+- features/step-definitions/sinatra_steps.rb
+- features/step-definitions/validation_steps.rb
+- features/support/env.rb
+- features/validation.feature
+- lib/midas-touch.rb
+- lib/midas-touch/filter.rb
+- lib/midas-touch/input.rb
+- lib/midas-touch/input_group.rb
+- lib/midas-touch/validation.rb
+- lib/midas-touch/version.rb
+- lib/sinatra/midas-touch.rb
+- lib/sinatra/midas-touch/dsl.rb
+- midas-touch.gemspec
+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.0.14
+signing_key: 
+specification_version: 4
+summary: Turn all your inputs to Gold.
+test_files:
+- features/filters.feature
+- features/input_group.feature
+- features/input_representation.feature
+- features/sinatra.feature
+- features/step-definitions/filter_steps.rb
+- features/step-definitions/general_steps.rb
+- features/step-definitions/input_group_steps.rb
+- features/step-definitions/input_steps.rb
+- features/step-definitions/sinatra_steps.rb
+- features/step-definitions/validation_steps.rb
+- features/support/env.rb
+- features/validation.feature