wpb 0.0.3 → 0.0.5

data/lib/wpb.rb

@@ -7,41 +7,48 @@ require "wpb/post"
 require "wpb/comment"
 require "active_record"
 
-config = {
-	:adapter  => "mysql",
-	:socket   => "/Applications/MAMP/tmp/mysql/mysql.sock", #/tmp/mysql.sock
-	:host     => "localhost",
-	:username => "root",
-	:password => "root",
-	:database => "wordpress"
-}
+##
+# The wrapper for the wpb gem
 
-ActiveRecord::Base.establish_connection(config)
-
-class AddType < ActiveRecord::Migration
-	def self.up
-		suppress_messages do
-			unless column_exists? :wp_posts, :type
-				add_column :wp_posts, :type, :string
-				PagePost.reset_column_information
+module WPB
+	class AddType < ActiveRecord::Migration
+		def self.up
+			suppress_messages do
+				unless column_exists? :wp_posts, :type
+					add_column :wp_posts, :type, :string
+					PagePost.reset_column_information
+				end
 			end
 		end
+
+	  def self.down
+	    remove_column :wp_posts, :type
+	  end
 	end
 	
-  def self.down
-    remove_column :wp_posts, :type
-  end
-end
+	class App
+		def self.run
+	  	config = {
+				:adapter  => "mysql",
+				:socket   => "/Applications/MAMP/tmp/mysql/mysql.sock", #/tmp/mysql.sock
+				:host     => "localhost",
+				:username => "root",
+				:password => "root",
+				:database => "wordpress"
+			}
 
-AddType::up
-PagePost.all.each do |p|
-	p.type = p.post_type.capitalize
-	if p.post_type != "post" && p.post_type != "page"
-		p.type = "Post"
+			ActiveRecord::Base.establish_connection(config)
+
+			AddType::up
+			PagePost.all.each do |p|
+				p.type = p.post_type.capitalize
+				if p.post_type != "post" && p.post_type != "page"
+					p.type = "Post"
+				end
+				p.save
+			end
+	  end
 	end
-	p.save
 end
 
-module WPB
-  
-end
+WPB::App::run

data/lib/wpb/bash.rb

@@ -0,0 +1,18 @@
+require "wpb/clamp/command"
+
+class Bash < Clamp::Command
+	option ["-v", "--version"], :flag, "print version"
+	
+	def execute
+		if version?
+			require "wpb/version"
+			print "WordPress Bash #{WPB::VERSION} (c) James Birtles"
+		else
+			irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+			libs = " -r irb/completion"
+			libs << " -r #{File.expand_path('../../wpb.rb', __FILE__)}"
+			puts "Connecting to database..."
+			exec "#{irb} #{libs}"
+		end
+	end
+end

data/lib/wpb/clamp/attribute.rb

@@ -0,0 +1,37 @@
+module Clamp
+  
+  class Attribute
+
+    attr_reader :description, :attribute_name, :default_value
+
+    def help_rhs
+      rhs = description
+      if defined?(@default_value)
+        rhs += " (default: #{@default_value.inspect})"
+      end
+      rhs
+    end
+    
+    def help
+      [help_lhs, help_rhs]
+    end
+    
+    def ivar_name
+      "@#{attribute_name}"
+    end
+    
+    def read_method
+      attribute_name
+    end
+    
+    def default_method
+      "default_#{read_method}"
+    end
+    
+    def write_method
+      "#{attribute_name}="
+    end
+
+  end
+  
+end

data/lib/wpb/clamp/attribute_declaration.rb

@@ -0,0 +1,40 @@
+module Clamp
+  
+  module AttributeDeclaration
+
+    protected
+    
+    def define_accessors_for(attribute, &block)
+      define_reader_for(attribute)
+      define_default_for(attribute)
+      define_writer_for(attribute, &block)
+    end
+    
+    def define_reader_for(attribute)
+      define_method(attribute.read_method) do
+        if instance_variable_defined?(attribute.ivar_name)
+          instance_variable_get(attribute.ivar_name)
+        elsif respond_to?(attribute.default_method)
+          send(attribute.default_method)
+        end
+      end
+    end
+
+    def define_default_for(attribute)
+      define_method(attribute.default_method) do
+        attribute.default_value
+      end
+    end
+
+    def define_writer_for(attribute, &block)
+      define_method(attribute.write_method) do |value|
+        if block
+          value = instance_exec(value, &block)
+        end
+        instance_variable_set(attribute.ivar_name, value)
+      end
+    end
+
+  end
+  
+end

data/lib/wpb/clamp/command.rb

@@ -0,0 +1,137 @@
+require 'clamp/errors'
+require 'clamp/help'
+require 'clamp/option/declaration'
+require 'clamp/option/parsing'
+require 'clamp/parameter/declaration'
+require 'clamp/parameter/parsing'
+require 'clamp/subcommand/declaration'
+require 'clamp/subcommand/execution'
+
+module Clamp
+
+  # {Command} models a shell command.  Each command invocation is a new object.
+  # Command options and parameters are represented as attributes 
+  # (see {Command::Declaration}).
+  #
+  # The main entry-point is {#run}, which uses {#parse} to populate attributes based 
+  # on an array of command-line arguments, then calls {#execute} (which you provide)
+  # to make it go.
+  #
+  class Command
+
+    # Create a command execution.
+    #
+    # @param [String] invocation_path the path used to invoke the command
+    # @param [Hash] context additional data the command may need
+    #
+    def initialize(invocation_path, context = {})
+      @invocation_path = invocation_path
+      @context = context
+    end
+
+    # @return [String] the path used to invoke this command
+    #
+    attr_reader :invocation_path
+    
+    # @return [Array<String>] unconsumed command-line arguments
+    #
+    def remaining_arguments
+      @remaining_arguments
+    end
+
+    # Parse command-line arguments.
+    #
+    # @param [Array<String>] arguments command-line arguments
+    # @return [Array<String>] unconsumed arguments
+    #
+    def parse(arguments)
+      @remaining_arguments = arguments.dup
+      parse_options
+      parse_parameters
+      @remaining_arguments
+    end
+
+    # Run the command, with the specified arguments.
+    #
+    # This calls {#parse} to process the command-line arguments, 
+    # then delegates to {#execute}.
+    #
+    # @param [Array<String>] arguments command-line arguments
+    #
+    def run(arguments)
+      parse(arguments)
+      execute
+			execute_subcommands
+    end
+
+    # Execute the command (assuming that all options/parameters have been set).
+    # 
+    # This method is designed to be overridden in sub-classes.
+    #
+    def execute
+    	raise "you need to define #execute"
+    end
+
+		def execute_subcommands
+			if self.class.has_subcommands?
+        execute_subcommand
+			end
+		end
+
+    # @return [String] usage documentation for this command
+    #
+    def help
+      self.class.help(invocation_path)
+    end
+
+    include Clamp::Option::Parsing
+    include Clamp::Parameter::Parsing
+    include Clamp::Subcommand::Execution
+
+    protected
+    
+    attr_accessor :context
+
+    private
+
+    def signal_usage_error(message)
+      e = UsageError.new(message, self)
+      e.set_backtrace(caller)
+      raise e
+    end
+
+    def help_requested=(value)
+      raise Clamp::HelpWanted.new(self)
+    end
+
+    class << self
+
+      include Clamp::Option::Declaration
+      include Clamp::Parameter::Declaration
+      include Clamp::Subcommand::Declaration
+      include Help
+
+      # Create an instance of this command class, and run it.
+      #
+      # @param [String] invocation_path the path used to invoke the command
+      # @param [Array<String>] arguments command-line arguments
+      # @param [Hash] context additional data the command may need
+      # 
+      def run(invocation_path = File.basename($0), arguments = ARGV, context = {})
+        begin 
+          new(invocation_path, context).run(arguments)
+        rescue Clamp::UsageError => e
+          $stderr.puts "ERROR: #{e.message}"
+          $stderr.puts ""
+          $stderr.puts "See: '#{e.command.invocation_path} --help'"
+          exit(1)
+        rescue Clamp::HelpWanted => e
+          puts e.command.help
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/wpb/clamp/errors.rb

@@ -0,0 +1,26 @@
+module Clamp
+  
+  class Error < StandardError
+
+    def initialize(message, command)
+      super(message)
+      @command = command
+    end
+
+    attr_reader :command
+
+  end
+
+  # raise to signal incorrect command usage
+  class UsageError < Error; end
+
+  # raise to request usage help
+  class HelpWanted < Error
+
+    def initialize(command)
+      super("I need help", command)
+    end
+
+  end
+
+end

data/lib/wpb/clamp/help.rb

@@ -0,0 +1,69 @@
+require 'stringio'
+
+module Clamp
+
+  module Help
+
+    def usage(usage)
+      @declared_usage_descriptions ||= []
+      @declared_usage_descriptions << usage
+    end
+
+    attr_reader :declared_usage_descriptions
+
+    def description=(description)
+      @description = description.dup
+      if @description =~ /^\A\n*( +)/
+        indent = $1
+        @description.gsub!(/^#{indent}/, '')
+      end
+      @description.strip!
+    end
+    
+    attr_reader :description
+    
+    def derived_usage_description
+      parts = parameters.map { |a| a.name }
+      parts.unshift("[OPTIONS]") if has_options?
+      parts.join(" ")
+    end
+
+    def usage_descriptions
+      declared_usage_descriptions || [derived_usage_description]
+    end
+
+    def help(invocation_path)
+      help = StringIO.new
+      help.puts "Usage:"
+      usage_descriptions.each_with_index do |usage, i|
+        help.puts "    #{invocation_path} #{usage}".rstrip
+      end
+      if description
+        help.puts ""
+        help.puts description.gsub(/^/, "  ")
+      end
+      detail_format = "    %-29s %s"
+      if has_parameters?
+        help.puts "\nParameters:"
+        parameters.each do |parameter|
+          help.puts detail_format % parameter.help
+        end
+      end
+      if has_subcommands?
+        help.puts "\nSubcommands:"
+        recognised_subcommands.each do |subcommand|
+          help.puts detail_format % subcommand.help
+        end
+      end
+      if has_options?
+        help.puts "\nOptions:"
+        recognised_options.each do |option|
+          help.puts detail_format % option.help
+        end
+      end
+      help.string
+    end
+
+  end
+
+end

data/lib/wpb/clamp/option.rb

@@ -0,0 +1,77 @@
+require 'clamp/attribute'
+
+module Clamp
+
+  class Option < Attribute
+
+    def initialize(switches, type, description, options = {})
+      @switches = Array(switches)
+      @type = type
+      @description = description
+      if options.has_key?(:attribute_name)
+        @attribute_name = options[:attribute_name].to_s 
+      end
+      if options.has_key?(:default)
+        @default_value = options[:default]
+      end
+    end
+
+    attr_reader :switches, :type
+
+    def attribute_name
+      @attribute_name ||= long_switch.sub(/^--(\[no-\])?/, '').tr('-', '_')
+    end
+    
+    def long_switch
+      switches.find { |switch| switch =~ /^--/ }
+    end
+
+    def handles?(switch)
+      recognised_switches.member?(switch)
+    end
+
+    def flag?
+      @type == :flag
+    end
+    
+    def flag_value(switch)
+      !(switch =~ /^--no-(.*)/ && switches.member?("--\[no-\]#{$1}"))
+    end
+
+    def read_method
+      if flag?
+        super + "?"
+      else
+        super
+      end
+    end
+    
+    def extract_value(switch, arguments)
+      if flag?
+        flag_value(switch)
+      else
+        arguments.shift
+      end
+    end
+    
+    def help_lhs
+      lhs = switches.join(", ")
+      lhs += " " + type unless flag?
+      lhs
+    end
+
+    private
+
+    def recognised_switches
+      switches.map do |switch|
+        if switch =~ /^--\[no-\](.*)/
+          ["--#{$1}", "--no-#{$1}"]
+        else
+          switch
+        end
+      end.flatten
+    end
+    
+  end
+
+end