railsapp_factory 0.0.1

data/.gitignore

@@ -0,0 +1,43 @@
+*.gem
+*.rbc
+.bundle
+/vendor/bundle
+.yardoc
+Gemfile.lock
+
+config/initializers/secret_token.rb
+.config
+
+InstalledFiles
+.yardoc
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+/coverage/
+/public/system/*
+/spec/tmp/*
+
+*.sassc
+.sass-cache
+/log/*
+/db/*.sqlite3
+
+capybara-*.html
+
+.rspec
+.rvmrc
+.ruby-version
+
+.project
+
+rerun.txt
+pickle-email-*.html
+
+/bin

data/.travis.yml

@@ -0,0 +1,36 @@
+language: ruby
+notifications:
+  email:
+    on_success: change
+    on_failure: always
+
+before_install:
+  - gem update --system $RUBYGEMS_VERSION
+
+  - gem --version
+  - gem install bundler
+  - bundle --version
+  - mkdir -p tmp/bundle
+
+bundler_args: "--binstubs"
+
+rvm: 
+  # - 1.8.7 - include below so RUBYGEMS version gets set
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - jruby-head
+  - rbx
+
+script: bin/rake build spec install
+
+matrix:
+  allow_failures:
+    # error: sqlite3-1.3.9/lib/sqlite3/sqlite3_native.so: undefined symbol: RBIGNUM_DIGITS
+    - rvm: rbx
+  include:
+    # set RUBYGEMS_VERSION=1.8.25 for ruby 1.8.7 to avoid "undefined method `source_index' for Gem:Module" errors
+    - rvm: 1.8.7
+      env: RUBYGEMS_VERSION=1.8.25
+

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Ian Heggie
+
+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,168 @@
+# RailsappFactory
+
+Rails application factory to make testing gems against multiple versions easier
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'railsapp_factory'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install railsapp_factory
+
+## Usage
+
+To get the list of available versions (that can be run with the ruby version you are currently running):
+
+   RailsappFactory.versions
+
+Depending on the ruby version in use, it will suggest versions '2.3', '3.0', '3.1', '3.2' and '4.0'. The latest in each series will be downloaded. You can also specify a specific version, eg '3.2.8' or 'edge' (edge has to be selected manually as unforsean changes may break the standard build process).
+
+The INTENT is to end up with:
+
+To test a gem (health_check in this case), run:
+
+   RailsappFactory.versions.each do |version|
+     railsapp = RailsappFactory.new(version)  # also accepts "edge"
+     railsapp.timeout = 300  # timeout operations after 300 seconds
+     railsapp.db = 'mysql2'   # database gem to use
+     railsapp.template = File.expand_path('templates/add-file.rb', File.dirname(__FILE__)) # ie full path name
+     # OR
+     railsapp.template = "http://example.com/example.rb"
+
+     # you can also append to the template defined above, or start a custom template from scratch by using append_to_template
+     # A temp file is created containing the combined template information
+
+     railsapp.append_to_template <<-EOF
+        gem "my_gem_name", :path => '#{File.expand_path('templates/add-file.rb', '..')}'
+        bundle install
+        generate(:scaffold, "person name:string")
+        route "root to: 'people#index'"
+        rake("db:migrate")
+     EOF
+
+     # following commands return a struct with stdout, stderr and exit_status
+     # and an exception is raised if build fails
+
+     puts "Latest version in #{railsapp.release} series is #{railsapp.version}"
+
+     railsapp.build   # run,rake,runner,console will all trigger this if you forget
+
+     railsapp.append_to_template 'gem "halo"'
+
+     railsapp.process_template  # apply template with rake command
+
+     # runs an expression in runner and ruby respectively, and uses to_json to return the result.
+     # exceptions are passed through, except for syntax errors
+
+     railsapp.rails_eval 'Some.rails(code)'     # with rails loaded
+     railsapp.ruby_eval 'Some.ruby(code)'       # without rails (except for 2.3* which requires rails to pass results back)
+
+     railsapp.run
+
+     # check server is actually running
+     railsapp.alive?.should be_true
+
+     # some helpers for constructing urls (strings)
+     puts "home url: #{railsapp.url}"
+     puts "url: #{railsapp.url('/search', {:author => {:name => 'fred'}})"
+
+     puts "Instance of URI: #{railsapp.uri('/some/path', :name => 'value')}"
+
+     puts "port: #{railsapp.port}"
+
+     railsapp.stop
+
+     # override ENV passed to rails app processes
+     railsapp.override_ENV['EDITOR'] = 'vi'
+
+     railsapp.in_app do
+                 # runs command in rails root dir without the extra environment variables bundler exec sets"
+       system 'some shell command'
+     end
+
+     railsapp.system_in_app 'another shell command'
+
+     railsapp.destroy
+   end
+
+   # removes all temp directories - TODO: stop any running servers
+   RailsappFactory.cleanup
+
+If you use rvm (eg travis.ci) or rbenv (like I do), then you also go the other way,
+and run you tests in a specific version of ruby (eg to use the later syntax), but build and/or run the rails app
+with the various ruby versions you have installed.
+
+It will attempt to find rvm / rbenv through environment variables first, the check the PATH, and lastly check the standard install directories under $HOME.
+This handles RubyMine's clearing of environment variables, running rbenv or rvm in command mode only whilst running the system ruby.
+
+    RailsappFactory.rubies                    # lists all ruby versions available (in the format the version manager prefers)
+    RailsappFactory.rvm?                      # is RVM available
+    RailsappFactory.rbenv?                    # is rbenv available
+    RailsappFactory.has_ruby_version_manager? # either available?
+    RailsappFactory.using_system_ruby?        # simple check that there are no rvm or rbenv specific directories in PATH
+
+    # example without having to build the actual rails app (run ruby commands)
+
+    RailsappFactory.rubies.each do |ruby_v|
+      it "provides a command prefix that will run ruby #{ruby_v}" do
+        prefix = RailsappFactory.ruby_command_prefix(ruby_v)
+        actual_ruby_v=`#{prefix} ruby -v`
+      end
+    end
+
+### Future Development
+
+At the moment the rubies system isn't smart enough to work out which ruby works with which rails versions,
+nor know the jruby and rbx switches that change the language modes. I intend to develop that area further.
+Suggestions welcome if checking RUBY_VERSION is sufficient, along with checking if the ruby_version changes
+from the default with `JRUBY_OPTS=--1.9, --1.8, --2.0` as well as `RBXOPT=-X18, -X19, -X20, -X21`,
+or if I need to do more.
+
+I am thinking of adding multiple entries in the rubies list for rbx / jruby if the env variables trigger a change in
+RUBY_VERSION, eg:
+* jruby-1.7.9
+* jruby-1.7.9/18mode
+* jruby-1.7.9/19mode
+* jruby-1.7.9/20mode
+
+    # example for a rail application
+
+    @factory = RailsappFactory.new   # chooses the most recent rails version compatible with RUBY_VERSION
+
+    @factory.rubies.each do |ruby_v|
+      @factory.use(ruby_v)
+      actual_ruby_v = @factory.rails_eval('RUBY_VERSION')
+      puts "Using #{@factory.using} ruby"
+    end
+    @factory.use(nil)  # revert to the default ruby (in PATH)
+
+    # You can also pass use a block, and it will revert the ruby version afterwards
+    @factory.use(ruby_v)
+      actual_ruby_v = @factory.rails_eval('RUBY_VERSION')
+    end
+
+
+I am considering get/put like integration tests have, but requires some thought first to be non rails version specific
+
+   #TODO: railsapp.get("/some/path") - returns status same as get in tests
+   #TODO: railsapp.post("/another/path", :author => { :name => 'fred' } ) - returns status same as post in tests
+
+
+## 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
+
+## License
+
+MIT - See LICENSE.txt

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+# If you want to make this the default task
+task :default => :spec

data/lib/railsapp_factory/build_error.rb

@@ -0,0 +1,7 @@
+class RailsappFactory
+
+  class BuildError < RuntimeError
+
+  end
+
+end

data/lib/railsapp_factory/build_methods.rb

@@ -0,0 +1,141 @@
+require 'fileutils'
+require 'tmpdir'
+require 'railsapp_factory'
+
+class RailsappFactory
+  module BuildMethods
+
+    # class variables used in module:
+    # @base_dir
+    # @built
+    # @bundled
+    # @root
+    # @release
+
+    def destroy
+      if @base_dir
+        stop
+        #  keep last built example in last.VERSION
+        FileUtils.rm_rf "#{TMPDIR}/last.#{@version}"
+        FileUtils.mv @base_dir, "#{TMPDIR}/last.#{@version}" if File.directory?(@base_dir)
+        FileUtils.rm_rf @base_dir  # to be sure, to be sure!
+      end
+      @base_dir = nil
+      @built = false
+      @bundled = false
+      @root = nil
+      @release = nil
+    end
+
+    def build
+      if built?
+        self.logger.info "Already built Rails #{@version} app in directory #{root}"
+        process_template
+        return false
+      end
+      self.use_template 'templates/add_json_pure.rb'
+      if self.version =~ /^2/
+        self.use_template 'templates/use_bundler_with_rails23.rb'
+      else
+        self.use_template 'templates/add_necessary_gems.rb'
+      end
+      new_arg = @version =~ /^2/ ? '' : ' new'
+      other_args = @version =~ /^2/ ? '' : '--no-rc --skip-bundle --force'
+      other_args <<= ' --edge' if @version == 'edge'
+      other_args <<= " -m #{self.template}" if self.template
+
+      self.logger.info "Creating Rails #{@version} app in directory #{root}"
+      unless in_app('.') { Kernel.system "sh -xc '#{rails_command} #{new_arg} #{root} -d #{db} #{other_args}' #{append_log 'rails_new.log'}" }
+        @built = true # avoid repeated build attempts
+        raise BuildError.new("rails #{new_arg}railsapp failed #{see_log 'rails_new.log'}")
+      end
+      @built = true
+      clear_template
+      expected_file = File.join(root, 'config', 'environment.rb')
+      raise BuildError.new("error building railsapp - missing #{expected_file}") unless File.exists?(expected_file)
+
+      command = "sh -xc 'bundle install --binstubs .bundle/bin' #{append_log 'bundle.log'}"
+      self.logger.info "Installing gems with binstubs using command: #{command}"
+      unless system_in_app command
+        raise BuildError.new("bundle install returned exit status #{$?} #{see_log 'bundle.log'}")
+      end
+      @bundled = true
+      raise BuildError.new("error installing gems - Gemfile.lock missing #{see_log 'bundle.log'}") unless File.exists?(File.join(root, 'Gemfile.lock'))
+      true
+    end
+
+    def built?
+      @built
+    end
+
+    def bundled?
+      @bundled
+    end
+
+# release installed as reported by the rails command itself
+    def release
+      @release ||= begin
+        cmd = rails_command
+        self.logger.debug "Getting release using command: #{cmd} '-v'"
+        r = in_app(RailsappFactory::TMPDIR) { `#{cmd} '-v'` }.chomp.sub(/^Rails */, '')
+        self.logger.debug "Release: #{r}"
+        r
+      end
+    end
+
+    def root
+      @root = File.join(base_dir, 'railsapp')
+    end
+
+    private
+
+    def rails_command
+      rails_cmd_dir = "#{RailsappFactory::TMPDIR}/rails-#{@version}"
+      rails_path = "#{rails_cmd_dir}/bin/rails"
+      #command = '"%s" "%s"' % [Gem.ruby, rails_path]
+      command = rails_path
+      unless File.exists?(rails_path)
+        self.logger.info "Creating bootstrap Rails #{@version} as #{rails_path}"
+        FileUtils.rm_rf rails_cmd_dir
+        FileUtils.mkdir_p rails_cmd_dir
+        Dir.chdir(rails_cmd_dir) do
+          create_Gemfile
+          Bundler.with_clean_env do
+            Kernel.system "sh -xc '#{bundle_command} install --binstubs' #{append_log 'bundle.log'}"
+          end
+        end
+        unless File.exists?(rails_path)
+          raise BuildError.new("Error getting rails_command: (#{rails_path})")
+        end
+      end
+      command
+    end
+
+    def create_Gemfile
+      version_spec = if @version == 'edge'
+                       "github: 'rails/rails'"
+                     elsif @version == '2.3-lts'
+                       ":git => 'git://github.com/makandra/rails.git', :branch => '2-3-lts'"
+                     elsif @version =~ /\.\d+\./
+                       "'#{@version}'"
+                     else
+                       "'~> #{@version}.0'"
+                     end
+      gemfile_content = <<-EOF
+        source '#{@gem_source}'
+        gem 'rails', #{version_spec}
+      EOF
+
+      File.open('Gemfile', 'w') { |f| f.puts gemfile_content }
+      self.logger.debug "Created Gemfile with: <<\n#{gemfile_content}>>"
+    end
+
+    def base_dir
+      @base_dir ||= begin
+        FileUtils.mkdir_p RailsappFactory::TMPDIR
+        Dir.mktmpdir("app-#{self.version.gsub(/\W/, '_')}-", RailsappFactory::TMPDIR)
+      end
+    end
+
+  end
+end

data/lib/railsapp_factory/class_methods.rb

@@ -0,0 +1,155 @@
+require 'cgi'
+require 'fileutils'
+
+class RailsappFactory
+  module ClassMethods
+    # encodes url query arguments, incl nested
+    def encode_query(args, prefix = '', suffix = '')
+      query = ''
+      args.each do |key, value|
+        if value.is_a?(Hash)
+          query <<= encode_query(value, "#{prefix}#{key}[", "]#{suffix}")
+        else
+          query <<= '&' << CGI::escape(prefix + key.to_s + suffix) << '=' << CGI::escape(value.to_s)
+        end
+      end if args
+      if prefix == ''
+        query.sub(/^&/, '?')
+      else
+        query
+      end
+    end
+
+    def cleanup
+      FileUtils.rm_rf RailsappFactory::TMPDIR
+    end
+
+    def versions(ruby_v = RUBY_VERSION)
+      case (ruby_v.to_s)
+        when /^1\.8\.6/
+          %w{2.3}
+        when /^1\.8\.7/
+          %w{2.3 2.3-lts 3.0 3.1 3.2}
+        when /^1\.9\.1/
+          %w{2.3}
+        when /^1\.9\.2/
+          %w{3.0 3.1 3.2}
+        when /^1\.9\.3/
+          %w{3.0 3.1 3.2 4.0}
+        when /^2\.[01]/
+          %w{4.0}
+        when /^1\./
+          []
+        when ''
+          # all
+          %w{2.3 2.3-lts 3.0 3.1 3.2 4.0}
+        else
+          %w{4.0} # a guess!
+      end
+    end
+
+    def rubies # (rails_v = nil)
+      find_ruby_version_manager
+      ruby_command_prefix_template
+      result = if @@rbenv_path
+                 `#{@@rbenv_path} versions --bare`
+               elsif @@rvm_path
+                 `#{@@rvm_path} list strings`
+               else
+                 ''
+               end.split(/\r?\n/)
+      # TODO: rework this to run each one and extract the RUBY_VERSION to work out what is compatible
+      # TODO: extend this with JRUBY_OPTS=--1.9, --1.8, --2.0 as well as  RBXOPT=-X18, -X19, -X20, -X21 and check which ones actually change the RUBY_VERSION value
+      # TODO: rbx is outputting an extra nil as it is running as irb sometimes .. test this
+      # if rails_v.nil?
+      #  result
+      #else
+      #  rails_v_compare = rails_v.sub(/^(\d+\.\d+).*?(-lts)?$/, '\1\2')
+      #  result.select do |ruby_v|
+      #    rails_v.nil? || versions(ruby_v).include?(rails_v_compare)
+      #  end
+      #end
+    end
+
+    def ruby_command_prefix(ruby_v = nil)
+      if ruby_v.to_s == ''
+        ''
+      else
+        ruby_command_prefix_template % ruby_v.to_s
+      end
+    end
+
+    def rbenv?
+      find_ruby_version_manager
+      @@rbenv_path
+    end
+
+    def rvm?
+      find_ruby_version_manager
+      @@rvm_path
+    end
+
+    def has_ruby_version_manager?
+      find_ruby_version_manager != ''
+    end
+
+    def using_system_ruby?
+      ENV['PATH'] !~ /\/\.?rbenv\/versions\// && ENV['PATH'] !~ /\/\.?rvm\/rubies\//
+    end
+
+    private
+
+    def list_rubies
+      find_ruby_version_manager
+      if @@rbenv_path
+         `#{@@rbenv_path} versions --bare`
+       elsif @@rvm_path
+         `#{@@rvm_path} list strings`
+       else
+         ''
+       end.split(/\r?\n/)
+    end
+
+    def ruby_command_prefix_template
+      @@ruby_command_prefix_template ||= begin
+        find_ruby_version_manager
+        if @@rbenv_path
+          "env 'RBENV_VERSION=%s' #{@@rbenv_path} exec"
+        elsif @@rvm_path
+          "#{@@rvm_path} '%s' do"
+        else
+          ''
+        end
+      end
+    end
+
+
+    def find_ruby_version_manager
+      @@found_ruby_version_manager ||= begin
+        @@rbenv_path = ENV['RBENV_ROOT'] ? "#{ENV['RBENV_ROOT']}/bin/rbenv" : nil
+        @@rvm_path = ENV['rvm_path'] ? "#{ENV['rvm_path']}/bin/rvm" : nil
+        unless @@rbenv_path || @@rvm_path
+          # RubyMine removes RBENV_PATH when a rbenv environment is selected
+          ENV['PATH'].split(':').each do |exec_path|
+            @@rbenv_path = "#{$1}/bin/rbenv" if exec_path =~ /^(.*\/\.?rbenv)\/(bin|versions)/
+            @@rvm_path = "#{$1}/bin/rbenv" if exec_path =~ /^(.*\/\.?rvm)\/(bin|rubies)/
+            break if @@rbenv_path || @@rvm_path
+          end
+          # In case we are running from system ruby and the shell environment is not set
+          unless @@rbenv_path || @@rvm_path
+            if File.exists? "#{ENV['HOME']}/.rbenv/bin/rbenv"
+              @@rbenv_path = "#{ENV['HOME']}/.rbenv/bin/rbenv"
+            elsif File.exists? "#{ENV['HOME']}/.rvm/bin/rvm"
+              @@rvm_path = "#{ENV['HOME']}/.rvm/bin/rvm"
+            end
+          end
+        end
+        @@rbenv_path = nil unless @@rbenv_path && File.exists?(@@rbenv_path)
+        @@rvm_path = nil if @@rbenv_path || !@@rvm_path || !File.exists?(@@rvm_path)
+        @@rbenv_path || @@rvm_path || ''
+      end
+    end
+
+  end
+
+end