clone 1.0.0.alpha → 1.0.0.beta

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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,147 @@
+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

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

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

@@ -0,0 +1,6 @@
+development:
+  sessions:
+    default:
+      database: db
+      hosts:
+        - localhost:27017

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

@@ -0,0 +1,14 @@
+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/mongoid/model/lib/mongoid/models/model.rb

@@ -0,0 +1,28 @@
+module MODULE
+  class CLASS
+    include Mongoid::Document #; include Mongoid::Timestamps  #; include Mongoid::Paranoia
+
+    store_in :collection => (self.to_s.split('::').last) #, :session => "default"
+
+    #embeds_many :target_class_name
+    #embeds_one  :target_class_name
+
+    #field      :name,
+    #           :type => String,
+    #           :default => "Hello World!"
+
+    #validates  :name,
+    #           :presence => true
+
+
+    ### you can validate here the fields
+    #self.fields.keys.each do |key|
+    #  validates  key.to_sym,
+    #             presence: true
+    #end
+
+    ### you can set here that only fields can be saved to db
+    #attr_accessible *fields.keys
+
+  end
+end

data/samples/mongoid/readme

@@ -0,0 +1,33 @@
+MongoDB Controller
+Adatbazis modellezo es segito eszkoz
+
+Mongoid is an ODM (Object Document Mapper)
+Framework for MongoDB, written in Ruby.
+
+Mongoid (pronounced mann-goyd) is an Object-Document-Mapper
+(ODM) for MongoDB written in Ruby. It was conceived in August,
+2009 during a whiskey-induced evening at the infamous Oasis
+in Florida, USA by Durran Jordan.
+
+The philosophy of Mongoid is to provide a familiar API to
+Ruby developers who have been using Active Record or Data Mapper,
+while leveraging the power of MongoDB's schemaless and performant
+document-based design, dynamic queries, and atomic modifier operations.
+
+Sample Syntax:
+
+class Artist
+  include Mongoid::Document
+  field :name, type: String
+  embeds_many :instruments
+end
+
+class Instrument
+  include Mongoid::Document
+  field :name, type: String
+  embedded_in :artist
+end
+
+syd = Artist.where(name: "Syd Vicious").between(age: 18..25).first
+syd.instruments.create(name: "Bass")
+syd.with(database: "bands", session: "backup").save!

data/samples/rack/init/Gemfile

@@ -0,0 +1,10 @@
+
+### Require Rack compatible gems
+gem "rack"
+gem "thin", "~> 1.5.1"
+#gem "webrick"
+#gem "ebb"
+#gem "fcgi"
+#gem "scgi"
+#gem "mongrel"
+#gem "passenger"

data/samples/rack/init/cmd.yml

@@ -0,0 +1,2 @@
+helper: init
+rack: scripts

data/samples/rack/init/config.ru

@@ -0,0 +1 @@
+require './server.rb'

data/samples/rack/init/docs/rack/rake introducing.txt

@@ -0,0 +1,60 @@
+ Introducing Rack
+
+
+Dabbling in my own web framework experiments, I noticed that there is a lot of code duplication among frameworks since they essentially all do the same things. And still, every Ruby web framework developer is writing his own handlers for every webserver he wants to use. Hopefully, the framework users are satisfied with that choice.
+
+However, in essence, dealing with HTTP is rather easy. In the end, you get a request and return a response. Let’s do the easiest thing possible: The canonical format of a HTTP request probably is a hash of a CGI-like environment (that’s what most frameworks I’ve looked at deal with, internally), and a response consists of three parts: a status, a set of headers, and a body.
+
+This could be easily mapped onto a method call in Ruby, looking like this:
+class HelloWorld
+  def call(env)
+    [200, {"Content-Type" => "text/plain"}, ["Hello world!"]]
+  end
+end
+
+
+You’ve just seen the most simple Rack application.
+
+Rack aims to provide a minimal API for connecting web servers and web frameworks.
+
+Informally, a Rack application is a thing that responds to #call and takes a hash as argument, returning an array of status, headers and a body. The body needs to respond to #each and then successively return strings that represent the response body. The hash given contains a CGI-ish set of environment variables and some special values, like the body stream of the request (env['rack.input']), or information about the run-time environment (e.g. env['rack.run_once']).
+
+Please note that this API is mainly used by framework developers and usually will not be exposed to framework users. It may seem a bit clumsy at first, or you may have expected a more “polished” API, but the important thing is that the API is very simple (notice that it even can be satisfied by a lambda) and not hard to adopt. (The Camping adapter is a mere five lines of code.)
+
+On top of this minimal API, there are libraries for commonly used things like query parsing or cookie handling and provide more convenience (Rack::Request and Rack::Response) that you are free to use if you wish.
+
+But the really cool thing about Rack is that it provides an extremely easy way to combine these web applications. After all, they are only Ruby objects with a single method that matters. And the thing that calls you must not really be a web server, but could as well be a different application! Let me show you a few Rack filters (or “middleware”) that already exist:
+•
+Rack::ShowExceptions catches all thrown exceptions and wraps them nicely in an helpful 500-page adapted from Django.
+
+•
+Rack::CommonLogger does Apache-style logs.
+
+•
+Rack::URLMap redirects to different Rack applications depending on the path and host (a very simple router).
+
+
+There is another tool, Rack::Lint that checks if your applications and filters play nicely with others so everything ought to work together.
+
+What do you gain if your web framework/server/application supports Rack?
+•
+Handlers for WEBrick, Mongrel and plain CGI (soon FastCGI, too), and every new webserver that provides a Rack handler. (Let n and m be the amount of servers and frameworks, without Rack it’s n*m, but with it’s n+m, which means less work for everyone.)
+
+•
+The possibility to run several applications inside a single webserver without external configuration.
+
+•
+Easier (integration and functional) testing, since everything can easily be mocked. (Helpers for this are coming soon, too.)
+
+•
+A greater diversity among frameworks, since writers now can concentrate on the parts that make it special and stop wasting their time on boring things.
+
+•
+More synergistic effects: Compare “That upload handler you wrote for IOWA is really great, too bad I use Camping.” with “That upload handler you wrote for Rack works great for me too!”
+
+
+Currently, Rack is supported by Camping (adapter included with Rack) and Ramaze, more adapters are in the works (a Rails one would be a really cool contribution, hint, hint).
+
+(If you are into Python, you’ll notice a lot of similarities between Rack and WSGI and Paste. That’s fully intended, as I think WSGI helped the Python web landscape really a lot.)
+
+A Rubyforge project has been requested, and a first release will happen really soon. If you’d like to help, contact me by mail or via IRC (chris2@#ruby-lang on FreeNode).

data/samples/rack/init/docs/rack/webservers/Thin

@@ -0,0 +1,43 @@
+Thin
+Tiny, fast & funny HTTP server
+
+Thin is a Ruby web server that glues together 3 of the best Ruby libraries in web history:
+
+The Mongrel parser: the root of Mongrel speed and security
+Event Machine: a network I/O library with extremely high scalability, performance and stability
+Rack: a minimal interface between webservers and Ruby frameworks
+Which makes it, with all humility, the most secure, stable, fast and extensible Ruby web server bundled in an easy to use gem for your own pleasure.
+
+Site:  http://code.macournoyer.com/thin/
+Group: http://groups.google.com/group/thin-ruby/topics
+Bugs:  http://github.com/macournoyer/thin/issues
+Code:  http://github.com/macournoyer/thin
+IRC:   #thin on freenode
+Installation
+For the latest stable version:
+
+gem install thin
+
+Or from source:
+
+git clone git://github.com/macournoyer/thin.git
+cd thin
+rake install
+Usage
+A +thin+ script offers an easy way to start your Rack application:
+
+cd to/your/app
+thin start
+When using with Rails and Bundler, make sure to add gem 'thin' to your Gemfile.
+
+See example directory for samples and run 'thin -h' for usage.
+
+License
+Ruby License, http://www.ruby-lang.org/en/LICENSE.txt.
+
+Credits
+The parser was stolen from Mongrel http://mongrel.rubyforge.org by Zed Shaw. Mongrel is copyright 2007 Zed A. Shaw and contributors. It is licensed under the Ruby license and the GPL2.
+
+Thin is copyright Marc-Andre Cournoyer macournoyer@gmail.com
+
+Get help at http://groups.google.com/group/thin-ruby/ Report bugs at https://github.com/macournoyer/thin/issues and major security issues directly to me macournoyer@gmail.com.