thorero-freezer 0.9.4

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Matt Aimonetti
+
+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

@@ -0,0 +1,35 @@
+merb-freezer
+============
+
+<<<<<<< HEAD:merb-freezer/README
+This plugin lets you freeze Merb and run it using the frozen gems. 
+
+==Why would you want to freeze Merb?
+
+* You might have multiple applications on the same server/slice/cluster. Different applications might require different versions of Merb. 
+
+* You might work with a team of developers and want everyone to be using the same Merb version.
+
+* You are using Merb Edge, you want to make sure the production server and your co workers are developing/testing against the same revision.
+
+
+==What are your options?
+
+* You just want to lock your app to a specific version. For instance version merb-core 0.9.2
+
+* You only want to use frozen gems located in /framework or /gems
+
+
+== How to lock your app?
+
+TODO
+
+== How to use frozen gems
+
+Instead of starting merb by typing "merb" in your console, type "frozen-merb" and that's it :)
+
+
+If frozen-merb can't find frozen gems in /framework or /gems then Merb will start normally using the system's gems.
+=======
+see README.markdown
+>>>>>>> new_merb_gen:merb-freezer/README

data/Rakefile

@@ -0,0 +1,70 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require "extlib"
+require 'merb-core/tasks/merb_rake_helper'
+
+##############################################################################
+# Package && release
+##############################################################################
+RUBY_FORGE_PROJECT  = "thorero"
+PROJECT_URL         = "http://merbivore.com"
+PROJECT_SUMMARY     = "Merb plugin that let's you freeze Merb"
+PROJECT_DESCRIPTION = PROJECT_SUMMARY
+
+GEM_AUTHOR = "Matt Aimonetti"
+GEM_EMAIL  = "mattaimonetti@gmail.com"
+
+GEM_NAME    = "thorero-freezer"
+PKG_BUILD   = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+GEM_VERSION = (Merb::MORE_VERSION rescue "0.9.4") + PKG_BUILD
+
+RELEASE_NAME    = "REL #{GEM_VERSION}"
+
+require "extlib/tasks/release"
+
+spec = Gem::Specification.new do |s|
+  s.rubyforge_project = RUBY_FORGE_PROJECT
+  s.name = GEM_NAME
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
+  s.summary = PROJECT_SUMMARY
+  s.description = PROJECT_DESCRIPTION
+  s.author = GEM_AUTHOR
+  s.email = GEM_EMAIL
+  s.homepage = PROJECT_URL
+  s.add_dependency('merb-core', ">= #{GEM_VERSION}")
+  s.require_path = 'lib'
+  s.bindir = "bin"
+  s.executables = %w( frozen-merb )
+  s.autorequire = 'merb-freezer'
+  s.require_path = 'lib'
+  s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,spec}/**/*")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "Install the gem"
+task :install => [:package] do
+  sh %{#{sudo} gem install #{install_home} pkg/#{GEM_NAME}-#{GEM_VERSION} --no-update-sources}
+end
+
+namespace :jruby do
+
+  desc "Run :package and install the resulting .gem with jruby"
+  task :install => :package do
+    sh %{#{sudo} jruby -S gem install #{install_home} pkg/#{GEM_NAME}-#{GEM_VERSION}.gem --no-rdoc --no-ri}
+  end
+
+end
+
+
+require 'rubygems'
+require "merb-core"
+require 'rake/gempackagetask'
+require "spec/rake/spectask"
+require 'merb-core/tasks/merb_rake_helper'
+

data/TODO

@@ -0,0 +1,5 @@
+TODO:
+Fix LICENSE with your name
+Fix Rakefile with your name and contact info
+Add your code to lib/merb-freezer.rb
+Add your Merb rake tasks to lib/merb-freezer/merbtasks.rb

data/bin/frozen-merb

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+root = nil
+%w[-m --merb-root].detect { |o| root = ARGV.index(o) }
+__DIR__ = root ? ARGV[root+1] : Dir.getwd
+
+framework = File.join(__DIR__,"framework")
+
+# load merb from the framework folder
+
+if File.directory?(framework)
+  puts "Running from frozen framework"
+  core = File.join(framework,"merb-core")
+  if File.directory?(core)
+    puts "using merb-core from #{core}"
+    $:.unshift File.join(core,"lib")
+  end
+  more = File.join(framework,"merb-more")
+  if File.directory?(more)
+    Dir.new(more).select {|d| d =~ /merb-/}.each do |d|
+      $:.unshift File.join(more,d,'lib')
+    end
+  end
+  plugins = File.join(framework,"merb-plugins")
+  if File.directory?(plugins)
+    Dir.new(plugins).select {|d| d =~ /merb_/}.each do |d|
+      $:.unshift File.join(plugins,d,'lib')
+    end
+  end
+  require "merb-core/core_ext/kernel"
+  require "merb-core/core_ext/rubygems"
+else
+  # load from the gems folder
+  gem = Dir["./gems/gems/merb-core-*"].last
+  if gem
+    require gem + "/lib/merb-core/core_ext/kernel"
+    require gem + "/lib/merb-core/core_ext/rubygems"
+  
+    Gem.clear_paths
+    Gem.path.unshift(__DIR__+"/gems")
+  else
+    puts "Can't run frozen Merb from framework/ and/or gems/ please freeze Merb"
+    puts "Merb will try to start using the system gems"
+  end
+end
+
+# load submodule gems
+gem_submodules_dir = File.join(__DIR__,"gems/submodules")
+if File.directory?(gem_submodules_dir)
+  Dir["#{gem_submodules_dir}/*"].each do |dir|
+    $:.unshift File.join(dir,"lib")
+  end
+end
+
+require 'merb-core'
+unless %w[-a --adapter -i --irb-console -r --script-runner].any? { |o| ARGV.index(o) }
+  ARGV.push *%w[-a mongrel]
+end
+  
+Merb.frozen! if (File.directory?(framework) || gem)
+Merb.start

data/lib/merb-freezer.rb

@@ -0,0 +1,21 @@
+require 'merb-freezer/freezer'
+require 'fileutils'
+
+# make sure we're running inside Merb
+if defined?(Merb::Plugins)
+
+  # Merb gives you a Merb::Plugins.config hash...feel free to put your stuff in your piece of it
+  Merb::Plugins.config[:merb_freezer] = {
+    :merb_best_framework_ever => true
+  }
+  
+  Merb::BootLoader.before_app_loads do
+    # require code that must be loaded before the application
+  end
+  
+  Merb::BootLoader.after_app_loads do
+    # code that can be required after the application loads
+  end
+  
+  Merb::Plugins.add_rakefiles "merb-freezer/merbtasks"
+end

data/lib/merb-freezer/freezer.rb

@@ -0,0 +1,75 @@
+require File.dirname(__FILE__) + '/freezer_mode'
+
+class Freezer
+  include FreezerMode
+  
+  attr_reader :mode, :component, :update
+  attr_accessor :freezer_dir
+   
+    @@components = 
+                  {
+                    "core" => "git://github.com/wycats/merb-core.git",
+                    "more" => "git://github.com/wycats/merb-more.git",
+                    "plugins" => "git://github.com/wycats/merb-plugins.git"
+                  }
+  
+    @@framework_dir = File.join(Dir.pwd, "framework")
+    @@gems_dir = File.join(Dir.pwd, "gems")
+
+    # Returns the components to freeze
+    # a class variable is used so we could decide to add a setter and support custom components
+    def self.components
+      @@components
+    end
+  
+    def self.framework_dir
+      @@framework_dir
+    end
+    
+    def self.gems_dir
+      @@gems_dir
+    end
+
+    # Freezes a component
+    #
+    # ==== Parameters
+    # component<String>::
+    #   The component to freeze, it needs to be defined in @@components
+    # update<Boolean>:: An optional value to tell the freezer to update the previously frozen or not, this will default to false
+    # mode<String>:: An optional value to tell the freezer what freezer mode to use (submodules or rubygems), this will default to submodules
+    #
+    def self.freeze(component, update, mode)
+      new(component, update, mode).freeze
+    end
+
+    # Initializes a Freeze instance
+    #
+    # ==== Parameters
+    # component<String>::
+    #   The component to freeze, it needs to be defined in @@components
+    # update<Boolean>:: An optional value to tell the freezer to update the previously frozen or not, this will default to false
+    # mode<String>:: An optional value to tell the freezer what freezer mode to use (submodules or rubygems), this will default to submodules
+    #
+    def initialize(component, update=false, mode=nil)
+      @component = Freezer.components.keys.include?(component) ? "merb-" + component : component
+      @update    = update
+      if (mode.nil? && framework_component?) || component.match(/^git:\/\//) || mode == 'submodules'
+        @mode = 'submodules'
+      else
+        @mode = 'rubygems'
+      end
+      @freezer_dir = framework_component? ? Freezer.framework_dir : Freezer.gems_dir
+    end
+    
+    # Calls the freezer mode on the component
+    def freeze
+      puts "freezing mode: #{@mode}"
+      send "#{@mode}_freeze"
+    end
+    
+    # Returns true if the gem is part of the Merb components
+    def framework_component?
+      Freezer.components.keys.include?(@component.gsub("merb-", ""))
+    end
+
+end

data/lib/merb-freezer/freezer_mode.rb

@@ -0,0 +1,116 @@
+require 'find'
+require 'rubygems'
+require 'rubygems/dependency_installer'
+
+module FreezerMode
+  
+  def sudo
+    windows = (PLATFORM =~ /win32|cygwin/) rescue nil
+    sudo = windows ? "" : "sudo"
+  end
+
+  def gitmodules
+    File.join(Dir.pwd, ".gitmodules")
+  end
+
+  # Uses the Git submodules to freeze a component
+  #
+  def submodules_freeze
+    # Ensure that required git commands are available
+    %w(git-pull git-submodule).each do |bin|
+      next if in_path?(bin)
+      $stderr.puts "ERROR: #{bin} must be avaible in PATH - you might want to freeze using MODE=rubygems"
+      exit 1
+    end
+
+    # Create directory to receive the frozen components
+    create_freezer_dir(freezer_dir)
+
+    if managed?(@component)
+      puts "#{@component} seems to be already managed by git-submodule."
+      if @update
+        puts "Trying to update #{@component} ..."
+        `cd #{freezer_dir}/#{@component} && git-pull`
+      else
+        puts "you might want to call this rake task using UPDATE=true if you wish to update the frozen gems using this task"
+      end
+    else
+      puts "Creating submodule for #{@component} ..."
+      if framework_component?
+        `cd #{Dir.pwd} & git-submodule --quiet add #{Freezer.components[@component.gsub("merb-", '')]} #{File.basename(freezer_dir)}/#{@component}`
+      else
+        `cd #{Dir.pwd} & git-submodule --quiet add #{@component} gems/submodules/#{@component.match(/.*\/(.*)\..{3}$/)[1]}`
+      end
+      if $?.success?
+        `git-submodule init`
+      else
+        # Should this instead be a raise?
+        $stderr.puts("ERROR: unable to create submodule for #{@component} - you might want to freeze using MODE=rubygems (make sure the current project has a git repository)")
+      end
+    end
+  end
+
+  # Uses rubygems to freeze the components locally
+  def rubygems_freeze
+    create_freezer_dir(freezer_dir)
+    puts "Install #{@component} and dependencies from rubygems"
+    if File.exist?(freezer_dir) && !File.writable?("#{freezer_dir}/cache")
+      puts "you might want to CHOWN the gems folder so it's not owned by root: sudo chown -R #{`whoami`} #{freezer_dir}"
+    end
+    install_rubygem @component
+  end
+  
+  # Install a gem - looks remotely and locally
+  # won't process rdoc or ri options.
+  def install_rubygem(gem, version = nil)
+    Gem.configuration.update_sources = false
+    Gem.clear_paths
+    installer = Gem::DependencyInstaller.new(:install_dir => freezer_dir)
+    exception = nil
+    begin
+      installer.install gem, version
+    rescue Gem::InstallError => e
+      exception = e
+    rescue Gem::GemNotFoundException => e
+      puts "Locating #{gem} in local gem path cache..."
+      spec = version ? Gem.cache.find_name(gem, "= #{version}").first : Gem.cache.find_name(gem).sort_by { |g| g.version }.last
+      if spec && File.exists?(gem_file = spec.installation_path / 'cache' / "#{spec.full_name}.gem")
+        installer.install gem_file
+      end
+      exception = e
+    end
+    if installer.installed_gems.empty? && e
+      puts "Failed to install gem '#{gem}' (#{e.message})"
+    end
+    installer.installed_gems.each do |spec|
+      puts "Successfully installed #{spec.full_name}"
+    end
+  end
+
+  def create_freezer_dir(path)
+    unless File.directory?(path)
+      puts "Creating freezer directory ..."
+      FileUtils.mkdir_p(path)
+    end
+  end
+
+  protected
+
+  # returns true if submodules are used
+  def in_submodule?(component)
+    return false unless File.exists?(gitmodules)
+    # File.read(gitmodules) =~ %r![submodule "#{freezer_dir}/#{component}"]!
+    File.read(gitmodules).match(%r!#{freezer_dir}/#{component}!)
+  end
+
+  # returns true if the component is in a submodule
+  def managed?(component)
+    File.directory?(File.join(freezer_dir, component)) || in_submodule?(component)
+  end
+
+  def in_path?(bin)
+    `which #{bin}`
+    !$?.nil? && $?.success?
+  end
+
+end

data/lib/merb-freezer/merbtasks.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + "/../merb-freezer"
+
+task :freeze => Freezer.components.keys.map { |component| "freeze:#{component}" }
+namespace :freeze do
+  Freezer.components.each do |component, git_repository|
+    desc "Freeze merb-#{component} from #{git_repository} or rubygems - use UPDATE=true to update a frozen component. By default this task uses git submodules. To freeze the latest gems versions use MODE=rubygems"
+    task component do
+      Freezer.freeze(component, ENV["UPDATE"], ENV["MODE"])
+    end
+  end
+end
+
+namespace :freeze do
+  
+  desc "freeze a gem locally. Usage: rake freeze:gem GEM=git://github.com/myobie/merb_paginate.git "
+  task :gem do
+    raise "Please specify the gem you want to freeze using GEM=git://github.com/myobie/merb_paginate.git or GEM=merbful_authentication" unless ENV["GEM"]
+    Freezer.freeze(ENV["GEM"], ENV["UPDATE"], ENV["MODE"])
+  end
+  
+  desc "freeze all merb components (core, more, plugins) - use MODE=rubgygems and UPDATE=true as in regular freezing tasks"
+  task :all do
+    ['core', 'more', 'plugins'].each do |component|
+      Freezer.freeze(component, ENV["UPDATE"], ENV["MODE"])
+    end
+  end
+  
+end

data/spec/merb-freezer_spec.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "merb-freezer" do
+  
+  before(:each) do
+    FileUtils.rm_rf('framework')
+    FileUtils.rm_rf('gems')
+  end
+  
+  after(:all) do
+    FileUtils.rm_rf('framework')
+    FileUtils.rm_rf('gems')
+  end
+  
+  it "should have a reference to all the git repos" do
+    Freezer.components.should be_an_instance_of(Hash)
+    component_repos = Freezer.components
+    ["core", "more", "plugins"].each do |component|
+      component_repos[component].should match(/git:\/\/.+/)
+    end
+  end
+  
+  it "should have a reference to the framework dir" do
+    Freezer.framework_dir.should_not be_nil
+  end
+  
+  it "should have a reference to the gems dir" do
+    Freezer.gems_dir.should_not be_nil
+  end
+  
+  it "should have a reference to the component freezing dir" do
+    mr_freeze = Freezer.new('core')
+    mr_freeze.freezer_dir.should == Freezer.framework_dir
+    
+    mrs_freeze = Freezer.new('matt-mojo')
+    mrs_freeze.freezer_dir.should == Freezer.gems_dir
+  end
+  
+  it "should be able to freeze a component using rubygems" do
+    mr_freeze = Freezer.new('core', nil, 'rubygems')
+    mr_freeze.mode.should == 'rubygems'
+    mr_freeze.freeze
+    File.exists?('framework').should be_true
+    File.exists?('framework/gems').should be_true
+  end
+  
+  it "should be able to freeze a component using submodules" do
+    mr_freeze = Freezer.new('core')
+    mr_freeze.framework_component?.should be_true
+    mr_freeze.mode.should == 'submodules'
+    # can't be tested since it needs to run from the toplevel of the working tree and I don't want to mess up the rest of the gems by accident
+    # mr_freeze.freeze.should_not raise_error
+    # File.exists?('framework/merb-core').should be_true
+    # File.exists?('.gitmodules').should be_true
+  end
+  
+  it "should be able to freeze a a non merb component gem using rubygems" do
+    mr_freeze = Freezer.new('googlecharts')
+    mr_freeze.framework_component?.should be_false
+    mr_freeze.component.should == 'googlecharts'
+    mr_freeze.mode.should == 'rubygems'
+    mr_freeze.freeze
+    File.exists?('gems').should be_true
+    Dir['gems/gems/googlecharts-1.*'].join(' ').include?('gems/gems/googlecharts-').should be_true
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+$TESTING=true
+<<<<<<< HEAD:merb-freezer/spec/spec_helper.rb
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+=======
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+require 'merb-freezer'
+>>>>>>> new_merb_gen:merb-freezer/spec/spec_helper.rb

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: thorero-freezer
+version: !ruby/object:Gem::Version 
+  version: 0.9.4
+platform: ruby
+authors: 
+- Matt Aimonetti
+autorequire: merb-freezer
+bindir: bin
+cert_chain: []
+
+date: 2008-08-02 00:00:00 +03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: merb-core
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.4
+    version: 
+description: Merb plugin that let's you freeze Merb
+email: mattaimonetti@gmail.com
+executables: 
+- frozen-merb
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- TODO
+files: 
+- LICENSE
+- README
+- Rakefile
+- TODO
+- lib/merb-freezer
+- lib/merb-freezer/freezer.rb
+- lib/merb-freezer/freezer_mode.rb
+- lib/merb-freezer/merbtasks.rb
+- lib/merb-freezer.rb
+- spec/merb-freezer_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://merbivore.com
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: thorero
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Merb plugin that let's you freeze Merb
+test_files: []
+