outil 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a3cfe1efb43ae4eb0bf954722310c091cfa0fbd3
+  data.tar.gz: 5f00fa7f90c1894982e0f3112c55fbea676e4e0c
+SHA512:
+  metadata.gz: eb6a368e983db65fa663bc7036444a3e1c9faaeafa7e681c3ac229d1289aeabc1a858a1aa9d5aaa619937a2609094425d023276c54ddcbef1a9d90df508b65a9
+  data.tar.gz: 3fdd16515f75d37b7da50785d75ba397c7212bc3423fe0bb3e29d17660db7da2d3ee750b1a0f89b5372922e9d0b72e21d734900d655422a75107ab9ce27ea497

data/bin/outil-boostrap

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+require 'outil'
+
+puts ARGV 
+Outil::OCS.bootstrap(:index => ARGV[1], :config => ARGV[2])
+

data/lib/outil.rb

@@ -0,0 +1,108 @@
+require 'bundler/setup'
+require 'ruby_decorators'
+require 'parser/current'
+require 'unparser'
+require 'yaml'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'outil/version'
+require 'outil/decorators'
+require 'outil/workspace'
+require 'outil/ocs'
+require 'outil/ocs/index'
+require 'outil/ocs/config'
+require 'outil/ocs/parser'
+
+module Outil
+
+    def self.index
+        Workspace.ocs.index
+    end
+
+    def self.reset!
+       Workspace.reset! 
+    end
+
+    def self.included(base)
+        # Add the decorator class-method logic to the includer
+        # E.G. The client has control over the "use" and "named"
+        # class-level directives.
+        
+        base.extend(Inferace)
+
+        # By default, only the Registration decorator
+        # is added, and it's added under the generic :outil namespace
+
+        base.class_eval do
+            use Decorators::Register
+            named :outil
+        end
+
+        # Pull all the AST's in the user index
+        # and define them as methods of the Bucket
+        # module just before the inclusion is done.
+        
+        Workspace.ocs.index.all.each do |ast|
+            Outil.module_eval <<-RUBY_EVAL
+                #{Unparser.unparse(ast)}
+            RUBY_EVAL
+        end
+    end
+
+    module Inferace
+        # BucketInterface is a basically
+        # a module mirror of the RubyDecorators::Interface
+        # class. To avoid adding dependencies, and increasing
+        # the sheer volume of hacks at work here, the Interface
+        # code is essentially copied and pasted here as module
+        # instance variables
+
+        include RubyDecorators
+        
+        def self.decorate
+            RubyDecorators::Stack.all << self
+            Workspace.sync
+        end
+
+        def named(name)
+            @name = name.to_s
+            class_eval <<-RUBY_EVAL
+            def self.#{@name}(dcr)
+                if decorators[dcr]
+                    self.decorate(decorators[dcr])
+                end
+            end
+            RUBY_EVAL
+        end
+
+        def name
+            @name ||= self.class.name.to_s
+        end
+
+        def decorators
+            @decorators ||= {}
+        end
+
+        def use *decs
+            append = Proc.new do |dec|
+                fmt = dec.name.split('::').last.
+                gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+                gsub(/([a-z\d])([A-Z])/,'\1_\2').
+                tr("-", "_").
+                downcase.
+                to_sym
+                self.decorators[fmt] = dec
+            end
+            decs.each &append
+        end
+
+        def registered_methods
+            @registered_methods ||= {}
+        end
+
+        def self.registered_decorators
+            @registered_decorators ||= {}
+        end
+    end
+end

data/lib/outil/decorators.rb

@@ -0,0 +1,30 @@
+module Outil
+  module Decorators
+
+    class Register < RubyDecorators::Decorator
+
+      def call(this, *args, &blk)
+        Outil::Workspace.scan *this.source_location << this.name
+        this.call(*args, &blk)
+      end
+
+    end
+
+    class NameSpace
+
+        def initialize(namespace)
+            @namespace = namespace
+        end
+
+        def call(this, *args, &blk)
+            # TODO
+            # Intended behavior is to register the decorated
+            # method under a given namespace, so you can
+            # have two methods named the same thing, etc.
+            this.call(*args, &blk)
+        end
+        
+    end
+
+  end
+end

data/lib/outil/ocs.rb

@@ -0,0 +1,24 @@
+module Outil
+
+  module OCS
+
+    # Object Control System
+
+    class << self
+
+      def config(params={})
+        @config ||= Config.new(params)
+      end
+
+      def bootstrap options={}
+        options.merge! Config.new().params
+        Dir.mkdir(options[:index]) unless Dir.exists?(options[:index])
+        File.open(options.delete(:path), 'w+') do |f|
+          f.write options.to_yaml
+        end
+      end
+
+    end
+  end
+
+end

data/lib/outil/ocs/config.rb

@@ -0,0 +1,51 @@
+module Outil
+  module OCS
+    class Config
+
+      INDEX_PATH = '.outil'
+      CONFIG_PATH = '.outil.rc'
+
+      def self.home_path
+        @home_path ||= File.expand_path(
+          File.expand_path(ENV['HOME'] || '~'))
+      end
+
+      attr :params
+
+      def initialize(params={})
+        @params = params
+        infer = Proc.new do |key, const|
+          @params[key] = "#{self.class.home_path}/#{const}"
+        end
+        infer.call(:index, INDEX_PATH)
+        infer.call(:path, CONFIG_PATH)
+      end
+
+      def options
+        @options ||= (
+          unless File.exists?(@params[:path])
+            raise StandardError "Could not locate your Outil Config File"
+          end
+          indifference = Proc.new do |hash, x|
+            hash[x.first] = x.last
+            hash[x.first.to_sym] = x.last
+            hash
+          end
+          YAML.load_file(@params[:path])
+            .inject(Hash.new, &indifference)
+          )
+      end
+
+      def index
+        @index ||= (
+          unless options[:index]
+            raise StandardError "Could not locate your Outil Index Path"
+          end
+          Index.new(:path => options[:index])
+        )
+      end
+
+    end
+  end
+end
+

data/lib/outil/ocs/index.rb

@@ -0,0 +1,68 @@
+module Outil
+  module OCS
+    class Index
+
+      attr :path
+
+      def initialize params={}
+        @path = params[:path]
+      end
+
+      def index_path
+        @index_path ||= "#{@path}/index"
+      end
+
+      def append name, ast
+        write_serialize name, ast
+        update_index name
+      end
+
+      def write_serialize name, ast
+        File.open("#{@path}/#{name}.ast", 'w+') do |file|
+            file.write ast.to_yaml
+        end
+      end
+
+      def indexed_names
+        File.open(index_path, 'r') do |f|
+          f.read.split(/\n/)
+        end.map(&:strip)
+      end
+
+      def update_index name
+        return if indexed_names.include?(name.to_s)
+        File.open(index_path, 'a') do |file|
+          file.write name.to_s << "\n"
+        end
+      end
+
+      def read(name)
+        File.open("#{@path}/#{name}.ast", 'r') do |file|
+            YAML.load(file.read)
+        end
+      end
+
+      def all
+        indexed_names.map do |name|
+          read name
+        end
+      end
+
+      def read_exec(name)
+        instance_eval <<-RUBY_EVAL
+          #{Unparser.unparse(read(name))}
+        RUBY_EVAL
+      end
+
+      def hard_reset!
+        Dir["#{@path}/*.ast"].each do |path| 
+          File.delete path
+        end
+        File.open(index_path, 'w+') do |file|
+          file.write String.new
+        end
+      end
+
+    end
+  end
+end

data/lib/outil/ocs/parser.rb

@@ -0,0 +1,63 @@
+module Outil
+  module OCS
+    class ObjectParser
+
+      attr :name, :path, :found
+
+      def initialize(path, name)
+        @path = path
+        @name = name
+        @found = false
+      end
+
+      def node
+        @node ||= Parser::CurrentRuby.parse(
+        File.open(@path, 'r') do |f|
+          f.read
+        end
+        )
+      end
+
+      def find
+        return @found if @found
+        set_and_stop = Proc.new do |node|
+          return @found = node
+        end
+        traverse = Proc.new do |node|
+          # if we're not at a node, we can move on
+          next unless node.is_a?(Parser::AST::Node)
+          # unless we're at a method definition
+          # we're probably in a begin block, a class, or module
+          # in which case traverse the children of the current node
+          node.children.each &traverse unless [:defs, :def].include?(node.type)
+          # bottom-level node interrogation...
+          case node.type
+          when :defs
+            # class methods
+            set_and_stop.call(node) if node.children[1] == name
+            next
+          when :def
+            # instance method
+            set_and_stop.call(node) if node.children.first == name
+            next
+          else
+            # other kind of object
+            if node.is_a?(Parser::AST::Node)
+              # another parent node
+              node.children.each &traverse
+            else
+              # the bottom of a node
+              next
+            end
+          end
+        end
+        begin
+          traverse.call(node)
+        rescue
+          false
+        end
+      end
+
+    end
+  end
+end

data/lib/outil/ocs/serialize.rb

@@ -0,0 +1,13 @@
+module Outil
+    module OCS
+        class Serialize
+            # TODO: Move the Index away from YAML and toward Binary
+            # I want to get away from using YAML
+            # dumps AST Node class as a serialization method
+            # and the nature of AST's themselves make
+            # them really friendly to binary serialization.
+            # In theory anyway.
+
+        end
+    end
+end

data/lib/outil/version.rb

@@ -0,0 +1,3 @@
+module Outil
+    VERSION = "0.1"
+end

data/lib/outil/workspace.rb

@@ -0,0 +1,35 @@
+module Outil
+
+  class Workspace
+
+    def self.ocs
+      @ocs ||= OCS::Config.new
+    end
+
+    def self.reset!
+      @references = []
+      @asts = {}
+    end
+
+    def self.references
+      @references ||= []
+    end
+
+    def self.asts
+      @asts ||= {}
+    end
+
+    def self.scan path, lineno, name
+      references << [path, lineno, name]
+      asts[name] = OCS::ObjectParser.new(path, name).find
+    end
+
+    def self.sync
+      asts.each_pair do |name, tree|
+        ocs.index.append name, tree
+      end
+    end
+
+  end
+
+end

data/spec/decorator_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Outil::Decorators do
+
+  describe Outil::Decorators::Register do
+
+    describe "call" do
+
+      it "should update workspace references" do
+        Outil.reset!
+        class DummyInterfaceTwo < RubyDecorators::Interface
+          use Outil::Decorators::Register
+          named :outil
+
+          outil :register
+          def baz
+            'bar'
+          end
+        end
+        DummyInterfaceTwo.new.baz
+        target = [[__FILE__, 18, :baz]]
+        Outil::Workspace.references.should eq target
+      end
+    end
+
+  end
+
+end

data/spec/index_spec.rb

@@ -0,0 +1,111 @@
+require 'rubygems'
+
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Outil::OCS::Index do
+
+    before do
+        @config = Outil::OCS::Config.new
+        @index = @config.index
+    end
+
+    describe "initialize" do
+        it "should set path instance variable" do
+            @index.path.should eq(@config.params[:index])
+        end
+    end
+
+    describe "index_path" do
+        it "should return the path with index at the end" do
+            @index.index_path.should eq(@config.params[:index] + "/index")
+        end
+    end
+
+    describe "write_serialize" do
+        it "should write a file named for the method to the index" do
+            @index.write_serialize(:hello, build_target_ast)
+            Dir["#{@index.path}/*.ast"].map do |path|
+                File.basename path
+            end.include?("hello.ast")
+                .should eq(true)
+        end
+    end
+
+    describe "indexed_names" do
+        it "return a list of registered methods names" do
+            @index.write_serialize(:hello, build_target_ast)
+            @index.indexed_names.include?("hello").should eq(true)
+        end
+    end
+
+    describe "update_index" do
+        it "adds a method name to the end of the index file" do
+            @index.write_serialize(:dummy, build_target_ast(:dummy))
+            @index.update_index :dummy
+            @index.indexed_names.include?('dummy').should eq(true)
+        end
+    end
+
+    describe "read" do
+        it "return an ast for the specified method" do
+            @index.write_serialize(:dummy, build_target_ast(:dummy))
+            @index.update_index :dummy
+            @index.read(:dummy).is_a?(Parser::AST::Node).should eq(true)
+        end
+    end
+
+    describe "append" do
+
+        before do
+            @index.append :baz, build_target_ast(:baz)
+        end
+
+        it "should write a file named for the method to the index" do
+            @index.indexed_names.include?('baz').should eq(true)
+        end
+
+        it "adds a method name to the end of the index file" do
+            Dir["#{@index.path}/*.ast"].map do |path|
+                File.basename path
+            end.include?("baz.ast")
+                .should eq(true)
+        end
+    end
+
+    describe "all" do
+        it "should return an array of asts" do
+            all_ast = Proc.new do |response|
+                response.map {|x| x.is_a?(Parser::AST::Node)}
+                    .uniq == [true]
+            end
+            all_ast.call(@index.all)
+        end
+    end
+
+    describe "read_exec" do
+        it "should produce a method" do
+            @index.read_exec(:hello)
+            @index.send(:hello).should eq('hello')
+        end
+    end
+
+    describe "update_index" do
+        it "should append method names to the index file" do
+            # initialize the interface a bunch and call the
+            # registered methods, to make sure they don't keep
+            10.times do 
+                DummyInterface.new.hello
+                DummyInterface.new.goodbye
+            end
+            target = ['hello', 'dummy']
+            include_all = Proc.new do |a,b|
+                a.map {|x| b.include?(x) }.uniq == [true]
+            end
+            indexed = @index.indexed_names
+            include_all.call(target,
+                             indexed)
+                .should eq(true)
+            
+        end
+    end
+end

data/spec/outil_spec.rb

@@ -0,0 +1,33 @@
+require 'rubygems'
+
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Outil do
+
+  before do
+
+    class MyClient
+      include Outil
+
+      outil :register
+      def foo
+        'bar'
+      end
+    end
+
+    Outil::Workspace.sync
+  end
+
+  describe "included" do
+    it "should include registered methods" do
+      client = MyClient.new
+      client.hello.should eq('hello')
+      client.goodbye.should eq('goodbye')
+    end
+
+    it "should allow registration for its own methods" do
+      Outil::Workspace.ocs.index.indexed_names.include?('foo').should eq(true)
+    end
+  end
+
+end

data/spec/parser_spec.rb

@@ -0,0 +1,61 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Outil::OCS::ObjectParser do
+
+    before do
+        Outil.reset!
+        DummyInterface.new.hello
+        @target = build_target_ast
+    end
+
+    after do
+        Outil.reset!
+    end
+
+    describe "append" do
+        it "append ast to workspace" do
+            Outil::Workspace.asts[:hello].should eq(@target)
+        end
+    end
+
+    describe "initialize" do
+        before do
+            @parser = Outil::OCS::ObjectParser.new(__FILE__, :hello)
+        end
+        
+        it "should set path" do
+            @parser.path.should eq(__FILE__)
+        end
+
+        it "should set name" do
+             @parser.name.should eq(:hello)
+        end
+    end
+
+    describe "node" do
+        before do
+            @parser = build_generic_parser
+        end
+
+        it "should return an ast" do
+            @parser.node.is_a?(Parser::AST::Node).should eq(true)
+        end
+    end
+
+    describe "find" do
+        before do
+            @parser = build_generic_parser
+        end
+
+        it "should locate the named method in the parse tree" do
+            @parser.find.should eq(build_target_ast)
+        end
+
+        it "should set the found instance variable" do
+            @parser.find
+            @parser.found.should eq(build_target_ast)
+        end
+
+    end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+require File.expand_path('../../lib/outil', __FILE__)
+require 'rspec'
+require 'rspec/expectations'
+
+def build_target_ast(name=false)
+    name = name ? name : :hello
+    Parser::AST::Node.new(:def,
+                          children=[name,
+                                    Parser::AST::Node.new(:args),
+                                    Parser::AST::Node.new(:str,
+                                                          children=["hello"])])
+end
+
+def build_generic_parser
+    Outil::OCS::ObjectParser
+                .new("#{File.dirname(__FILE__)}/spec_helper.rb", 
+                     :hello)
+end
+
+
+class DummyInterface < RubyDecorators::Interface
+    use Outil::Decorators::Register
+    named :outil
+
+    outil :register
+    def hello
+        'hello'
+    end
+
+    outil :register
+    def goodbye
+        'goodbye'
+    end
+
+end
+
+DummyInterface.new.hello
+
+Outil::Workspace.sync

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: outil
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Matt Aliabadi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.0.beta5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.0.beta5
+- !ruby/object:Gem::Dependency
+  name: unparser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Outil is a library for storing and importing reusable code
+email:
+- mattmaliabadi@gmail.com
+executables:
+- outil-boostrap
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/outil-boostrap
+- lib/outil/decorators.rb
+- lib/outil/ocs/config.rb
+- lib/outil/ocs/index.rb
+- lib/outil/ocs/parser.rb
+- lib/outil/ocs/serialize.rb
+- lib/outil/ocs.rb
+- lib/outil/version.rb
+- lib/outil/workspace.rb
+- lib/outil.rb
+- spec/decorator_spec.rb
+- spec/index_spec.rb
+- spec/outil_spec.rb
+- spec/parser_spec.rb
+- spec/spec_helper.rb
+homepage: http://www.github.com/maliabadi/outil
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.6
+signing_key: 
+specification_version: 4
+summary: Stores persistently available utility functions
+test_files: []