apimaster 0.0.1 → 0.0.2

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Admaster Inc
+
+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.md

@@ -0,0 +1,12 @@
+API Master
+==========
+
+A simple restful api framework the provides a gem that...
+
+Developing
+----------
+
+    % gem install apimaster
+    % mkdir your_app_name & cd your_app_name
+    % apimaster install your_app_name
+    % bundle install

data/apimaster.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |s|
+  s.name        = 'apimaster'
+  s.version     = '0.0.2'
+  s.date        = '2012-07-06'
+  s.summary     = "ApiMaster!"
+  s.description = "A simple restful api framework."
+  s.authors     = ["Sun", "Zhang", "Li"]
+  s.email       = 'sunxiqiu@admaster.com.cn'
+  s.files       = Dir['{bin/*,lib/**/*, test/*}'] +
+                  %w(LICENSE README.md apimaster.gemspec)
+  s.homepage    = 'http://rubygems.org/gems/apimaster'
+  s.executables << 'apimaster'
+  #s.add_dependency "erb"
+end

data/bin/apimaster

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'apimaster/generators/scripts'
+
+Apimaster::Generators::Scripts::Base.new.run(ARGV)

data/lib/apimaster.rb

@@ -1 +1,22 @@
+# encoding: utf-8
+#
+# Copyright (C) 2011-2012  AdMaster, Inc.
 
+module Apimaster end
+module Apimaster::Helpers end
+module Apimaster::Controllers end
+module Apimaster::Models end
+
+require_relative './apimaster/setting'
+require_relative './apimaster/error'
+require_relative './apimaster/mapper'
+
+require_relative './apimaster/helpers/headers.rb'
+require_relative './apimaster/helpers/request.rb'
+require_relative './apimaster/helpers/session.rb'
+
+require_relative './apimaster/models/user.rb'
+require_relative './apimaster/models/user_mock.rb'
+
+require_relative './apimaster/controllers/errors.rb'
+require_relative './apimaster/application'

data/lib/apimaster/application.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+#
+# Copyright (C) 2011-2012  AdMaster, Inc.
+
+module Apimaster
+  class Application < Sinatra::Base
+
+    # Helpers
+    superclass.helpers Sinatra::JSON
+    superclass.helpers Apimaster::Helpers::Request
+    superclass.helpers Apimaster::Helpers::Headers
+    superclass.helpers Apimaster::Helpers::Session
+
+    superclass.configure :development do
+      superclass.register Sinatra::Reloader
+      superclass.also_reload "./app/{controllers,models,helpers}/**/*.rb"
+    end
+
+    superclass.configure do
+      superclass.set :root, ::File.expand_path(".")
+      superclass.set :json_encoder, :to_json
+      superclass.set :show_exceptions, false
+    end
+
+    use Apimaster::Controllers::Errors
+
+  end
+end

data/lib/apimaster/controllers/errors.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+#
+# Copyright (C) 2011-2012  AdMaster, Inc.
+
+module Apimaster::Controllers
+
+  class Errors < Sinatra::Base
+
+    superclass.error Apimaster::NormalError do
+      e = env['sinatra.error']
+      error = [:resource, :code, :field].inject({}) do |err, val|
+        if e.respond_to?(val) and v = e.send(val)
+          err[val] = v
+        end
+        err
+      end
+
+      messages = {:message => e.message}
+      messages[:errors] = [error] unless error.empty?
+      json messages
+    end
+
+    superclass.error do
+      raise env['sinatra.error'] if development?
+      json :message => "Internal Server Error"
+    end
+
+    not_found do
+      json message: "Not Found"
+    end
+
+  end
+end
+

data/lib/apimaster/error.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+#
+# Copyright (C) 2011-2012  AdMaster, Inc.
+#
+# @author: sunxiqiu@admaster.com.cn
+
+module Apimaster
+
+  class NormalError < StandardError
+    attr_reader :code
+    attr_reader :error
+    attr_reader :resource
+    attr_reader :field
+
+    # error :missing, :missing_field, :invalid, :already_exists
+    def initialize(message = '', code = nil, error = :invalid, resource = nil, field = nil)
+      @code = code
+      @error = error.to_sym
+      @resource = resource
+      @field = field
+      super(message)
+    end
+  end
+
+  class MissingError < NormalError
+    def initialize(resource = nil)
+      super("Resource '#{resource}' does not exist.", 404, :missing, resource)
+    end
+  end
+
+  class MissingFieldError < NormalError
+    def initialize(resource = nil, field = nil)
+      super("Required field '#{field}' on a resource '#{resource}' has not been set.", 422, :missing_field, resource, field)
+    end
+  end
+
+  class InvalidFieldError < NormalError
+    def initialize(resource = nil, field = nil)
+      super("The formatting of the field '#{field}' on a resource '#{resource}' is invalid.", 422, :invalid, resource, field)
+    end
+  end
+
+  class AlreadyExistsError < NormalError
+    def initialize(resource = nil, field = nil)
+      super("Another resource '#{resource}' has the same value as this field '#{field}'. ", 409, :already_exists, resource, field)
+    end
+  end
+
+  class RelationExistsError < NormalError
+    def initialize(resource = nil, field = nil)
+      super("Our results indicate a positive relationship exists.", 409, :relation_exists, resource, field)
+    end
+  end
+
+  class RequestError < StandardError
+    def initialize(resource = nil, field = nil)
+      super("Problems parsing JSON.", 400, :parse_error, resource, field)
+    end
+  end
+
+  class UnauthorizedError < NormalError
+    def initialize(resource = nil, field = nil)
+      super("Your authorization token were invalid.", 401, :unauthorized, resource, field)
+    end
+  end
+
+  class PermissionDeniedError < NormalError
+    def initialize(resource = nil, field = nil)
+      super("Permission denied to access resource '#{resource}'.", 403, :forbidden, resource, field)
+    end
+  end
+
+  class OauthError < NormalError
+    def initialize(message)
+      super(message, 422, :oauth_error)
+    end
+  end
+
+end

data/lib/apimaster/generators/application.rb

@@ -0,0 +1,112 @@
+require 'rbconfig'
+
+module Apimaster::Generators
+  class Application < Create
+
+    DEFAULT_SHEBANG = File.join(RbConfig::CONFIG['bindir'],
+                                RbConfig::CONFIG['ruby_install_name'])
+
+    default_options   :shebang => DEFAULT_SHEBANG,
+                      :an_option => 'some_default'
+
+    attr_reader :app_name, :module_name
+
+    def initialize(runtime_args, runtime_options = {})
+      runtime_options[:source] = File.dirname(__FILE__) + '/templates'
+      runtime_options[:destination] = Dir.pwd
+      runtime_options[:collision] = :ask
+      runtime_options[:stdout] = STDOUT
+      super
+      usage if args.empty?
+      #@destination_root = args.shift
+      #@app_name     = File.basename(File.expand_path(@destination_root))
+      @app_name     = args[0]
+      raise 'Undefined app name.' unless @app_name
+      @module_name  = camelize(app_name)
+      extract_options
+    end
+
+    def manifest
+      record do |m|
+        # Ensure appropriate folder(s) exists
+        m.directory ''
+        BASEDIRS.each { |path| m.directory path }
+        m.directory "lib/#{app_name}"
+
+        # config
+        m.template "config/boot.rb.erb", "config/boot.rb"
+        m.template "config/patches.rb.erb", "config/patches.rb"
+        m.template "config/initializer.rb.erb", "config/initializer.rb"
+        m.template "config/application.rb.erb", "config/application.rb"
+        m.template "config/settings/mongoid.yml.erb", "config/settings/mongoid.yml"
+        m.template "config/settings/app.yml.erb", "config/settings/app.yml"
+        m.template "config/settings/oauth.yml.erb", "config/settings/oauth.yml"
+
+        # Create stubs
+        m.template "config.ru.erb", "config.ru"
+        m.template "gitignore", ".gitignore"
+        m.template "lib/module.rb.erb", "lib/#{app_name}.rb"
+        m.template "app/controllers/index_controller.rb.erb", "app/controllers/index_controller.rb"
+
+        # Test stubs
+        m.template "test/test_helper.rb.erb", "test/test_helper.rb"
+        m.template "test/functional_test.rb.erb", "test/functional/index_controller_test.rb"
+        m.template "test/unit_test.rb.erb", "test/unit/#{app_name}_test.rb"
+
+        %w(LICENSE Rakefile README.md Gemfile TODO).each do |file|
+          m.template file, file
+        end
+      end
+    end
+
+    protected
+      def banner
+        <<-EOS
+  Creates a Apimaster scaffold.
+
+  USAGE: apimaster new your_app_name"
+  EOS
+      end
+
+      def add_options!(opts)
+        opts.separator ''
+        opts.separator 'Options:'
+        # For each option below, place the default
+        # at the top of the file next to "default_options"
+        # opts.on("-a", "--author=\"Your Name\"", String,
+        #         "Some comment about this option",
+        #         "Default: none") { |x| options[:author] = x }
+        opts.on("-v", "--version", "Show the #{File.basename($0)} version number and quit.")
+      end
+
+      def extract_options
+        # for each option, extract it into a local variable (and create an "attr_reader :author" at the top)
+        # Templates can access these value via the attr_reader-generated methods, but not the
+        # raw instance variable value.
+        # @author = options[:author]
+      end
+
+      # Installation skeleton.  Intermediate directories are automatically
+      # created so don't sweat their absence here.
+      BASEDIRS = %w(
+        app
+        app/controllers
+        app/views
+        app/models
+        app/helpers
+        bin
+        config
+        config/settings
+        config/locales
+        doc
+        lib
+        log
+        test
+        test/unit
+        test/functional
+        test/factory
+        tmp
+        public
+      )
+  end
+end

data/lib/apimaster/generators/base.rb

@@ -0,0 +1,206 @@
+# Apimaster::Generators is a code generation platform Ruby frameworks.
+# Generators are easily invoked within Ruby framework instances
+# to add and remove components such as library and test files.
+#
+# New generators are easy to create and may be distributed within RubyGems,
+# user home directory, or within each Ruby framework that uses Apimaster::Generators.
+#
+# For example, newgem uses Apimaster::Generators to generate new RubyGems. Those
+# generated RubyGems can then use Apimaster::Generators (via a generated script/generate
+# application) to generate tests and executable apps, etc, for the RubyGem.
+#
+# Generators may subclass other generators to provide variations that
+# require little or no new logic but replace the template files.
+#
+# For a RubyGem, put your generator classes and templates within subfolders
+# of the +generators+ directory.
+#
+# The layout of generator files can be seen in the built-in
+# +test_unit+ generator:
+#
+#   test_unit_generators/
+#     test_unit/
+#       test_unit_generator.rb
+#       templates/
+#         test_unit.rb
+#
+# The directory name (+test_unit+) matches the name of the generator file
+# (test_unit_generator.rb) and class (+TestUnitGenerators+). The files
+# that will be copied or used as templates are stored in the +templates+
+# directory.
+#
+# The filenames of the templates don't matter, but choose something that
+# will be self-explanatory since you will be referencing these in the
+# +manifest+ method inside your generator subclass.
+#
+#
+module Apimaster::Generators
+  class GeneratorsError < StandardError; end
+  class UsageError < GeneratorsError; end
+
+
+  # The base code generator is bare-bones.  It sets up the source and
+  # destination paths and tells the logger whether to keep its trap shut.
+  #
+  # It's useful for copying files such as stylesheets, images, or
+  # javascripts.
+  #
+  # For more comprehensive template-based passive code generation with
+  # arguments, you'll want Apimaster::Generators::NamedBase.
+  #
+  # Generators create a manifest of the actions they perform then hand
+  # the manifest to a command which replays the actions to do the heavy
+  # lifting (such as checking for existing files or creating directories
+  # if needed). Create, destroy, and list commands are included.  Since a
+  # single manifest may be used by any command, creating new generators is
+  # as simple as writing some code templates and declaring what you'd like
+  # to do with them.
+  #
+  # The manifest method must be implemented by subclasses, returning a
+  # Apimaster::Generators::Manifest.  The +record+ method is provided as a
+  # convenience for manifest creation.  Example:
+  #
+  #   class StylesheetGenerators < Apimaster::Generators::Base
+  #     def manifest
+  #       record do |m|
+  #         m.directory('public/stylesheets')
+  #         m.file('application.css', 'public/stylesheets/application.css')
+  #       end
+  #     end
+  #   end
+  #
+  # See Apimaster::Generators::Commands::Create for a list of methods available
+  # to the manifest.
+  class Base
+    include Options
+
+    # Declare default options for the generator.  These options
+    # are inherited to subclasses.
+    default_options :collision => :ask, :quiet => false, :stdout => STDOUT
+
+    # A logger instance available everywhere in the generator.
+    attr_accessor :logger
+
+    # Either Apimaster::Generators::Base, or a subclass (e.g. Rails::Generators::Base)
+    # Currently used to determine the lookup paths via the overriden const_missing mechansim
+    # in lookup.rb
+    attr_accessor :active
+
+    # Every generator that is dynamically looked up is tagged with a
+    # Spec describing where it was found.
+    attr_accessor :spec
+    #class_attribute :spec
+
+    attr_reader :source_root, :destination_root, :args, :stdout
+
+    def initialize(runtime_args, runtime_options = {})
+      runtime_options[:backtrace] = true
+      @logger = SimpleLogger.new
+      @args = runtime_args
+      parse!(@args, runtime_options)
+
+      # Derive source and destination paths.
+      @source_root = options[:source] || File.join(spec.path, 'templates')
+      if options[:destination]
+        @destination_root = options[:destination]
+      end
+
+      # Silence the logger if requested.
+      #logger.quiet = options[:quiet]
+
+      @stdout = options[:stdout]
+
+      # Raise usage error if help is requested.
+      usage if options[:help]
+    end
+
+    # Generators must provide a manifest.  Use the +record+ method to create
+    # a new manifest and record your generator's actions.
+    def manifest
+      raise NotImplementedError, "No manifest for '#{spec.name}' generator."
+    end
+
+    # Return the full path from the source root for the given path.
+    # Example for source_root = '/source':
+    #   source_path('some/path.rb') == '/source/some/path.rb'
+    #
+    # The given path may include a colon ':' character to indicate that
+    # the file belongs to another generator.  This notation allows any
+    # generator to borrow files from another.  Example:
+    #   source_path('model:fixture.yml') = '/model/source/path/fixture.yml'
+    def source_path(relative_source)
+      # Check whether we're referring to another generator's file.
+      name, path = relative_source.split(':', 2)
+
+      # If not, return the full path to our source file.
+      if path.nil?
+        File.join(source_root, name)
+
+      # Otherwise, ask our referral for the file.
+      else
+        # FIXME: this is broken, though almost always true.  Others'
+        # source_root are not necessarily the templates dir.
+        File.join(self.class.lookup(name).path, 'templates', path)
+      end
+    end
+
+    # Return the full path from the destination root for the given path.
+    # Example for destination_root = '/dest':
+    #   destination_path('some/path.rb') == '/dest/some/path.rb'
+    def destination_path(relative_destination)
+      File.expand_path(File.join(destination_root, relative_destination))
+    end
+
+    # Return the basename of the destination_root,
+    # BUT, if it is trunk, tags, or branches, it continues to the
+    # parent path for the name
+    def base_name
+      name = File.basename(destination_root)
+      root = destination_root
+      while %w[trunk branches tags].include? name
+        root = File.expand_path(File.join(root, ".."))
+        name = File.basename(root)
+      end
+      name
+    end
+
+    def after_generate
+    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
+      # Look up generator instance and invoke command on it.
+      manifest.replay(self)
+      after_generate
+    rescue => e
+      puts e
+      puts "  #{e.backtrace.join("\n  ")}\n" if options[:backtrace]
+      raise SystemExit unless options[:no_exit]
+    end
+
+    def camelize(term, uppercase_first_letter = true)
+      string = term.to_s
+      string = string.sub(/^[a-z\d]*/) { $&.capitalize }
+      string.gsub(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }.gsub('/', '::')
+    end
+
+    protected
+      # Convenience method for generator subclasses to record a manifest.
+      def record
+        Apimaster::Generators::Manifest.new(self) { |m| yield m }
+      end
+
+      # Override with your own usage banner.
+      def banner
+        "Usage: #{$0} #{spec.name} [options]"
+      end
+
+      # Read USAGE from file in generator base path.
+      def usage_message
+        File.read(File.join(spec.path, 'USAGE')) rescue ''
+      end
+  end
+
+end