apimaster 0.0.1 → 0.0.2

data/lib/apimaster/generators/manifest.rb

@@ -0,0 +1,51 @@
+module Apimaster::Generators
+
+  # Manifest captures the actions a generator performs.  Instantiate
+  # a manifest with an optional target object, hammer it with actions,
+  # then replay or rewind on the object of your choice.
+  #
+  # Example:
+  #   manifest = Manifest.new { |m|
+  #     m.make_directory '/foo'
+  #     m.create_file '/foo/bar.txt'
+  #   }
+  #   manifest.replay(creator)
+  #   manifest.rewind(destroyer)
+  class Manifest
+    attr_reader :target
+
+    # Take a default action target.  Yield self if block given.
+    def initialize(target = nil)
+      @target, @actions = target, []
+      yield self if block_given?
+    end
+
+    # Record an action.
+    def method_missing(action, *args, &block)
+      @actions << [action, args, block]
+    end
+
+    # Replay recorded actions.
+    def replay(target = nil)
+      send_actions(target || @target, @actions)
+    end
+
+    # Rewind recorded actions.
+    def rewind(target = nil)
+      send_actions(target || @target, @actions.reverse)
+    end
+
+    # Erase recorded actions.
+    def erase
+      @actions = []
+    end
+
+    private
+      def send_actions(target, actions)
+        actions.each do |method, args, block|
+          target.send(method, *args, &block)
+        end
+      end
+  end
+
+end

data/lib/apimaster/generators/options.rb

@@ -0,0 +1,162 @@
+require 'optparse'
+
+module Apimaster::Generators
+  module Options
+    def self.included(base)
+      base.extend(ClassMethods)
+      class << base
+        if respond_to?(:inherited)
+          alias_method :inherited_without_options, :inherited
+        end
+        alias_method :inherited, :inherited_with_options
+      end
+    end
+
+    module ClassMethods
+
+      EMPTY_INHERITABLE_ATTRIBUTES = {}.freeze
+
+      def inherited_with_options(sub)
+        inherited_without_options(sub) if respond_to?(:inherited_without_options)
+        sub.extend(Apimaster::Generators::Options::ClassMethods)
+      end
+
+      def mandatory_options(options = nil)
+        if options
+          write_inheritable_attribute(:mandatory_options, options)
+        else
+          read_inheritable_attribute(:mandatory_options) or write_inheritable_attribute(:mandatory_options, {})
+        end
+      end
+
+      def default_options(options = nil)
+        if options
+          write_inheritable_attribute(:default_options, options)
+        else
+          read_inheritable_attribute(:default_options) or write_inheritable_attribute(:default_options, {})
+        end
+      end
+
+      def read_inheritable_attribute(key)
+        inheritable_attributes[key]
+      end
+
+      def write_inheritable_attribute(key, value)
+        if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+          @inheritable_attributes = {}
+        end
+        inheritable_attributes[key] = value
+      end
+
+      def inheritable_attributes
+        @inheritable_attributes ||= EMPTY_INHERITABLE_ATTRIBUTES
+      end
+
+      # Merge together our class options.  In increasing precedence:
+      #   default_options   (class default options)
+      #   runtime_options   (provided as argument)
+      #   mandatory_options (class mandatory options)
+      def full_options(runtime_options = {})
+        default_options.merge(runtime_options).merge(mandatory_options)
+      end
+
+    end
+
+    # Each instance has an options hash that's populated by #parse.
+    def options
+      @options ||= {}
+    end
+    attr_writer :options
+
+    protected
+      # Convenient access to class mandatory options.
+      def mandatory_options
+        self.class.mandatory_options
+      end
+
+      # Convenient access to class default options.
+      def default_options
+        self.class.default_options
+      end
+
+      # Merge together our instance options.  In increasing precedence:
+      #   default_options   (class default options)
+      #   options           (instance options)
+      #   runtime_options   (provided as argument)
+      #   mandatory_options (class mandatory options)
+      def full_options(runtime_options = {})
+        self.class.full_options(options.merge(runtime_options))
+      end
+
+      # Parse arguments into the options hash.  Classes may customize
+      # parsing behavior by overriding these methods:
+      #   #banner                 Usage: ./script/generate [options]
+      #   #add_options!           Options:
+      #                             some options..
+      #   #add_general_options!   General Options:
+      #                             general options..
+      def parse!(args, runtime_options = {})
+        self.options = {}
+
+        @option_parser = OptionParser.new do |opt|
+          opt.banner = banner
+          add_options!(opt)
+          add_general_options!(opt)
+          opt.parse!(args)
+        end
+
+        return args
+      ensure
+        self.options = full_options(runtime_options)
+      end
+
+      # Raise a usage error.  Override usage_message to provide a blurb
+      # after the option parser summary.
+      def usage(message = usage_message)
+        #raise UsageError, "#{@option_parser}\n#{message}"
+        puts "#{@option_parser}\n#{message}"
+      end
+
+      def usage_message
+        ''
+      end
+
+      # Override with your own usage banner.
+      def banner
+        "Usage: #{$0} [options]"
+      end
+
+      # Override to add your options to the parser:
+      #   def add_options!(opt)
+      #     opt.on('-v', '--verbose') { |value| options[:verbose] = value }
+      #   end
+      def add_options!(opt)
+      end
+
+      # Adds general options like -h and --quiet.  Usually don't override.
+      def add_general_options!(opt)
+        opt.separator 'General Options:'
+
+        opt.on('-h', '--help', 'Show this help message and quit.') { |v| options[:help] = v }
+        opt.on('-p', '--pretend', 'Run but do not make any changes.') { |v| options[:pretend] = v }
+        opt.on('-f', '--force', 'Overwrite files that already exist.') { options[:collision] = :force }
+        opt.on('-s', '--skip', 'Skip files that already exist.') { options[:collision] = :skip }
+        opt.on('-q', '--quiet', 'Suppress normal output.') { |v| options[:quiet] = v }
+        opt.on('-t', '--backtrace', 'Debugging: show backtrace on errors.') { |v| options[:backtrace] = v }
+        opt.on('-c', '--svn', 'Modify files with subversion. (Note: svn must be in path)') do
+          options[:svn] = `svn status`.inject({}) do |opt, e|
+            opt[e.chomp[7..-1]] = true
+            opt
+          end
+        end
+        opt.on('-g', '--git', 'Modify files with git. (Note: git must be in path)') do
+          options[:git] = `git status`.inject({:new => {}, :modified => {}}) do |opt, e|
+            opt[:new][e.chomp[14..-1]] = true if e =~ /new file:/
+            opt[:modified][e.chomp[14..-1]] = true if e =~ /modified:/
+            opt
+          end
+        end
+      end
+
+  end
+end

data/lib/apimaster/generators/scripts.rb

@@ -0,0 +1,64 @@
+
+module Apimaster end
+
+require File.dirname(__FILE__) + '/options'
+require File.dirname(__FILE__) + '/manifest'
+require File.dirname(__FILE__) + '/simple_logger'
+
+require File.dirname(__FILE__) + '/base'
+require File.dirname(__FILE__) + '/command'
+require File.dirname(__FILE__) + '/application'
+
+module Apimaster::Generators
+  module Scripts
+
+    # Generator scripts handle command-line invocation.  Each script
+    # responds to an invoke! class method which handles option parsing
+    # and generator invocation.
+    class Base
+      include Options
+
+      default_options :collision => :ask, :quiet => false
+
+      attr_reader :stdout
+      attr_accessor :commands
+
+      def initialize
+        @commands ||= {}
+        register("new", Application)
+      end
+
+      def register name, klass
+        @commands[name] = klass
+      end
+
+      # Run the generator script.  Takes an array of unparsed arguments
+      # and a hash of parsed arguments, takes the generator as an option
+      # or first remaining argument, and invokes the requested command.
+      def run(args = [], runtime_options = {})
+        @stdout = runtime_options[:stdout] || $stdout
+        begin
+          parse!(args.dup, runtime_options)
+        rescue OptionParser::InvalidOption => e
+          # Don't cry, script. Generators want what you think is invalid.
+        end
+
+        # Look up generator instance and invoke command on it.
+        if command = args.shift
+          raise "Invalid command name: #{command}" unless commands.key?(command)
+          commands[command].new(args).run
+        else
+          usage
+        end
+        end
+      rescue => e
+        stdout.puts e
+        stdout.puts "  #{e.backtrace.join("\n  ")}\n" if options[:backtrace]
+        raise SystemExit unless options[:no_exit]
+      end
+
+      def usage
+        stdout.puts "apimaster new your_app_name"
+      end
+  end
+end

data/lib/apimaster/generators/simple_logger.rb

@@ -0,0 +1,44 @@
+module Apimaster::Generators
+  class SimpleLogger # :nodoc:
+    attr_reader :out
+    attr_accessor :quiet
+
+    def initialize(out = $stdout)
+      @out = out
+      @quiet = false
+      @level = 0
+    end
+
+    def log(status, message, &block)
+      @out.print("%12s  %s%s\n" % [status, '  ' * @level, message]) unless quiet
+      indent(&block) if block_given?
+    end
+
+    def indent(&block)
+      @level += 1
+      if block_given?
+        begin
+          block.call
+        ensure
+          outdent
+        end
+      end
+    end
+
+    def outdent
+      @level -= 1
+      if block_given?
+        begin
+          block.call
+        ensure
+          indent
+        end
+      end
+    end
+
+    private
+      def method_missing(method, *args, &block)
+        log(method.to_s, args.first, &block)
+      end
+  end
+end

data/lib/apimaster/generators/templates/Gemfile

@@ -0,0 +1,21 @@
+#source :gemcutter
+source "https://rubygems.org"
+
+gem "sinatra"
+gem "sinatra-contrib"
+gem "thin"
+gem "json"
+gem "rake"
+gem "apimaster"
+
+group :development do
+end
+
+group :production do
+end
+
+group :test do
+  gem "sqlite3"
+  gem "rack-test"
+end
+

data/lib/apimaster/generators/templates/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) <%= Time.now.year %> YOUR NAME
+
+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/lib/apimaster/generators/templates/README.md

@@ -0,0 +1,10 @@
+<%= app_name %>
+<%= "=" * app_name.size %>
+
+A sinatra app the provides a gem that...
+
+Developing
+==========
+    % gem install bundler
+    % bundle install
+    % bundle exec rake

data/lib/apimaster/generators/templates/Rakefile

@@ -0,0 +1,19 @@
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'date'
+require 'bundler'
+
+task :default => [:spec]
+
+require 'spec/rake/spectask'
+desc "Run specs"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = %w(-fs --color)
+  t.spec_opts << '--loadby' << 'random'
+
+  t.rcov_opts << '--exclude' << 'spec,.bundle'
+  t.rcov = ENV.has_key?('NO_RCOV') ? ENV['NO_RCOV'] != 'true' : true
+  t.rcov_opts << '--text-summary'
+  t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
+end

data/lib/apimaster/generators/templates/TODO

@@ -0,0 +1,4 @@
+TODO:
+Fix LICENSE with your name
+Fix Rakefile with your name and contact info
+Add your code to lib/<%= app_name %>.rb

data/lib/apimaster/generators/templates/app/controllers/index_controller.rb.erb

@@ -0,0 +1,7 @@
+module <%= module_name %>
+  class IndexController < Sinatra::Base
+    get '/' do
+      json message: "Hello There, buddy!"
+    end
+  end
+end

data/lib/apimaster/generators/templates/config.ru.erb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+#
+# Copyright (C) 2011-2012  AdMaster, Inc.
+
+# This file is used by Rack-based servers to start the application.
+
+require "./config/boot"
+run <%= module_name %>::Application

data/lib/apimaster/generators/templates/config/application.rb.erb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+#
+# Copyright (C) 2011-2012  AdMaster, Inc.
+
+module <%= module_name %>
+  class Application < Sinatra::Base
+
+    use Apimaster::Application
+
+    before do
+      # authorize
+    end
+
+    # controllers
+    use IndexController
+    # use YourCountroller
+
+  end
+end

data/lib/apimaster/generators/templates/config/boot.rb.erb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+#
+# Copyright (C) 2011-2012  AdMaster, Inc.
+
+require "rubygems"
+require "bundler"
+require "cgi"
+
+require "./config/patches"
+require "./config/initializer"
+require "./lib/<%= app_name %>"
+
+Dir.glob "./app/{models,helpers,controllers}/**/*.rb" do |f|
+  require f
+end
+
+require "./config/application"