hack_tree 0.1.0

data/lib/hack_tree/node/base.rb

@@ -0,0 +1,34 @@
+module HackTree
+  module Node
+    class Base
+      # Brief 1-line description, if present.
+      attr_accessor :brief_desc
+
+      # Multi-line description, if present.
+      attr_accessor :full_desc
+
+      # Node name, Symbol.
+      attr_accessor :name
+
+      # Parent group or <tt>nil</tt>.
+      attr_accessor :parent
+
+      def initialize(attrs = {})
+        attrs.each {|k, v| send("#{k}=", v)}
+      end
+
+      #   global_name   # => "hello"
+      #   global_name   # => "rails.db.tables"
+      def global_name
+        pcs = []
+        cursor = self
+        begin
+          pcs << cursor.name
+          cursor = cursor.parent
+        end while cursor
+
+        pcs.reverse.join(".")
+      end
+    end # Base
+  end
+end

data/lib/hack_tree/node/group.rb

@@ -0,0 +1,8 @@
+require File.join(File.dirname(__FILE__), "base")
+
+module HackTree
+  module Node
+    class Group < Base
+    end
+  end
+end

data/lib/hack_tree/node/hack.rb

@@ -0,0 +1,10 @@
+require File.join(File.dirname(__FILE__), "base")
+
+module HackTree
+  module Node
+    class Hack < Base
+      # The actual code block to execute.
+      attr_accessor :block
+    end # Hack
+  end
+end

data/lib/hack_tree/node.rb

@@ -0,0 +1,13 @@
+module HackTree
+  module Node
+    # Node (group/hack) regexp without delimiters.
+    NAME_REGEXP = /[a-zA-Z_]\w*/
+
+    # Node names which can't be used due to serious reasons.
+    FORBIDDEN_NAMES = [
+      :inspect,
+      :method_missing,
+      :to_s,
+    ]
+  end
+end

data/lib/hack_tree/parser/base.rb

@@ -0,0 +1,26 @@
+module HackTree
+  module Parser
+    # Base class for parsers. Parsers generally process text into collection(s).
+    class Base
+      def initialize(attrs = {})
+        attrs.each {|k, v| send("#{k}=", v)}
+      end
+
+      # Synonym of #process.
+      def [](content)
+        process(content)
+      end
+
+      def process(content)
+        # NOTE: In parser meaning "content" argument name looks more solid. For mapper "data" is more appropriate. Both are okay for their cases.
+        raise "Redefine `process` in your class (#{self.class})"
+      end
+
+      private
+
+      def require_attr(attr)
+        send(attr) or raise "`#{attr}` is not set"
+      end
+    end
+  end
+end

data/lib/hack_tree/parser/desc.rb

@@ -0,0 +1,66 @@
+require File.join(File.dirname(__FILE__), "base")
+
+module HackTree
+  module Parser
+    # DSL <tt>desc</tt> parser.
+    class Desc < Base
+      # Parse description text, always return Array of 2 elements.
+      #
+      #   process(content)    # => [nil, nil]. Neither brief nor full description is present.
+      #   process(content)    # => ["...", nil]. Brief description is present, full isn't.
+      #   process(content)    # => ["...", "..."]. Both brief and full descriptions are present.
+      def process(content)
+        lines = content.lstrip.lines.to_a
+        return [nil, nil] if lines.empty?
+
+        # If we're here, `brief` is certainly present.
+        brief = lines.shift.rstrip
+
+        # Extract full lines with original indentation on the left.
+
+        indented_lines = []
+        gap = true    # We're skipping the gap between the brief and the full.
+
+        lines.each do |line|
+          line = line.rstrip
+          next if gap and line.empty?
+
+          # First non-empty line, the gap is over.
+          gap = false
+
+          indented_lines << line
+        end
+
+        # Compute minimum indentation level. Empty lines don't count.
+        indent = indented_lines.reject(&:empty?).map do |s|
+          s.match(/\A(\s*)\S/)[1].size
+        end.min.to_i
+
+        # Apply indentation.
+        unindented_lines = indented_lines.map do |line|
+          line.empty?? line : line[indent..-1]
+        end
+
+        # Reject empty lines at the end.
+        final_lines = []
+        buf = []
+        unindented_lines.each do |line|
+          # Accumulate empty lines.
+          if line.empty?
+            buf << line
+            next
+          end
+
+          # Non-empty line, flush `buf` and start over.
+          final_lines += buf + [line]
+          buf = []
+        end
+
+        [
+          brief,
+          (final_lines.join("\n") if not final_lines.empty?),
+        ]
+      end
+    end
+  end # Parser
+end

data/lib/hack_tree/tools.rb

@@ -0,0 +1,26 @@
+module HackTree
+  module Tools
+    #   compute_name_align(["alfa", "bravo"], 8..16)    # => 8
+    def self.compute_name_align(names, limit)
+      (v = eval(vn = "names")).is_a?(klass = Array) or raise ArgumentError, "`#{vn}` must be #{klass}, #{v.class} (#{v.inspect}) given"
+      (v = eval(vn = "limit")).is_a?(klass = Range) or raise ArgumentError, "`#{vn}` must be #{klass}, #{v.class} (#{v.inspect}) given"
+
+      computed = names.map(&:size).select {|n| n <= limit.max}.max.to_i
+
+      [limit.min, computed].max
+    end
+
+    #   format_node_name(node)          # => "hello"
+    #   format_node_name(node, "yo")    # => "yo"
+    def self.format_node_name(node, name = nil)
+      case node
+      when Node::Group
+        ::HackTree.conf.group_format
+      when Node::Hack
+        ::HackTree.conf.hack_format
+      else
+        raise ArgumentError, "Unknown node class #{node.class}, SE" 
+      end % (name || node.name).to_s
+    end
+  end
+end

data/lib/hack_tree.rb

@@ -0,0 +1,233 @@
+[
+  "hack_tree/**/*.rb",
+].each do |fmask|
+  Dir[File.join(File.dirname(__FILE__), fmask)].each do |fn|
+    require fn
+  end
+end
+
+module HackTree
+  VERSION = "0.1.0"
+
+  # Standard hacks bundled with the gem, their global names.
+  STD_HACKS = [
+    "hack_tree.reload",
+    "ls",
+  ]
+
+  # Clear everything. See Instance#clear.
+  def self.clear
+    instance.clear
+  end
+
+  # Clear config. See Instance#clear_conf.
+  def self.clear_conf
+    instance.clear_conf
+  end
+
+  # Clear group/hack definitions ("nodes" in general). See Instance#clear_nodes.
+  def self.clear_nodes
+    instance.clear_nodes
+  end
+
+  # Get configuration object.
+  #
+  # See also:
+  #
+  # * HackTree::Config
+  # * Instance#conf
+  def self.conf
+    instance.conf
+  end
+
+  # Define hacks.
+  #
+  #   HackTree.define do
+  #     group :greeting do
+  #       desc "Say hello"
+  #       hack :hello do |*args|
+  #         puts "Hello, %s!" % (args[0] || "world")
+  #       end
+  #     end
+  #   end
+  def self.define(&block)
+    instance.define(&block)
+  end
+
+  # Enable HackTree globally.
+  #
+  #   >> HackTree.enable
+  #   Greetings.
+  #   >> c
+  #   hello         # Say hello
+  #   >> c.hello
+  #   Hello, world!
+  #
+  # Options:
+  #
+  #   :completion => T|F      # Enable completion enhancement. Default is true.
+  #   :with_std => [...]      # Load only these standard hacks.
+  #   :without_std => [...]   # Load all but these standard hacks.
+  #   :quiet => T|F           # Be quiet. Default is false.
+  #
+  # Examples:
+  #
+  # TODO.
+  def self.enable(method_name = :c, options = {})
+    options = options.dup
+    o = {}
+
+    o[k = :completion] = (v = options.delete(k)).nil?? true : v
+    o[k = :with_std] = options.delete(k)
+    o[k = :without_std] = options.delete(k)
+    o[k = :quiet] = (v = options.delete(k)).nil?? false : v
+
+    raise ArgumentError, "Unknown option(s): #{options.inspect}" if not options.empty?
+
+    if o[:with_std] and o[:without_std]
+      # Exception is better than warning. It has a stack trace.
+      raise ArgumentError, "Options `:with_std` and `:without_std` are mutually exclusive"
+    end
+
+    @enabled_as = method_name
+
+    if not o[:quiet]
+      # Print the banner before everything. If there are warnings, we'll know they are related to us somehow.
+      ::Kernel.puts "Console hacks are available. Use `%s`, `%s.hack?`, `%s.hack [args]`" % ([@enabled_as]*3)
+    end
+
+    # NOTE: This can't be put into `Instance`, it's a name-based global.
+    eval <<-EOT
+      module ::Kernel
+        private
+
+        def #{method_name}
+          ::HackTree.instance.action
+        end
+      end
+    EOT
+
+    # Install completion enhancement.
+    if o[:completion]
+      old_proc = Readline.completion_proc
+
+      Readline.completion_proc = lambda do |input|
+        candidates = instance.completion_logic(input, :enabled_as => @enabled_as)
+
+        # NOTE: Block result.
+        if candidates.is_a? Array
+          candidates
+        elsif old_proc
+          # Pass control.
+          old_proc.call(input)
+        else
+          # Nothing we can do.
+          []
+        end
+      end # @completion_proc =
+    end # if o[:completion]
+
+    # Load standard hacks.
+
+    global_names = if (ar = o[:with_std])
+      # White list.
+      STD_HACKS & ar.map(&:to_s)
+    elsif (ar = o[:without_std])
+      # Black list.
+      STD_HACKS - ar.map(&:to_s)
+    else
+      # Default.
+      STD_HACKS
+    end
+
+    global_names.each do |global_name|
+      bn = global_name.gsub(".", "/") + ".rb"
+      fn = File.join(File.dirname(__FILE__), "../hacks", bn)
+      load fn
+    end
+
+    nil
+  end
+
+  def self.enabled_as
+    @enabled_as
+  end
+
+  def self.instance
+    @instance ||= Instance.new
+  end
+end
+
+#--------------------------------------- Junk
+
+if false
+      # * Using array is a reliable way to ensure a newline after the banner.
+      ::Kernel.puts [
+        #"",
+        "Console hacks are available. Use `%s`, `%s.hack?`, `%s.hack [args]`" % ([@enabled_as]*3),
+        #"",
+      ]
+end
+
+if false
+  # Node (group/hack) regexp without delimiters.
+  NAME_REGEXP = /[a-zA-Z_]\w*/
+
+  # Node names which can't be used due to serious reasons.
+  FORBIDDEN_NAMES = [
+    :inspect,
+    :method_missing,
+    :to_s,
+  ]
+end
+
+if false
+  # Create the action object.
+  #
+  #   module Kernel
+  #     # Access our hacks via <tt>c</tt>.
+  #     def c
+  #       ::HackTree.action
+  #     end
+  #   end
+  #
+  #   >> c
+  #   hello       # Say hello
+  #   >> c.hello
+  #   Hello, world!
+  #
+  # See also ::enable.
+  def self.action
+    ActionContext.new(@nodes)
+  end
+
+  # Clear self.
+  def self.clear
+    # Request re-initialization upon first use of any kind.
+    @is_initialized = false
+  end
+
+  # Access nodes (groups/hacks) created via the DSL.
+  def self.nodes
+    @nodes
+  end
+
+  # See #nodes.
+  def self.nodes=(ar)
+    @nodes = ar
+  end
+
+  # NOTE: We need this wrapper to create private singletons.
+  class << self
+    private
+
+    # On-the-fly initializer.
+    def _otf_init
+      return if @is_initialized
+
+      @is_initialized = true
+      @nodes = []
+      @dsl_root = DslContext.new(@nodes)
+    end
+  end # class << self
+end

data/spec/lib/hack_tree/parser/desc_spec/000,brief.txt

@@ -0,0 +1 @@
+Brief

data/spec/lib/hack_tree/parser/desc_spec/000,full.txt

@@ -0,0 +1,3 @@
+Full 1
+
+  Full 2

data/spec/lib/hack_tree/parser/desc_spec/000.txt

@@ -0,0 +1,5 @@
+Brief
+
+  Full 1
+  
+    Full 2

data/spec/lib/hack_tree/parser/desc_spec/010,brief.txt

@@ -0,0 +1 @@
+Краткое описание

data/spec/lib/hack_tree/parser/desc_spec/010,full.txt

@@ -0,0 +1,3 @@
+Длинное описание 1
+
+  Длинное описание 2

data/spec/lib/hack_tree/parser/desc_spec/010.txt

@@ -0,0 +1,8 @@
+     Краткое описание
+  
+  
+  Длинное описание 1
+    
+    Длинное описание 2
+  
+  

data/spec/lib/hack_tree/parser/desc_spec.rb

@@ -0,0 +1,50 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe HackTree::Parser::Desc do
+  before :each do
+    @parser = described_class.new
+  end
+
+  it "should generally work" do
+    sets = [
+      ["", [nil, nil]],
+      ["  ", [nil, nil]],
+      [" \t\n \n ", [nil, nil]],
+      ["Brief", ["Brief", nil]],
+      ["   Brief\t\t\n\n", ["Brief", nil]],
+      ["\n\n\nBrief\t\t\n\n", ["Brief", nil]],
+      ["Brief\nFull 1  \nFull 2", ["Brief", "Full 1\nFull 2"]],
+      ["Brief\nFull 1  \nFull 2\n\n    ", ["Brief", "Full 1\nFull 2"]],
+      ["Brief\n\n\nFull 1\nFull 2", ["Brief", "Full 1\nFull 2"]],
+      ["Brief\n  Full 1\n  Full 2", ["Brief", "Full 1\nFull 2"]],
+      ["Brief\n  Full 1\n    Full 2", ["Brief", "Full 1\n  Full 2"]],
+      ["Brief\n  Full 1\n\n    Full 2", ["Brief", "Full 1\n\n  Full 2"]],
+      ["Brief\n  Full 1\n  \n    Full 2", ["Brief", "Full 1\n\n  Full 2"]],
+
+      # File-based tests for more complex cases.
+      [["000"], [["000,brief"], ["000,full"]]],
+      [["010"], [["010,brief"], ["010,full"]]],
+    ]
+
+    path = Pathname(__FILE__[0..-4])
+
+    sets.each do |input_spec, expected_spec|
+      input = if input_spec.is_a? Array
+        # Input is a file reference.
+        File.read(path + "#{input_spec[0]}.txt")
+      else
+        # Input is plain.
+        input_spec
+      end
+
+      expected = expected_spec.map do |spec|
+        # Same rule as for input.
+        spec.is_a?(Array) ? File.read(path + "#{spec[0]}.txt") : spec
+      end
+
+      print_on_failure("-- input_spec:#{input_spec.inspect}") do
+        @parser[input].should == expected
+      end
+    end
+  end
+end

data/spec/lib/hack_tree/parser/spec_helper.rb

@@ -0,0 +1,3 @@
+require File.join(File.dirname(__FILE__), "../spec_helper")
+
+# Custom stuff for this group.

data/spec/lib/hack_tree/spec_helper.rb

@@ -0,0 +1,3 @@
+require File.join(File.dirname(__FILE__), "../spec_helper")
+
+# Custom stuff for this group.

data/spec/lib/spec_helper.rb

@@ -0,0 +1,3 @@
+require File.join(File.dirname(__FILE__), "../spec_helper")
+
+# Custom stuff for this group.

data/spec/spec_helper.rb

@@ -0,0 +1,53 @@
+require "pathname"
+
+# Load stuff.
+[
+  "lib/**/*.rb",
+].each do |fmask|
+  Dir["./#{fmask}"].each do |fn|
+    ##puts "-- req '#{fn}'"
+    require fn
+  end
+end
+
+# TODO: When this becomes a gem, use gem instead of direct copy.
+module RSpec
+  module PrintOnFailure
+    module Helpers
+      # Output <tt>message</tt> before the failed tests in <tt>block</tt>. Useful when input and expected data
+      # are defined as collections.
+      #
+      #   sets = [
+      #     ["hello", "HELLO"],
+      #     ["123", "456"],
+      #   ]
+      #
+      #   sets.each do |input, expected|
+      #     print_on_failure("-- input:'#{input}'") do
+      #       input.upcase.should == expected
+      #     end
+      #   end
+      def print_on_failure(message, &block)
+        begin
+          yield
+        rescue Exception
+          # Catch just everything, report and then re-run. The test may fail due to an exception, not necessarily unmatched expectation.
+          puts message
+          yield
+        end
+      end
+    end
+  end
+end
+
+begin
+  # 2.x.
+  RSpec.configure do |config|
+    config.include ::RSpec::PrintOnFailure::Helpers
+  end
+rescue NameError
+  # 1.3.
+  Spec::Runner.configure do |config|
+    config.include ::RSpec::PrintOnFailure::Helpers
+  end
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: hack_tree
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Alex Fortuna
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-04 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &71051990 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *71051990
+description: HackTree lets you organize and share your console hacks in an effective
+  and uniform way. Blah-blah-blah.
+email:
+- alex.r@askit.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- hack_tree.gemspec
+- hacks/hack_tree/reload.rb
+- hacks/ls.rb
+- lib/generators/hack_tree/USAGE
+- lib/generators/hack_tree/hack_tree_generator.rb
+- lib/generators/hack_tree/templates/INSTALL
+- lib/generators/hack_tree/templates/hack_tree.rb
+- lib/generators/hack_tree/templates/hello.rb
+- lib/hack_tree.rb
+- lib/hack_tree/action_context.rb
+- lib/hack_tree/config.rb
+- lib/hack_tree/dsl_context.rb
+- lib/hack_tree/instance.rb
+- lib/hack_tree/node.rb
+- lib/hack_tree/node/base.rb
+- lib/hack_tree/node/group.rb
+- lib/hack_tree/node/hack.rb
+- lib/hack_tree/parser/base.rb
+- lib/hack_tree/parser/desc.rb
+- lib/hack_tree/tools.rb
+- spec/lib/hack_tree/parser/desc_spec.rb
+- spec/lib/hack_tree/parser/desc_spec/000,brief.txt
+- spec/lib/hack_tree/parser/desc_spec/000,full.txt
+- spec/lib/hack_tree/parser/desc_spec/000.txt
+- spec/lib/hack_tree/parser/desc_spec/010,brief.txt
+- spec/lib/hack_tree/parser/desc_spec/010,full.txt
+- spec/lib/hack_tree/parser/desc_spec/010.txt
+- spec/lib/hack_tree/parser/spec_helper.rb
+- spec/lib/hack_tree/spec_helper.rb
+- spec/lib/spec_helper.rb
+- spec/spec_helper.rb
+homepage: http://github.com/dadooda/hack_tree
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Organize and share your console hacks
+test_files: []