orion 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 142f0738a84b14879a801534a2a582b442078d27
-  data.tar.gz: f2bf18e3513faa642b8529d9645bbed978f63861
+  metadata.gz: b5725831d98f7cd26ee72862fb3548ffbca64bef
+  data.tar.gz: 8f45aa5e5cabc427b37f63848e5028dcb66595f3
 SHA512:
-  metadata.gz: 03df67ff4fb3b9d79a6047f0e8cfebc2509fff6326d3a47ebe15aca4eb08facf64da5e04ead7e700f0f652fcf8c9f9fa03c5b2b2da877b19427a520466657f9b
-  data.tar.gz: 4f9a11da2b86a0cf54360e42cee99a6f6d3b1300ac33c1a18c1238dbc579d174fc36cb9cb3800b16af0e86f8f5cede0f883cdcc52dabbe04e76dcd9991f51d3b
+  metadata.gz: fae5ab16115782b25d90634c12ab029ca87a633a7e7c4af00785e6b129cdde4444a335040b8bcb30423d0aebff3d61f8c7cefe7ec72aa6bda9a351b524908703
+  data.tar.gz: 808686314a191d1444806e7cac7edf83db8e7e91c1ba00a18195d86c15d6b4af2d749ed51c05a513f2bb7dd4d5465c3c6a444d1f65134827542bea20abc2dd5b

data/lib/orion.rb

@@ -5,13 +5,13 @@ require "orion/delete"
 require "orion/info"
 
 module Orion
-  def self.search(root_path, query)
-    method_call = Orion::Search.new(root_path).with_response(query)
+  def self.search(root_path, query_hash)
+    method_call = Orion::Search.new(root_path).search(query_hash).to_orion
     block_given? ? yield(method_call) : method_call
   end
 
-  def self.delete(root_path, query)
-    found_files = Orion::Search.new(root_path).search(query)
+  def self.delete(root_path, query_hash)
+    found_files = Orion::Search.new(root_path).search(query_hash)
     if block_given?
       yield Orion::Delete.with_response(found_files)
     else

data/lib/orion/orion_objects/fixnum.rb

@@ -0,0 +1,37 @@
+class Fixnum
+  def seconds
+    self
+  end
+
+  def minutes
+    self * 60.seconds
+  end
+
+  def hours
+    self * 60.minutes
+  end
+
+  def days
+    self * 24.hours
+  end
+
+  def weeks
+    self * 7.days
+  end
+
+  def months
+    self * 4.weeks
+  end
+
+  def years
+    self * 12.months
+  end
+
+  alias_method :second, :seconds
+  alias_method :minute, :minutes
+  alias_method :hour, :hours
+  alias_method :day, :days
+  alias_method :week, :weeks
+  alias_method :month, :months
+  alias_method :year, :years
+end

data/lib/orion/orion_objects/hash.rb

@@ -4,4 +4,8 @@ class Hash
   def to_orion
     OpenStruct.new(self)
   end
+
+  def self.diff(hash1, hash2)
+    Hash[*((hash1.size > hash2.size) ? hash1.to_a - hash2.to_a : hash2.to_a - hash1.to_a).flatten] 
+  end
 end

data/lib/orion/orion_objects/time.rb

@@ -0,0 +1,13 @@
+class Time
+  def >(other_time)
+    (self <=> other_time) == 1 ? true : false
+  end
+
+  def <(other_time)
+    (self <=> other_time) == -1 ? true : false
+  end
+
+  def ==(other_time)
+    (self <=> other_time) == 0 ? true : false
+  end
+end

data/lib/orion/orion_support/find/find.rb

@@ -0,0 +1,72 @@
+# Original from:
+#   https://github.com/ruby/ruby/blob/trunk/lib/find.rb?source=cc
+# Modified to fit Orion purposes
+
+require "orion/orion_support/i18n"
+require "orion/orion_objects/fixnum"
+
+module Orion
+  module Find
+    def find(*paths, conditions) # :yield: path
+      raise I18n.t("errors.search.not_conditions_provided") if conditions.empty?
+      condition_string = condition_statement(validate(conditions))
+      results = []
+
+      paths.collect!{|d| raise Errno::ENOENT unless File.exist?(d); d.dup}
+      while file = paths.shift
+        catch(:prune) do
+          results << file.dup.taint if eval(condition_string)
+          begin
+            s = File.lstat(file)
+          rescue Errno::ENOENT, Errno::EACCES, Errno::ENOTDIR, Errno::ELOOP, Errno::ENAMETOOLONG
+            next
+          end
+          if s.directory? then
+            begin
+              fs = Dir.entries(file)
+            rescue Errno::ENOENT, Errno::EACCES, Errno::ENOTDIR, Errno::ELOOP, Errno::ENAMETOOLONG
+              next
+            end
+            fs.sort!
+            fs.reverse_each {|f|
+              next if f == "." or f == ".."
+              f = File.join(file, f)
+              paths.unshift f.untaint
+            }
+          end
+        end
+      end
+      results
+    end
+
+    def self.validate(conditions)
+      valid_conditions = [:name, :atime, :ctime, :mtime, :ftype, :size, :absolute_path, :basename, :directory?, :dirname, :executable?, :exists?, :extname, :file?, :readable?, :socket?, :symlink?, :writable?, :zero?]
+      invalid_cond = ((valid_conditions+conditions.keys)-(valid_conditions&conditions.keys))-(valid_conditions-(valid_conditions&conditions.keys))
+      invalid_cond.empty? ? conditions : raise(NoMethodError)
+    end
+
+    def self.arrange_conditions(conditions)
+      @comparative_conditions = conditions.select{|k,v| v =~ /(>)|(<)/ } # size: '> 999'
+      @equality_conditions = Hash.diff(conditions, @comparative_conditions) # name: '.rb'
+    end
+
+    # Creates a conditional statement string with the given conditions
+    def self.condition_statement(conditions)
+      arrange_conditions(conditions)
+      conditions_array = conditions.has_key?(:name) ? ["file.include?(conditions[:name])"] : []
+      @equality_conditions.each do |k, v|
+        conditions_array << "File.send(:#{k}, file) == conditions[:#{k}]" unless k == :name
+      end
+      @comparative_conditions.each do |k, v|
+        conditions_array << "File.send(:#{k}, file) #{conditions[k]}"
+      end
+      conditions_array.join(" && ")
+    end
+
+    def prune
+      throw :prune
+    end
+
+    module_function :find, :prune
+  end
+end

data/lib/orion/search.rb

@@ -1,5 +1,4 @@
-require 'find'
-require "orion/orion_objects/array"
+require 'orion/orion_support/find/find'
 require "orion/orion_objects/nil"
 
 module Orion
@@ -7,28 +6,11 @@ module Orion
     attr_accessor :root_path
 
     def initialize(root_path)
-      @root_path ||= root_path
+      @root_path ||= File.expand_path(root_path)
     end
 
     def search(query)
-      find(query)
-    end
-
-    def with_response(query)
-      find(query).to_orion
-    end
-
-    private
-
-    def find(query)
-      results = []
-      Find.find(@root_path) do |path|
-        unless FileTest.directory?(path)
-          file = File.basename(path)
-          results << path if file.include?(query)
-        end
-      end
-      results
+      Find.find(@root_path, query)
     end
   end
 end

data/lib/orion/version.rb

@@ -1,3 +1,3 @@
 module Orion
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: orion
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Bismark
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-19 00:00:00.000000000 Z
+date: 2013-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -73,13 +73,14 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/boyer_moore/rich_hash.rb
-- lib/boyer_moore/boyer_moore.rb
 - lib/orion.rb
+- lib/orion/orion_support/find/find.rb
 - lib/orion/orion_support/i18n.rb
+- lib/orion/orion_objects/fixnum.rb
 - lib/orion/orion_objects/array.rb
 - lib/orion/orion_objects/nil.rb
 - lib/orion/orion_objects/hash.rb
+- lib/orion/orion_objects/time.rb
 - lib/orion/version.rb
 - lib/orion/delete.rb
 - lib/orion/search.rb

data/lib/boyer_moore/boyer_moore.rb

@@ -1,90 +0,0 @@
-require "boyer_moore/rich_hash"
-# ported directly from this version wikipedia:
-# http://en.wikipedia.org/w/index.php?title=Boyer%E2%80%93Moore_string_search_algorithm&diff=391986850&oldid=391398281
-# it's not very rubyish but it works
-module Orion
-  module BoyerMoore    
-
-    def self.compute_prefix(str) 
-      size = str.length
-      k = 0
-      result = [0]
-      1.upto(size - 1) do |q|
-        while (k > 0) && (str[k] != str[q])
-          k = result[k-1]
-        end
-        k += 1 if(str[k] == str[q])
-        result[q] = k
-      end
-      result
-    end
-
-    def self.prepare_badcharacter_heuristic(str)
-      result = Orion::RichHash.new
-      0.upto(str.length - 1) do |i|
-        result[str[i]] = i
-      end
-      result
-    end
-
-    def self.prepare_goodsuffix_heuristic(normal)
-      size = normal.size
-      result = []
-
-      reversed = normal.dup.reverse
-      prefix_normal = compute_prefix(normal)
-      prefix_reversed = compute_prefix(reversed)
-
-      0.upto(size) do |i|
-        result[i] = size - prefix_normal[size-1]
-      end
-
-      0.upto(size-1) do |i|
-        j = size - prefix_reversed[i]
-        k = i - prefix_reversed[i]+1
-        result[j] = k if result[j] > k
-      end
-      result
-    end
-
-    def self.search(haystack, needle)
-      needle_len = needle.size
-      haystack_len = haystack.size
-
-      return nil if haystack_len == 0
-      return haystack if needle_len == 0
-
-      badcharacter = self.prepare_badcharacter_heuristic(needle)
-      goodsuffix   = self.prepare_goodsuffix_heuristic(needle)
-
-      s = 0
-      while s <= haystack_len - needle_len
-        j = needle_len
-        while (j > 0) && self.needle_matches?(needle[j-1], haystack[s+j-1])
-          j -= 1
-        end
-
-        if(j > 0)
-          k = badcharacter[haystack[s+j-1]]
-          k = -1 unless k
-          if (k < j) && (m = j-k-1) > goodsuffix[j]
-            s += m
-          else
-            s += goodsuffix[j]
-          end
-        else
-          return s
-        end
-      end
-      return nil
-    end
-
-    def self.needle_matches?(needle, haystack)
-      if needle.kind_of?(Regexp)
-        needle.match(haystack) ? true : false 
-      else
-        needle == haystack
-      end
-    end
-  end
-end

data/lib/boyer_moore/rich_hash.rb

@@ -1,29 +0,0 @@
-# Hash impersonator that accepts regular expressions as keys.  But the regular
-# expression lookups are slow, so don't use them (unless you have to).
-module Orion
-  class RichHash
-    def initialize
-      @regexps = {}
-      @regular = {}
-    end
-
-    def [](k)
-      regular = @regular[k]
-      return regular if regular
-      if @regexps.size > 0
-        @regexps.each do |regex,v| # linear search is going to be slow
-          return v if regex.match(k) 
-        end
-      end
-      nil
-    end
-
-    def []=(k,v)
-      if k.kind_of?(Regexp)
-        @regexps[k] = v
-      else
-        @regular[k] = v
-      end
-    end
-  end
-end