big_band 0.2.5 → 0.4.0

data/depgen/depgen.rb

@@ -1,123 +0,0 @@
-require "fileutils"
-
-class Depgen
-
-  SETUP_TOOLS = [:bundler, :gem, :monk, :rip, :vendor]
-
-  class << self
-    include Enumerable
-    attr_reader :all, :option_stack
-
-    def default_options
-      @option_stack.inject({}) { |a, b| a.merge b }
-    end
-
-    def each(&block)
-      all.values.each(&block)
-    end
-
-    def github(user, project = nil, options = {}, &block)
-      raise "cannot call github within #{@wrapper}" if @wrapper and @wrapper != :github
-      project ||= {}
-      if block
-        @user, @wrapper, wrapper_was, user_was = user, :github, @wrapper, @user
-        result = with_options(options.merge(project), &block)
-        @user, @wrapper = user_was, wrapper_was
-      elsif @wrapper
-        wrapper_was, @wrapper = @wrapper, nil
-        result = send :github, @user, user, options.merge(project)
-        @wrapper = wrapper_was
-      else
-        raise ArgumentError, "no project given" if project.nil? or project.is_a? Hash
-        result = new project, options.merge(:git => "git://github.com/#{user}/#{project}.git")
-      end
-      result
-    end
-
-    def inherited(klass)
-      super
-      klass.set_defaults
-    end
-
-    def new(name, options = {})
-      return send(@wrapper, name, options) if @wrapper
-      result = (all[name] ||= super()).apply default_options.merge(options).merge(:name => name)
-      yield result if block_given?
-      @stack << result if @stack
-      result
-    end
-
-    alias add new
-    alias [] new
-
-    def set_defaults
-      @all ||= {}
-      @option_stack ||= []
-    end
-
-    def with_options(options = {})
-      @stack, stack_was = [], @stack
-      @option_stack.push options
-      yield(self)
-      @stack, result = stack_was, @stack
-      @stack.push(*result) if @stack
-      @option_stack.pop
-      result
-    end
-
-    SETUP_TOOLS.each do |tool|
-      eval "def setup_#{tool}(*args); each { |e| e.setup_#{tool}(*args) if e.only.include? #{tool.inspect} }; end"
-    end
-  end
-
-  set_defaults
-  attr_accessor :name, :git, :version, :git_ref, :gem_comp, :only
-
-  def apply(options = {})
-    options.each { |k,v| send "#{k}=", v }
-    self
-  end
-
-  def git_ref
-    version ? @git_ref % version : "HEAD"
-  end
-
-  def initialize
-    super
-    apply :git_ref => "%s", :only => SETUP_TOOLS, :gem_comp => ">="
-  end
-  
-  def only
-    [@only].flatten
-  end
-
-  def setup_bundler(bundler, options = {})
-    bundler.gem(name, version, {:git => git, :ref => git_ref, :require_as => nil}.merge(options))
-  end
-
-  def setup_gem(spec)
-    spec.add_dependency name, "#{gem_comp} #{version}"
-  end
-
-  def setup_monk(output)
-    output.puts [name, gem_comp, version, git].compact.join(" ")
-  end
-
-  def setup_rip(output)
-    output.puts "#{git} #{git_ref}"
-  end
-
-  def setup_vendor(dir = "vendor", verbose = true, &run_cmd)
-    util = verbose ? FileUtils::Verbose : FileUtils
-    run_cmd ||= proc { |cmd| exit 1 unless system cmd }
-    util.mkdir_p dir
-    util.chdir(dir) do
-      run_cmd["git clone #{git} #{name}"] unless File.exist? name
-      util.chdir(name) do
-        run_cmd["git checkout master && git pull"]
-        run_cmd["git checkout #{git_ref}"]
-      end
-    end
-  end
-
-end

data/depgen/depgen.task

@@ -1,42 +0,0 @@
-DEP_FILE  = ENV["DEP_FILE"]  || "dependencies.rb" unless defined? DEP_FILE
-DEP_CLASS = ENV["DEP_CLASS"] || "Dependencies"    unless defined? DEP_CLASS
-
-unless File.exist? DEP_FILE
-  File.open(DEP_FILE, "w") do |f|
-    f.puts 'require "depgen/depgen"', "class #{DEP_CLASS} < Depgen", "end"
-  end
-end
-
-def dep_generate(name, file, &block)
-  desc "generate #{name} configuration"
-  task(name) { File.open(file, "w", &block)}
-end
-
-load DEP_FILE
-DEPENDENCIES = Object.const_get DEP_CLASS
-
-namespace :dependencies do
-
-  namespace :vendor do
-    desc "unpack all dependencies in vendor/"
-    task(:all) { DEPENDENCIES.setup_vendor { |cmd| sh cmd } }
-    DEPENDENCIES.each do |dep|
-      desc "unpack #{dep.name} #{dep.version} in vendor/#{dep.name}/"
-      task(dep.name) { dep.setup_vendor { |cmd| sh cmd } }
-    end
-  end
-
-  namespace :generate do
-    dep_generate(:rip, "deps.rip") { |f| DEPENDENCIES.setup_rip(f) }
-    dep_generate(:bundler, "Gemfile") { |f| f.puts "load #{DEP_FILE.inspect}", "#{DEP_CLASS}.setup_bunlder(self)" }
-    dep_generate(:monk, "dependencies") {|f| DEPENDENCIES.setup_rip(f) }
-  end
-
-  desc "list all dependencies"
-  task :list do
-    DEPENDENCIES.each do |dep|
-      puts "#{dep.name} #{dep.version}"
-    end
-  end
-
-end

data/depgen/depgen_spec.rb

@@ -1,127 +0,0 @@
-require "depgen"
-require "fileutils"
-include FileUtils
-
-
-TEMP_DIR = File.join File.dirname(__FILE__), "tmp"
-TEMP_DIR.replace SPEC_TEMP_DIR if defined? SPEC_TEMP_DIR and SPEC_TEMP_DIR
-mkdir_p TEMP_DIR
-
-describe Depgen do
-
-  def depgen(&block)
-    Class.new(Depgen, &block)
-  end
-
-  before { @dep = depgen }
-
-  describe :default_options do
-
-    it "is empty per default" do
-      @dep.default_options.should be_empty
-    end
-
-    it "contains elements from the option stack" do
-      @dep.option_stack.push :foo => 10, :bar => 23
-      @dep.default_options[:foo].should == 10
-      @dep.option_stack.push :foo => 42
-      @dep.default_options[:foo].should == 42
-      @dep.default_options[:bar].should == 23
-      @dep.option_stack.pop
-      @dep.default_options[:foo].should == 10
-    end
-
-  end
-
-  describe :each do
-
-    before do
-      @foo = @dep.add "foo"
-      @bar = depgen.add "bar"
-    end
-
-    it "yields through directly created dependencies" do
-      @dep.each { |d| d.should == @foo }
-    end
-
-    it "yields not through dependencies from other subclasses" do
-      @dep.each { |d| d.should != @foo }
-    end
-
-  end
-
-  describe :github do
-
-    it "sets up git url correctly" do
-      @dep.github("rkh", "depgen").git.should  == "git://github.com/rkh/depgen.git"
-    end
-
-    it "takes a block so you don't have to repeat yourself" do
-      @dep.github("rkh") do |d|
-        d.add("depgen").git.should  == "git://github.com/rkh/depgen.git"
-        d.add("big_band").git.should  == "git://github.com/rkh/big_band.git"
-      end
-    end
-
-  end
-
-  describe "#git_ref" do
-
-    it "equals version per default" do
-      @dep.add("foo", :version => "bar").git_ref == "bar"
-    end
-
-    it "subistutes %s with version" do
-      @dep.add("foo", :version => "bar", :git_ref => "foo%sbaz").git_ref == "foobarbaz"
-    end
-
-  end
-
-  describe "#setup_bundler" do
-    it "uses Bundler's gem to set up dependencies" do
-      @dep.add "foo", :version => "1.0", :git => "bar"
-      bundler = mock("bundler")
-      bundler.should_receive(:gem).once.with "foo", "1.0", hash_including(:git => "bar", :require_as => nil, :foo => :bar)
-      @dep.setup_bundler bundler, :foo => :bar
-    end
-  end
-
-  describe "#setup_gem" do
-    it "uses gemspec method add_dependency" do
-      @dep.add "foo", :version => "1.0", :gem_comp => ">="
-      gemspec = mock("gemspec")
-      gemspec.should_receive(:add_dependency).once.with "foo", ">= 1.0"
-      @dep.setup_gem gemspec
-    end
-  end
-
-  describe "#setup_monk" do
-    it "produces valid lines" do
-      @dep.add "foo", :version => "1.0", :git => "bar", :gem_comp => ">="
-      out = StringIO.new
-      @dep.setup_monk out
-      out.rewind
-      out.read.should == "foo >= 1.0 bar\n"
-    end
-  end
-
-  describe "#setup_rip" do
-    it "produces valid lines" do
-      @dep.add "foo", :version => "1.0", :git => "bar", :gem_comp => ">="
-      out = StringIO.new
-      @dep.setup_rip out
-      out.rewind
-      out.read.should == "bar 1.0\n"
-    end
-  end
-
-  describe "#setup_vendor" do
-    it "populates the given vendor directory" do
-      @dep.github "rkh", "big_band", :git_ref => "HEAD"
-      @dep.setup_vendor "#{TEMP_DIR}/vendor"
-      File.directory?("#{TEMP_DIR}/vendor/big_band").should be_true
-      rm_rf "#{TEMP_DIR}/vendor"
-    end  
-  end
-
-end

data/deps.rip

@@ -1,8 +0,0 @@
-git://github.com/chriseppstein/compass.git v0.8.17
-git://github.com/nex3/haml.git 2.2.17
-git://github.com/lsegal/yard.git 0.5.2
-git://github.com/dchelimsky/rspec.git 1.3.0
-git://github.com/rkh/monkey-lib.git v0.3.5
-git://github.com/rack/rack.git 1.0.1
-git://github.com/sinatra/sinatra.git 0.9.4
-git://github.com/brynary/rack-test.git v0.5.3

data/example/example.rb

@@ -1,13 +0,0 @@
-$LOAD_PATH.unshift(File.expand_path(__FILE__ + "/../../lib"), *Dir.glob(File.expand_path(__FILE__ + "/../../vendor/*/lib")))
-require "big_band"
-
-class Example < BigBand
-
-  # The index page. You should see this comment in YARD.
-  get "/" do
-    haml :index
-  end
-  
-  run! if run?
-
-end

data/example/views/index.haml

@@ -1,8 +0,0 @@
-index page
-%a{:href => "/", :class => "fancy-button1"} fancy
-%a{:href => "/", :class => "fancy-button2"} fancy
-%a{:href => "/", :class => "fancy-button3"} fancy
-%a{:href => "/", :class => "fancy-button4"} fancy
-%a{:href => "/", :class => "fancy-button5"} fancy
-%a{:href => "/", :class => "fancy-button6"} fancy
-%a{:href => "/", :class => "fancy-button7"} fancy

data/example/views/layout.haml

@@ -1,2 +0,0 @@
-%link{:rel => "stylesheet", :href => "/stylesheets/screen.css", :type => "text/css"}/
-!=yield

data/example/views/stylesheets/_base.sass

@@ -1 +0,0 @@
-@import big_band.sass

data/example/views/stylesheets/screen.sass

@@ -1,12 +0,0 @@
-@import base.sass
-
-body
-  padding: 1em
-  background-color: #eee
-
-@for !i from 1 through 7
-  a.fancy-button#{!i}
-    +fancy-button-link(#800, 10px + 10px * !i)
-
-=attr(!name, !value)
-  #{!name} = !value

data/lib/big_band/advanced_routes.rb

@@ -1,188 +0,0 @@
-require "sinatra/base"
-
-class BigBand < Sinatra::Base
-
-  # AdvancedRoutes makes routes first class objects in Sinatra:
-  #
-  #   require "sinatra"
-  #   require "big_band"
-  #
-  #   admin_route = get "/admin" do
-  #     administrate_stuff
-  #   end
-  #
-  #   before do
-  #     # Let's deactivate the route if we have no password file.
-  #     if File.exists? "admin_password"
-  #       admin_route.activate
-  #     else
-  #       admin_route.deactivate 
-  #     end
-  #   end
-  #
-  #   first_route = get "/:name" do
-  #     # stuff
-  #   end
-  #
-  #   other_route = get "/foo_:name" do
-  #     # other stuff
-  #   end
-  #
-  #   # Unfortunatly first_route will catch all the requests other_route would
-  #   # have gotten, since it has been defined first. But wait, we can fix this!
-  #   other_route.promote
-  module AdvancedRoutes
-
-    module ArrayMethods
-      ::Array.send :include, self
-
-      def to_route(verb, args = {})
-        dup.to_route! verb, args
-      end
-
-      def to_route!(verb, args = {})
-        extend BigBand::AdvancedRoutes::Route
-        self.verb = verb
-        args.each do |key, value|
-          send "#{key}=", value
-        end
-        self
-      end
-
-      def signature
-        self
-      end
-
-    end
-
-    module Route
-
-      def self.new(verb, args = {})
-        [].to_route! verb, args
-      end
-
-      attr_accessor :app, :verb, :file, :line, :path, :docstring
-
-      def pattern;    self[0]; end
-      def keys;       self[1]; end
-      def conditions; self[2]; end
-      def block;      self[3]; end
-      alias to_proc block
-
-      def pattern=(value);    self[0] = value; end
-      def keys=(value);       self[1] = value; end
-      def conditions=(value); self[2] = value; end
-      def block=(value);      self[3] = value; end
-
-      def signature
-        [pattern, keys, conditions, block]
-      end
-
-      def active?
-        app.routes[verb].include? self
-      end
-
-      def activate(at_top = false)
-        also_change.each { |r| r.activate }
-        return if active?
-        meth = at_top ? :unshift : :push
-        (app.routes[verb] ||= []).send(meth, self)
-        invoke_hook :route_added, verb, path, block
-        invoke_hook :advanced_root_activated, self
-        self
-      end
-
-      def deactivate
-        also_change.each { |r| r.deactivate }
-        return unless active?
-        (app.routes[verb] ||= []).delete(signature)
-        invoke_hook :route_removed, verb, path, block
-        invoke_hook :advanced_root_deactivated, self
-        self
-      end
-
-      def promote(upwards = true)
-        also_change.each { |r| r.promote(upwards) }
-        deactivate
-        activate(upwards)
-      end
-
-      def file?
-        !!@file
-      end
-
-      def inspect
-        "#<BigBand::AdvancedRoutes::Route #{ivar_inspect.join ", "}>"
-      end
-
-      def to_route(verb, args = {})
-        args = args.dup
-        [:app, :verb, :file, :line, :path].each { |key| args[key] ||= send(key) }
-        super(verb, args)
-      end
-
-      def also_change(*other_routes)
-        (@also_change ||= []).push(*other_routes)
-      end
-
-      private
-
-      def ivar_inspect
-        [:signature, :verb, :app, :file, :line].map do |var|
-          value = send(var)
-          "@#{var}=#{value.inspect}" unless value.nil?
-        end.compact
-      end
-
-      def invoke_hook(*args)
-        app.send(:invoke_hook, *args)
-      end
-
-    end
-
-    module ClassMethods
-
-      def get(path, opts={}, &block)
-        first_route, *other_routes = capture_routes { super }
-        first_route.also_change(*other_routes)
-        first_route
-      end
-
-      def route(verb, path, options={}, &block)
-        file, line = block.source_location if block.respond_to? :source_location
-        file ||= caller_files.first
-        route = super(verb, path, options, &block)
-        route.to_route! verb, :app => self, :file => file.expand_path, :line => line, :path => path
-        invoke_hook :advanced_root_added, route
-        @capture_routes << route if @capture_routes
-        route
-      end
-
-      def each_route(&block)
-        return enum_for(:each_route) if respond_to? :enum_for and not block
-        routes.inject([]) { |result, (verb, list)| result.push *list.each(&block) }
-      end
-
-      private
-
-      def capture_routes
-        capture_routes_was, @capture_routes = @capture_routes, []
-        yield
-        captured, @capture_routes = @capture_routes, capture_routes_was
-        captured
-      end
-
-    end
-
-    def self.registered(klass)
-      klass.extend ClassMethods
-      klass.routes.each do |verb, routes|
-        routes.each do |route|
-          route.to_route! verb, :app => klass
-          klass.send :invoke_hook, :advanced_root_added, route
-        end
-      end
-    end
-
-  end
-end