rango 0.0.3

data/lib/rango/bundling/strategies/gem.rb

@@ -0,0 +1,55 @@
+# coding: utf-8
+
+# Rango.dependency "dm-core"
+# Rango.dependency "term-ansicolor", as: "term/ansicolor"
+# Rango.dependency "pupu", github_gem: "botanicus-pupu", as: "pupu/adapters/rango"
+# Rango.dependency "dm-validations", gem: "dm-more"
+class Rango
+  module Bundling
+    class GemStrategy < Strategy
+      # @since 0.0.2
+      def setup
+        @gem = options[:gem]
+        # Rango.dependency "dm-core", gem: true
+        @gem = @name if @gem.is_a?(TrueClass)
+        @version = options[:version]
+      end
+
+      # @since 0.0.2
+      def match?
+        self.options.key?(:gem)
+      end
+
+      def install(path = @name)
+        %x[gem install #{path} -i #{gems_directory}]
+      end
+
+      # @since 0.0.2
+      def run
+        part = File.join(Gem.path, "cache", @gem)
+        if @version
+          path = "#{part}-#{@version}.gem"
+        else
+          path = Dir["#{part}-*.gem"].last
+        end
+        FileUtils.mkdir(Project.settings.gems_directory)
+        self.install path
+      end
+    end
+
+    class GithubGem < GemStrategy
+      def initialize(name, options)
+        gem = options[:github_gem]
+        super(name, options.merge(gem: gem))
+      end
+
+      def install(path = @name)
+        %x[gem install #{path}  -i #{gems_directory} -s http://gems.github.com]
+      end
+
+      def match?
+        self.options.key?(:github_gem)
+      end
+    end
+  end
+end

data/lib/rango/bundling/strategies/git.rb

@@ -0,0 +1,71 @@
+# coding: utf-8
+
+# NOTE: we need to
+class Rango
+  module Bundling
+    # 1) clone git repo
+    # 2) run gem build, rake gem, rake package
+    # 3) install gem locally
+    class GitCloneStrategy < Strategy
+      attr_accessor :repo
+      # @since 0.0.2
+      def setup
+        @repo = self.options[:git]
+      end
+
+      # @since 0.0.2
+      def match?
+        self.options.key?(:git)
+      end
+
+      # @since 0.0.2
+      def run
+        %x[git clone #{self.repo} #{self.sources_directory}]
+      end
+    end
+
+    class GithubStrategy < GitCloneStrategy
+      # @since 0.0.2
+      def initialize(name, options)
+        path = "git://github.com/#{path}.git"
+        super(name, options.merge(git: path))
+      end
+
+      # @since 0.0.2
+      def match?
+        self.options.key?(:github)
+      end
+    end
+
+    class GitSubmoduleStrategy < Strategy
+      # @since 0.0.2
+      def setup
+        @submodule = @options[:submodule]
+      end
+
+      # @since 0.0.2
+      def match?
+        options.key?(:submodule)
+      end
+
+      # @since 0.0.2
+      def run
+        cmd "git submodule add #{@repo}"
+        # TODO
+      end
+    end
+
+    class GithubSubmoduleStrategy < GitSubmoduleStrategy
+      # @since 0.0.2
+      def initialize(name, options)
+        path = "git://github.com/#{path}.git"
+        super(name, options.merge(submodule: path))
+      end
+
+      # @since 0.0.2
+      def match?
+        self.options.key?(:github_submodule)
+      end
+    end
+  end
+end

data/lib/rango/bundling/strategies/hg.rb

@@ -0,0 +1,9 @@
+# coding: utf-8
+
+class Rango
+  module Bundling
+    class MercurialCloneStrategy < Strategy
+      # TODO
+    end
+  end
+end

data/lib/rango/bundling/strategy.rb

@@ -0,0 +1,85 @@
+# coding: utf-8
+
+class Rango
+  module Bundling
+    class << self
+      attribute :strategies, Array.new
+      attribute :dependencies, Array.new
+    end
+
+    class Strategy
+      class << self
+        # @since 0.0.2
+        def register
+          Rango.logger.info("Strategy #{self} registered")
+          Rango::Bundling.strategies.push(self)
+        end
+
+        def inherited(base)
+          base.register
+        end
+
+        # @since 0.0.2
+        def find(name, options)
+          Rango::Bundling.strategies.each do |strategy|
+            strategy = strategy.new(name, options)
+            return strategy if strategy.match?
+          end
+          return nil
+        end
+
+        def install
+          Rango.dependencies.each(&:install)
+        end
+      end
+
+      attr_accessor :name, :options
+      def initialize(name, options)
+        @name    = name
+        @options = options
+        self.setup if self.respond_to?(:setup)
+      end
+
+      def register
+        Rango::Bundling.dependencies.push(self)
+        return self
+      end
+
+      def sources_directory
+        File.join(Project.settings.sources_directory, @name)
+      end
+
+      def gems_directory
+        Project.settings.gems_directory
+      end
+
+      def activate_gem
+        args = [@options[:gem]]
+        version = @version || @options[:version]
+        args.push(version) if version
+        gem *args
+      end
+
+      def load
+        # self.activate_gem if @options[:gem]
+        require (@options[:as] || @name)
+      end
+    end
+
+    class RequireStrategy < Strategy
+      # @since 0.0.2
+      def match?
+        self.options.empty?
+      end
+
+      # @since 0.0.2
+      def run
+        Rango.logger.error("This dependency can't be bundled. Please provide more options.")
+      end
+
+      def load
+        require @name
+      end
+    end
+  end
+end

data/lib/rango/cli/generator.rb

@@ -0,0 +1,15 @@
+# coding: utf-8
+
+class Rango
+  class Generator
+    def initialize(argv)
+      type = argv.shift
+      Rango.import("cli/#{type}")
+      constant = Rango.const_get(type.camel_case)
+      constant.new(argv).create
+    rescue ArgumentError => exception
+      raise exception
+      # TODO: message
+    end
+  end
+end

data/lib/rango/cli/project.rb

@@ -0,0 +1,87 @@
+# coding: utf-8
+
+require "yaml"
+require "ostruct"
+require "fileutils"
+require "rango" # logger
+require "erubis"
+
+# TODO
+# metadata :file option for rendering just one file
+# gem installation (for plugin)
+# prazdne .gitignore kvuli gitu
+
+# - Find possible location and take first one
+# - If type of the location is full, then copy it's content directory to the desired name
+# - If type of the location is diff, then take another location, copy it and then copy files from the first one
+# - Run init.rb
+
+# preprocessing.rb
+# @foo = "bar"
+
+# erubis
+# <%= %> a <%% %%>
+
+# models/%model%.rb
+# model.rb.rbt, posts.html.erb.rbt
+
+# content/foo
+# xxx/bar
+# => rango generate bigproject blog --models=post,tag --controllers=posts,tags
+# iterovat pres kolekce => to uz vyzaduje templatovaci engine
+
+class Rango
+  class Project
+    def self.rango_root
+      File.join(File.dirname(__FILE__), "..", "..", "..")
+    end
+
+    def self.stubs_dirs
+      ["#{ENV["HOME"]}/.rango/stubs", "#{self.rango_root}/stubs"]
+    end
+
+    def self.list
+      output = Hash.new
+      self.stubs_dirs.each do |directory|
+        files = map { |directory| Dir["#{directory}/*"] }.flatten
+        directories = files.select { |file| Dir.exist?(file) }
+        output[directory] = directories
+      end
+      return output
+    end
+
+    def initialize(type, name)
+      dir = stubs_dirs.find { |dir| File.exist?("#{dir}/#{type}") }
+      if File.exist?(name)
+        abort "#{name} already exist, aborting."
+      end
+    end
+
+    def create
+      if self.config.type == "diff"
+      elsif self.config.type == "full"
+        # TODO: log it
+        FileUtils.cp_r(File.join(dir, type), name)
+        puts "#{type.capitalize} #{name} have been created (used stub from #{dir})."
+      end
+      load "init.rb"
+    end
+
+    def validations
+      ["diff", "full"].include?(self.config.type)
+    end
+
+    # Metadata options
+    # :type: full|diff
+    # :file: flat.ru
+    def metadata
+      metadata_file = File.join(@stubs_dir, "metadata.yml")
+      YAML::load_file(metadata_file)
+    end
+
+    def config
+      defaults = {processing: true, type: "full"}
+      OpenStruct.new(defaults.merge(self.metadata))
+    end
+  end
+end

data/lib/rango/cli/simple_template.rb

@@ -0,0 +1,47 @@
+# coding: utf-8
+
+# I know, I know, we have Rubigen, Templater and others, but Rango needs something really simple, so user can start work immediately and can't study bloated docs
+
+require "erubis"
+require "fileutils"
+require "tempfile"
+
+# TODO
+# replace %variable% in file path
+# just one file generation (settings, flat.ru)
+
+# @future 0.0.3 It's just a prototype now. But it will be available in 0.0.3. Stay tuned!
+# @example
+#   Rango::SimpleTemplate.new("my_generator_dir", user: "botanicus", constant: -> { |argv| argv.first.camel_case })
+class Rango
+  class SimpleTemplate
+    attr_accessor :context
+    def initialize(path, context = Hash.new)
+      @path = path
+      @context = context
+    end
+
+    def generate
+      if Dir.exist?(@path)
+        Find.find(@path) do |file|
+          # mkdir -p if directory
+          # gsub co
+          output = proceed_file(file)
+          FileUtils.cp(output.path, location)
+        end
+      else
+      end
+    end
+
+    protected
+    def proceed_file(file)
+      if file.split(".").last == "rbt" # proceed and copy output
+        Tempfile.open(File.basename(file)) do |file|
+          file.print(Erubis::Eruby.new(file))
+        end
+      else # just copy
+        File.new(file)
+      end
+    end
+  end
+end

data/lib/rango/contrib/pagination.rb

@@ -0,0 +1,15 @@
+require "pathname" # TODO: it should be done in dm-aggregates
+Rango.dependency("dm-aggregates")
+
+Rango.import("contrib/pagination/page")
+Rango.import("contrib/pagination/strategies")
+Rango.import("contrib/pagination/helpers")
+Rango.import("contrib/pagination/adapters/#{Project.settings.orm || "datamapper"}")
+
+Rango.import("mvc/controller") # TODO: it should not works just with controller
+Rango::Controller.send(:include, Rango::Pagination::PaginationMixin)
+# require code that must be loaded before the application
+
+# default route rule
+# /products?page=5
+Rango::Pagination::Strategies::Default.activate

data/lib/rango/contrib/pagination/README.textile

@@ -0,0 +1,21 @@
+h1. About
+
+h1. Usage
+
+<pre>
+dependency "rango-haml"
+dependency "rango-pagination"
+</pre>
+
+<pre>
+class Posts < Application
+  before :setup_page
+  private
+  def setup_page
+    @page = Order.page(params[:page] || 1)
+  end
+end
+</pre>
+
+# it will be partial "gems/gems/rango-pagination/app/rango-pagination/views", page: @page
+paginate @page

data/lib/rango/contrib/pagination/TODO

@@ -0,0 +1,3 @@
+Page.current is pretty bad idea
+Features should works
+Everything should be in Rango::Pagination ... or maybe Rango::Page? It will be better because it do not conflict with existing rango-pagination package

data/lib/rango/contrib/pagination/_pagination.html.haml

@@ -0,0 +1,39 @@
+/ FAQ: yep, this file must be called _pagination and not
+/ just pagination, because it is how partial method works
+/ 1  2  3  4  5  <6>  7  8  9 10 11
+/ 6  7  8  9 10 <11> 12 13 14 15 16
+- unless page.max.eql?(1)
+  - if page.previous
+    /= link_to "<< Předchozí", "?page=#{page.previous.number}"
+    != link_to "<< Předchozí", Page.route(request, page, page.previous.number)
+  - if page.max <= 11
+    - (1..page.max).each do |pagenum|
+      - if page.number.eql?(pagenum)
+        = pagenum
+      - else
+        /= link_to pagenum, "?page=#{pagenum}"
+        != link_to pagenum, Page.route(request, page, pagenum)
+  - elsif page.number <= 6
+    - (1..11).each do |pagenum|
+      - if page.number.eql?(pagenum)
+        = pagenum
+      - else
+        /= link_to pagenum, "?page=#{pagenum}"
+        != link_to pagenum, Page.route(request, page, pagenum)
+  - elsif page.number >= (page.max - 6)
+    - ((page.max - 11)..(page.max)).each do |pagenum|
+      - if page.number.eql?(pagenum)
+        = pagenum
+      - else
+        /= link_to pagenum, "?page=#{pagenum}"
+        != link_to pagenum, Page.route(request, page, pagenum)
+  - else
+    - ((page.number - 5)..(page.number + 5)).each do |pagenum|
+      - if page.number.eql?(pagenum)
+        = pagenum
+      - else
+        /= link_to pagenum, "?page=#{pagenum}"
+        != link_to pagenum, Page.route(request, page, pagenum)
+  - if page.next
+    /= link_to "Další >>", "?page=#{page.next.number}"
+    != link_to "Další >>", Page.route(request, page, page.next.number)