prigner 0.1.0

data/lib/prigner/cli/list.rb

@@ -0,0 +1,54 @@
+# Copyright (c) 2010 Codigorama, Hallison Batista
+
+require "prigner"
+
+program = :prign
+command = File.basename(__FILE__, ".rb")
+@options = {}
+
+def templates_by_namespace(indent)
+  templates = Prigner::Template.all
+  message = []
+  templates.map do |namespace, list|
+    message << "* #{namespace}"
+    list.map do |template|
+      message << ("#{indent}> %-16s %s" % [template.name, template.spec.description])
+    end
+  end
+  message.join("\n")
+end
+
+def show(message)
+  puts "#{Prigner::Version}"
+  puts "\n#{message}"
+end
+
+begin
+
+ARGV.options do |arguments|
+
+  arguments.summary_indent = "  "
+  arguments.summary_width  = 24
+  arguments.banner = <<-end_banner.gsub /^[ ]{4}/, ''
+    #{Prigner::Version}
+
+    List all templates.
+
+    Usage:
+      #{program} #{command}
+
+  end_banner
+
+  if ARGV.empty?
+    show(templates_by_namespace(arguments.summary_indent))
+    exit 0
+  else
+    arguments.parse!
+  end
+end
+
+rescue => error
+  puts "#{program}: #{command}: #{error.message} (#{error.class})"
+  exit 1
+end
+

data/lib/prigner/cli/new.rb

@@ -0,0 +1,96 @@
+# Copyright (c) 2010 Hallison Batista
+
+require "prigner"
+
+program = :prign
+command = File.basename(__FILE__, ".rb")
+
+begin
+  ARGV.options do |arguments|
+
+    arguments.summary_indent = "  "
+    arguments.summary_width  = 24
+    arguments.banner = <<-end_banner.gsub /^[ ]{6}/, ''
+      #{Prigner::Version}
+
+      Usage:
+        #{program} #{command} <namespace>[:template] <path> [options]
+
+      Templates:
+        #{Prigner::CLI.templates.sort.join("\n" + arguments.summary_indent)}
+
+    end_banner
+
+    unless ARGV.empty?
+      name  = ARGV.shift
+      path  = ARGV.shift unless name.nil?
+
+      template = Prigner::Template.load(*name.split(":"))
+
+      if template
+        arguments.banner = <<-end_banner.gsub /^[ ]{10}/, ''
+          #{Prigner::Version}
+
+          Usage:
+            #{program} #{command} #{template.mask} <path> [options]
+
+        end_banner
+
+        if template.options
+          arguments.separator "Options:"
+
+          template.options.members.map do |name|
+            option = template.options[name]
+            arguments.on("-#{name[0..0]}", "--#{name}", nil, option.description) do
+              option.enabled = true
+            end
+          end
+        end
+
+      else
+        raise RuntimeError, "unable to load template '#{name}'"
+      end
+    end
+
+    unless path
+      puts arguments
+      exit 0
+    end
+
+    arguments.parse!
+
+    project = Prigner::Project.new(path)
+    builder = Prigner::Builder.new(project, template)
+
+    status = Prigner::CLI::Status.new
+
+    status.setup do
+      state :success, :created
+      state :failure, :fail
+      state :error,   :error
+      format :title, "\n* %-74s"
+      format :info,  "  %-69s [%7s]"
+    end
+
+    puts Prigner::Version
+
+    status.start "Creating project path" do
+      builder.make_project_path
+    end
+
+    status.start "Creating directories" do
+      builder.make_project_directories
+    end
+
+    status.start "Writing files" do
+      builder.make_project_files
+    end
+
+  end
+
+rescue => error
+  puts "#{program}: #{command}: #{error.message} (#{error.class})"
+  puts "Try '#{program} #{command} -h' or '#{program} #{command} --help' for more information."
+  exit 1
+end
+

data/lib/prigner/cli.rb

@@ -0,0 +1,102 @@
+# == Command-Line Interface
+#
+# This module look a command placed in CLI directory and run it.
+module Prigner::CLI
+
+  require "rbconfig"
+
+  # Ruby VM installed in OS.
+  def self.ruby
+    File.join(*::RbConfig::CONFIG.values_at("bindir", "ruby_install_name")) +
+    ::RbConfig::CONFIG["EXEEXT"]
+  end
+
+  # The CLI path.
+  def self.path
+    "#{Prigner::ROOT}/lib/prigner/cli"
+  end
+
+  # List all templates as commands.
+  def self.templates
+    Prigner::Template.all.map do |namespace, templates|
+      templates.map{ |template| template.mask }
+    end.flatten
+  end
+
+  # List of commands placed in <tt>lib/prigner/cli/</tt>.
+  def self.commands
+    Dir["#{path}/*.rb"].map do |source|
+      File.basename(source, ".rb")
+    end.sort
+  end
+
+  # Source command placed in CLI directory.
+  def self.source(command)
+    "#{path}/#{command}.rb"
+  end
+
+  # Look command in *CLI* directory and execute (by exec).
+  def self.run(*args)
+    command = args.shift if commands.include? args.first
+    raise RuntimeError, "unknown command '#{args.first}'" unless command
+    rubyopt = "-I#{Prigner::ROOT}/lib"
+    exec ruby, rubyopt, source(command), *args
+  end
+
+  class Status
+
+    attr_reader :formats
+
+    attr_reader :count
+
+    attr_reader :states
+
+    attr_reader :current
+
+    def initialize
+      @states = {
+        :success => :done,
+        :failure => :fail,
+        :error   => :err
+      }
+      @formats = {
+        :title => "\n* %-74s",
+        :info  => "\n  %-70s [%4s]"
+      }
+      @count = {}
+      @states.keys.each{|k| @count[k] = 0 }
+    end
+
+    def setup(&block)
+      instance_eval(&block)
+    end
+
+    def state(key, value)
+      return unless @states.has_key?key
+      @states[key] = value
+      @count[key] = 0
+    end
+
+    def format(key, format)
+      @formats[key] = "#{format}\n" if @formats.has_key?key
+    end
+
+    def increment!
+      @count[@current] += 1
+    end
+
+    def start(title, &block)
+      printf @formats[:title], title
+      hash = yield block
+      hash.each do |message, status|
+        @current = status ? :success : :failure
+        printf @formats[:info], message, @states[@current]
+        increment!
+      end
+    end
+
+  end
+
+end
+
+

data/lib/prigner/extensions.rb

@@ -0,0 +1,67 @@
+class Symbol
+
+  # Method for comparison between symbols.
+  def <=>(other)
+    self.to_s <=> other.to_s
+  end
+
+end
+
+class Hash
+
+  alias has? has_key?
+
+  # Only symbolize all keys, including all key in sub-hashes. 
+  def symbolize_keys
+    return self.clone if self.empty?
+    self.inject({}) do |hash, (key, value)|
+      hash[key.to_sym] = if value.kind_of? Hash
+                           value.symbolize_keys
+                         else
+                           value
+                         end
+      hash
+    end
+  end
+
+  # Set instance variables by key and value only if object respond
+  # to access method for variable.
+  def instance_variables_set_to(object)
+    collect do |variable, value|
+      object.instance_variable_set("@#{variable}", value) if object.respond_to? variable
+    end
+    object
+  end
+
+  # Convert to Struct including all values that are Hash class.
+  def to_struct
+    keys    = self.keys.sort
+    members = keys.map{ |key| key.to_sym }
+    Struct.new(*members).new(*keys.map do |key|
+      if self[key].kind_of? Hash
+        self[key].to_struct
+      else
+        self[key]
+      end
+    end) unless self.empty?
+  end
+
+end
+
+class Struct
+
+  # Public bind.
+  def binding
+    super
+  end
+
+end
+
+class Pathname
+
+  def chpath(source, path)
+    self.path.gsub(%r{#{source}}, path).to_path
+  end
+
+end
+

data/lib/prigner/model.rb

@@ -0,0 +1,97 @@
+# == Model
+#
+# This class implements several methods for load a model file of template.
+# 
+# Basically behaviour as parser based in a ERB file placed in +models+
+# directory of a Template.
+#
+# Example:
+#
+#   # model: jedi/knight
+#   class <%=name.capitalize%>
+#   <%for attribute in attributes%>
+#     attr_accessor :<%=attribute%>
+#   <%end%>
+#     def initialize(<%=attributes.join(",")%>)
+#     <%for attribute in attributes%>
+#       @<%=attribute%> = <%attribute%>
+#     <%end%>
+#     end
+#
+#     def to_s
+#     <%for attribute in attributes%>
+#       "\n<%=attribute.capitalize%>: #{<%=attribute%>}"
+#     <%end%>
+#     end
+#   end
+#
+#   <%=name%> = <%=name.capitalize%>.new("Yoda", "Jedi Grand Master")
+#   # end model
+#
+#   $> model = Pringer::Model.new "jedi/knight", {
+#        :name       => "knight",
+#        :attributes => [ :name, :position ]
+#      }
+#   $> model.build!
+#   $> model.contents
+#   => class Knight
+#   => 
+#   =>   attr_accessor :name
+#   =>   attr_accessor :position
+#   => 
+#   =>   def initialize(name,position)
+#   =>
+#   =>     @name = name
+#   =>     @position = position
+#   =>
+#   =>   end
+#   =>
+#   =>   def to_s
+#   =>
+#   =>     "\nName: #{name}"
+#   =>     "\nPosition: #{position}"
+#   =>
+#   =>   end
+#   => end
+#   =>
+#   => knight = Knight.new("Yoda", "Jedi Grand Master")
+#
+class Prigner::Model
+
+  # Model path file.
+  attr_reader :path
+
+  # Parsed contents.
+  attr_reader :contents
+
+  # Value bindings.
+  attr_accessor :binder
+
+  # Result file written
+  attr_reader :file_written
+
+  # Initializes a model passing all attributes by Hash.
+  def initialize(path, binder = {})
+    @path   = Pathname.new(path)
+    @binder = (binder.kind_of? Hash) ? binder.to_struct : binder
+  end
+
+  # Build model contents.
+  def build!
+    require "erb"
+    @contents = ::ERB.new(@path.read).result(binder.binding)
+  end
+
+  # Write contents into file.
+  def write(file)
+    @file_written = file
+    file = Pathname.new(file)
+    file.dirname.mkpath
+    file.open "w+" do |output|
+      output << self.build!
+    end
+    self
+  end
+
+end
+

data/lib/prigner/project.rb

@@ -0,0 +1,71 @@
+# == Project
+#
+# This class is a simple implementation of a tree of directories. It is used
+# in model files.
+class Prigner::Project
+
+  # Project name.
+  attr_reader :name
+
+  alias project name
+
+  # Project files.
+  attr_reader :path
+
+  # Project timestamp
+  attr_reader :timestamp
+
+  # Initialize a new project directory path.
+  def initialize(path)
+    @path = File.expand_path(path =~ /^\/.*/ ? path : "#{Dir.pwd}/#{path}")
+    @name = File.basename(@path)
+    @timestamp = DateTime.now
+  end
+
+  def name_splited
+    @name.split(/[-_]/)
+  end
+
+  def namespace(joiner = "::")
+    name_splited.join(joiner)
+  end
+
+  def upper_camel_case_namespace(joiner = "::")
+    name_splited.map{ |str| str.capitalize }.join(joiner)
+  end
+
+  def lower_camel_case_namespace(joiner = "::")
+    return name if name_splited.size == 0
+    name_splited[1..-1].map do |str|
+      str.capitalize
+    end.unshift(name_splited.first).join(joiner)
+  end
+
+  def upper_case_namespace(joiner = "::")
+    upper_camel_case_namespace(joiner).upcase
+  end
+
+  def lower_case_namespace(joiner = "::")
+    upper_camel_case_namespace(joiner).downcase
+  end
+
+  def upper_camel_case_name
+    upper_camel_case_namespace(nil)
+  end
+
+  alias class_name upper_camel_case_name
+
+  def lower_camel_case_name
+    lower_camel_case_namespace(nil)
+  end
+
+  def user
+    Etc.getpwnam(Etc.getlogin)
+  end
+
+  def author
+    self.user.gecos.split(",").first
+  end
+
+end # Project
+

data/lib/prigner/template.rb

@@ -0,0 +1,148 @@
+# == Project Template
+#
+# This class implements several methods for load a template for a new project.
+# Basically, a template is based in an YAML file for +specfile+ and a directory
+# containing all files to be parsed. 
+#
+# The template tree is based in following structure:
+#
+#   namespace
+#   `-- template
+#       |-- models
+#       `-- specfile
+# 
+# See Spec class for more information about mandatory attributes for draw your
+# project using +specfile+.
+class Prigner::Template
+
+  # Namespace of template.
+  attr_reader :namespace
+
+  # Name of template.
+  attr_reader :name
+
+  # List of models.
+  attr_reader :models
+
+  # List of directories that will created in project tree.
+  attr_reader :directories
+
+  # List of options (see Spec#options).
+  attr_reader :options
+
+  # Path to template.
+  attr_reader :path
+
+  # Specifications
+  attr_reader :spec
+
+  # Initialize a template using a path.
+  #
+  # Example:
+  #
+  #   template = Prigner::Template.new "path/to/template"
+  #
+  # The template initialization will search the +specfile+ in path passed as
+  # argument (<tt>path/to/template/specfile</tt>) for Spec attributes.
+  def initialize(path)
+    @path      = Pathname.new(path).tap{ |check| check.stat }
+    @namespace = @path.parent.basename.to_s
+    @name      = @path.basename.to_s
+    initialize_specfile
+    initialize_options
+    initialize_directories
+    initialize_models
+  rescue Exception => error
+    raise RuntimeError, error.message
+  end
+
+  # Mask for presentation of template.
+  def mask
+    @name == "default" ? @namespace : "#{@namespace}:#{@name}"
+  end
+
+  # Load template from shared directories. The shared path set the home user
+  # directory and Prigner::Template shared files.
+  def self.load(namespace, template = :default)
+    shared_path.map do |source|
+      path = "#{source}/#{namespace}/#{template}"
+      return new(path) if File.exist? path
+    end
+    nil
+  end
+
+  # Look at user home and template shared path.
+  def self.shared_path
+    user_home_templates = File.join(user_home_basedir, "templates")
+    [ user_home_templates, "#{Prigner::ROOT}/share/templates" ]
+  end
+
+  # User home.
+  def self.user_home
+    File.expand_path "~"
+  rescue
+    if File::ALT_SEPARATOR then
+      "C:/"
+    else
+      "/"
+    end
+  end
+
+  # User home base directory for Prigner files.
+  def self.user_home_basedir
+    File.join(user_home, ".prigner")
+  end
+
+  # Return all template paths placed in shared user or in project base
+  # directory.
+  def self.all_template_paths
+    shared_path.map do |source|
+      Dir.glob("#{source}/*/*")
+    end.flatten.compact
+  end
+
+  # All templates grouped by namespace.
+  def self.all
+    all_template_paths.map do |path|
+      new(path)
+    end.inject({}) do |group, template|
+      group[template.namespace] ||= []
+      group[template.namespace] << template
+      group
+    end
+  end
+
+  private
+
+  # Return the specfile placed in template path.
+  def specfile
+    Dir["#{@path}/[Ss]pecfile"].first
+  end
+
+  # Load +specfile+ placed in template path.
+  def initialize_specfile
+    @spec = Prigner::Spec.load(specfile)
+  end
+
+  # Initialize options.
+  def initialize_options
+    @options = @spec.options.inject({}) do |options, (name, desc)|
+      options[name] = { :enabled => nil, :description => desc }
+      options
+    end.to_struct if @spec.options
+  end
+
+  def initialize_directories
+    @directories = @spec.directories
+  end
+
+  def initialize_models
+    @models = @spec.files.inject({}) do |models, (source, file)|
+      model = Prigner::Model.new(@path.join("models", source))
+      models[model] = file ? file : source
+      models
+    end if @spec.files
+  end
+
+end
+