rango 0.0.3

data/lib/rango/rango.rb

@@ -0,0 +1,75 @@
+# coding: utf-8
+
+Rango.import("exceptions")
+Rango.import("loggers/logger")
+Rango.import("bundling/dependency")
+
+class Rango
+  class << self
+    # @since 0.0.2
+    # @example
+    #   Rango.path
+    #   # => /usr/lib/ruby/lib/ruby/site_ruby/1.8/rango
+    # @return [Path] Rango root path
+    def path
+      @path ||= Path.new(self.root)
+    end
+
+    # @since 0.0.1
+    # @example
+    #   Rango.root
+    #   # => /usr/lib/ruby/lib/ruby/site_ruby/1.8/rango
+    # @return [Rango::Logger] Logger for logging framework-related stuff. For logging project-relating stuff please use Project.logger.
+    # @see Project::logger
+    def logger
+      @logger ||= Rango::Logger.new
+    end
+
+    # @since 0.0.1
+    # @example
+    #   Rango.boot(flat: true)
+    # @param [Hash] options You can specify flat: true for sinatra-like flat application.
+    # @return [Boolean] Returns true if boot succeed or false if not. If ARGV includes "-i", IRB interactive session will start.
+    def boot(options = Hash.new)
+      Rango.flat = true if options[:flat]
+      if options[:force]
+        Rango.import!("boot")
+      else
+        Rango.import("boot")
+      end
+    end
+
+    # @since 0.0.2
+    def reboot(options = Hash.new)
+      self.boot(options.merge(force: true))
+    end
+
+    # @since 0.0.2
+    def app
+      # $DEBUG = Project.settings.debug # It looks terrible, but rack works with it
+      Rango.import("rack/dispatcher")
+      return Rango::Dispatcher.app
+    rescue Exception => exception
+      Rango.logger.exception(exception)
+      return false
+    end
+
+    # Start IRB interactive session
+    # @since 0.0.1
+    def interactive
+      require "irb"
+      try_require "irb/completion" # some people can have ruby compliled without readline
+      ARGV.clear # otherwise irb will read it
+      IRB.start
+    end
+
+    # @since 0.0.1
+    # @return [Boolean] If application is flat or not.
+    questionable :flat, false
+    questionable :debug, true
+
+    # Rango.template("404.html")
+    def template(basename)
+    end
+  end
+end

data/lib/rango/router/adapters/basic.rb

@@ -0,0 +1,21 @@
+# coding: utf-8
+
+# Rack::URLMap is very easy router included directly in rack distribution
+# You can't use stuff like "posts/:id" there, so env["rango.router.params"]
+# allways will be just empty hash
+
+Rango.import("router/dispatcher")
+
+class Rango
+  class Router
+    module Basic
+      def set_rack_env(env)
+        env["rango.router.params"] = Hash.new
+        env["rango.router.app"] = self
+      end
+
+      # register it
+      Rango::Router::Dispatcher.router_adapter = self
+    end
+  end
+end

data/lib/rango/router/adapters/rack-router.rb

@@ -0,0 +1,18 @@
+# coding: utf-8
+
+require "rack/router"
+Rango.import("router/dispatcher")
+
+class Rango
+  class Router
+    module RackRouter
+      def set_rack_env(env)
+        env["rango.router.params"] = env["rack_router.params"]
+        env["rango.router.app"] = self
+      end
+
+      # register it
+      Rango::Router::Dispatcher.router_adapter = self
+    end
+  end
+end

data/lib/rango/router/dispatcher.rb

@@ -0,0 +1,29 @@
+# coding: utf-8
+
+class Rango
+  class Router
+    module Dispatcher
+      class << self
+        attr_accessor :router_adapter
+        def included(klass)
+          self.install_hook(klass)
+        end
+
+        def extended(object)
+          self.install_hook(object.class)
+        end
+
+        def install_hook(klass)
+          klass.send(:include, self.router_adapter)
+        rescue TypeError
+          raise TypeError, "You must set the Dispatcher.router_adapter first. For example Dispatcher.router_adapter = Rango::Router::RackRouter"
+        end
+
+        def route_to(env, app)
+          Rango.logger.inspect("Routing request to #{app.inspect}")
+          app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/rango/router/specification.txt

@@ -0,0 +1,16 @@
+=== Introduction ===
+Rango doesn't have its own router, so you can use what you like or write your own. The only thing you need to do is set few variables in rack env.
+
+=== Rack env ===
+env["rango.router.params"]
+env["rango.router.app"]
+
+=== Strategies variables ===
+You can define what variables you like, the only rule there is that you must stay in namespace of your strategy.
+
+env["rango.controller.name"]
+env["rango.controller.action"]
+
+=== Available routers ===
+Rack::URLMap
+rack-router

data/lib/rango/settings.rb

@@ -0,0 +1,87 @@
+# coding: utf-8
+
+class Rango
+  module Settings
+    class Settings
+      # @since 0.0.1
+      # @example
+      #   Project.settings.merge(MyPlugin.settings)
+      # @param [Rango::Settings] another Settings which will be merged into self. It doesn't change self.
+      # @return [Hash] Hash of settings attributes.
+      # TODO: maybe it should returns Rango::Settings?
+      def merge(another)
+        self.hattributes.merge(another.hattributes)
+      end
+
+      # @since 0.0.1
+      # @example
+      #   Project.settings.merge!(MyPlugin.settings)
+      # @param [Rango::Settings] another Settings which will be merged into self. It change self.
+      # @return [Hash] Hash of settings attributes.
+      # TODO: maybe it should returns Rango::Settings?
+      def merge!(another)
+        self.hattributes.merge!(another.hattributes)
+      end
+
+      # @since 0.0.1
+      # @example
+      # @return [String] All settings attributes in inspect format.
+      def inspect
+        self.hattributes.inspect
+      end
+
+      # @since 0.0.1
+      def to_hash
+        self.hattributes.reject { |key, value| value.nil? }
+      end
+
+      # @since 0.0.2
+      def settings_module(name)
+        if self.hattributes[name]
+          return self.hattributes[name]
+        else
+          Rango.import("settings/#{name}")
+          const_name = name.to_s.camel_case
+          constant = Rango::Settings.const_get(const_name)
+          instance = constant.new
+          self.hattributes[name] = instance
+        end
+      end
+
+      # @since 0.0.1
+      # @example
+      #   Project.configure do
+      #     self.foobar = "something"
+      #   end
+      #   # => Logger will warn you that property foobar doesn't exist.
+      # @param [type] name explanation
+      def method_missing(name, *args, &block)
+        if name.to_s.match(/^([\w\d]+)=$/) && args.length.eql?(1)# && not block_given?
+          Rango.logger.warn("Unknown setting item: #$1")
+        else
+          super(name, *args, &block)
+        end
+      end
+    end
+
+    class Anonymous < Settings
+      # @since 0.0.2
+      # @example
+      #   Project.configure do
+      #     self.foobar = "something"
+      #   end
+      #   # => Set the property without warning
+      # @param [type] name explanation
+      def method_missing(name, *args, &block)
+        if name.to_s.match(/^([\w\d]+)=$/) && args.length.eql?(1)# && not block_given?
+          self.class.hattribute $1.to_sym
+          self.send(name, *args, &block)
+        else
+          super(name, *args, &block)
+        end
+      end
+    end
+  end
+end
+
+Rango.import("settings/framework")

data/lib/rango/settings/erubis.rb

@@ -0,0 +1,13 @@
+# coding: utf-8
+
+class Rango
+  module Settings
+    class Erubis < Settings
+      # @since 0.0.2
+      hattribute :pattern, "<% %>" # can be string or regexp
+
+      # @since 0.0.2
+      hattribute :custom_class # use your own class instead of Erubis::Eruby. Don't forget that you must include (TODO: what) for autoescaping
+    end
+  end
+end

data/lib/rango/settings/framework.rb

@@ -0,0 +1,85 @@
+# coding: utf-8
+
+class Rango
+  module Settings
+    class Framework < Settings
+      # @since 0.0.1
+      # @return [Boolean] explanation
+      hattribute :debug, true
+
+      # @since 0.0.1
+      # @return [Boolean] Path to your router. Default +urls.rb+.
+      hattribute :router, "urls.rb"
+
+      # @since 0.0.1
+      # @return [String] Path to your +media+ directory.
+      hattribute :media_root, lambda { Project.path.join("media").to_s }
+
+      # @since 0.0.2
+      # @return [String] rango-project.org/media/javascripts/mootools-core.js
+      hattribute :media_prefix, "/media"
+
+      # @since 0.0.1
+      # @return [Array[String]] Array with paths where Rango will trying to find templates.
+      hattribute :template_dirs, ["templates"]
+
+      # @since 0.0.1
+      # @return [String] Name of your database or path to the database if you are using SQLite3.
+      hattribute :database_name, lambda { "#{Rango.environment}.db" }
+
+      # @since 0.0.2
+      # @return [String] Array of emails.
+      hattribute :admins, Array.new
+
+      # @since 0.0.1
+      # @return [String] Database adapter.
+      hattribute :database_adapter, "sqlite3"
+
+      # @since 0.0.1
+      # @return [String] explanation
+      # hattribute :logger_strategy, "fireruby"
+
+      # @since 0.0.1
+      # @return [Boolean] ORM. Can be datamapper or nil.
+      hattribute :orm
+
+      # @since 0.0.1
+      # @return [Boolean] Template engine. Can be haml, erb, erubis or nil (so just plain html will be returned).
+      hattribute :template_engine, "haml"
+
+      # @since 0.0.1
+      # @return [Boolean] Testing engine. Can be rspec or nil.
+      hattribute :testing_engine
+
+      # @since 0.0.1
+      # @return [Boolean] Features engine. Can be cucumber or nil.
+      hattribute :features_engine
+
+      # @since 0.0.2
+      hattribute :mime_formats, Array.new
+
+      # @since 0.0.2
+      hattribute :autoescape, true
+
+      # @since 0.0.2
+      hattribute :gems_directory, lambda { File.join(Project.root, "gems") }
+
+      # @since 0.0.2
+      hattribute :sources_directory, lambda { File.join(Project.root, "sources") }
+
+      # @since 0.0.2
+      # Project.settings.erubis.pattern
+      # hattribute :erubis, lambda { self.settings_module(:erubis) }
+      def erubis
+        self.settings_module(:erubis)
+      end
+
+      # @since 0.0.2
+      # Project.settings.haml.format
+      # hattribute :haml, lambda { self.settings_module(:haml) }
+      def haml
+        self.settings_module(:haml)
+      end
+    end
+  end
+end

data/lib/rango/settings/haml.rb

@@ -0,0 +1,35 @@
+# coding: utf-8
+
+class Rango
+  module Settings
+    class Haml < Settings
+      # @since 0.0.2
+      # Determines the output format. The default is :xhtml. Other options are :html4 and :html5, which are identical to :xhtml except there are no self-closing tags, XML prolog is ignored and correct DOCTYPEs are generated.
+      hattribute :format, :xhtml
+
+      # @since 0.0.2
+      # Sets whether or not to escape HTML-sensitive characters in script. If this is true, = behaves like &=; otherwise, it behaves like !=. Note that if this is set, != should be used for yielding to subtemplates and rendering partials. Defaults to false.
+      hattribute :escape_html, lambda { Project.settings.autoescape }
+
+      # @since 0.0.2
+      # Whether or not attribute hashes and Ruby scripts designated by =  or ~ should be evaluated. If this is true, said scripts are rendered as empty strings. Defaults to false.
+      hattribute :suppress_eval, false
+
+      # @since 0.0.2
+      # The character that should wrap element attributes. This defaults to ' (an apostrophe). Characters of this type within the attributes will be escaped (e.g. by replacing them with &apos;) if the character is an apostrophe or a quotation mark.
+      hattribute :attr_wrapper, '"'
+
+      # @since 0.0.2
+      # A list of tag names that should be automatically self-closed if they have no content. Defaults to ['meta', 'img', 'link', 'br', 'hr', 'input', 'area', 'param', 'col', 'base'].
+      hattribute :autoclose, %w[meta img link br hr input area param col base]
+
+      # @since 0.0.2
+      # A list of tag names that should automatically have their newlines preserved using the Haml::Helpers#preserve  helper. This means that any content given on the same line as the tag will be preserved. For example
+      # %textarea= "Foo\nBar"
+      # compiles to:
+      # <textarea>Foo&&#x000A;Bar</textarea>
+      # Defaults to ['textarea', 'pre'].
+      hattribute :preserve, %w[textarea pre]
+    end
+  end
+end

data/lib/rango/support/cucumber/steps/given_steps.rb

@@ -0,0 +1,5 @@
+# coding: utf-8
+
+Given /^user is at ([^\s]+)$/ do |url|
+  request(url)
+end

data/lib/rango/support/cucumber/steps/then_steps.rb

@@ -0,0 +1,41 @@
+# coding: utf-8
+
+# HTTP 200
+Then "it should respond successfuly" do
+  @response.should be_successful
+end
+
+# not HTTP 200
+Then "the (.*) ?request should fail" do |_|
+  @response.should_not be_successful
+end
+
+# HTTP 404, 406, 500
+Then /it should have status (\d{3})/ do |status|
+  @response.status.should eql(status.to_i)
+end
+
+Then /^(\w+) should be redirected to "(.+)"$/ do |who, uri|
+  @response.should redirect_to(uri)
+end
+
+# content type
+Then /it should render page in (\w+) format/ do |format|
+  @response.should have_content_type(format.to_sym)
+end
+
+# have given content
+Then /^I should see "(.*)"$/ do |text|
+  #@response.body.to_s.should =~ /#{text}/m
+  @response.body.should have_content(text)
+end
+
+# have not given content
+Then /^I should not see "(.*)"$/ do |text|
+  @response.body.to_s.should_not =~ /#{text}/m
+end
+
+# have given message
+Then /^I should see an? (\w+) message$/ do |message_type|
+  @response.should have_xpath("//*[@class='#{message_type}']")
+end

data/lib/rango/support/cucumber/steps/when_steps.rb

@@ -0,0 +1,54 @@
+# coding: utf-8
+
+# Roles:
+#   - user (general user)
+#   - admin (authenticated user)
+#   - customer ()
+#   - guest ()
+
+# request
+# use it just for /admin, /login and /
+# in other cases use "click to"
+# THIS CONFLICT WITH SOME STUFF IN EXCEPTIONS FEATURE
+#When /^\w+ goes to (.+)$/ do |uri|
+#  @response = request(uri)
+#end
+
+# Commonly used webrat steps
+# http://github.com/brynary/webrat
+When /^(\w+) goes to "(.+)"$/ do |user, path|
+  @response = visit(path)
+end
+
+When /^I press "(.*)"$/ do |button|
+  click_button(button)
+end
+
+# "user click to" or "admin click to"
+When /^\w+ click to "(.*)"$/ do |link|
+  @response = click_link(link)
+end
+
+When /^I fill in "(.*)" with "(.*)"$/ do |field, value|
+  fill_in(field, with: value)
+end
+
+When /^I select "(.*)" from "(.*)"$/ do |value, field|
+  select(value, from: field)
+end
+
+When /^I check "(.*)"$/ do |field|
+  check(field)
+end
+
+When /^I uncheck "(.*)"$/ do |field|
+  uncheck(field)
+end
+
+When /^I choose "(.*)"$/ do |field|
+  choose(field)
+end
+
+When /^I attach the file at "(.*)" to "(.*)" $/ do |path, field|
+  attach_file(field, path)
+end