social_snippet 0.0.9 → 0.0.10

data/lib/social_snippet/repository/drivers/entry.rb

@@ -0,0 +1,11 @@
+class ::SocialSnippet::Repository::Drivers::Entry
+
+  attr_reader :path
+  attr_reader :data
+
+  def initialize(new_path, new_data = nil)
+    @path = new_path
+    @data = new_data
+  end
+
+end

data/lib/social_snippet/repository/drivers/git_driver.rb

@@ -0,0 +1,100 @@
+module SocialSnippet::Repository::Drivers
+
+  class GitDriver < DriverBase
+
+    attr_reader :rugged_repo
+
+    def fetch
+      dest_dir = ::Dir.mktmpdir
+      @rugged_repo = ::Rugged::Repository.clone_at(url, dest_dir)
+    end
+
+    def snippet_json
+      @snippet_json ||= read_snippet_json
+    end
+
+    def read_snippet_json
+      oid = rugged_repo.head.target.tree["snippet.json"][:oid]
+      @snippet_json ||= ::JSON.parse rugged_repo.lookup(oid).read_raw.data
+    end
+
+    def read_file(oid)
+      rugged_repo.lookup(oid).read_raw.data
+    end
+
+    def each_directory(ref)
+      rugged_ref(ref).target.tree.each do |c|
+        next unless c[:type] == :tree
+        yield ::SocialSnippet::Repository::Drivers::Entry.new(c[:name])
+      end
+    end
+
+    def each_file(ref, &block)
+      walk_tree rugged_ref(ref).target.tree, ::Array.new, &block
+    end
+
+    def walk_tree(tree, parents)
+      tree.each_blob do |c|
+        path = ::File.join(*parents, c[:name])
+        yield ::SocialSnippet::Repository::Drivers::Entry.new(path, read_file(c[:oid]))
+      end
+      tree.each_tree do |t|
+        parents.push t[:name]
+        walk_tree(rugged_repo.lookup(t[:oid]), parents) do |content|
+          yield content
+        end
+        parents.pop
+      end
+    end
+
+    def current_ref
+      rugged_repo.head.name.gsub /^refs\/heads\//, ""
+    end
+
+    def rugged_ref(ref_name)
+      rugged_repo.references.each("refs/*/#{ref_name}").first
+    end
+
+    def rev_hash(ref)
+      rugged_ref(ref).target_id
+    end
+
+    def refs
+      all_refs = []
+      all_refs.concat remote_refs
+      all_refs.concat tags
+      all_refs
+    end
+
+    def remote_refs
+      rugged_repo.references.each("refs/remotes/origin/**/*").map do |r|
+        r.name.match(/^refs\/remotes\/origin\/(.*)/)[1]
+      end
+    end
+
+    def tags
+      rugged_repo.references.each("refs/tags/**/*").map do |r|
+        r.name.match(/^refs\/tags\/(.*)/)[1]
+      end
+    end
+
+    class << self
+
+      def target_url?(url)
+        uri = ::URI.parse(url)
+        is_git_uri(uri)
+      end
+
+      def is_git_uri(uri)
+        /git|https?/ === uri.scheme
+      end
+
+      def target_path?(path)
+        ::File.directory?(path) && ::File.directory?(::File.join path, ".git")
+      end
+
+    end # class << self
+
+  end # GitDriver
+
+end # SocialSnippet

data/lib/social_snippet/repository/models.rb

@@ -0,0 +1,15 @@
+module SocialSnippet::Repository::Models
+
+  def self.const_missing(name)
+    if name === :Package
+      require_relative "models/package"
+      ::SocialSnippet::Repository::Models::Package
+    elsif name === :Repository
+      require_relative "models/repository"
+      ::SocialSnippet::Repository::Models::Repository
+    else
+      super
+    end
+  end
+
+end

data/lib/social_snippet/repository/models/package.rb

@@ -0,0 +1,97 @@
+module SocialSnippet::Repository::Models
+
+  class Package < ::SocialSnippet::Document
+
+    @@core = nil
+
+    field :repo_name, :type => String  # key
+    field :rev_hash, :type => String   # key
+    field :name, :type => String
+    field :paths, :type => Array, :default => ::Array.new
+    field :dependencies, :type => Hash, :default => ::Hash.new
+
+    def display_name
+      name || "#{repo_name}@#{rev_hash}"
+    end
+
+    def normalize_path(path)
+      ::Pathname.new(path).cleanpath.to_s
+    end
+
+    def add_path(path)
+      push :paths => path
+    end
+
+    def add_directory(path)
+      path = normalize_path(path)
+      add_path path + "/"
+      dir_path = real_path(path)
+      core.storage.mkdir_p dir_path
+    end
+
+    def add_file(path, data)
+      path = normalize_path(path)
+      add_path path
+      file_path = real_path(path)
+      core.storage.mkdir_p ::File.dirname(file_path)
+      core.storage.write file_path, data
+    end
+
+    def add_dependency(name, ref)
+      modifier = {}
+      modifier[name] = ref
+      push :dependencies => modifier
+    end
+
+    def has_dependencies?
+      not dependencies.empty?
+    end
+
+    def snippet_json_text
+      json_path = real_path("snippet.json")
+      core.storage.read json_path
+    end
+
+    def snippet_json
+      @snippet_json ||= parse_snippet_json
+    end
+
+    def parse_snippet_json
+      ::JSON.parse(snippet_json_text)
+    end
+
+    def glob(glob_pattern)
+      paths.select do |path|
+        ::File.fnmatch glob_pattern, path, ::File::FNM_PATHNAME
+      end
+    end
+
+    def real_path(path = nil)
+      core.config.package_path repo_name, rev_hash, path
+    end
+
+    # path from snippet_json["main"]
+    def snippet_path(path = nil)
+      if snippet_json["main"].nil?
+        real_path path
+      else
+        real_path ::File.join(snippet_json["main"], path)
+      end
+    end
+
+    def core
+      @@core
+    end
+
+    def self.core
+      @@core
+    end
+
+    def self.core=(new_core)
+      @@core = new_core
+    end
+
+  end # Package
+
+end # ::SocialSnippet::Repository::Models
+

data/lib/social_snippet/repository/models/repository.rb

@@ -0,0 +1,94 @@
+module SocialSnippet::Repository::Models
+
+  class Repository < ::SocialSnippet::Document
+
+    @@core = nil
+
+    field :url, :type => String
+    field :name, :type => String
+    field :current_ref, :type => String
+    field :refs, :type => Array, :default => ::Array.new
+    # rev_hash[ref] => Commit ID
+    field :rev_hash, :type => Hash, :default => ::Hash.new
+    # package_refs[ref] => rev_hash
+    field :package_refs, :type => Hash, :default => ::Hash.new
+
+    def add_package(ref)
+      modifier = ::Hash.new
+      modifier[ref] = rev_hash[ref]
+      push :package_refs => modifier
+    end
+
+    def add_ref(ref, rev_hash)
+      add_to_set :refs => ref
+      modifier = ::Hash.new
+      modifier[ref] = rev_hash
+      push :rev_hash => modifier
+    end
+
+    def has_ref?(ref)
+      refs.include? ref
+    end
+
+    def package_ref_keys
+      package_refs.map {|k, _| k }
+    end
+
+    def package_minor_versions
+      package_versions.map do |v|
+        ::SocialSnippet::Version.minor v
+      end.uniq
+    end
+
+    def latest_package_version(pattern = "")
+      find_latest_version package_versions, pattern
+    end
+
+    def package_versions
+      select_versions package_ref_keys
+    end
+
+    # Returns latest version
+    def latest_version(pattern = "")
+      find_latest_version versions, pattern
+    end
+
+    # Returns all versions
+    def versions
+      select_versions refs
+    end
+
+    def find_latest_version(versions, pattern = "")
+      matches = versions.select {|ref| ::SocialSnippet::Version.is_matched_version_pattern(pattern, ref)}
+      ::VersionSorter.rsort(matches).first
+    end
+
+    def select_versions(refs)
+      refs.select {|ref| ::SocialSnippet::Version.is_version(ref) }
+    end
+
+    def has_package_versions?
+      not package_versions.empty?
+    end
+
+    # Check repository has version ref
+    def has_versions?
+      not versions.empty?
+    end
+
+    def core
+      @@core
+    end
+
+    def self.core
+      @@core
+    end
+
+    def self.core=(new_core)
+      @@core = new_core
+    end
+
+  end
+
+end
+

data/lib/social_snippet/repository/repository_manager.rb

@@ -2,9 +2,6 @@ module SocialSnippet::Repository
 
   class RepositoryManager
 
-    attr_reader :installer
-    attr_reader :repo_paths
-    attr_reader :repo_cache_path
     attr_reader :core
 
     # Constructor
@@ -12,31 +9,6 @@ module SocialSnippet::Repository
     # @param new_core [::SocialSnippet::Core]
     def initialize(new_core)
       @core = new_core
-      @installer = ::SocialSnippet::Repository::RepositoryInstaller.new(core)
-      @repo_cache_path = core.config.repository_cache_path
-      @repo_paths = []
-
-      init_repo_paths
-      init_repo_cache_path
-    end
-
-    def init_repo_cache_path
-      ::FileUtils.mkdir_p repo_cache_path
-    end
-
-    def init_repo_paths
-      repo_paths.push installer.path
-      repo_paths.each {|path| ::FileUtils.mkdir_p path }
-    end
-
-    def deps(repo_name, repo_ref = nil)
-      repo = find_repository(repo_name)
-      repo.checkout(repo_ref) unless repo_ref.nil?
-      repo.dependencies
-    end
-
-    def has_deps?(repo_name, repo_ref = nil)
-      not deps(repo_name, repo_ref).empty?
     end
 
     # Get snippet by context and tag
@@ -53,8 +25,8 @@ module SocialSnippet::Repository
     # @param tag [::SocialSnippet::Tag] The tag of snippet
     def resolve_snippet_path(context, tag)
       if tag.has_repo?
-        repo = find_repository_by_tag(tag)
-        repo.real_path tag.path
+        pkg = find_package_by_tag(tag)
+        pkg.snippet_path tag.path
       else
         new_context = context.clone
         new_context.dirname + "/" + tag.filename
@@ -64,36 +36,38 @@ module SocialSnippet::Repository
     # Find repository by tag
     #
     # @param tag [::SocialSnippet::Tag] The tag of repository
-    def find_repository_by_tag(tag)
+    def find_package_by_tag(tag)
       if tag.has_ref?
-        find_repository(tag.repo, tag.ref)
+        find_package(tag.repo, tag.ref)
       else
-        find_repository(tag.repo)
+        find_package(tag.repo)
       end
     end
 
     # Find repository by repo name
     #
     # @param name [String] The name of repository
-    def find_repository(name, ref = nil)
-      return nil if name.nil? || name.empty?
-
-      repo_paths.each do |repo_path|
-        path = "#{repo_path}/#{name}"
-        if ::Dir.exists?(path)
-          repo = RepositoryFactory.create(path, ref)
-          repo.load_cache repo_cache_path
-          return repo
-        end
-      end
+    def find_package(name, ref = nil)
+      repo = find_repository(name)
+      ref ||= repo.latest_package_version || repo.current_ref
+      raise "invalid references" unless repo.has_ref?(ref)
+      Models::Package.find_by(
+        :repo_name => name,
+        :rev_hash => repo.rev_hash[ref],
+      )
+    end
 
-      nil
+    def find_repository(name)
+      Models::Repository.find_by(:name => name)
+    end
+
+    def find_repository_by_url(url)
+      Models::Repository.find_by(:url => url)
     end
 
     def find_repositories_start_with(prefix)
-      glob_path = ::File.join(installer.path, "#{prefix}*")
-      ::Dir.glob(glob_path).map do |repopath|
-        Pathname(repopath).basename.to_s
+      Models::Repository.where(:name => /^#{prefix}.*/).map do |repo|
+        repo.name
       end
     end
 
@@ -103,12 +77,12 @@ module SocialSnippet::Repository
     end
 
     def complete_file_name(keyword)
-      repo_name   = get_repo_name(keyword)
-      repo        = find_repository(repo_name)
-      file_path   = get_file_path_prefix(keyword)
-      glob_path   = "#{file_path}*"
+      repo_name = get_repo_name(keyword)
+      package   = find_package(repo_name)
+      file_path = keyword_filepath(keyword)
+      glob_path = "#{file_path}*"
 
-      repo.glob(glob_path).map do |cand_file_path|
+      package.glob(glob_path).map do |cand_file_path|
         if ::File.directory?(cand_file_path)
           Pathname(cand_file_path).basename.to_s + "/"
         else
@@ -135,7 +109,7 @@ module SocialSnippet::Repository
       /^[^@]*@[^<]+<([^:#>]*[^:#>])$/.match(keyword)[1]
     end
 
-    def get_file_path_prefix(keyword)
+    def keyword_filepath(keyword)
       /^[^@]*@[^<]+<[^#:]+:([^>]*)$/.match(keyword)[1]
     end
 
@@ -147,30 +121,68 @@ module SocialSnippet::Repository
       /^[^@]*@[^<]+<[^#:]+:[^>]*$/ === keyword
     end
 
-    def cache_installing_repo(repo, options = {})
-      repo.create_cache repo_cache_path
+    def install(url, ref, options = ::Hash.new)
+      driver = core.driver_factory.clone(url)
+      ref ||= resolve_ref_by_driver(driver)
+      repo = update_repository(driver, url)
+      create_package driver, ref
     end
 
-    def fetch(repo_name, options)
-      installer.fetch repo_name, options
+    def resolve_ref_by_driver(driver)
+      driver.latest_version || driver.current_ref
     end
 
-    def update(repo_name, repo_ref, repo, options)
-      cache_installing_repo repo, options
-      installer.add repo_name, repo_ref
+    def update_repository(driver, url)
+      repo = Models::Repository.find_or_create_by(:url => url)
+      repo.update_attributes! :name => driver.snippet_json["name"]
+      driver.each_ref {|ref| repo.add_ref ref, driver.rev_hash(ref) }
+      repo
     end
 
-    def install(repo_name, repo_ref, repo, options)
-      installer.copy_repository repo, options
-      update repo_name, repo_ref, repo, options
+    def create_package(driver, ref)
+      repo_name = driver.snippet_json["name"]
+      package = Models::Package.create(
+        :repo_name => repo_name,
+        :rev_hash => driver.rev_hash(ref),
+        :name => "#{driver.snippet_json["name"]}##{ref}",
+      )
+
+      repo = find_repository(repo_name)
+      repo.add_package ref
+
+      driver.each_directory(ref) do |dir|
+        package.add_directory dir.path
+      end
+      driver.each_file(ref) do |content|
+        package.add_file content.path, content.data
+      end
+
+      unless package.snippet_json["dependencies"].nil?
+        package.snippet_json["dependencies"].each do |dep_name, dep_ref|
+          package.add_dependency dep_name, dep_ref
+        end
+      end
+
+      package
     end
 
     def exists?(repo_name, repo_ref = nil)
-      installer.exists? repo_name, repo_ref
+      # not found repo
+      return false unless Models::Repository.where(:name => repo_name).exists?
+
+      repo = Models::Repository.find_by(:name => repo_name)
+      if repo_ref.nil?
+        true
+      else
+        Models::Package.where(
+          :repo_name => repo_name,
+          :rev_hash => repo.rev_hash[repo_ref],
+        ).exists?
+      end
     end
 
-    def each_installed_repo(&block)
-      installer.each &block
+    def each_repo(&block)
+      Models::Repository.all.each &block
     end
 
   end # RepositoryManager