modernizer 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MDlmNWRiNjc1OGY4N2JiYzEwMWYxOTMwZjRlYThlODA1YWQ3YWQ4Ng==
+  data.tar.gz: !binary |-
+    NDM4MGNlOTU0ZGQ1MGJkYTMxMDBjYjI3NzQ0NjhiNjZmNzQ5ODg3Mw==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    NTk0MmU2MDMzMTFjZDc3NmFhMjA2YTc5OWRhNjZkZTQ3OGEyMzc3YWIxYjE3
+    Nzg4NDViMmUwYzMwZWZmYThmYTc5NDljOTAzODI3NTlhYTM3YTZiN2U1Y2Q0
+    NGJlZmUxOWI5ZjM3MjVmZDk1M2NkYzJiMWU5MmZiMWNkYzM0NWI=
+  data.tar.gz: !binary |-
+    MWMwMDc3MTI5YmIzNDc0NzE4MzA3MmIxNTcyZjIwMmFmNTYxMjUxZmFkNjY3
+    OWUzYzlmYTlmNjkzOTU5N2YyOWYzNDc4MzM4YTM3MWQ0MGUwZDg2MDE0ZDA1
+    OWFhM2ZiZjJkNDU3YjQzZDhmNTk4NmQwZmIxOTMyN2E4ODZmNTQ=

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Tucker Joseph
+
+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,48 @@
+# Modernizer
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'modernizer'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install modernizer
+
+## Usage
+```ruby
+Modernizer.new do
+  request_version { @env[...] }
+
+  first do
+    add('hello') { 'hardcoded' }
+  end
+ 
+  modernize '1.2.1' do
+    add('foo') { "#{@body['hello']}-bar" }
+  end
+ 
+  modernize '1.2.3' do
+    remove 'hello'
+    compute('foo') {|x| "baz-#{x}" }
+  end
+ 
+  last do
+    remove 'foo'
+  end
+end
+```
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+require File.expand_path('../spec/spec_tasks.rb', __FILE__)
+
+task :default => [:test]

data/lib/modernizer/map_methods.rb

@@ -0,0 +1,35 @@
+module Modernize
+  module MapMethods
+    class << self
+      # Adds a field based on the result of the block
+      # if the field doesn't already exist.
+      #
+      def add(struct, field, block)
+        h = struct.hash
+        h[field] = struct.instance_exec(&block) if h[field].nil?
+      end
+
+      # Removes a field.
+      #
+      def remove(struct, field, block)
+        struct.hash.delete(field)
+      end
+
+      # Maps an existing field passing the current value
+      # as a parameter to the block.
+      #
+      def map(struct, field, block)
+        h = struct.hash
+        h[field] = struct.instance_exec(h[field], &block) unless h[field].nil?
+      end
+
+      # Adds or updates a field passing the current value (if any)
+      # as a parameter to the block.
+      #
+      def compute(struct, field, block)
+        h = struct.hash
+        h[field] = struct.instance_exec(h[field], &block)
+      end
+    end
+  end
+end

data/lib/modernizer/meta_methods.rb

@@ -0,0 +1,53 @@
+module Modernize
+  module MetaMethods
+    class << self
+
+      # Defines a set of translations to run in order to modernizer
+      # a given version.
+      #
+      def modernize(parser, args, &block)
+        raise ArgumentError.new("wrong number of arguments (#{args.size} for 1)") if args.size != 1
+        raise StandardError.new('version is not valid') unless Gem::Version.correct?(args[0])
+        parser.translations[args[0]] = VersionParser.parse(&block)
+      end
+
+      # Stores the block for determining the version.
+      #
+      def version(parser, args, &block)
+        raise ArgumentError.new("wrong number of arguments (#{args.size} for 0)") if args.size != 0
+        parser.has_version = true
+        parser.initial_version = block
+      end
+
+      # Method for setting the translations which get run before any others,
+      #
+      def first(parser, args, &block)
+        raise ArgumentError.new("wrong number of arguments (#{args.size} for 0)") if args.size != 0
+        parser.translations[:first] = VersionParser.parse(&block)
+      end
+
+      # Method for setting the translations which get run after any others.
+      #
+      def last(parser, args, &block)
+        raise ArgumentError.new("wrong number of arguments (#{args.size} for 0)") if args.size != 0
+        parser.translations[:last] = VersionParser.parse(&block)
+      end
+
+      # Sets the order of translations to be ascending i.e.
+      # first do version 0.0.1 then version 0.0.2 etc.
+      #
+      def ascending(parser, args, &block)
+        raise ArgumentError.new("wrong number of arguments (#{args.size} for 0)") if args.size != 0
+        parser.order = :ascending
+      end
+
+      # Sets the order of translations to be descending i.e.
+      # first do version 0.0.9 then version 0.0.8 etc.
+      #
+      def descending(parser, args, &block)
+        raise ArgumentError.new("wrong number of arguments (#{args.size} for 0)") if args.size != 0
+        parser.order = :descending
+      end
+    end
+  end
+end

data/lib/modernizer/parser.rb

@@ -0,0 +1,45 @@
+module Modernize
+  class Parser
+    # Executes a block to figure out the sets of translations and version.
+    #
+    def self.parse(&block)
+      context = BlockParsingContext.new
+      context.instance_exec(&block)
+      context.migrations
+    end
+  end
+
+  # Struct for storing the translations and block for determining version
+  #
+  class CompiledMigrations < Struct.new(:translations, :version, :order); end
+
+  class VersionError < StandardError; end
+
+  # Class for the context in which the block will get run
+  #
+  class BlockParsingContext
+    attr_accessor :translations, :initial_version, :has_version, :order
+
+    def initialize
+      @translations = {}
+      @initial_version = nil
+      @has_version = false
+      @order = :ascending
+    end
+
+    # Determines what versions there are and before + after if any.
+    #
+    def method_missing(method, *args, &block)
+      raise NoMethodError.new("Undefined translation method #{method}") unless MetaMethods.respond_to?(method)
+      MetaMethods.send(method, self, args, &block)
+    end
+
+    # Returns the struct of version block and translation sets
+    # throws an error if no block is provided for determining version.
+    #
+    def migrations
+      raise VersionError.new('did not provide a way to determine version') unless @has_version
+      CompiledMigrations.new(@translations, @initial_version, @order)
+    end
+  end
+end

data/lib/modernizer/version.rb

@@ -0,0 +1,3 @@
+module Modernizer
+  VERSION = '0.0.1'
+end

data/lib/modernizer/version_parser.rb

@@ -0,0 +1,33 @@
+module Modernize
+  class VersionParser
+    # Takes a block for a given version and generates the translations.
+    #
+    def self.parse(&block)
+      context = VersionParsingContext.new
+      context.instance_exec(&block)
+      context.migration
+    end
+  end
+
+  # Class for the context to executed the block in.
+  #
+  class VersionParsingContext
+    def initialize
+      @maps = []
+    end
+
+    # Figures out which translations are done for each version.
+    #
+    def method_missing(method, *args, &block)
+      raise ArgumentError.new("wrong number of arguments (#{args.size} for 1)") if args.size != 1
+      raise NoMethodError.new("Undefined translation method #{method}") unless MapMethods.respond_to?(method)
+      @maps << {name: method, field: args[0], block: block}
+    end
+
+    # Returns all the translations for a verion.
+    #
+    def migration
+      @maps
+    end
+  end
+end

data/lib/modernizer.rb

@@ -0,0 +1,111 @@
+require 'modernizer/version'
+require 'modernizer/map_methods'
+require 'modernizer/meta_methods'
+require 'modernizer/version_parser'
+require 'modernizer/parser'
+
+module Modernize
+  class Modernizer
+
+    # Generates the set of migrations by parsing the passed in block
+    #
+    def initialize(&block)
+      @migrations = Parser.parse(&block)
+    end
+
+    # Translates a hash based on defined migrations
+    # with a given context and returns the hash.
+    # This will modify whatever gets passed in.
+    #
+    def translate(context, hash)
+      # makes sure that the context is a hash
+      raise ArgumentError.new('did not pass a hash for the context') unless context.is_a?(Hash)
+      raise ArgumentError.new('cannot provide include hash in context') if context[:hash]
+      # create the context instance for instance variables
+      struct = StructContext.new(context, hash)
+
+      # instantiate MapMethods to perform translations and define lambda
+      # for how to tranlate a field
+      #
+
+      translate = lambda { |t|
+        MapMethods.send(t[:name], struct, t[:field], t[:block])
+      }
+
+      # determine the version of the incoming hash
+      #
+      struct_version = struct.instance_exec(&@migrations.version)
+
+      raise StandardError.new('calculated version is not valid') unless Gem::Version.correct?(struct_version)
+
+      # get the first and last translations
+      #
+      firsts = @migrations.translations.delete(:first)
+      lasts = @migrations.translations.delete(:last)
+
+      # gets a list of the potential versions and then sorts them
+      #
+      migration_versions = @migrations.translations.keys.sort! do |x,y|
+        Gem::Version.new(x) <=> Gem::Version.new(y)
+      end
+
+      # reverse order if descending was specified
+      #
+      migration_versions = @migrations.order == :descending ? migration_versions.reverse : migration_versions
+      # run the first translations if they exist
+      #
+      firsts.each(&translate) if firsts
+
+      # determine the first version to run translations
+      #
+      first_index = @migrations.order == :ascending ? migration_versions.find_index(struct_version) : nil
+      last_index = @migrations.order == :descending ? migration_versions.find_index(struct_version) : nil
+
+      # run all subsequent version translations
+      #
+      migration_versions.each_with_index do |version, index|
+        next unless !first_index || index >= first_index
+        next unless !last_index || index <= last_index
+        @migrations.translations[version].each(&translate)
+      end
+
+      # run the first translations if they exist
+      #
+      lasts.each(&translate) if lasts
+
+      # return hash
+      #
+      struct.hash
+    end
+  end
+
+  private
+
+  # This class is used to make the context key/values available
+  # as instance variables to the map methods.
+  #
+  class StructContext
+    def initialize(context, hash)
+      create_getter(:hash, hash)
+      context.each do |key, value|
+        create_getter(key, value)
+      end
+    end
+
+    # Helper method which wraps define_method.
+    #
+    def create_method(name, &block)
+      self.class.send(:define_method, name, &block)
+    end
+
+    # Creates getters for each instance variable and sets
+    # the initial value.
+    #
+    def create_getter(name, value)
+      instance_variable_set(:"@#{name}", value)
+      create_method(name.to_sym) do
+        instance_variable_get(:"@#{name}")
+      end
+    end
+  end
+end

data/modernizer.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'modernizer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'modernizer'
+  spec.version       = Modernizer::VERSION
+  spec.authors       = ['Tucker Joseph']
+  spec.email         = ['rtjoseph11@gmail.com']
+  spec.description   = %q{convert hashes based on translations associated with versions}
+  spec.summary       = %q{see description}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  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.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'mocha'
+  spec.add_development_dependency 'minitest', '~> 4.7'
+end

data/spec/modernizer_spec.rb

@@ -0,0 +1,257 @@
+require File.expand_path('../../lib/modernizer.rb', __FILE__)
+require 'minitest/autorun'
+require 'mocha/setup'
+
+describe 'Modernize' do
+  describe 'add a field' do
+    before do
+      @m = Modernize::Modernizer.new do
+        version { @env['version'] }
+
+        modernize '0.0.1' do
+          add('foo'){ 'bar' }
+        end
+      end
+    end
+
+    it 'should add foo to the body' do
+      result = @m.translate({:env => {'version' => '0.0.1'}}, {})
+      expected = {'foo' => 'bar'}
+      assert_equal expected, result
+    end
+  end
+
+  describe 'remove a field' do
+    before do
+      @m = Modernize::Modernizer.new do
+        version { @env['version'] }
+
+        modernize '0.0.1' do
+          remove 'foo'
+        end
+      end
+    end
+
+    it 'should remove foo from the body' do
+      result = @m.translate({:env => {'version' => '0.0.1'}}, {'foo' => 'bar', 'fizz' => 'buzz'})
+      expected = {'fizz' => 'buzz'}
+      assert_equal expected, result
+    end
+  end
+
+  describe 'compute a field' do
+    before do
+      @m = Modernize::Modernizer.new do
+        version { @env['version'] }
+
+        modernize '0.0.1' do
+          compute('retina') do |value|
+            if @hash['device-type'] == 'android'
+              false
+            else
+              case value
+              when 1 then true
+              when 0 then false
+              else false
+              end
+            end
+          end
+        end
+      end
+    end
+
+    it 'should set retina to false for android' do
+      result = @m.translate({:env => {'version' => '0.0.1'}}, {'foo' => 'bar', 'device-type' => 'android'})
+      expected = {'foo' => 'bar', 'device-type' => 'android', 'retina' => false}
+      assert_equal expected, result
+    end
+
+    it 'should convert numbers to booleans' do
+      result = @m.translate({:env => {'version' => '0.0.1'}}, {'foo' => 'bar', 'device-type' => 'iOS', 'retina' => 1})
+      expected = {'foo' => 'bar', 'device-type' => 'iOS', 'retina' => true}
+      assert_equal expected, result
+    end
+  end
+
+  describe 'first methods' do
+    before do
+      @m = Modernize::Modernizer.new do
+        version { @env['version'] }
+
+        first do
+          add('foo'){'bar'}
+
+          compute('fizz'){|value| "thing-#{value}"}
+        end
+
+        modernize '0.0.1' do
+          remove 'foo'
+        end
+      end
+    end
+
+    it 'should remove foo from the body' do
+      result = @m.translate({:env => {'version' => '0.0.1'}}, {'baz' => 'thing', 'fizz' => 'buzz'})
+      expected = {'baz' => 'thing', 'fizz' => 'thing-buzz'}
+      assert_equal expected, result
+    end
+  end
+
+  describe 'last methods' do
+    before do
+      @m = Modernize::Modernizer.new do
+        version { @env['version'] }
+
+        modernize '0.0.1' do
+          remove 'foo'
+        end
+
+        last do
+          add('foo'){'bar'}
+
+          compute('fizz'){|value| "thing-#{value}"}
+        end
+      end
+    end
+
+    it 'should remove foo from the body' do
+      result = @m.translate({:env => {'version' => '0.0.1'}}, {'foo' => 'thing', 'fizz' => 'buzz'})
+      expected = {'foo' => 'bar', 'fizz' => 'thing-buzz'}
+      assert_equal expected, result
+    end
+  end
+
+  describe 'version sorting' do
+    before do
+      @m = Modernize::Modernizer.new do
+        modernize '0.0.2' do
+          add('foo'){'bar'}
+
+          compute('fizz'){|value| "thing-#{value}"}
+        end
+
+        modernize '0.0.1' do
+          remove 'foo'
+        end
+
+        version { @env['version'] }
+      end
+    end
+
+    it 'should remove foo from the body' do
+      result = @m.translate({:env => {'version' => '0.0.1'}}, {'foo' => 'thing', 'fizz' => 'buzz'})
+      expected = {'foo' => 'bar', 'fizz' => 'thing-buzz'}
+      assert_equal expected, result
+    end
+  end
+
+  describe 'add/map do not overwrite/add keys/values' do
+    before do
+      @m = Modernize::Modernizer.new do
+        modernize '0.0.1' do
+          add('foo'){'bar'}
+
+          map('fizz'){|value| "thing-#{value}"}
+        end
+
+        version { @env['version'] }
+      end
+    end
+
+    it 'should not have fizz and not overwrite foo' do
+      result = @m.translate({:env => {'version' => '0.0.1'}}, {'foo' => 'thing'})
+      expected = {'foo' => 'thing'}
+      assert_equal expected, result
+    end
+  end
+
+  describe 'context variables are available' do
+    before do
+      @m = Modernize::Modernizer.new do
+        modernize '0.0.1' do
+          add('foo'){'bar'}
+          add('version'){@thing['version']}
+          map('fizz'){|value| "thing-#{value}-#{@hash['foo']}-#{@name['mark']}"}
+        end
+
+        version { @thing['version'] }
+      end
+    end
+
+    it 'should yield values as expected' do
+      result = @m.translate({:thing => {'version' => '0.0.1'}, :name => {'mark' => 'kinsella'}}, {'some' => 'thing', 'fizz' => 'buzz'})
+      expected = {'some' => 'thing', 'foo' => 'bar', 'version' => '0.0.1', 'fizz' => 'thing-buzz-bar-kinsella'}
+      assert_equal expected, result
+    end
+  end
+
+  describe 'throws an error if hash is provided in context' do
+    before do
+      @m = Modernize::Modernizer.new do
+        version { @env['version'] }
+
+        modernize '0.0.1' do
+          add('foo'){ 'bar' }
+        end
+      end
+    end
+
+    it 'should throw an argument error' do
+      assert_raises(ArgumentError) { @m.translate({:env => {'version' => '0.0.1'}, :hash => {'doesnt' => 'work'}}, {}) }
+    end
+  end
+
+  describe 'throws an error if calculated version is not valid' do
+    before do
+      @m = Modernize::Modernizer.new do
+        version { @env['version'] }
+
+        modernize '0.0.1' do
+          add('foo'){ 'bar' }
+        end
+      end
+    end
+
+    it 'should throw an standard error' do
+      assert_raises(StandardError) { @m.translate({:env => {'version' => 'XXX'}}, {}) }
+    end
+  end
+
+  describe 'throws an error if modernizer version is not valid' do
+    it 'should throw an standard error' do
+      assert_raises(StandardError) do
+        Modernize::Modernizer.new do
+          version { @env['version'] }
+
+          modernize 'XXX' do
+            add('foo'){ 'bar' }
+          end
+        end
+      end
+    end
+  end
+
+  describe 'will modernize in descending order' do
+    before do
+      @m = Modernize::Modernizer.new do
+        descending
+        modernize '0.0.3' do
+          remove 'foo'
+          compute('fizz'){|value| "thing-#{value}"}
+        end
+
+        modernize '0.0.2' do
+          add('foo'){'bar'}
+        end
+
+        version { @env['version'] }
+      end
+    end
+
+    it 'should remove foo from the body' do
+      result = @m.translate({:env => {'version' => '0.0.1'}}, {'foo' => 'thing', 'fizz' => 'buzz'})
+      expected = {'foo' => 'bar', 'fizz' => 'thing-buzz'}
+      assert_equal expected, result
+    end
+  end
+end

data/spec/spec_tasks.rb

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+Rake::TestTask.new('test:modernizer') do |test|
+  test.pattern = 'spec/modernizer_spec.rb'
+  test.verbose = true
+end
+
+desc 'Run application test suite'
+task 'test' => "test:modernizer"

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: modernizer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tucker Joseph
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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: mocha
+  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: '4.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.7'
+description: convert hashes based on translations associated with versions
+email:
+- rtjoseph11@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/modernizer.rb
+- lib/modernizer/map_methods.rb
+- lib/modernizer/meta_methods.rb
+- lib/modernizer/parser.rb
+- lib/modernizer/version.rb
+- lib/modernizer/version_parser.rb
+- modernizer.gemspec
+- spec/modernizer_spec.rb
+- spec/spec_tasks.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.0.6
+signing_key: 
+specification_version: 4
+summary: see description
+test_files:
+- spec/modernizer_spec.rb
+- spec/spec_tasks.rb
+has_rdoc: