appetizer 0.0.0

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 'http://rubygems.org'
+
+# Specify your gem's dependencies in appetizer.gemspec
+gemspec

data/README.md

@@ -0,0 +1,48 @@
+# Appetizer
+
+A lightweight init process for Rack apps.
+
+## Assumptions
+
+* Running Ruby 1.9.2 or better.
+* Using Bundler.
+* Logging in all envs except `test` is to `STDOUT`. Logging in `test`
+  is to `tmp/test.log`.
+* Default internal and external encodings are `Encoding::UTF_8`.
+
+## Load/Init Lifecycle
+
+0. Optionally `require "appetizer/{rack,rake}"`, which will
+1. `require "appetizer/setup"`, which will
+2. `load "config/env.local.rb"` if it exists, then
+3. `load "config/env.rb"` if **it** exists.
+4. `load "config/env/#{App.env}.rb"` if **it** exists, then
+5. App code is loaded, but not initialized.
+6. `App.init!` is called. Happens automatically if step 1 occurred.
+7. Fire the `initializing` event.
+8. `load "config/init.rb"` if it exists.
+9. `load "config/{init/**/*.rb"`, then
+10. Fire the `initialized` event.
+
+## License (MIT)
+
+Copyright 2011 Audiosocket (tech@audiosocket.com)
+
+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/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/appetizer.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Audiosocket"]
+  gem.email         = ["tech@audiosocket.com"]
+  gem.description   = "A lightweight init process for Rack apps."
+  gem.summary       = "Provides Railsish environments and initializers."
+  gem.homepage      = "https://github.com/audiosocket/appetizer"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- test/*`.split("\n")
+  gem.name          = "appetizer"
+  gem.require_paths = ["lib"]
+  gem.version       = "0.0.0"
+
+  gem.required_ruby_version = ">= 1.9.2"
+end

data/lib/appetizer/console.rb

@@ -0,0 +1,3 @@
+def reload!
+  exec "irb -r bundler/setup -r appetizer/setup"
+end

data/lib/appetizer/events.rb

@@ -0,0 +1,15 @@
+module Appetizer
+  module Events
+    def fire event
+      hooks[event].each { |h| h.call }
+    end
+
+    def hooks
+      @hooks ||= Hash.new { |h, k| h[k] = [] }
+    end
+
+    def on event, &block
+      hooks[event] << block
+    end
+  end
+end

data/lib/appetizer/init.rb

@@ -0,0 +1,3 @@
+require "appetizer/setup"
+
+App.init!

data/lib/appetizer/populator.rb

@@ -0,0 +1,62 @@
+module Appetizer
+
+  # Helps assign values from a low-level structure to a rich domain
+  # model. Most useful as an explicit alternative to ActiveRecord's
+  # mass-assignment, with an AR object as the target and a params hash
+  # as the source.
+
+  class Populator
+    attr_reader :target
+    attr_reader :source
+
+    def initialize target, source, &block
+      @target = target
+      @source = source
+
+      yield self if block_given?
+    end
+
+    def nested key, target = nil, &block
+      source   = self.source[key] || self.source[key.intern]
+      target ||= self.target.send key
+
+      Populator.new target, source, &block if source
+    end
+
+    def set key, value = nil, &block
+      value ||= source[key] || source[key.intern]
+
+      return if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+      block ? block[value] : target.send("#{key}=", value)
+    end
+
+    module Helpers
+
+      # Call `ctor.new` to create a new model object, then populate,
+      # save, and JSONify as in `update`.
+
+      def create ctor, &block
+        obj = populate ctor.new, &block
+        obj.save!
+
+        halt 201, json(obj)
+      end
+
+      # Use a populator to assign values from `params` to `obj`,
+      # returning it when finished. `&block` is passed a populator
+      # instance.
+
+      def populate obj, &block
+        Populator.new(obj, params, &block).target
+      end
+
+      # Populate (see `populate`) an `obj` with `params` data, saving
+      # when finished. Returns JSON for `obj`.
+
+      def update obj, &block
+        populate(obj, &block).save!
+        json obj
+      end
+    end
+  end
+end

data/lib/appetizer/rack/splash.rb

@@ -0,0 +1,29 @@
+module Appetizer
+  module Rack
+    class Splash
+      def initialize root = "public", glob = "**/*", &notfound
+        notfound ||= lambda { |env|
+          [404, { "Content-Type" => "text/plain" }, []]
+        }
+
+        urls = Dir[File.join root, glob].sort.
+          select { |f| File.file? f }.
+          map    { |f| f[root.length..-1] }
+
+        @static = ::Rack::Static.new notfound, root: root, urls: urls
+      end
+
+      def call env
+        if env["PATH_INFO"] == "/"
+          env["PATH_INFO"] = "/index.html"
+        end
+
+        @static.call env
+      end
+
+      def self.call env
+        new.call env
+      end
+    end
+  end
+end

data/lib/appetizer/rack.rb

@@ -0,0 +1,2 @@
+require "appetizer/init"
+require "appetizer/rack/splash"

data/lib/appetizer/rake.rb

@@ -0,0 +1,19 @@
+# Entry point for Rakefiles.
+
+require "appetizer/setup"
+
+# Tasks from Appetizer. Only the first level, since other requires
+# (like appetizer/rake/test) have their own tasks in subdirs.
+
+here = File.expand_path "..", __FILE__
+Dir["#{here}/tasks/*.rake"].sort.each { |f| App.load f }
+
+# Load test tasks if the app appears to use tests.
+
+if File.directory? "test"
+  Dir["#{here}/tasks/test/*.rake"].sort.each { |f| App.load f }
+end
+
+# Tasks from the app itself.
+
+Dir["lib/tasks/**/*.rake"].sort.each { |f| App.load f }

data/lib/appetizer/setup.rb

@@ -0,0 +1,101 @@
+$:.unshift File.expand_path "lib"
+
+require "appetizer/events"
+require "fileutils"
+require "logger"
+
+Encoding.default_external = Encoding::UTF_8
+Encoding.default_internal = Encoding::UTF_8
+
+module App
+  extend Appetizer::Events
+
+  def self.env
+    (ENV["RACK_ENV"] || ENV["RAILS_ENV"] || "development").intern
+  end
+
+  def self.development?
+    :development == env
+  end
+
+  def self.init!
+    return true if defined?(@initialized) && @initialized
+
+    fire :initializing
+
+    load "config/init.rb" if File.exists? "config/init.rb"
+    Dir["config/init/**/*.rb"].sort.each { |f| load f }
+
+    # If the app has an app/models directory, autorequire 'em.
+
+    if File.directory? "app/models"
+      $:.unshift File.expand_path "app/models"
+      Dir["app/models/**/*.rb"].sort.each { |f| require f[11..-4] }
+    end
+
+    fire :initialized
+
+    @initialized = true
+  end
+
+  def self.load file
+    now = Time.now.to_f if ENV["TRACE"]
+    Kernel.load file
+    p :load => { file => (Time.now.to_f - now) } if ENV["TRACE"]
+  end
+
+  def self.log
+    @log ||= Logger.new test? ? "tmp/test.log" : $stdout
+  end
+
+  def self.production?
+    :production == env
+  end
+
+  def self.require file
+    now = Time.now.to_f if ENV["TRACE"]
+    Kernel.require file
+    p :require => { file => (Time.now.to_f - now) } if ENV["TRACE"]
+  end
+
+  def self.test?
+    :test == env
+  end
+end
+
+# Set default log formatter and level. WARN for production, INFO
+# otherwise. Override severity with the `LOG_LEVEL` env
+# var. Formatter just prefixes with severity.
+
+App.log.formatter = lambda do |severity, time, program, message|
+  "[#{severity}] #{message}\n"
+end
+
+App.log.level = ENV["LOG_LEVEL"] ?
+  Logger.const_get(ENV["LOG_LEVEL"].upcase) :
+  App.production? ? Logger::WARN : Logger::INFO
+
+def (App.log).write message
+  self << message
+end
+
+# Make sure tmp exists, a bunch of things may use it.
+
+FileUtils.mkdir_p "tmp"
+
+# Load the global env files.
+
+App.load "config/env.local.rb" if File.exists? "config/env.local.rb"
+App.load "config/env.rb"       if File.exists? "config/env.rb"
+
+# Load the env-specific file.
+
+envfile = "config/env/#{App.env}.rb"
+load envfile if File.exists? envfile
+
+if defined? IRB
+  IRB.conf[:PROMPT_MODE] = :SIMPLE
+
+  App.require "appetizer/console"
+  App.init!
+end

data/lib/appetizer/tasks/console.rake

@@ -0,0 +1,5 @@
+desc "A REPL, run `reload!` to reload."
+task :console do
+  require "appetizer/console"
+  reload!
+end

data/lib/appetizer/tasks/init.rake

@@ -0,0 +1 @@
+task(:init) { App.init! }

data/lib/appetizer/tasks/test/test.rake

@@ -0,0 +1,12 @@
+desc "Run tests."
+task :test do
+  cmd = [
+         "ruby",
+         "-I", "lib:test",
+         "-e", "Dir['test/**/*_test.rb'].each { |f| load f }"
+        ]
+
+  exec *cmd
+end
+
+task :default => :test

data/lib/appetizer/test.rb

@@ -0,0 +1,43 @@
+ENV["RACK_ENV"] = ENV["RAILS_ENV"] = "test"
+
+require "minitest/autorun"
+
+module Appetizer
+  class Test < MiniTest::Unit::TestCase
+    def setup
+      self.class.setups.each { |s| instance_eval(&s) }
+    end
+
+    def teardown
+      self.class.teardowns.each { |t| instance_eval(&t) }
+    end
+
+    def self.setup &block
+      setups << block
+    end
+
+    def self.setups
+      @setups ||= (ancestors - [self]).
+        map { |a| a.respond_to?(:setups) && a.setups }.
+        select { |s| s }.
+        compact.flatten.reverse
+    end
+
+    def self.teardown &block
+      teardowns.unshift block
+    end
+
+    def self.teardowns
+      @teardowns ||= (ancestors - [self]).
+        map { |a| a.respond_to?(:teardowns) && a.teardowns }.
+        select { |t| t}.
+        compact.flatten
+    end
+
+    def self.test name, &block
+      define_method "test #{name}", &block
+    end
+  end
+end
+
+require "appetizer/init"

data/lib/appetizer.rb

@@ -0,0 +1 @@
+require "appetizer/setup"

data/test/appetizer/populator_test.rb

@@ -0,0 +1,77 @@
+require "appetizer/test"
+require "appetizer/populator"
+
+class Appetizer::PopulatorTest < Appetizer::Test
+  def test_initialize
+    p = Appetizer::Populator.new :target, :source
+
+    assert_equal :target, p.target
+    assert_equal :source, p.source
+  end
+
+  def test_nested
+    t2 = mock { expects(:bar=).with "baz" }
+
+    t = mock do
+      expects(:foo).returns t2
+    end
+
+    Appetizer::Populator.new t, foo: { bar: "baz" } do |p|
+      p.nested :foo do |p|
+        p.set :bar
+      end
+    end
+  end
+
+  def test_populate_target
+    t2 = mock { expects(:bar=).with "baz" }
+    t  = mock { expects(:foo).never }
+
+    Appetizer::Populator.new t, foo: { bar: "baz" } do |p|
+      p.populate :foo, t2 do |p|
+        p.set :bar
+      end
+    end
+  end
+
+  def test_set
+    t = mock { expects(:foo=).with("bar").twice }
+
+    Appetizer::Populator.new t, foo: "bar" do |p|
+      p.set :foo
+      p.set "foo"
+    end
+  end
+
+  def test_set_missing_source_value
+    t = mock { expects(:foo=).never }
+
+    Appetizer::Populator.new t, Hash.new do |p|
+      p.set :foo
+    end
+  end
+
+  def test_set_nil_source_value
+    t = mock { expects(:foo=).never }
+
+    Appetizer::Populator.new t, foo: nil do |p|
+      p.set :foo
+    end
+  end
+
+  def test_set_empty_source_value
+    t = mock { expects(:foo=).never }
+
+    Appetizer::Populator.new t, foo: "" do |p|
+      p.set :foo
+    end
+  end
+
+  def test_set_with_block
+    t = mock { expects(:foo=).with "BAR" }
+
+    Appetizer::Populator.new t, foo: "bar" do |p|
+      p.set(:foo) { |v| p.target.foo = v.upcase }
+    end
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: appetizer
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Audiosocket
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-10 00:00:00.000000000Z
+dependencies: []
+description: A lightweight init process for Rack apps.
+email:
+- tech@audiosocket.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- appetizer.gemspec
+- lib/appetizer.rb
+- lib/appetizer/console.rb
+- lib/appetizer/events.rb
+- lib/appetizer/init.rb
+- lib/appetizer/populator.rb
+- lib/appetizer/rack.rb
+- lib/appetizer/rack/splash.rb
+- lib/appetizer/rake.rb
+- lib/appetizer/setup.rb
+- lib/appetizer/tasks/console.rake
+- lib/appetizer/tasks/init.rake
+- lib/appetizer/tasks/test/test.rake
+- lib/appetizer/test.rb
+- test/appetizer/populator_test.rb
+homepage: https://github.com/audiosocket/appetizer
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Provides Railsish environments and initializers.
+test_files:
+- test/appetizer/populator_test.rb