clone 1.0.0.beta → 1.0.0.beta2

data/samples/mongoid/init/lib/mongoid/dsl/init.rb

@@ -1,37 +0,0 @@
-def filling(hash)
-  if hash.class == Array
-    hash=Hash[*hash]
-  end
-
-  ### hash data converting
-  hash.each do |key,value|
-
-    case value.to_s.downcase
-
-      when "string"
-        hash[key]=RND.string(18,2)
-
-      when "date"
-        hash[key]=RND.date
-
-      when "datetime"
-        hash[key]=RND.datetime
-
-      when "time"
-        hash[key]=RND.time
-
-      when "integer","float"
-        hash[key]=RND.integer(11)
-
-      when "boolean"
-        hash[key]=RND.boolean
-
-      when "moped::bson::objectid","object"
-        hash.delete key
-
-    end
-
-  end
-
-  return hash
-end

data/samples/mongoid/init/lib/mongoid/dsl/params.rb

@@ -1,67 +0,0 @@
-class Hash
-  def find_hashize
-    return_hash = self
-    return_hash.delete 'route_info'
-    return_hash.delete 'method'
-    return_hash.delete 'path'
-
-    #%w[ id  ].each do |one_key|
-    #  if !return_hash[one_key].nil?
-    #    return_hash['_id']= return_hash[one_key]
-    #    return_hash.delete one_key
-    #  end
-    #end
-
-    return_hash.each do |key,value|
-      if value.class == String
-        return_hash[key]=value.duck
-      end
-    end
-
-    return_hash.each do |key,value|
-      if key.to_s == '_id'
-        return_hash[key]= Moped::BSON::ObjectId.from_string(value.to_s)
-      end
-    end
-
-
-    return return_hash
-  end
-  def new_hashize
-    return_hash = self
-    %w[route_info method path _id id parentid parent_id].each do |one_element|
-      return_hash.delete one_element
-    end
-    return_hash.each do |key,value|
-      if value.class == String
-        return_hash[key]=value.duck
-      end
-    end
-    return return_hash
-  end
-  def extraction_next_item(oth_str,offsets=2)
-    extracted_string= String.new
-    position_nmbr= 0
-    loop do
-      begin
-        new_indx= (self.inspect.positions(oth_str).last+offsets)+position_nmbr
-        new_element= self.inspect[new_indx]
-        if new_element == ' ' || new_element == ','
-          break
-        else
-          extracted_string+= new_element
-          position_nmbr+= 1
-        end
-      rescue Exception
-        break
-      end
-    end
-
-    if extracted_string.include?('(.:format)>')
-      index_nbr= extracted_string.length-1
-      extracted_string= extracted_string[0..(index_nbr-('(.:format)>'.length))]
-    end
-
-    return extracted_string
-  end
-end

data/samples/mongoid/init/lib/mongoid/meta/banned.rb

@@ -1,147 +0,0 @@
-module Mongoid
-  module Banned
-    class Elements
-      ### Elements        output Format: [*String]
-      @@elements_list ||= Array.new
-      class << self
-        def add(input)
-          case input.class.to_s.downcase
-            when "class"
-              @@elements_list.push input.to_s
-            when "string"
-              @@elements_list.push input
-            when "array"
-              input.each do |one_element|
-                @@elements_list.push one_element.to_s
-              end
-            else
-              @@elements_list.push input.to_s
-          end
-        end
-        def list
-          return @@elements_list
-        end
-      end
-    end
-    class ModelElements
-      ### modelElements   output Format: [*Class => String]
-      @@element_list ||= Array.new
-      class << self
-        def add(hash)
-
-          if hash.class == Array
-            hash= Hash[*hash]
-          end
-
-          tmp_array= Array.new
-          tmp_hash= Hash.new
-          hash.each do |key,value|
-            if key.class != Class
-              tmp_hash[key.to_s]= value
-            else
-              tmp_hash[key]= value
-            end
-          end
-          tmp_hash.each do |key,value|
-
-            case value.class.to_s.downcase
-
-              when "string"
-                tmp_array.push( { key => value })
-
-              when "array"
-                value.each do |one_element|
-                  tmp_array.push( {key => value.to_s})
-                end
-
-              else
-                tmp_array.push( {key => value.to_s})
-
-            end
-
-          end
-
-          tmp_array.each do |one_element|
-            @@element_list.push one_element
-          end
-        end
-        def list
-          return @@element_list
-        end
-      end
-    end
-    class Models
-      ### Models          output Format: [*Class]
-      @@model_list ||= Array.new
-      class << self
-        def add(input)
-          case input.class.to_s.downcase
-            when "class"
-              @@model_list.push input
-            when "string"
-              @@model_list.push input.to_s
-            when "array"
-              input.each do |one_element|
-                @@model_list.push one_element.to_s
-              end
-            else
-              @@model_list.push input.to_s
-          end
-        end
-        def list
-          return @@model_list
-        end
-      end
-    end
-    class ProtocolElements
-      ### Elements        output Format: [*String]
-      @@elements_list ||= Array.new
-      class << self
-        def add(input)
-          case input.class.to_s.downcase
-            when "class"
-              @@elements_list.push input.to_s
-            when "string"
-              @@elements_list.push input
-            when "array"
-              input.each do |one_element|
-                @@elements_list.push one_element.to_s
-              end
-            else
-              @@elements_list.push input.to_s
-          end
-        end
-        def list
-          return @@elements_list
-        end
-      end
-    end
-    class << self
-      def list
-        tmp_hash= Hash.new
-        tmp_hash[:Elements]= self::Elements.list
-        tmp_hash[:ModelElements]= self::ModelElements.list
-        tmp_hash[:Models]= self::Models.list
-        tmp_hash[:ProtocolElements]= self::ProtocolElements.list
-
-        return tmp_hash
-      end
-    end
-  end
-end
-
-begin
-  CONFIG.data['mongoid']['control']['banned'].each do |key,value|
-    case key.to_s.downcase
-      when "modelelements","model_elements","modelelement","model_element"
-        Mongoid::Banned::ModelElements.add value
-      when "elements","element"
-        Mongoid::Banned::Elements.add value
-      when "protocol","protocolelements"
-        Mongoid::Banned::ProtocolElements.add value
-      when "models","model"
-        Mongoid::Banned::Models.add value
-    end
-  end
-rescue Exception
-end

data/samples/mongoid/init/lib/mongoid/meta/control.yml

@@ -1,13 +0,0 @@
-banned:
-  Elements:
-    - test
-
-  Models:
-    - OUR::Test
-
-  ModelElements:
-    - OUR::Test: test
-  Protocol:
-    - route_info
-    - method
-    - path

data/samples/mongoid/init/lib/mongoid/meta/mpatch.rb

@@ -1,14 +0,0 @@
-module Mongoid
-  module Document
-
-    def self.included(base)
-      @classes ||= Array.new
-      @classes.push base.name
-    end
-
-    def self.classes
-      @classes
-    end
-
-  end
-end

data/samples/rack/init/lib/rack/meta/webserver/thin.rb

@@ -1,45 +0,0 @@
-require "yaml"
-THIN_CONFIG= YAML.load_file(File.expand_path(File.join(File.dirname(__FILE__),'thin.yml')))
-
-module Thin
-  class Server
-    def initialize(*args, &block)
-      host, port, options = DEFAULT_HOST, DEFAULT_PORT, {}
-
-      # Guess each parameter by its type so they can be
-      # received in any order.
-      args.each do |arg|
-        case arg
-          when Fixnum, /^\d+$/ then port    = arg.to_i
-          when String          then host    = arg
-          when Hash            then options = arg
-          else
-            @app = arg if arg.respond_to?(:call)
-        end
-      end
-
-      # Set tag if needed
-      self.tag = options[:tag]
-
-      # Try to intelligently select which backend to use.
-      @backend = select_backend(host, port, options)
-
-      load_cgi_multipart_eof_fix
-
-      @backend.server = self
-
-      # Set defaults
-      @backend.maximum_connections            = THIN_CONFIG['DEFAULT_MAXIMUM_CONNECTIONS'].to_i
-      @backend.maximum_persistent_connections = THIN_CONFIG['DEFAULT_MAXIMUM_PERSISTENT_CONNECTIONS'].to_i
-      @backend.timeout                        = THIN_CONFIG['DEFAULT_TIMEOUT'].to_i
-
-      # Allow using Rack builder as a block
-      @app = Rack::Builder.new(&block).to_app if block
-
-      # If in debug mode, wrap in logger adapter
-      @app = Rack::CommonLogger.new(@app) if Logging.debug?
-
-      setup_signals unless options[:signals].class == FalseClass
-    end
-  end
-end

data/samples/rack/init/lib/rack/meta/webserver/thin.yml

@@ -1,6 +0,0 @@
-DEFAULT_MAXIMUM_CONNECTIONS: 1001
-DEFAULT_MAXIMUM_PERSISTENT_CONNECTIONS: 1001
-DEFAULT_TIMEOUT: 30
-tcp:
-  min: 10000
-  max: 10099

data/samples/rest_client/init/Gemfile

@@ -1,5 +0,0 @@
-
-#A simple HTTP and REST client for Ruby,
-#inspired by the Sinatra microframework
-#style of specifying actions: get, put, post, delete
-gem "rest-client"

data/samples/rest_client/init/boot.rb

@@ -1,2 +0,0 @@
-# Load rest-client parts
-require_relative_directory File.join "config","rest_client"

data/samples/rest_client/init/cmd.yml

@@ -1 +0,0 @@
-helper: init

data/samples/rest_client/init/config/rest_client/defaults.rb

@@ -1,16 +0,0 @@
-module REST
-  class Client
-
-    class << self
-      attr_accessor :target,
-                    :port
-    end
-
-    def after_initialize
-      return unless new_record?
-      self.target = "0.0.0.0"
-      self.port   = "8080"
-    end
-
-  end
-end

data/samples/rest_client/init/docs/rest_client/simple overlook

@@ -1,251 +0,0 @@
-REST Client – simple DSL for accessing HTTP and REST resources
-Build status:
-
-A simple HTTP and REST client for Ruby, inspired by the Sinatra’s microframework style of specifying actions: get, put, post, delete.
-
-Main page: github.com/rest-client/rest-client
-
-Mailing list: rest.client@librelist.com (send a mail to subscribe).
-
-Usage: Raw URL
-
-require 'rest_client'
-
-RestClient.get 'http://example.com/resource'
-
-RestClient.get 'http://example.com/resource', {:params => {:id => 50, 'foo' => 'bar'}}
-
-RestClient.get 'https://user:password@example.com/private/resource', {:accept => :json}
-
-RestClient.post 'http://example.com/resource', :param1 => 'one', :nested => { :param2 => 'two' }
-
-RestClient.post "http://example.com/resource", { 'x' => 1 }.to_json, :content_type => :json, :accept => :json
-
-RestClient.delete 'http://example.com/resource'
-
-response = RestClient.get 'http://example.com/resource'
-response.code
-➔ 200
-response.cookies
-➔ {"Foo"=>"BAR", "QUUX"=>"QUUUUX"}
-response.headers
-➔ {:content_type=>"text/html; charset=utf-8", :cache_control=>"private" ...
-response.to_str
-➔ \n<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n   \"http://www.w3.org/TR/html4/strict.dtd\">\n\n<html ....
-
-RestClient.post( url,
-  {
-    :transfer => {
-      :path => '/foo/bar',
-      :owner => 'that_guy',
-      :group => 'those_guys'
-    },
-     :upload => {
-      :file => File.new(path, 'rb')
-    }
-  })
-Multipart
-
-Yeah, that’s right! This does multipart sends for you!
-
-RestClient.post '/data', :myfile => File.new("/path/to/image.jpg", 'rb')
-This does two things for you:
-
-Auto-detects that you have a File value sends it as multipart
-
-Auto-detects the mime of the file and sets it in the HEAD of the payload for each entry
-
-If you are sending params that do not contain a File object but the payload needs to be multipart then:
-
-RestClient.post '/data', {:foo => 'bar', :multipart => true}
-Usage: ActiveResource-Style
-
-resource = RestClient::Resource.new 'http://example.com/resource'
-resource.get
-
-private_resource = RestClient::Resource.new 'https://example.com/private/resource', 'user', 'pass'
-private_resource.put File.read('pic.jpg'), :content_type => 'image/jpg'
-See RestClient::Resource module docs for details.
-
-Usage: Resource Nesting
-
-site = RestClient::Resource.new('http://example.com')
-site['posts/1/comments'].post 'Good article.', :content_type => 'text/plain'
-See RestClient::Resource docs for details.
-
-Exceptions (see www.w3.org/Protocols/rfc2616/rfc2616-sec10.html)
-
-for results code between 200 and 207 a RestClient::Response will be returned
-
-for results code 301, 302 or 307 the redirection will be followed if the request is a get or a head
-
-for result code 303 the redirection will be followed and the request transformed into a get
-
-for other cases a RestClient::Exception holding the Response will be raised, a specific exception class will be thrown for know error codes
-
-RestClient.get 'http://example.com/resource'
-➔ RestClient::ResourceNotFound: RestClient::ResourceNotFound
-
-begin
-  RestClient.get 'http://example.com/resource'
-rescue => e
-  e.response
-end
-➔ 404 Resource Not Found | text/html 282 bytes
-Result handling
-
-A block can be passed to the RestClient method, this block will then be called with the Response. Response.return! can be called to invoke the default response’s behavior.
-
-# Don't raise exceptions but return the response
-RestClient.get('http://example.com/resource'){|response, request, result| response }
-➔ 404 Resource Not Found | text/html 282 bytes
-
-# Manage a specific error code
-RestClient.get('http://my-rest-service.com/resource'){ |response, request, result, &block|
-  case response.code
-  when 200
-    p "It worked !"
-    response
-  when 423
-    raise SomeCustomExceptionIfYouWant
-  else
-    response.return!(request, result, &block)
-  end
-}
-
-# Follow redirections for all request types and not only for get and head
-# RFC : "If the 301, 302 or 307 status code is received in response to a request other than GET or HEAD,
-#        the user agent MUST NOT automatically redirect the request unless it can be confirmed by the user,
-#        since this might change the conditions under which the request was issued."
-RestClient.get('http://my-rest-service.com/resource'){ |response, request, result, &block|
-  if [301, 302, 307].include? response.code
-    response.follow_redirection(request, result, &block)
-  else
-    response.return!(request, result, &block)
-  end
-}
-Non-normalized URIs.
-
-If you want to use non-normalized URIs, you can normalize them with the addressable gem (addressable.rubyforge.org/api/).
-
-require 'addressable/uri'
-RestClient.get(Addressable::URI.parse("http://www.詹姆斯.com/").normalize.to_str)
-Lower-level access
-
-For cases not covered by the general API, you can use the RestClient::Request class which provide a lower-level API.
-
-You can:
-
-specify ssl parameters
-
-override cookies
-
-manually handle the response (so you can operate on the response stream than reading it fully in memory)
-
-see the class’ rdoc for more information.
-
-Shell
-
-The restclient shell command gives an IRB session with RestClient already loaded:
-
-$ restclient
->> RestClient.get 'http://example.com'
-Specify a URL argument for get/post/put/delete on that resource:
-
-$ restclient http://example.com
->> put '/resource', 'data'
-Add a user and password for authenticated resources:
-
-$ restclient https://example.com user pass
->> delete '/private/resource'
-Create ~/.restclient for named sessions:
-
-sinatra:
-  url: http://localhost:4567
-rack:
-  url: http://localhost:9292
-private_site:
-  url: http://example.com
-  username: user
-  password: pass
-Then invoke:
-
-$ restclient private_site
-Use as a one-off, curl-style:
-
-$ restclient get http://example.com/resource > output_body
-
-$ restclient put http://example.com/resource < input_body
-Logging
-
-To enable logging you can
-
-set RestClient.log with a ruby Logger
-
-or set an environment variable to avoid modifying the code (in this case you can use a file name, “stdout” or “stderr”):
-
-$ RESTCLIENT_LOG=stdout path/to/my/program
-Either produces logs like this:
-
-RestClient.get "http://some/resource"
-# => 200 OK | text/html 250 bytes
-RestClient.put "http://some/resource", "payload"
-# => 401 Unauthorized | application/xml 340 bytes
-Note that these logs are valid Ruby, so you can paste them into the restclient shell or a script to replay your sequence of rest calls.
-
-Proxy
-
-All calls to RestClient, including Resources, will use the proxy specified by RestClient.proxy:
-
-RestClient.proxy = "http://proxy.example.com/"
-RestClient.get "http://some/resource"
-# => response from some/resource as proxied through proxy.example.com
-Often the proxy url is set in an environment variable, so you can do this to use whatever proxy the system is configured to use:
-
-RestClient.proxy = ENV['http_proxy']
-Query parameters
-
-Request objects know about query parameters and will automatically add them to the url for GET, HEAD and DELETE requests and escape the keys and values as needed:
-
-RestClient.get 'http://example.com/resource', :params => {:foo => 'bar', :baz => 'qux'}
-# will GET http://example.com/resource?foo=bar&baz=qux
-Cookies
-
-Request and Response objects know about HTTP cookies, and will automatically extract and set headers for them as needed:
-
-response = RestClient.get 'http://example.com/action_which_sets_session_id'
-response.cookies
-# => {"_applicatioN_session_id" => "1234"}
-
-response2 = RestClient.post(
-  'http://localhost:3000/',
-  {:param1 => "foo"},
-  {:cookies => {:session_id => "1234"}}
-)
-# ...response body
-SSL Client Certificates
-
-RestClient::Resource.new(
-  'https://example.com',
-  :ssl_client_cert  =>  OpenSSL::X509::Certificate.new(File.read("cert.pem")),
-  :ssl_client_key   =>  OpenSSL::PKey::RSA.new(File.read("key.pem"), "passphrase, if any"),
-  :ssl_ca_file      =>  "ca_certificate.pem",
-  :verify_ssl       =>  OpenSSL::SSL::VERIFY_PEER
-).get
-Self-signed certificates can be generated with the openssl command-line tool.
-
-Hook
-
-RestClient.add_before_execution_proc add a Proc to be called before each execution, it’s handy if you need a direct access to the http request.
-
-Example:
-
-# Add oath support using the oauth gem
-require 'oauth'
-access_token = ...
-
-RestClient.add_before_execution_proc do |req, params|
-  access_token.sign! req
-end
-
-RestClient.get 'http://example.com'