webbynode-blueprint 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Webbynode
+
+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.rdoc

@@ -0,0 +1,81 @@
+= blueprint
+
+Blueprint is a DSL that allows creating MyStacks and CommunityStacks to be deployed on Webbynode. 
+
+The current incarnation is to be considered early alpha, and only builds the Hash required to describe the components of the Stack.
+
+As code advances, this will become a full API for interacting with Webbynode and maintaining stacks.
+
+Before upcoming sections, kudos to Sean O'Halpin, the guy behind the ruby lib/gem {Doodle}[http://doodle.rubyforge.org/] for allowing me to use his Doodle::Util module on this. Thanks Sean!
+
+== Example
+
+Code of a blueprint will be something like this:
+
+	rails_rs = blueprint(:type => "readystack", :name => "rs.rails") do |f|
+	  # this blueprint delivers "rs.rails"
+	  f.provides "rs.rails"
+  
+	  # dependencies and order of execution -- top => bottom
+	  # apache2/ngnix, mysql/postgre, passenger/mongrel
+	  f.requires :group => "webservers", 
+	             :with => ["apache2", "nginx"]
+	  f.requires :group => "database",   
+	             :with => ["mysql-server", "postgresqlserver"]
+	  f.requires "rails"
+	  f.requires :group => "proxy",      
+	             :with => ["passenger", "mongrel_cluster"]
+  
+	  # attributes
+	  f.attributes :required => 'y'
+	  f.outputs    :installed_gems => "^Installed following gems: (.*)",
+	               :success_indicator => "^SUCCESS: (.*)"
+  
+	  # always installs rails
+	  f.dependency "rails", :render_as => "hidden"
+
+	  # gives two webserver/proxy combo options:
+	  # apache2 + passenger or nginx + mongrel
+	  f.parameter "webserver-proxy", :label => "WebServer and Proxy" do |p|
+	    p.attributes :required => "y"
+
+	    p.aggregate "Apache2 and Passenger", :render_as => "radio" do |agr|
+	      agr.dependency "apache2"
+	      agr.dependency "passenger"
+	    end
+    
+	    p.aggregate "Nginx and Mongrel Cluster", :render_as => "radio" do |agr|
+	      agr.dependency "nginx"
+	      agr.dependency "mongrel_cluster"
+	    end
+    
+	    # doesn't install webserver/proxy
+	    p.aggregate "No webserver & proxy", :render_as => "radio" do |agr|
+	      agr.parameter "-"
+	    end
+	  end
+  
+	  # database options: mysql or postgresql
+	  f.parameter "database-server", :label => "Database Server" do |p|
+	    p.attributes :required => "y"
+    
+	    p.dependency "mysql-server",     :label => "MySQL",      :render_as => "radio"
+	    p.dependency "postgresqlserver", :label => "PostgreSQL", :render_as => "radio"
+	    p.no_op      "No database server", :render_as => "radio"
+	  end
+  
+	  # list of gems
+	  f.aggregate "Additional Gems" do |agr|
+	    %w{will_paginate thoughtbot-paperclip 
+	      rspec authlogic hpricot capistrano}.each do |gem|
+        
+	        agr.parameter "gem_#{gem}", :label => gem, :render_as => "checkbox"
+        
+	    end
+	  end
+	end
+
+
+== Copyright
+
+Copyright (c) 2009 Webbynode. See LICENSE for details.

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 0
+:patch: 1
+:major: 0

data/lib/blueprint/blueprint.rb

@@ -0,0 +1,54 @@
+require "blueprint/components"
+require "blueprint/utils"
+require "yaml"
+
+class Blueprint
+  include Utils
+  include BlueprintComponents
+  
+  def initialize(blueprint_def)
+    @def = blueprint_def
+  end
+  
+  def provides(*args)
+    opts = args.last.is_a?(Hash) ? args.pop : nil
+    s = (@def[:content] = args.pop)
+    
+    if opts
+      @def.merge!(opts)
+      
+    else
+      @def[:script] = "#{s}.sh"
+      @def[:email] = "#{s}.markdown"
+      
+    end
+    
+    (errors ||= []) << "provides requires an argument" unless @def.has_key?(:email)
+    (errors ||= []) << "no email template found for #{@def[:content]}" unless @def.has_key?(:email)
+    (errors ||= []) << "no script found for #{@def[:content]}" unless @def.has_key?(:script)
+    
+    raise "Errors: #{errors * ", "}" if errors
+  end
+  
+  def requires(req)
+    if req.is_a?(Hash)
+      requirement_def = { :group => req[:group], :contains => req[:with] }
+    else
+      requirement_def = { :group => req, :contains => req }
+    end
+    
+    (@def[:dependencies] ||= []) << requirement_def
+  end
+  
+  def attributes(attrs)
+    @def[:attributes] = attrs
+  end
+  
+  def outputs(attrs)
+    @def[:output_params] = attrs
+  end
+  
+  def to_yaml
+    stringify_keys(@def, true).to_yaml
+  end
+end

data/lib/blueprint/components.rb

@@ -0,0 +1,104 @@
+require "blueprint/utils"
+
+module BlueprintComponents
+  class Component
+    class << self
+      attr_accessor :item_type
+      attr_accessor :block
+    end
+
+    def self.creates(*args, &block)
+      self.item_type = args.pop
+      if block_given?
+        self.block = block
+      end
+    end
+
+    def attributes(*args)
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+      @def.merge!(opts)
+    end
+
+    def initialize(*args)
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+      @def = { :item_type => self.class.item_type }.merge(opts)
+      if self.class.block
+        @def.merge!(self.class.block.call(args, opts))
+      end
+    end
+  end
+
+  class Value < Component
+    include BlueprintComponents
+
+    creates "value" do |args, opts|
+      { :content => args.pop }.merge(opts)
+    end
+  end
+
+  class Parameter < Component
+    include BlueprintComponents
+
+    def value(*args)
+      val = Value.new(*args)
+      unless val.definition[:label]
+        val.definition[:label] = val.definition[:content]
+      end
+      add_child val
+    end  
+
+    creates "param" do |args, opts|
+      { :content => args.pop }.merge(opts)
+    end
+  end
+
+  class Aggregate < Component
+    include BlueprintComponents
+
+    creates "aggregate" do |args, opts|
+      { :label => args.pop }.merge(opts)
+    end
+  end
+
+  class Dependency < Component
+    include BlueprintComponents
+
+    creates "dependency" do |args, opts|
+      { :content => args.pop }.merge(opts)
+    end
+  end
+
+  def parameter(*args, &block)
+    param = Parameter.new(*args)
+    yield param if block_given?
+    add_child param
+  end
+  
+  def dependency(*args, &block)
+    dep = Dependency.new(*args)
+    yield dep if block_given?
+    add_child dep
+  end
+  
+  def no_op(*args, &block)
+    opts = args.last.is_a?(Hash) ? args.pop : {}
+    dependency nil, { :label => args.pop }.merge(opts)
+  end
+  
+  def aggregate(*args, &block)
+    aggregate = Aggregate.new(*args)
+    yield aggregate if block_given?
+    add_child aggregate
+  end
+  
+  def definition
+    @def
+  end
+  
+  module_function
+  
+  def add_child(control)
+    (@def[:children] ||= []) << control.definition
+    control
+  end
+end

data/lib/blueprint/utils.rb

@@ -0,0 +1,172 @@
+# Shameless copy of Doodle::Utils (by Sean O'Halpin - http://doodle.rubyforge.org/)
+module Utils
+  module ClassMethods
+
+    # unnest arrays by one level of nesting, e.g. [1, [[2], 3]] =>
+    # [1, [2], 3].
+    def flatten_first_level(enum)
+      enum.inject([]) {|arr, i|
+        if i.kind_of?(Array)
+          arr.push(*i)
+        else
+          arr.push(i)
+        end
+      }
+    end
+
+    # convert a CamelCasedWord to a snake_cased_word
+    # based on version in facets/string/case.rb, line 80
+    def snake_case(camel_cased_word)
+      # if all caps, just downcase it
+      if camel_cased_word =~ /^[A-Z]+$/
+        camel_cased_word.downcase
+      else
+        camel_cased_word.to_s.gsub(/([A-Z]+)([A-Z])/,'\1_\2').gsub(/([a-z])([A-Z])/,'\1_\2').downcase
+      end
+    end
+    alias :snakecase :snake_case
+
+    # resolve a constant of the form Some::Class::Or::Module -
+    # doesn't work with constants defined in anonymous
+    # classes/modules
+    def const_resolve(constant)
+      constant.to_s.split(/::/).reject{|x| x.empty?}.inject(Object) { |prev, this| prev.const_get(this) }
+    end
+
+    # deep copy of object (unlike shallow copy dup or clone)
+    def deep_copy(obj)
+      Marshal.load(Marshal.dump(obj))
+    end
+
+    # normalize hash keys using method (e.g. +:to_sym+, +:to_s+)
+    #
+    # [+hash+] target hash to update
+    # [+recursive+] recurse into child hashes if +true+ (default is not to recurse)
+    # [+method+] method to apply to key (default is +:to_sym+)
+    def normalize_keys!(hash, recursive = false, method = :to_sym)
+      if hash.kind_of?(Hash)
+        hash.keys.each do |key|
+          normalized_key = key.respond_to?(method) ? key.send(method) : key
+          v = hash.delete(key)
+          if recursive
+            if v.kind_of?(Hash)
+              v = normalize_keys!(v, recursive, method)
+            elsif v.kind_of?(Array)
+              v = v.map{ |x| normalize_keys!(x, recursive, method) }
+            end
+          end
+          hash[normalized_key] = v
+        end
+      end
+      hash
+    end
+
+    # normalize hash keys using method (e.g. :to_sym, :to_s)
+    # - returns copy of hash
+    # - optionally recurse into child hashes
+    # see #normalize_keys! for details
+    def normalize_keys(hash, recursive = false, method = :to_sym)
+      if recursive
+        h = deep_copy(hash)
+      else
+        h = hash.dup
+      end
+      normalize_keys!(h, recursive, method)
+    end
+
+    # convert keys to symbols
+    # - updates target hash in place
+    # - optionally recurse into child hashes
+    def symbolize_keys!(hash, recursive = false)
+      normalize_keys!(hash, recursive, :to_sym)
+    end
+
+    # convert keys to symbols
+    # - returns copy of hash
+    # - optionally recurse into child hashes
+    def symbolize_keys(hash, recursive = false)
+      normalize_keys(hash, recursive, :to_sym)
+    end
+
+    # convert keys to strings
+    # - updates target hash in place
+    # - optionally recurse into child hashes
+    def stringify_keys!(hash, recursive = false)
+      normalize_keys!(hash, recursive, :to_s)
+    end
+
+    # convert keys to strings
+    # - returns copy of hash
+    # - optionally recurse into child hashes
+    def stringify_keys(hash, recursive = false)
+      normalize_keys(hash, recursive, :to_s)
+    end
+
+    # simple (!) pluralization - if you want fancier, override this method
+    def pluralize(string)
+      s = string.to_s
+      if s =~ /s$/
+        s + 'es'
+      else
+        s + 's'
+      end
+    end
+
+    # caller
+    def doodle_caller
+      if $DEBUG
+        caller
+      else
+        [caller[-1]]
+      end
+    end
+
+    # execute block - catch any exceptions and return as value
+    def try(&block)
+      begin
+        block.call
+      rescue Exception => e
+        e
+      end
+    end
+
+    # normalize a name to contain only those characters which are
+    # valid for a Ruby constant
+    def normalize_const(const)
+      const.to_s.gsub(/[^A-Za-z_0-9]/, '')
+    end
+
+    # lookup a constant along the module nesting path
+    def const_lookup(const, context = self)
+      #p [:const_lookup, const, context]
+      const = Utils.normalize_const(const)
+      result = nil
+      if !context.kind_of?(Module)
+        context = context.class
+      end
+      klasses = context.to_s.split(/::/)
+      #p klasses
+
+      path = []
+      0.upto(klasses.size - 1) do |i|
+        path << Doodle::Utils.const_resolve(klasses[0..i].join('::'))
+      end
+      path = (path.reverse + context.ancestors).flatten
+      #p [:const, context, path]
+      path.each do |ctx|
+        #p [:checking, ctx]
+        if ctx.const_defined?(const)
+          result = ctx.const_get(const)
+          break
+        end
+      end
+      if result.nil?
+        raise NameError, "Uninitialized constant #{const} in context #{context}"
+      else
+        result
+      end
+    end
+  end
+  extend ClassMethods
+  include ClassMethods
+end

data/lib/blueprint.rb

@@ -0,0 +1,14 @@
+require 'blueprint/blueprint'
+require 'blueprint/components'
+require 'blueprint/utils'
+
+def blueprint(*args, &block)
+  blueprint_def = args.last.is_a?(Hash) ? args.pop : {}
+  blueprint = Blueprint.new(blueprint_def)
+  
+  if block_given?
+    yield blueprint
+  end
+  
+  blueprint
+end

data/test/blueprint_test.rb

@@ -0,0 +1,113 @@
+require 'test_helper'
+
+class BlueprintTest < Test::Unit::TestCase
+  def rails_blueprint
+    blueprint(:type => "stack", :name => "rails") do |f|
+      f.provides "rails"
+
+      f.parameter "version", :label => "Rails Version", :render_as => "combobox" do |p|
+        p.value "2.3.2"
+        p.value "2.2.2"
+        p.value "2.1.2"
+      end
+
+      f.parameter "doc_rdoc", :label => "Install rdoc", :render_as => "checkbox"
+      f.parameter "doc_ri",   :label => "Install ri",   :render_as => "checkbox"
+
+      f.parameter "create-dummyapp", 
+        :label => "Create dummy app?", 
+        :render_as => "checkbox",
+        :attributes => {:default => "y"}
+      f.parameter "dummyapp-path", 
+        :label => "Path for dummy app",
+        :render_as => "text",
+        :attributes => {
+          "required"         => "y",
+          "default"          => "/var/rails",
+          "validation"       => "^((?:\/[a-zA-Z0-9]+(?:_[a-zA-Z0-9]+)*(?:\-[a-zA-Z0-9]+)*)+)$",
+          "validation_error" => "Use a valid path without an ending slash (ie, <code>/var/www</code>)"
+        }
+
+      f.parameter "dummyapp-database", 
+        :label => "Database for dummy app", 
+        :render_as => "combobox" do |p|
+
+          p.value "sqlite3", :label => "SQLite 3"
+          p.value "mysql", :label => "MySQL"
+          p.value "sqlite2", :label => "SQLite 2"
+          p.value "postgresql", :label => "PostgreSQL"
+
+      end
+    end
+  end
+  
+  def rails_readystack_blueprint
+    blueprint(:type => "readystack", :name => "rs.rails") do |f|
+      # this blueprint delivers "rs.rails"
+      f.provides "rs.rails"
+
+      # dependencies and order of execution -- top => bottom
+      # apache2/ngnix, mysql/postgre, passenger/mongrel
+      f.requires :group => "webservers", 
+                 :with => ["apache2", "nginx"]
+      f.requires :group => "database",   
+                 :with => ["mysql-server", "postgresqlserver"]
+      f.requires "rails"
+      f.requires :group => "proxy",      
+                 :with => ["passenger", "mongrel_cluster"]
+
+      # attributes
+      f.attributes :required => 'y'
+      f.outputs    :installed_gems => "^Installed following gems: (.*)",
+                   :success_indicator => "^SUCCESS: (.*)"
+
+      # always installs rails
+      f.dependency "rails", :render_as => "hidden"
+
+      # gives two webserver/proxy combo options:
+      # apache2 + passenger or nginx + mongrel
+      f.parameter "webserver-proxy", :label => "WebServer and Proxy" do |p|
+        p.attributes :required => "y"
+
+        p.aggregate "Apache2 and Passenger", :render_as => "radio" do |agr|
+          agr.dependency "apache2"
+          agr.dependency "passenger"
+        end
+
+        p.aggregate "Nginx and Mongrel Cluster", :render_as => "radio" do |agr|
+          agr.dependency "nginx"
+          agr.dependency "mongrel_cluster"
+        end
+
+        # doesn't install webserver/proxy
+        p.aggregate "No webserver & proxy", :render_as => "radio" do |agr|
+          agr.parameter "-"
+        end
+      end
+
+      # database options: mysql or postgresql
+      f.parameter "database-server", :label => "Database Server" do |p|
+        p.attributes :required => "y"
+
+        p.dependency "mysql-server",     :label => "MySQL",      :render_as => "radio"
+        p.dependency "postgresqlserver", :label => "PostgreSQL", :render_as => "radio"
+        p.no_op      "No database server", :render_as => "radio"
+      end
+
+      # list of gems
+      f.aggregate "Additional Gems" do |agr|
+        %w{will_paginate thoughtbot-paperclip 
+          rspec authlogic hpricot capistrano}.each do |gem|
+
+            agr.parameter "gem_#{gem}", :label => gem, :render_as => "checkbox"
+
+        end
+      end
+    end
+  end
+
+  should "probably rename this file and start testing for real" do
+    puts rails_blueprint.to_yaml
+    puts rails_readystack_blueprint.to_yaml
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'blueprint'
+
+class Test::Unit::TestCase
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: webbynode-blueprint
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Felipe Coury
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-29 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: felipe@webbynode.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE
+files: 
+- README.rdoc
+- VERSION.yml
+- lib/blueprint
+- lib/blueprint/blueprint.rb
+- lib/blueprint/components.rb
+- lib/blueprint/utils.rb
+- lib/blueprint.rb
+- test/blueprint_test.rb
+- test/test_helper.rb
+- LICENSE
+has_rdoc: true
+homepage: http://github.com/webbynode/blueprint
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+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: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Wanna build a stack? Give us the blueprint.
+test_files: []
+